Add empty RTCPeerConnection interface

components/script/dom/mod.rs

@@ -439,6 +439,7 @@ pub mod radionodelist;
 pub mod range;
 pub mod request;
 pub mod response;
+pub mod rtcpeerconnection;
 pub mod screen;
 pub mod serviceworker;
 pub mod serviceworkercontainer;

components/script/dom/rtcpeerconnection.rs

@@ -0,0 +1,42 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::dom::bindings::codegen::Bindings::RTCPeerConnectionBinding;
+use crate::dom::bindings::codegen::Bindings::RTCPeerConnectionBinding::RTCConfiguration;
+use crate::dom::bindings::error::Fallible;
+use crate::dom::bindings::reflector::reflect_dom_object;
+use crate::dom::bindings::reflector::DomObject;
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::eventtarget::EventTarget;
+use crate::dom::globalscope::GlobalScope;
+use crate::dom::window::Window;
+use dom_struct::dom_struct;
+
+#[dom_struct]
+pub struct RTCPeerConnection {
+    eventtarget: EventTarget,
+}
+
+impl RTCPeerConnection {
+    pub fn new_inherited() -> RTCPeerConnection {
+        RTCPeerConnection {
+            eventtarget: EventTarget::new_inherited(),
+        }
+    }
+
+    pub fn new(global: &GlobalScope) -> DomRoot<RTCPeerConnection> {
+        reflect_dom_object(
+            Box::new(RTCPeerConnection::new_inherited()),
+            global,
+            RTCPeerConnectionBinding::Wrap,
+        )
+    }
+
+    pub fn Constructor(
+        window: &Window,
+        _config: &RTCConfiguration,
+    ) -> Fallible<DomRoot<RTCPeerConnection>> {
+        Ok(RTCPeerConnection::new(&window.global()))
+    }
+}

components/script/dom/webidls/RTCPeerConnection.webidl

@@ -0,0 +1,77 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+// https://w3c.github.io/webrtc-pc/#interface-definition
+
+[Constructor(optional RTCConfiguration configuration),
+ Exposed=Window, Pref="dom.webrtc.enabled"]
+interface RTCPeerConnection : EventTarget {
+    // Promise<RTCSessionDescriptionInit> createOffer(optional RTCOfferOptions options);
+    // Promise<RTCSessionDescriptionInit> createAnswer(optional RTCAnswerOptions options);
+    // Promise<void>                      setLocalDescription(RTCSessionDescriptionInit description);
+    // readonly attribute RTCSessionDescription? localDescription;
+    // readonly attribute RTCSessionDescription? currentLocalDescription;
+    // readonly attribute RTCSessionDescription? pendingLocalDescription;
+    // Promise<void>                      setRemoteDescription(RTCSessionDescriptionInit description);
+    // readonly attribute RTCSessionDescription? remoteDescription;
+    // readonly attribute RTCSessionDescription? currentRemoteDescription;
+    // readonly attribute RTCSessionDescription? pendingRemoteDescription;
+    // Promise<void>                      addIceCandidate(RTCIceCandidateInit candidate);
+    // readonly attribute RTCSignalingState      signalingState;
+    // readonly attribute RTCIceGatheringState   iceGatheringState;
+    // readonly attribute RTCIceConnectionState  iceConnectionState;
+    // readonly attribute RTCPeerConnectionState connectionState;
+    // readonly attribute boolean?               canTrickleIceCandidates;
+    // static sequence<RTCIceServer>      getDefaultIceServers();
+    // RTCConfiguration                   getConfiguration();
+    // void                               setConfiguration(RTCConfiguration configuration);
+    // void                               close();
+    //          attribute EventHandler           onnegotiationneeded;
+    //          attribute EventHandler           onicecandidate;
+    //          attribute EventHandler           onicecandidateerror;
+    //          attribute EventHandler           onsignalingstatechange;
+    //          attribute EventHandler           oniceconnectionstatechange;
+    //          attribute EventHandler           onicegatheringstatechange;
+    //          attribute EventHandler           onconnectionstatechange;
+};
+
+dictionary RTCConfiguration {
+    sequence<RTCIceServer>   iceServers;
+    RTCIceTransportPolicy    iceTransportPolicy = "all";
+    RTCBundlePolicy          bundlePolicy = "balanced";
+    RTCRtcpMuxPolicy         rtcpMuxPolicy = "require";
+    DOMString                peerIdentity;
+    // sequence<RTCCertificate> certificates;
+    [EnforceRange]
+    octet                    iceCandidatePoolSize = 0;
+};
+
+enum RTCIceTransportPolicy {
+    "relay",
+    "all"
+};
+
+enum RTCBundlePolicy {
+    "balanced",
+    "max-compat",
+    "max-bundle"
+};
+
+enum RTCRtcpMuxPolicy {
+    // At risk due to lack of implementers' interest.
+    "negotiate",
+    "require"
+};
+
+dictionary RTCIceServer {
+    required (DOMString or sequence<DOMString>) urls;
+             DOMString                          username;
+             DOMString /*(DOMString or RTCOAuthCredential)*/  credential;
+             RTCIceCredentialType               credentialType = "password";
+};
+
+enum RTCIceCredentialType {
+    "password",
+    "oauth"
+};