/* jshint moz:true, browser:true */ /* 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 http://mozilla.org/MPL/2.0/. */ "use strict"; const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; Cu.import("resource://gre/modules/Services.jsm"); Cu.import("resource://gre/modules/XPCOMUtils.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "PeerConnectionIdp", "resource://gre/modules/media/PeerConnectionIdp.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "convertToRTCStatsReport", "resource://gre/modules/media/RTCStatsReport.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "AppConstants", "resource://gre/modules/AppConstants.jsm"); const PC_CONTRACT = "@mozilla.org/dom/peerconnection;1"; const PC_OBS_CONTRACT = "@mozilla.org/dom/peerconnectionobserver;1"; const PC_ICE_CONTRACT = "@mozilla.org/dom/rtcicecandidate;1"; const PC_SESSION_CONTRACT = "@mozilla.org/dom/rtcsessiondescription;1"; const PC_MANAGER_CONTRACT = "@mozilla.org/dom/peerconnectionmanager;1"; const PC_STATS_CONTRACT = "@mozilla.org/dom/rtcstatsreport;1"; const PC_STATIC_CONTRACT = "@mozilla.org/dom/peerconnectionstatic;1"; const PC_SENDER_CONTRACT = "@mozilla.org/dom/rtpsender;1"; const PC_RECEIVER_CONTRACT = "@mozilla.org/dom/rtpreceiver;1"; const PC_COREQUEST_CONTRACT = "@mozilla.org/dom/createofferrequest;1"; const PC_DTMF_SENDER_CONTRACT = "@mozilla.org/dom/rtcdtmfsender;1"; const PC_CID = Components.ID("{bdc2e533-b308-4708-ac8e-a8bfade6d851}"); const PC_OBS_CID = Components.ID("{d1748d4c-7f6a-4dc5-add6-d55b7678537e}"); const PC_ICE_CID = Components.ID("{02b9970c-433d-4cc2-923d-f7028ac66073}"); const PC_SESSION_CID = Components.ID("{1775081b-b62d-4954-8ffe-a067bbf508a7}"); const PC_MANAGER_CID = Components.ID("{7293e901-2be3-4c02-b4bd-cbef6fc24f78}"); const PC_STATS_CID = Components.ID("{7fe6e18b-0da3-4056-bf3b-440ef3809e06}"); const PC_STATIC_CID = Components.ID("{0fb47c47-a205-4583-a9fc-cbadf8c95880}"); const PC_SENDER_CID = Components.ID("{4fff5d46-d827-4cd4-a970-8fd53977440e}"); const PC_RECEIVER_CID = Components.ID("{d974b814-8fde-411c-8c45-b86791b81030}"); const PC_COREQUEST_CID = Components.ID("{74b2122d-65a8-4824-aa9e-3d664cb75dc2}"); const PC_DTMF_SENDER_CID = Components.ID("{3610C242-654E-11E6-8EC0-6D1BE389A607}"); function logMsg(msg, file, line, flag, winID) { let scriptErrorClass = Cc["@mozilla.org/scripterror;1"]; let scriptError = scriptErrorClass.createInstance(Ci.nsIScriptError); scriptError.initWithWindowID(msg, file, null, line, 0, flag, "content javascript", winID); let console = Cc["@mozilla.org/consoleservice;1"]. getService(Ci.nsIConsoleService); console.logMessage(scriptError); }; let setupPrototype = (_class, dict) => { _class.prototype.classDescription = _class.name; Object.assign(_class.prototype, dict); } // Global list of PeerConnection objects, so they can be cleaned up when // a page is torn down. (Maps inner window ID to an array of PC objects). class GlobalPCList { constructor() { this._list = {}; this._networkdown = false; // XXX Need to query current state somehow this._lifecycleobservers = {}; this._nextId = 1; Services.obs.addObserver(this, "inner-window-destroyed", true); Services.obs.addObserver(this, "profile-change-net-teardown", true); Services.obs.addObserver(this, "network:offline-about-to-go-offline", true); Services.obs.addObserver(this, "network:offline-status-changed", true); Services.obs.addObserver(this, "gmp-plugin-crash", true); Services.obs.addObserver(this, "PeerConnection:response:allow", true); Services.obs.addObserver(this, "PeerConnection:response:deny", true); if (Cc["@mozilla.org/childprocessmessagemanager;1"]) { let mm = Cc["@mozilla.org/childprocessmessagemanager;1"].getService(Ci.nsIMessageListenerManager); mm.addMessageListener("gmp-plugin-crash", this); } } notifyLifecycleObservers(pc, type) { for (var key of Object.keys(this._lifecycleobservers)) { this._lifecycleobservers[key](pc, pc._winID, type); } } addPC(pc) { let winID = pc._winID; if (this._list[winID]) { this._list[winID].push(Cu.getWeakReference(pc)); } else { this._list[winID] = [Cu.getWeakReference(pc)]; } pc._globalPCListId = this._nextId++; this.removeNullRefs(winID); } findPC(globalPCListId) { for (let winId in this._list) { if (this._list.hasOwnProperty(winId)) { for (let pcref of this._list[winId]) { let pc = pcref.get(); if (pc && pc._globalPCListId == globalPCListId) { return pc; } } } } } removeNullRefs(winID) { if (this._list[winID] === undefined) { return; } this._list[winID] = this._list[winID].filter( function (e,i,a) { return e.get() !== null; }); if (this._list[winID].length === 0) { delete this._list[winID]; } } hasActivePeerConnection(winID) { this.removeNullRefs(winID); return this._list[winID] ? true : false; } handleGMPCrash(data) { let broadcastPluginCrash = function(list, winID, pluginID, pluginName) { if (list.hasOwnProperty(winID)) { list[winID].forEach(function(pcref) { let pc = pcref.get(); if (pc) { pc._pc.pluginCrash(pluginID, pluginName); } }); } }; // a plugin crashed; if it's associated with any of our PCs, fire an // event to the DOM window for (let winId in this._list) { broadcastPluginCrash(this._list, winId, data.pluginID, data.pluginName); } } receiveMessage({ name, data }) { if (name == "gmp-plugin-crash") { this.handleGMPCrash(data); } } observe(subject, topic, data) { let cleanupPcRef = function(pcref) { let pc = pcref.get(); if (pc) { pc._pc.close(); delete pc._observer; pc._pc = null; } }; let cleanupWinId = function(list, winID) { if (list.hasOwnProperty(winID)) { list[winID].forEach(cleanupPcRef); delete list[winID]; } }; if (topic == "inner-window-destroyed") { let winID = subject.QueryInterface(Ci.nsISupportsPRUint64).data; cleanupWinId(this._list, winID); if (this._lifecycleobservers.hasOwnProperty(winID)) { delete this._lifecycleobservers[winID]; } } else if (topic == "profile-change-net-teardown" || topic == "network:offline-about-to-go-offline") { // As Necko doesn't prevent us from accessing the network we still need to // monitor the network offline/online state here. See bug 1326483 this._networkdown = true; } else if (topic == "network:offline-status-changed") { if (data == "offline") { this._networkdown = true; } else if (data == "online") { this._networkdown = false; } } else if (topic == "gmp-plugin-crash") { if (subject instanceof Ci.nsIWritablePropertyBag2) { let pluginID = subject.getPropertyAsUint32("pluginID"); let pluginName = subject.getPropertyAsAString("pluginName"); let data = { pluginID, pluginName }; this.handleGMPCrash(data); } } else if (topic == "PeerConnection:response:allow" || topic == "PeerConnection:response:deny") { var pc = this.findPC(data); if (pc) { if (topic == "PeerConnection:response:allow") { pc._settlePermission.allow(); } else { let err = new pc._win.DOMException("The request is not allowed by " + "the user agent or the platform in the current context.", "NotAllowedError"); pc._settlePermission.deny(err); } } } } _registerPeerConnectionLifecycleCallback(winID, cb) { this._lifecycleobservers[winID] = cb; } } setupPrototype(GlobalPCList, { QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsIMessageListener, Ci.nsISupportsWeakReference, Ci.IPeerConnectionManager]), classID: PC_MANAGER_CID, _xpcom_factory: { createInstance: function(outer, iid) { if (outer) { throw Cr.NS_ERROR_NO_AGGREGATION; } return _globalPCList.QueryInterface(iid); } } }); var _globalPCList = new GlobalPCList(); class RTCIceCandidate { init(win) { this._win = win; } __init(dict) { Object.assign(this, dict); } } setupPrototype(RTCIceCandidate, { classID: PC_ICE_CID, contractID: PC_ICE_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, Ci.nsIDOMGlobalPropertyInitializer]) }); class RTCSessionDescription { init(win) { this._win = win; this._winID = this._win.QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID; } __init({ type, sdp }) { Object.assign(this, { _type: type, _sdp: sdp }); } get type() { return this._type; } set type(type) { this.warn(); this._type = type; } get sdp() { return this._sdp; } set sdp(sdp) { this.warn(); this._sdp = sdp; } warn() { if (!this._warned) { // Warn once per RTCSessionDescription about deprecated writable usage. this.logWarning("RTCSessionDescription's members are readonly! " + "Writing to them is deprecated and will break soon!"); this._warned = true; } } logWarning(msg) { let err = this._win.Error(); logMsg(msg, err.fileName, err.lineNumber, Ci.nsIScriptError.warningFlag, this._winID); } } setupPrototype(RTCSessionDescription, { classID: PC_SESSION_CID, contractID: PC_SESSION_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, Ci.nsIDOMGlobalPropertyInitializer]) }); class RTCStatsReport { constructor(win, dict) { this._win = win; this._pcid = dict.pcid; this._report = convertToRTCStatsReport(dict); } setInternal(aKey, aObj) { return this.__DOM_IMPL__.__set(aKey, aObj); } // TODO: Remove legacy API eventually // see Bug 1328194 // // Since maplike is recent, we still also make the stats available as legacy // enumerable read-only properties directly on our content-facing object. // Must be called after our webidl sandwich is made. makeStatsPublic(warnNullable, isLegacy) { let legacyProps = {}; for (let key in this._report) { let internal = Cu.cloneInto(this._report[key], this._win); if (isLegacy) { internal.type = this._specToLegacyFieldMapping[internal.type] || internal.type; } this.setInternal(key, internal); let value = Cu.cloneInto(this._report[key], this._win); value.type = this._specToLegacyFieldMapping[value.type] || value.type; legacyProps[key] = { enumerable: true, configurable: false, get: Cu.exportFunction(function() { if (warnNullable.warn) { warnNullable.warn(); warnNullable.warn = null; } return value; }, this.__DOM_IMPL__.wrappedJSObject) }; } Object.defineProperties(this.__DOM_IMPL__.wrappedJSObject, legacyProps); } get mozPcid() { return this._pcid; } } setupPrototype(RTCStatsReport, { classID: PC_STATS_CID, contractID: PC_STATS_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]), _specToLegacyFieldMapping: { 'inbound-rtp' : 'inboundrtp', 'outbound-rtp':'outboundrtp', 'candidate-pair':'candidatepair', 'local-candidate':'localcandidate', 'remote-candidate':'remotecandidate' } }); class RTCPeerConnection { constructor() { this._senders = []; this._receivers = []; this._pc = null; this._closed = false; this._localType = null; this._remoteType = null; // http://rtcweb-wg.github.io/jsep/#rfc.section.4.1.9 // canTrickle == null means unknown; when a remote description is received it // is set to true or false based on the presence of the "trickle" ice-option this._canTrickle = null; // States this._iceGatheringState = this._iceConnectionState = "new"; this._hasStunServer = this._hasTurnServer = false; this._iceGatheredRelayCandidates = false; // TODO: Remove legacy API eventually // see Bug 1328194 this._onGetStatsIsLegacy = false; } init(win) { this._win = win; } __init(rtcConfig) { this._winID = this._win.QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID; // TODO: Update this code once we support pc.setConfiguration, to track // setting from content independently from pref (Bug 1181768). if (rtcConfig.iceTransportPolicy == "all" && Services.prefs.getBoolPref("media.peerconnection.ice.relay_only")) { rtcConfig.iceTransportPolicy = "relay"; } this._config = Object.assign({}, rtcConfig); if (!rtcConfig.iceServers || !Services.prefs.getBoolPref("media.peerconnection.use_document_iceservers")) { try { rtcConfig.iceServers = JSON.parse(Services.prefs.getCharPref("media.peerconnection.default_iceservers") || "[]"); } catch (e) { this.logWarning( "Ignoring invalid media.peerconnection.default_iceservers in about:config"); rtcConfig.iceServers = []; } try { this._mustValidateRTCConfiguration(rtcConfig, "Ignoring invalid media.peerconnection.default_iceservers in about:config"); } catch (e) { this.logWarning(e.message); rtcConfig.iceServers = []; } } else { // This gets executed in the typical case when iceServers // are passed in through the web page. this._mustValidateRTCConfiguration(rtcConfig, "RTCPeerConnection constructor passed invalid RTCConfiguration"); } var principal = Cu.getWebIDLCallerPrincipal(); this._isChrome = Services.scriptSecurityManager.isSystemPrincipal(principal); if (_globalPCList._networkdown) { throw new this._win.DOMException( "Can't create RTCPeerConnections when the network is down", "InvalidStateError"); } this.makeGetterSetterEH("ontrack"); this.makeLegacyGetterSetterEH("onaddstream", "Use peerConnection.ontrack instead."); this.makeLegacyGetterSetterEH("onaddtrack", "Use peerConnection.ontrack instead."); this.makeGetterSetterEH("onicecandidate"); this.makeGetterSetterEH("onnegotiationneeded"); this.makeGetterSetterEH("onsignalingstatechange"); this.makeGetterSetterEH("onremovestream"); this.makeGetterSetterEH("ondatachannel"); this.makeGetterSetterEH("oniceconnectionstatechange"); this.makeGetterSetterEH("onicegatheringstatechange"); this.makeGetterSetterEH("onidentityresult"); this.makeGetterSetterEH("onpeeridentity"); this.makeGetterSetterEH("onidpassertionerror"); this.makeGetterSetterEH("onidpvalidationerror"); this._pc = new this._win.PeerConnectionImpl(); this._operationsChain = this._win.Promise.resolve(); this.__DOM_IMPL__._innerObject = this; this._observer = new this._win.PeerConnectionObserver(this.__DOM_IMPL__); var location = "" + this._win.location; // Warn just once per PeerConnection about deprecated getStats usage. this._warnDeprecatedStatsAccessNullable = { warn: () => this.logWarning("non-maplike pc.getStats access is deprecated, and will be removed in the near future! " + "See http://w3c.github.io/webrtc-pc/#getstats-example for usage.") }; this._warnDeprecatedStatsCallbacksNullable = { warn: () => this.logWarning("Callback-based pc.getStats is deprecated, and will be removed in the near future! Use promise-version! " + "See http://w3c.github.io/webrtc-pc/#getstats-example for usage.") }; // Add a reference to the PeerConnection to global list (before init). _globalPCList.addPC(this); this._impl.initialize(this._observer, this._win, rtcConfig, Services.tm.currentThread); this._certificateReady = this._initCertificate(rtcConfig.certificates); this._initIdp(); _globalPCList.notifyLifecycleObservers(this, "initialized"); } get _impl() { if (!this._pc) { throw new this._win.DOMException( "RTCPeerConnection is gone (did you enter Offline mode?)", "InvalidStateError"); } return this._pc; } getConfiguration() { return this._config; } async _initCertificate(certificates = []) { let certificate; if (certificates.length > 1) { throw new this._win.DOMException( "RTCPeerConnection does not currently support multiple certificates", "NotSupportedError"); } if (certificates.length) { certificate = certificates.find(c => c.expires > Date.now()); if (!certificate) { throw new this._win.DOMException( "Unable to create RTCPeerConnection with an expired certificate", "InvalidParameterError"); } } if (!certificate) { certificate = await this._win.RTCPeerConnection.generateCertificate({ name: "ECDSA", namedCurve: "P-256" }); } this._impl.certificate = certificate; } _resetPeerIdentityPromise() { this._peerIdentity = new this._win.Promise((resolve, reject) => { this._resolvePeerIdentity = resolve; this._rejectPeerIdentity = reject; }); } _initIdp() { this._resetPeerIdentityPromise(); this._lastIdentityValidation = this._win.Promise.resolve(); let prefName = "media.peerconnection.identity.timeout"; let idpTimeout = Services.prefs.getIntPref(prefName); this._localIdp = new PeerConnectionIdp(this._win, idpTimeout); this._remoteIdp = new PeerConnectionIdp(this._win, idpTimeout); } // Add a function to the internal operations chain. async _chain(func) { let p = (async () => { await this._operationsChain; // Don't _checkClosed() inside the chain, because it throws, and spec // behavior is to NOT reject outstanding promises on close. This is what // happens most of the time anyways, as the c++ code stops calling us once // closed, hanging the chain. However, c++ may already have queued tasks // on us, so if we're one of those then sit back. if (this._closed) { return; } return await func(); })(); // don't propagate errors in the operations chain (this is a fork of p). this._operationsChain = p.catch(() => {}); return await p; } // It's basically impossible to use async directly in JSImplemented code, // because the implicit promise must be wrapped to the right type for content. // // The _async wrapper takes care of this. The _legacy wrapper implements // legacy callbacks in a manner that produces correct line-numbers in errors, // provided that methods validate their inputs before putting themselves on // the pc's operations chain. // // These wrappers also serve as guards against settling promises past close(). _async(func) { return this._win.Promise.resolve(this._closeWrapper(func)); } _legacy(...args) { return this._win.Promise.resolve(this._legacyCloseWrapper(...args)); } _auto(onSucc, onErr, func) { return (typeof onSucc == "function") ? this._legacy(onSucc, onErr, func) : this._async(func); } async _closeWrapper(func) { let closed = this._closed; try { let result = await func(); if (!closed && this._closed) { await new Promise(() => {}); } return result; } catch (e) { if (!closed && this._closed) { await new Promise(() => {}); } throw e; } } async _legacyCloseWrapper(onSucc, onErr, func) { let wrapCallback = cb => result => { try { cb && cb(result); } catch (e) { this.logErrorAndCallOnError(e); } }; try { wrapCallback(onSucc)(await func()); } catch (e) { wrapCallback(onErr)(e); } } /** * An RTCConfiguration may look like this: * * { "iceServers": [ { urls: "stun:stun.example.org", }, * { url: "stun:stun.example.org", }, // deprecated version * { urls: ["turn:turn1.x.org", "turn:turn2.x.org"], * username:"jib", credential:"mypass"} ] } * * This function normalizes the structure of the input for rtcConfig.iceServers for us, * so we test well-formed stun/turn urls before passing along to C++. * msg - Error message to detail which array-entry failed, if any. */ _mustValidateRTCConfiguration({ iceServers }, msg) { // Normalize iceServers input iceServers.forEach(server => { if (typeof server.urls === "string") { server.urls = [server.urls]; } else if (!server.urls && server.url) { // TODO: Remove support for legacy iceServer.url eventually (Bug 1116766) server.urls = [server.url]; this.logWarning("RTCIceServer.url is deprecated! Use urls instead."); } }); let ios = Cc['@mozilla.org/network/io-service;1'].getService(Ci.nsIIOService); let nicerNewURI = uriStr => { try { return ios.newURI(uriStr); } catch (e if (e.result == Cr.NS_ERROR_MALFORMED_URI)) { throw new this._win.DOMException(msg + " - malformed URI: " + uriStr, "SyntaxError"); } }; var stunServers = 0; iceServers.forEach(({ urls, username, credential, credentialType }) => { if (!urls) { throw new this._win.DOMException(msg + " - missing urls", "InvalidAccessError"); } urls.map(url => nicerNewURI(url)).forEach(({ scheme, spec }) => { if (scheme in { turn:1, turns:1 }) { if (username == undefined) { throw new this._win.DOMException(msg + " - missing username: " + spec, "InvalidAccessError"); } if (credential == undefined) { throw new this._win.DOMException(msg + " - missing credential: " + spec, "InvalidAccessError"); } if (credentialType != "password") { this.logWarning("RTCConfiguration TURN credentialType \""+ credentialType + "\" is not yet implemented. Treating as password."+ " https://bugzil.la/1247616"); } this._hasTurnServer = true; stunServers += 1; } else if (scheme in { stun:1, stuns:1 }) { this._hasStunServer = true; stunServers += 1; } else { throw new this._win.DOMException(msg + " - improper scheme: " + scheme, "SyntaxError"); } if (scheme in { stuns:1, turns:1 }) { this.logWarning(scheme.toUpperCase() + " is not yet supported."); } if (stunServers >= 5) { this.logError("Using five or more STUN/TURN servers causes problems"); } else if (stunServers > 2) { this.logWarning("Using more than two STUN/TURN servers slows down discovery"); } }); }); } // Ideally, this should be of the form _checkState(state), // where the state is taken from an enumeration containing // the valid peer connection states defined in the WebRTC // spec. See Bug 831756. _checkClosed() { if (this._closed) { throw new this._win.DOMException("Peer connection is closed", "InvalidStateError"); } } dispatchEvent(event) { // PC can close while events are firing if there is an async dispatch // in c++ land. But let through "closed" signaling and ice connection events. if (!this._closed || this._inClose) { this.__DOM_IMPL__.dispatchEvent(event); } } // Log error message to web console and window.onerror, if present. logErrorAndCallOnError(e) { this.logMsg(e.message, e.fileName, e.lineNumber, Ci.nsIScriptError.exceptionFlag); // Safely call onerror directly if present (necessary for testing) try { if (typeof this._win.onerror === "function") { this._win.onerror(e.message, e.fileName, e.lineNumber); } } catch(e) { // If onerror itself throws, service it. try { this.logMsg(e.message, e.fileName, e.lineNumber, Ci.nsIScriptError.errorFlag); } catch(e) {} } } logError(msg) { this.logStackMsg(msg, Ci.nsIScriptError.errorFlag); } logWarning(msg) { this.logStackMsg(msg, Ci.nsIScriptError.warningFlag); } logStackMsg(msg, flag) { let err = this._win.Error(); this.logMsg(msg, err.fileName, err.lineNumber, flag); } logMsg(msg, file, line, flag) { return logMsg(msg, file, line, flag, this._winID); } getEH(type) { return this.__DOM_IMPL__.getEventHandler(type); } setEH(type, handler) { this.__DOM_IMPL__.setEventHandler(type, handler); } makeGetterSetterEH(name) { Object.defineProperty(this, name, { get:function() { return this.getEH(name); }, set:function(h) { return this.setEH(name, h); } }); } makeLegacyGetterSetterEH(name, msg) { Object.defineProperty(this, name, { get:function() { return this.getEH(name); }, set:function(h) { this.logWarning(name + " is deprecated! " + msg); return this.setEH(name, h); } }); } createOffer(optionsOrOnSucc, onErr, options) { // This entry-point handles both new and legacy call sig. Decipher which one if (typeof optionsOrOnSucc == "function") { return this._legacy(optionsOrOnSucc, onErr, () => this._createOffer(options)); } return this._async(() => this._createOffer(optionsOrOnSucc)); } async _createOffer(options) { this._checkClosed(); let origin = Cu.getWebIDLCallerPrincipal().origin; return await this._chain(async () => { let haveAssertion; if (this._localIdp.enabled) { haveAssertion = this._getIdentityAssertion(origin); } await this._getPermission(); await this._certificateReady; let sdp = await new Promise((resolve, reject) => { this._onCreateOfferSuccess = resolve; this._onCreateOfferFailure = reject; this._impl.createOffer(options); }); if (haveAssertion) { await haveAssertion; sdp = this._localIdp.addIdentityAttribute(sdp); } return Cu.cloneInto({ type: "offer", sdp }, this._win); }); } createAnswer(optionsOrOnSucc, onErr) { // This entry-point handles both new and legacy call sig. Decipher which one if (typeof optionsOrOnSucc == "function") { return this._legacy(optionsOrOnSucc, onErr, () => this._createAnswer({})); } return this._async(() => this._createAnswer(optionsOrOnSucc)); } async _createAnswer(options) { this._checkClosed(); let origin = Cu.getWebIDLCallerPrincipal().origin; return await this._chain(async () => { // We give up line-numbers in errors by doing this here, but do all // state-checks inside the chain, to support the legacy feature that // callers don't have to wait for setRemoteDescription to finish. if (!this.remoteDescription) { throw new this._win.DOMException("setRemoteDescription not called", "InvalidStateError"); } if (this.remoteDescription.type != "offer") { throw new this._win.DOMException("No outstanding offer", "InvalidStateError"); } let haveAssertion; if (this._localIdp.enabled) { haveAssertion = this._getIdentityAssertion(origin); } await this._getPermission(); await this._certificateReady; let sdp = await new Promise((resolve, reject) => { this._onCreateAnswerSuccess = resolve; this._onCreateAnswerFailure = reject; this._impl.createAnswer(); }); if (haveAssertion) { await haveAssertion; sdp = this._localIdp.addIdentityAttribute(sdp); } return Cu.cloneInto({ type: "answer", sdp }, this._win); }); } async _getPermission() { if (!this._havePermission) { let privileged = this._isChrome || AppConstants.MOZ_B2G || Services.prefs.getBoolPref("media.navigator.permission.disabled"); if (privileged) { this._havePermission = Promise.resolve(); } else { this._havePermission = new Promise((resolve, reject) => { this._settlePermission = { allow: resolve, deny: reject }; let outerId = this._win.QueryInterface(Ci.nsIInterfaceRequestor). getInterface(Ci.nsIDOMWindowUtils).outerWindowID; let chrome = new CreateOfferRequest(outerId, this._winID, this._globalPCListId, false); let request = this._win.CreateOfferRequest._create(this._win, chrome); Services.obs.notifyObservers(request, "PeerConnection:request", null); }); } } return await this._havePermission; } setLocalDescription(desc, onSucc, onErr) { return this._auto(onSucc, onErr, () => this._setLocalDescription(desc)); } async _setLocalDescription({ type, sdp }) { this._checkClosed(); this._localType = type; let action = this._actions[type]; if (action === undefined) { throw new this._win.DOMException( "Invalid type " + type + " provided to setLocalDescription", "InvalidParameterError"); } if (action == Ci.IPeerConnection.kActionPRAnswer) { throw new this._win.DOMException("pranswer not yet implemented", "NotSupportedError"); } if (!sdp && action != Ci.IPeerConnection.kActionRollback) { throw new this._win.DOMException( "Empty or null SDP provided to setLocalDescription", "InvalidParameterError"); } return await this._chain(async () => { await this._getPermission(); await new Promise((resolve, reject) => { this._onSetLocalDescriptionSuccess = resolve; this._onSetLocalDescriptionFailure = reject; this._impl.setLocalDescription(action, sdp); }); }); } async _validateIdentity(sdp, origin) { let expectedIdentity; // Only run a single identity verification at a time. We have to do this to // avoid problems with the fact that identity validation doesn't block the // resolution of setRemoteDescription(). let p = (async () => { try { await this._lastIdentityValidation; let msg = await this._remoteIdp.verifyIdentityFromSDP(sdp, origin); expectedIdentity = this._impl.peerIdentity; // If this pc has an identity already, then the identity in sdp must match if (expectedIdentity && (!msg || msg.identity !== expectedIdentity)) { this.close(); throw new this._win.DOMException( "Peer Identity mismatch, expected: " + expectedIdentity, "IncompatibleSessionDescriptionError"); } if (msg) { // Set new identity and generate an event. this._impl.peerIdentity = msg.identity; this._resolvePeerIdentity(Cu.cloneInto({ idp: this._remoteIdp.provider, name: msg.identity }, this._win)); } } catch(e) { this._rejectPeerIdentity(e); // If we don't expect a specific peer identity, failure to get a valid // peer identity is not a terminal state, so replace the promise to // allow another attempt. if (!this._impl.peerIdentity) { this._resetPeerIdentityPromise(); } throw e; } })(); this._lastIdentityValidation = p.catch(() => {}); // Only wait for IdP validation if we need identity matching if (expectedIdentity) { await p; } } setRemoteDescription(desc, onSucc, onErr) { return this._auto(onSucc, onErr, () => this._setRemoteDescription(desc)); } async _setRemoteDescription({ type, sdp }) { this._checkClosed(); this._remoteType = type; let action = this._actions[type]; if (action === undefined) { throw new this._win.DOMException( "Invalid type " + type + " provided to setRemoteDescription", "InvalidParameterError"); } if (action == Ci.IPeerConnection.kActionPRAnswer) { throw new this._win.DOMException("pranswer not yet implemented", "NotSupportedError"); } if (!sdp && type != "rollback") { throw new this._win.DOMException( "Empty or null SDP provided to setRemoteDescription", "InvalidParameterError"); } // Get caller's origin before hitting the promise chain let origin = Cu.getWebIDLCallerPrincipal().origin; return await this._chain(async () => { let haveSetRemote = (async () => { await this._getPermission(); await new Promise((resolve, reject) => { this._onSetRemoteDescriptionSuccess = resolve; this._onSetRemoteDescriptionFailure = reject; this._impl.setRemoteDescription(action, sdp); }); this._updateCanTrickle(); })(); if (action != Ci.IPeerConnection.kActionRollback) { // Do setRemoteDescription and identity validation in parallel await this._validateIdentity(sdp, origin); } await haveSetRemote; }); } setIdentityProvider(provider, protocol, username) { this._checkClosed(); this._localIdp.setIdentityProvider(provider, protocol, username); } async _getIdentityAssertion(origin) { await this._certificateReady; return await this._localIdp.getIdentityAssertion(this._impl.fingerprint, origin); } getIdentityAssertion() { this._checkClosed(); let origin = Cu.getWebIDLCallerPrincipal().origin; return this._win.Promise.resolve(this._chain(() => this._getIdentityAssertion(origin))); } get canTrickleIceCandidates() { return this._canTrickle; } _updateCanTrickle() { let containsTrickle = section => { let lines = section.toLowerCase().split(/(?:\r\n?|\n)/); return lines.some(line => { let prefix = "a=ice-options:"; if (line.substring(0, prefix.length) !== prefix) { return false; } let tokens = line.substring(prefix.length).split(" "); return tokens.some(x => x === "trickle"); }); }; let desc = null; try { // The getter for remoteDescription can throw if the pc is closed. desc = this.remoteDescription; } catch (e) {} if (!desc) { this._canTrickle = null; return; } let sections = desc.sdp.split(/(?:\r\n?|\n)m=/); let topSection = sections.shift(); this._canTrickle = containsTrickle(topSection) || sections.every(containsTrickle); } // TODO: Implement processing for end-of-candidates (bug 1318167) addIceCandidate(cand, onSucc, onErr) { return this._auto(onSucc, onErr, () => cand && this._addIceCandidate(cand)); } async _addIceCandidate({ candidate, sdpMid, sdpMLineIndex }) { this._checkClosed(); if (sdpMid === null && sdpMLineIndex === null) { throw new this._win.DOMException( "Invalid candidate (both sdpMid and sdpMLineIndex are null).", "TypeError"); } return await this._chain(() => { if (!this.remoteDescription) { throw new this._win.DOMException( "setRemoteDescription needs to called before addIceCandidate", "InvalidStateError"); } return new Promise((resolve, reject) => { this._onAddIceCandidateSuccess = resolve; this._onAddIceCandidateError = reject; this._impl.addIceCandidate(candidate, sdpMid || "", sdpMLineIndex); }); }); } addStream(stream) { stream.getTracks().forEach(track => this.addTrack(track, stream)); } addTrack(track, stream) { if (stream.currentTime === undefined) { throw new this._win.DOMException("invalid stream.", "InvalidParameterError"); } this._checkClosed(); this._senders.forEach(sender => { if (sender.track == track) { throw new this._win.DOMException("already added.", "InvalidParameterError"); } }); this._impl.addTrack(track, stream); let sender = this._win.RTCRtpSender._create(this._win, new RTCRtpSender(this, track, stream)); this._senders.push(sender); return sender; } removeTrack(sender) { this._checkClosed(); var i = this._senders.indexOf(sender); if (i >= 0) { this._senders.splice(i, 1); this._impl.removeTrack(sender.track); // fires negotiation needed } } _insertDTMF(sender, tones, duration, interToneGap) { return this._impl.insertDTMF(sender.__DOM_IMPL__, tones, duration, interToneGap); } _getDTMFToneBuffer(sender) { return this._impl.getDTMFToneBuffer(sender.__DOM_IMPL__); } async _replaceTrack(sender, withTrack) { this._checkClosed(); return await this._chain(() => new Promise((resolve, reject) => { this._onReplaceTrackSender = sender; this._onReplaceTrackWithTrack = withTrack; this._onReplaceTrackSuccess = resolve; this._onReplaceTrackFailure = reject; this._impl.replaceTrack(sender.track, withTrack); })); } _setParameters({ track }, parameters) { if (!Services.prefs.getBoolPref("media.peerconnection.simulcast")) { return; } // validate parameters input var encodings = parameters.encodings || []; encodings.reduce((uniqueRids, { rid, scaleResolutionDownBy }) => { if (scaleResolutionDownBy < 1.0) { throw new this._win.RangeError("scaleResolutionDownBy must be >= 1.0"); } if (!rid && encodings.length > 1) { throw new this._win.DOMException("Missing rid", "TypeError"); } if (uniqueRids[rid]) { throw new this._win.DOMException("Duplicate rid", "TypeError"); } uniqueRids[rid] = true; return uniqueRids; }, {}); this._impl.setParameters(track, parameters); } _getParameters({ track }) { if (!Services.prefs.getBoolPref("media.peerconnection.simulcast")) { return; } return this._impl.getParameters(track); } close() { if (this._closed) { return; } this._closed = true; this._inClose = true; this.changeIceConnectionState("closed"); this._localIdp.close(); this._remoteIdp.close(); this._impl.close(); this._inClose = false; } getLocalStreams() { this._checkClosed(); return this._impl.getLocalStreams(); } getRemoteStreams() { this._checkClosed(); return this._impl.getRemoteStreams(); } getSenders() { return this._senders; } getReceivers() { return this._receivers; } mozSelectSsrc(receiver, ssrcIndex) { this._impl.selectSsrc(receiver.track, ssrcIndex); } get localDescription() { this._checkClosed(); let sdp = this._impl.localDescription; if (sdp.length == 0) { return null; } return new this._win.RTCSessionDescription({ type: this._localType, sdp }); } get remoteDescription() { this._checkClosed(); let sdp = this._impl.remoteDescription; if (sdp.length == 0) { return null; } return new this._win.RTCSessionDescription({ type: this._remoteType, sdp }); } get peerIdentity() { return this._peerIdentity; } get idpLoginUrl() { return this._localIdp.idpLoginUrl; } get id() { return this._impl.id; } set id(s) { this._impl.id = s; } get iceGatheringState() { return this._iceGatheringState; } get iceConnectionState() { return this._iceConnectionState; } get signalingState() { // checking for our local pc closed indication // before invoking the pc methods. if (this._closed) { return "closed"; } return { "SignalingInvalid": "", "SignalingStable": "stable", "SignalingHaveLocalOffer": "have-local-offer", "SignalingHaveRemoteOffer": "have-remote-offer", "SignalingHaveLocalPranswer": "have-local-pranswer", "SignalingHaveRemotePranswer": "have-remote-pranswer", "SignalingClosed": "closed" }[this._impl.signalingState]; } changeIceGatheringState(state) { this._iceGatheringState = state; _globalPCList.notifyLifecycleObservers(this, "icegatheringstatechange"); this.dispatchEvent(new this._win.Event("icegatheringstatechange")); } changeIceConnectionState(state) { if (state != this._iceConnectionState) { this._iceConnectionState = state; _globalPCList.notifyLifecycleObservers(this, "iceconnectionstatechange"); this.dispatchEvent(new this._win.Event("iceconnectionstatechange")); } } getStats(selector, onSucc, onErr) { let isLegacy = (typeof onSucc) == "function"; if (isLegacy && this._warnDeprecatedStatsCallbacksNullable.warn) { this._warnDeprecatedStatsCallbacksNullable.warn(); this._warnDeprecatedStatsCallbacksNullable.warn = null; } return this._auto(onSucc, onErr, () => this._getStats(selector, isLegacy)); } async _getStats(selector, isLegacy) { // getStats is allowed even in closed state. return await this._chain(() => new Promise((resolve, reject) => { this._onGetStatsIsLegacy = isLegacy; this._onGetStatsSuccess = resolve; this._onGetStatsFailure = reject; this._impl.getStats(selector); })); } createDataChannel(label, { maxRetransmits, ordered, negotiated, id = 0xFFFF, maxRetransmitTime, maxPacketLifeTime = maxRetransmitTime, protocol } = {}) { this._checkClosed(); if (maxRetransmitTime !== undefined) { this.logWarning("Use maxPacketLifeTime instead of deprecated maxRetransmitTime which will stop working soon in createDataChannel!"); } if (maxPacketLifeTime !== undefined && maxRetransmits !== undefined) { throw new this._win.DOMException( "Both maxPacketLifeTime and maxRetransmits cannot be provided", "InvalidParameterError"); } // Must determine the type where we still know if entries are undefined. let type; if (maxPacketLifeTime) { type = Ci.IPeerConnection.kDataChannelPartialReliableTimed; } else if (maxRetransmits) { type = Ci.IPeerConnection.kDataChannelPartialReliableRexmit; } else { type = Ci.IPeerConnection.kDataChannelReliable; } // Synchronous since it doesn't block. return this._impl.createDataChannel(label, protocol, type, ordered, maxPacketLifeTime, maxRetransmits, negotiated, id); } } setupPrototype(RTCPeerConnection, { classID: PC_CID, contractID: PC_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, Ci.nsIDOMGlobalPropertyInitializer]), _actions: { offer: Ci.IPeerConnection.kActionOffer, answer: Ci.IPeerConnection.kActionAnswer, pranswer: Ci.IPeerConnection.kActionPRAnswer, rollback: Ci.IPeerConnection.kActionRollback, answer: Ci.IPeerConnection.kActionAnswer, }, }); // This is a separate class because we don't want to expose it to DOM. class PeerConnectionObserver { init(win) { this._win = win; } __init(dompc) { this._dompc = dompc._innerObject; } newError(message, code) { // These strings must match those defined in the WebRTC spec. const reasonName = [ "", "InternalError", "InvalidCandidateError", "InvalidParameterError", "InvalidStateError", "InvalidSessionDescriptionError", "IncompatibleSessionDescriptionError", "InternalError", "IncompatibleMediaStreamTrackError", "InternalError" ]; let name = reasonName[Math.min(code, reasonName.length - 1)]; return new this._dompc._win.DOMException(message, name); } dispatchEvent(event) { this._dompc.dispatchEvent(event); } onCreateOfferSuccess(sdp) { this._dompc._onCreateOfferSuccess(sdp); } onCreateOfferError(code, message) { this._dompc._onCreateOfferFailure(this.newError(message, code)); } onCreateAnswerSuccess(sdp) { this._dompc._onCreateAnswerSuccess(sdp); } onCreateAnswerError(code, message) { this._dompc._onCreateAnswerFailure(this.newError(message, code)); } onSetLocalDescriptionSuccess() { this._dompc._onSetLocalDescriptionSuccess(); } onSetRemoteDescriptionSuccess() { this._dompc._onSetRemoteDescriptionSuccess(); } onSetLocalDescriptionError(code, message) { this._localType = null; this._dompc._onSetLocalDescriptionFailure(this.newError(message, code)); } onSetRemoteDescriptionError(code, message) { this._remoteType = null; this._dompc._onSetRemoteDescriptionFailure(this.newError(message, code)); } onAddIceCandidateSuccess() { this._dompc._onAddIceCandidateSuccess(); } onAddIceCandidateError(code, message) { this._dompc._onAddIceCandidateError(this.newError(message, code)); } onIceCandidate(sdpMLineIndex, sdpMid, candidate) { let win = this._dompc._win; if (candidate) { if (candidate.includes(" typ relay ")) { this._dompc._iceGatheredRelayCandidates = true; } candidate = new win.RTCIceCandidate({ candidate, sdpMid, sdpMLineIndex }); } else { candidate = null; } this.dispatchEvent(new win.RTCPeerConnectionIceEvent("icecandidate", { candidate })); } onNegotiationNeeded() { this.dispatchEvent(new this._win.Event("negotiationneeded")); } // This method is primarily responsible for updating iceConnectionState. // This state is defined in the WebRTC specification as follows: // // iceConnectionState: // ------------------- // new Any of the RTCIceTransports are in the new state and none // of them are in the checking, failed or disconnected state. // // checking Any of the RTCIceTransports are in the checking state and // none of them are in the failed or disconnected state. // // connected All RTCIceTransports are in the connected, completed or // closed state and at least one of them is in the connected // state. // // completed All RTCIceTransports are in the completed or closed state // and at least one of them is in the completed state. // // failed Any of the RTCIceTransports are in the failed state. // // disconnected Any of the RTCIceTransports are in the disconnected state // and none of them are in the failed state. // // closed All of the RTCIceTransports are in the closed state. handleIceConnectionStateChange(iceConnectionState) { let pc = this._dompc; if (pc.iceConnectionState === iceConnectionState) { return; } if (pc.iceConnectionState === 'new') { var checking_histogram = Services.telemetry.getHistogramById("WEBRTC_ICE_CHECKING_RATE"); if (iceConnectionState === 'checking') { checking_histogram.add(true); } else if (iceConnectionState === 'failed') { checking_histogram.add(false); } } else if (pc.iceConnectionState === 'checking') { var success_histogram = Services.telemetry.getHistogramById("WEBRTC_ICE_SUCCESS_RATE"); if (iceConnectionState === 'completed' || iceConnectionState === 'connected') { success_histogram.add(true); } else if (iceConnectionState === 'failed') { success_histogram.add(false); } } if (iceConnectionState === 'failed') { if (!pc._hasStunServer) { pc.logError("ICE failed, add a STUN server and see about:webrtc for more details"); } else if (!pc._hasTurnServer) { pc.logError("ICE failed, add a TURN server and see about:webrtc for more details"); } else if (pc._hasTurnServer && !pc._iceGatheredRelayCandidates) { pc.logError("ICE failed, your TURN server appears to be broken, see about:webrtc for more details"); } else { pc.logError("ICE failed, see about:webrtc for more details"); } } pc.changeIceConnectionState(iceConnectionState); } // This method is responsible for updating iceGatheringState. This // state is defined in the WebRTC specification as follows: // // iceGatheringState: // ------------------ // new The object was just created, and no networking has occurred // yet. // // gathering The ICE agent is in the process of gathering candidates for // this RTCPeerConnection. // // complete The ICE agent has completed gathering. Events such as adding // a new interface or a new TURN server will cause the state to // go back to gathering. // handleIceGatheringStateChange(gatheringState) { let pc = this._dompc; if (pc.iceGatheringState === gatheringState) { return; } pc.changeIceGatheringState(gatheringState); } onStateChange(state) { switch (state) { case "SignalingState": this.dispatchEvent(new this._win.Event("signalingstatechange")); break; case "IceConnectionState": this.handleIceConnectionStateChange(this._dompc._pc.iceConnectionState); break; case "IceGatheringState": this.handleIceGatheringStateChange(this._dompc._pc.iceGatheringState); break; case "SdpState": // No-op break; case "ReadyState": // No-op break; case "SipccState": // No-op break; default: this._dompc.logWarning("Unhandled state type: " + state); break; } } onGetStatsSuccess(dict) { let pc = this._dompc; let chromeobj = new RTCStatsReport(pc._win, dict); let webidlobj = pc._win.RTCStatsReport._create(pc._win, chromeobj); chromeobj.makeStatsPublic(pc._warnDeprecatedStatsCallbacksNullable && pc._warnDeprecatedStatsAccessNullable, pc._onGetStatsIsLegacy); pc._onGetStatsSuccess(webidlobj); } onGetStatsError(code, message) { this._dompc._onGetStatsFailure(this.newError(message, code)); } onAddStream(stream) { let ev = new this._dompc._win.MediaStreamEvent("addstream", { stream }); this.dispatchEvent(ev); } onRemoveStream(stream) { this.dispatchEvent(new this._dompc._win.MediaStreamEvent("removestream", { stream })); } onAddTrack(track, streams) { let pc = this._dompc; let receiver = pc._win.RTCRtpReceiver._create(pc._win, new RTCRtpReceiver(this, track)); pc._receivers.push(receiver); let ev = new pc._win.RTCTrackEvent("track", { receiver, track, streams }); this.dispatchEvent(ev); // Fire legacy event as well for a little bit. ev = new pc._win.MediaStreamTrackEvent("addtrack", { track }); this.dispatchEvent(ev); } onRemoveTrack(track) { let pc = this._dompc; let i = pc._receivers.findIndex(receiver => receiver.track == track); if (i >= 0) { pc._receivers.splice(i, 1); } } onReplaceTrackSuccess() { var pc = this._dompc; pc._onReplaceTrackSender.track = pc._onReplaceTrackWithTrack; pc._onReplaceTrackWithTrack = null; pc._onReplaceTrackSender = null; pc._onReplaceTrackSuccess(); } onReplaceTrackError(code, message) { var pc = this._dompc; pc._onReplaceTrackWithTrack = null; pc._onReplaceTrackSender = null; pc._onReplaceTrackFailure(this.newError(message, code)); } notifyDataChannel(channel) { this.dispatchEvent(new this._dompc._win.RTCDataChannelEvent("datachannel", { channel })); } onDTMFToneChange(trackId, tone) { var pc = this._dompc; var sender = pc._senders.find(({track}) => track.id == trackId); sender.dtmf.dispatchEvent(new pc._win.RTCDTMFToneChangeEvent("tonechange", { tone })); } } setupPrototype(PeerConnectionObserver, { classID: PC_OBS_CID, contractID: PC_OBS_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, Ci.nsIDOMGlobalPropertyInitializer]) }); class RTCPeerConnectionStatic { init(win) { this._winID = win.QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID; } registerPeerConnectionLifecycleCallback(cb) { _globalPCList._registerPeerConnectionLifecycleCallback(this._winID, cb); } } setupPrototype(RTCPeerConnectionStatic, { classID: PC_STATIC_CID, contractID: PC_STATIC_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, Ci.nsIDOMGlobalPropertyInitializer]) }); class RTCDTMFSender { constructor(sender) { this._sender = sender; } get toneBuffer() { return this._sender._pc._getDTMFToneBuffer(this._sender); } get ontonechange() { return this.__DOM_IMPL__.getEventHandler("ontonechange"); } set ontonechange(handler) { this.__DOM_IMPL__.setEventHandler("ontonechange", handler); } insertDTMF(tones, duration, interToneGap) { this._sender._pc._checkClosed(); if (this._sender._pc._senders.indexOf(this._sender.__DOM_IMPL__) == -1) { throw new this._sender._pc._win.DOMException("RTCRtpSender is stopped", "InvalidStateError"); } duration = Math.max(40, Math.min(duration, 6000)); if (interToneGap < 30) interToneGap = 30; tones = tones.toUpperCase(); if (tones.match(/[^0-9A-D#*,]/)) { throw new this._sender._pc._win.DOMException("Invalid DTMF characters", "InvalidCharacterError"); } this._sender._pc._insertDTMF(this._sender, tones, duration, interToneGap); } } setupPrototype(RTCDTMFSender, { classID: PC_DTMF_SENDER_CID, contractID: PC_DTMF_SENDER_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) }); class RTCRtpSender { constructor(pc, track, stream) { let dtmf = pc._win.RTCDTMFSender._create(pc._win, new RTCDTMFSender(this)); Object.assign(this, { _pc: pc, track, _stream: stream, dtmf }); } replaceTrack(withTrack) { return this._pc._async(() => this._pc._replaceTrack(this, withTrack)); } setParameters(parameters) { return this._pc._win.Promise.resolve() .then(() => this._pc._setParameters(this, parameters)); } getParameters() { return this._pc._getParameters(this); } } setupPrototype(RTCRtpSender, { classID: PC_SENDER_CID, contractID: PC_SENDER_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) }); class RTCRtpReceiver { constructor(pc, track) { Object.assign(this, { _pc: pc, track }); } } setupPrototype(RTCRtpReceiver, { classID: PC_RECEIVER_CID, contractID: PC_RECEIVER_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) }); class CreateOfferRequest { constructor(windowID, innerWindowID, callID, isSecure) { Object.assign(this, { windowID, innerWindowID, callID, isSecure }); } } setupPrototype(CreateOfferRequest, { classID: PC_COREQUEST_CID, contractID: PC_COREQUEST_CONTRACT, QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) }); this.NSGetFactory = XPCOMUtils.generateNSGetFactory( [GlobalPCList, RTCDTMFSender, RTCIceCandidate, RTCSessionDescription, RTCPeerConnection, RTCPeerConnectionStatic, RTCRtpReceiver, RTCRtpSender, RTCStatsReport, PeerConnectionObserver, CreateOfferRequest] );