From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- dom/media/PeerConnection.sys.mjs | 2022 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 2022 insertions(+) create mode 100644 dom/media/PeerConnection.sys.mjs (limited to 'dom/media/PeerConnection.sys.mjs') diff --git a/dom/media/PeerConnection.sys.mjs b/dom/media/PeerConnection.sys.mjs new file mode 100644 index 0000000000..adb9cc3ba3 --- /dev/null +++ b/dom/media/PeerConnection.sys.mjs @@ -0,0 +1,2022 @@ +/* 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/. */ + +const lazy = {}; +ChromeUtils.defineESModuleGetters(lazy, { + PeerConnectionIdp: "resource://gre/modules/media/PeerConnectionIdp.sys.mjs", +}); + +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_STATIC_CONTRACT = "@mozilla.org/dom/peerconnectionstatic;1"; +const PC_COREQUEST_CONTRACT = "@mozilla.org/dom/createofferrequest;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_STATIC_CID = Components.ID("{0fb47c47-a205-4583-a9fc-cbadf8c95880}"); +const PC_COREQUEST_CID = Components.ID( + "{74b2122d-65a8-4824-aa9e-3d664cb75dc2}" +); + +function logMsg(msg, file, line, flag, winID) { + let scriptErrorClass = Cc["@mozilla.org/scripterror;1"]; + let scriptError = scriptErrorClass.createInstance(Ci.nsIScriptError); + scriptError.initWithWindowID( + `WebRTC: ${msg}`, + file, + null, + line, + 0, + flag, + "content javascript", + winID + ); + Services.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). +export 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 (Services.cpmm) { + Services.cpmm.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; + } + } + } + } + return null; + } + + 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]; + } + } + + 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._suppressEvents = true; + pc.close(); + } + }; + + 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: ChromeUtils.generateQI([ + "nsIObserver", + "nsISupportsWeakReference", + ]), + classID: PC_MANAGER_CID, +}); + +var _globalPCList = new GlobalPCList(); + +export class RTCIceCandidate { + init(win) { + this._win = win; + } + + __init(dict) { + if (dict.sdpMid == null && dict.sdpMLineIndex == null) { + throw new this._win.TypeError( + "Either sdpMid or sdpMLineIndex must be specified" + ); + } + Object.assign(this, dict); + } +} + +setupPrototype(RTCIceCandidate, { + classID: PC_ICE_CID, + contractID: PC_ICE_CONTRACT, + QueryInterface: ChromeUtils.generateQI(["nsIDOMGlobalPropertyInitializer"]), +}); + +export class RTCSessionDescription { + init(win) { + this._win = win; + this._winID = this._win.windowGlobalChild.innerWindowId; + } + + __init({ type, sdp }) { + if (!type) { + throw new this._win.TypeError( + "Missing required 'type' member of RTCSessionDescriptionInit" + ); + } + 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: ChromeUtils.generateQI(["nsIDOMGlobalPropertyInitializer"]), +}); + +// Records PC related telemetry +class PeerConnectionTelemetry { + // ICE connection state enters connected or completed. + recordConnected() { + Services.telemetry.scalarAdd("webrtc.peerconnection.connected", 1); + this.recordConnected = () => {}; + } + // DataChannel is created + _recordDataChannelCreated() { + Services.telemetry.scalarAdd( + "webrtc.peerconnection.datachannel_created", + 1 + ); + this._recordDataChannelCreated = () => {}; + } + // DataChannel initialized with maxRetransmitTime + _recordMaxRetransmitTime(maxRetransmitTime) { + if (maxRetransmitTime === undefined) { + return false; + } + Services.telemetry.scalarAdd( + "webrtc.peerconnection.datachannel_max_retx_used", + 1 + ); + this._recordMaxRetransmitTime = () => true; + return true; + } + // DataChannel initialized with maxPacketLifeTime + _recordMaxPacketLifeTime(maxPacketLifeTime) { + if (maxPacketLifeTime === undefined) { + return false; + } + Services.telemetry.scalarAdd( + "webrtc.peerconnection.datachannel_max_life_used", + 1 + ); + this._recordMaxPacketLifeTime = () => true; + return true; + } + // DataChannel initialized + recordDataChannelInit(maxRetransmitTime, maxPacketLifeTime) { + const retxUsed = this._recordMaxRetransmitTime(maxRetransmitTime); + if (this._recordMaxPacketLifeTime(maxPacketLifeTime) && retxUsed) { + Services.telemetry.scalarAdd( + "webrtc.peerconnection.datachannel_max_retx_and_life_used", + 1 + ); + this.recordDataChannelInit = () => {}; + } + this._recordDataChannelCreated(); + } +} + +export class RTCPeerConnection { + constructor() { + this._pc = null; + this._closed = false; + + // 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; + + // So we can record telemetry on state transitions + this._iceConnectionState = "new"; + + this._hasStunServer = this._hasTurnServer = false; + this._iceGatheredRelayCandidates = false; + // Records telemetry + this._pcTelemetry = new PeerConnectionTelemetry(); + } + + init(win) { + this._win = win; + } + + // Pref-based overrides; will _not_ be reflected in getConfiguration + _applyPrefsToConfig(rtcConfig) { + if ( + rtcConfig.iceTransportPolicy == "all" && + Services.prefs.getBoolPref("media.peerconnection.ice.relay_only") + ) { + rtcConfig.iceTransportPolicy = "relay"; + } + + 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._validateIceServers( + rtcConfig.iceServers, + "Ignoring invalid media.peerconnection.default_iceservers in about:config" + ); + } catch (e) { + this.logWarning(e.message); + rtcConfig.iceServers = []; + } + } + } + + _validateConfig(rtcConfig) { + if ("sdpSemantics" in rtcConfig) { + if (rtcConfig.sdpSemantics == "plan-b") { + this.logWarning( + `Outdated and non-standard {sdpSemantics: "plan-b"} is not ` + + `supported! WebRTC may be unreliable. Please update code to ` + + `follow standard "unified-plan".` + ); + } + // Don't let it show up in getConfiguration. + delete rtcConfig.sdpSemantics; + } + + if (this._config) { + // certificates must match + if (rtcConfig.certificates.length != this._config.certificates.length) { + throw new this._win.DOMException( + "Cannot change certificates with setConfiguration (length differs)", + "InvalidModificationError" + ); + } + for (let i = 0; i < rtcConfig.certificates.length; i++) { + if (rtcConfig.certificates[i] != this._config.certificates[i]) { + throw new this._win.DOMException( + `Cannot change certificates with setConfiguration ` + + `(cert at index ${i} differs)`, + "InvalidModificationError" + ); + } + } + + // bundlePolicy must match + if (rtcConfig.bundlePolicy != this._config.bundlePolicy) { + throw new this._win.DOMException( + "Cannot change bundlePolicy with setConfiguration", + "InvalidModificationError" + ); + } + + // peerIdentity must match + if ( + rtcConfig.peerIdentity && + rtcConfig.peerIdentity != this._config.peerIdentity + ) { + throw new this._win.DOMException( + "Cannot change peerIdentity with setConfiguration", + "InvalidModificationError" + ); + } + + // TODO (bug 1339203): rtcpMuxPolicy must match + // TODO (bug 1529398): iceCandidatePoolSize must match if sLD has ever + // been called. + } + + // This gets executed in the typical case when iceServers + // are passed in through the web page. + this._validateIceServers( + rtcConfig.iceServers, + "RTCPeerConnection constructor passed invalid RTCConfiguration" + ); + } + + _checkIfIceRestartRequired(rtcConfig) { + if (this._config) { + if (rtcConfig.iceTransportPolicy != this._config.iceTransportPolicy) { + this._pc.restartIceNoRenegotiationNeeded(); + return; + } + if ( + JSON.stringify(this._config.iceServers) != + JSON.stringify(rtcConfig.iceServers) + ) { + this._pc.restartIceNoRenegotiationNeeded(); + } + } + } + + __init(rtcConfig) { + this._winID = this._win.windowGlobalChild.innerWindowId; + let certificates = rtcConfig.certificates || []; + + if (certificates.some(c => c.expires <= Date.now())) { + throw new this._win.DOMException( + "Unable to create RTCPeerConnection with an expired certificate", + "InvalidAccessError" + ); + } + + // TODO(bug 1531875): Check origin of certs + + // TODO(bug 1176518): Remove this code once we support multiple certs + let certificate; + if (certificates.length == 1) { + certificate = certificates[0]; + } else if (certificates.length) { + throw new this._win.DOMException( + "RTCPeerConnection does not currently support multiple certificates", + "NotSupportedError" + ); + } + + this._documentPrincipal = Cu.getWebIDLCallerPrincipal(); + + 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("ondatachannel"); + this.makeGetterSetterEH("oniceconnectionstatechange"); + this.makeGetterSetterEH("onicegatheringstatechange"); + this.makeGetterSetterEH("onconnectionstatechange"); + this.makeGetterSetterEH("onidentityresult"); + this.makeGetterSetterEH("onpeeridentity"); + this.makeGetterSetterEH("onidpassertionerror"); + this.makeGetterSetterEH("onidpvalidationerror"); + + this._pc = new this._win.PeerConnectionImpl(); + + this.__DOM_IMPL__._innerObject = this; + const observer = new this._win.PeerConnectionObserver(this.__DOM_IMPL__); + + // Add a reference to the PeerConnection to global list (before init). + _globalPCList.addPC(this); + + this._pc.initialize(observer, this._win); + + this.setConfiguration(rtcConfig); + + this._certificateReady = this._initCertificate(certificate); + this._initIdp(); + _globalPCList.notifyLifecycleObservers(this, "initialized"); + } + + getConfiguration() { + const config = Object.assign({}, this._config); + delete config.sdpSemantics; + return config; + } + + setConfiguration(rtcConfig) { + this._checkClosed(); + this._validateConfig(rtcConfig); + this._checkIfIceRestartRequired(rtcConfig); + + // Allow prefs to tweak these settings before passing to c++, but hide all + // of that from JS. + const configWithPrefTweaks = Object.assign({}, rtcConfig); + this._applyPrefsToConfig(configWithPrefTweaks); + this._pc.setConfiguration(configWithPrefTweaks); + + this._config = Object.assign({}, rtcConfig); + } + + async _initCertificate(certificate) { + if (!certificate) { + certificate = await this._win.RTCPeerConnection.generateCertificate({ + name: "ECDSA", + namedCurve: "P-256", + }); + } + this._pc.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 lazy.PeerConnectionIdp(this._win, idpTimeout); + this._remoteIdp = new lazy.PeerConnectionIdp(this._win, idpTimeout); + } + + // Add a function to the internal operations chain. + + _chain(operation) { + return this._pc.chain(operation); + } + + // 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); + } + } + + // This implements the fairly common "Queue a task" logic + async _queueTaskWithClosedCheck(func) { + const pc = this; + return new this._win.Promise((resolve, reject) => { + Services.tm.dispatchToMainThread({ + run() { + try { + if (!pc._closed) { + func(); + resolve(); + } + } catch (e) { + reject(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. + */ + _validateIceServers(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 nicerNewURI = uriStr => { + try { + return Services.io.newURI(uriStr); + } catch (e) { + if (e.result == Cr.NS_ERROR_MALFORMED_URI) { + throw new this._win.DOMException( + `${msg} - malformed URI: ${uriStr}`, + "SyntaxError" + ); + } + throw e; + } + }; + + var stunServers = 0; + + iceServers.forEach(({ urls, username, credential, credentialType }) => { + if (!urls) { + // TODO: Remove once url is deprecated (Bug 1369563) + throw new this._win.TypeError( + "Missing required 'urls' member of RTCIceServer" + ); + } + if (!urls.length) { + throw new this._win.DOMException( + `${msg} - urls is empty`, + "SyntaxError" + ); + } + urls + .map(url => nicerNewURI(url)) + .forEach(({ scheme, spec, query }) => { + if (scheme in { turn: 1, turns: 1 }) { + if (username == undefined) { + throw new this._win.DOMException( + `${msg} - missing username: ${spec}`, + "InvalidAccessError" + ); + } + if (username.length > 512) { + throw new this._win.DOMException( + `${msg} - username longer then 512 bytes: ${username}`, + "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; + // If this is not a TURN TCP/TLS server, it is also a STUN server + const parameters = query.split("&"); + if (!parameters.includes("transport=tcp")) { + this._hasStunServer = 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 }) { + 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._suppressEvents) { + 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.errorFlag + ); + + // 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() { + return this.getEH(name); + }, + set(h) { + this.setEH(name, h); + }, + }); + } + + makeLegacyGetterSetterEH(name, msg) { + Object.defineProperty(this, name, { + get() { + return this.getEH(name); + }, + set(h) { + this.logWarning(name + " is deprecated! " + msg); + this.setEH(name, h); + }, + }); + } + + createOffer(optionsOrOnSucc, onErr, options) { + let onSuccess = null; + if (typeof optionsOrOnSucc == "function") { + onSuccess = optionsOrOnSucc; + } else { + options = optionsOrOnSucc; + } + // This entry-point handles both new and legacy call sig. Decipher which one + if (onSuccess) { + return this._legacy(onSuccess, onErr, () => this._createOffer(options)); + } + return this._async(() => this._createOffer(options)); + } + + // Ensures that we have at least one transceiver of |kind| that is + // configured to receive. It will create one if necessary. + _ensureOfferToReceive(kind) { + let hasRecv = this.getTransceivers().some( + transceiver => + transceiver.getKind() == kind && + (transceiver.direction == "sendrecv" || + transceiver.direction == "recvonly") && + !transceiver.stopped + ); + + if (!hasRecv) { + this._addTransceiverNoEvents(kind, { direction: "recvonly" }); + } + } + + // Handles offerToReceiveAudio/Video + _ensureTransceiversForOfferToReceive(options) { + if (options.offerToReceiveAudio) { + this._ensureOfferToReceive("audio"); + } + + if (options.offerToReceiveVideo) { + this._ensureOfferToReceive("video"); + } + + this.getTransceivers() + .filter(transceiver => { + return ( + (options.offerToReceiveVideo === false && + transceiver.receiver.track.kind == "video") || + (options.offerToReceiveAudio === false && + transceiver.receiver.track.kind == "audio") + ); + }) + .forEach(transceiver => { + if (transceiver.direction == "sendrecv") { + transceiver.setDirectionInternal("sendonly"); + } else if (transceiver.direction == "recvonly") { + transceiver.setDirectionInternal("inactive"); + } + }); + } + + _createOffer(options) { + this._checkClosed(); + this._ensureTransceiversForOfferToReceive(options); + return this._chain(() => this._createAnOffer(options)); + } + + async _createAnOffer(options = {}) { + switch (this.signalingState) { + case "stable": + case "have-local-offer": + break; + default: + throw new this._win.DOMException( + `Cannot create offer in ${this.signalingState}`, + "InvalidStateError" + ); + } + let haveAssertion; + if (this._localIdp.enabled) { + haveAssertion = this._getIdentityAssertion(); + } + await this._getPermission(); + await this._certificateReady; + let sdp = await new Promise((resolve, reject) => { + this._onCreateOfferSuccess = resolve; + this._onCreateOfferFailure = reject; + this._pc.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)); + } + + _createAnswer(options) { + this._checkClosed(); + return this._chain(() => this._createAnAnswer()); + } + + async _createAnAnswer() { + if (this.signalingState != "have-remote-offer") { + throw new this._win.DOMException( + `Cannot create answer in ${this.signalingState}`, + "InvalidStateError" + ); + } + let haveAssertion; + if (this._localIdp.enabled) { + haveAssertion = this._getIdentityAssertion(); + } + await this._getPermission(); + await this._certificateReady; + let sdp = await new Promise((resolve, reject) => { + this._onCreateAnswerSuccess = resolve; + this._onCreateAnswerFailure = reject; + this._pc.createAnswer(); + }); + if (haveAssertion) { + await haveAssertion; + sdp = this._localIdp.addIdentityAttribute(sdp); + } + return Cu.cloneInto({ type: "answer", sdp }, this._win); + } + + async _getPermission() { + if (!this._havePermission) { + const privileged = + this._documentPrincipal.isSystemPrincipal || + 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.docShell.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"); + }); + } + } + return this._havePermission; + } + + _sanityCheckSdp(sdp) { + // The fippo butter finger filter AKA non-ASCII chars + // Note: SDP allows non-ASCII character in the subject (who cares?) + // eslint-disable-next-line no-control-regex + let pos = sdp.search(/[^\u0000-\u007f]/); + if (pos != -1) { + throw new this._win.DOMException( + "SDP contains non ASCII characters at position " + pos, + "InvalidParameterError" + ); + } + } + + setLocalDescription(desc, onSucc, onErr) { + return this._auto(onSucc, onErr, () => this._setLocalDescription(desc)); + } + + _setLocalDescription({ type, sdp }) { + if (type == "pranswer") { + throw new this._win.DOMException( + "pranswer not yet implemented", + "NotSupportedError" + ); + } + this._checkClosed(); + return this._chain(async () => { + // Avoid Promise.all ahead of synchronous part of spec algorithm, since it + // defers. NOTE: The spec says to return an already-rejected promise in + // some cases, which is difficult to achieve in practice from JS (would + // require avoiding await and then() entirely), but we want to come as + // close as we reasonably can. + const p = this._getPermission(); + if (!type) { + switch (this.signalingState) { + case "stable": + case "have-local-offer": + case "have-remote-pranswer": + type = "offer"; + break; + default: + type = "answer"; + break; + } + } + if (!sdp) { + if (type == "offer") { + await this._createAnOffer(); + } else if (type == "answer") { + await this._createAnAnswer(); + } + } else { + this._sanityCheckSdp(sdp); + } + + try { + await new Promise((resolve, reject) => { + this._onSetDescriptionSuccess = resolve; + this._onSetDescriptionFailure = reject; + this._pc.setLocalDescription(this._actions[type], sdp); + }); + await p; + } catch (e) { + this._pc.onSetDescriptionError(); + throw e; + } + await this._pc.onSetDescriptionSuccess(type, false); + }); + } + + async _validateIdentity(sdp, origin) { + // 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(). + const validate = async () => { + // Access this._pc synchronously in case pc is closed later + const identity = this._pc.peerIdentity; + await this._lastIdentityValidation; + const msg = await this._remoteIdp.verifyIdentityFromSDP(sdp, origin); + // If this pc has an identity already, then the identity in sdp must match + if (identity && (!msg || msg.identity !== identity)) { + throw new this._win.DOMException( + "Peer Identity mismatch, expected: " + identity, + "OperationError" + ); + } + if (this._closed) { + return; + } + if (msg) { + // Set new identity and generate an event. + this._pc.peerIdentity = msg.identity; + this._resolvePeerIdentity( + Cu.cloneInto( + { + idp: this._remoteIdp.provider, + name: msg.identity, + }, + this._win + ) + ); + } + }; + + const haveValidation = validate(); + + // Always eat errors on this chain + this._lastIdentityValidation = haveValidation.catch(() => {}); + + // If validation fails, we have some work to do. Fork it so it cannot + // interfere with the validation chain itself, even if the catch function + // throws. + haveValidation.catch(e => { + if (this._closed) { + return; + } + 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._pc.peerIdentity) { + this._resetPeerIdentityPromise(); + } + }); + + if (this._closed) { + return; + } + // Only wait for IdP validation if we need identity matching + if (this._pc.peerIdentity) { + await haveValidation; + } + } + + setRemoteDescription(desc, onSucc, onErr) { + return this._auto(onSucc, onErr, () => this._setRemoteDescription(desc)); + } + + _setRemoteDescription({ type, sdp }) { + if (!type) { + throw new this._win.TypeError( + "Missing required 'type' member of RTCSessionDescriptionInit" + ); + } + if (type == "pranswer") { + throw new this._win.DOMException( + "pranswer not yet implemented", + "NotSupportedError" + ); + } + this._checkClosed(); + return this._chain(async () => { + try { + if (type == "offer" && this.signalingState == "have-local-offer") { + await new Promise((resolve, reject) => { + this._onSetDescriptionSuccess = resolve; + this._onSetDescriptionFailure = reject; + this._pc.setLocalDescription( + Ci.IPeerConnection.kActionRollback, + "" + ); + }); + await this._pc.onSetDescriptionSuccess("rollback", false); + this._updateCanTrickle(); + } + + if (this._closed) { + return; + } + + this._sanityCheckSdp(sdp); + + const p = this._getPermission(); + + const haveSetRemote = new Promise((resolve, reject) => { + this._onSetDescriptionSuccess = resolve; + this._onSetDescriptionFailure = reject; + this._pc.setRemoteDescription(this._actions[type], sdp); + }); + + if (type != "rollback") { + // Do setRemoteDescription and identity validation in parallel + await this._validateIdentity(sdp); + } + await p; + await haveSetRemote; + } catch (e) { + this._pc.onSetDescriptionError(); + throw e; + } + + await this._pc.onSetDescriptionSuccess(type, true); + this._updateCanTrickle(); + }); + } + + setIdentityProvider(provider, { protocol, usernameHint, peerIdentity } = {}) { + this._checkClosed(); + peerIdentity = peerIdentity || this._pc.peerIdentity; + this._localIdp.setIdentityProvider( + provider, + protocol, + usernameHint, + peerIdentity + ); + } + + async _getIdentityAssertion() { + await this._certificateReady; + return this._localIdp.getIdentityAssertion( + this._pc.fingerprint, + this._documentPrincipal.origin + ); + } + + getIdentityAssertion() { + this._checkClosed(); + return this._win.Promise.resolve( + this._chain(() => this._getIdentityAssertion()) + ); + } + + 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); + } + + addIceCandidate(cand, onSucc, onErr) { + if ( + cand.candidate != "" && + cand.sdpMid == null && + cand.sdpMLineIndex == null + ) { + throw new this._win.TypeError( + "Cannot add a candidate without specifying either sdpMid or sdpMLineIndex" + ); + } + return this._auto(onSucc, onErr, () => this._addIceCandidate(cand)); + } + + async _addIceCandidate({ + candidate, + sdpMid, + sdpMLineIndex, + usernameFragment, + }) { + this._checkClosed(); + return this._chain(async () => { + if ( + !this._pc.pendingRemoteDescription.length && + !this._pc.currentRemoteDescription.length + ) { + throw new this._win.DOMException( + "No remoteDescription.", + "InvalidStateError" + ); + } + return new Promise((resolve, reject) => { + this._onAddIceCandidateSuccess = resolve; + this._onAddIceCandidateError = reject; + this._pc.addIceCandidate( + candidate, + sdpMid || "", + usernameFragment || "", + sdpMLineIndex + ); + }); + }); + } + + restartIce() { + this._pc.restartIce(); + } + + addStream(stream) { + stream.getTracks().forEach(track => this.addTrack(track, stream)); + } + + addTrack(track, ...streams) { + this._checkClosed(); + + if ( + this.getTransceivers().some( + transceiver => transceiver.sender.track == track + ) + ) { + throw new this._win.DOMException( + "This track is already set on a sender.", + "InvalidAccessError" + ); + } + + let transceiver = this.getTransceivers().find(transceiver => { + return ( + transceiver.sender.track == null && + transceiver.getKind() == track.kind && + !transceiver.stopped && + !transceiver.hasBeenUsedToSend() + ); + }); + + if (transceiver) { + transceiver.sender.setTrack(track); + transceiver.sender.setStreamsImpl(...streams); + if (transceiver.direction == "recvonly") { + transceiver.setDirectionInternal("sendrecv"); + } else if (transceiver.direction == "inactive") { + transceiver.setDirectionInternal("sendonly"); + } + } else { + transceiver = this._addTransceiverNoEvents( + track, + { + streams, + direction: "sendrecv", + }, + true + ); + } + + this.updateNegotiationNeeded(); + return transceiver.sender; + } + + removeTrack(sender) { + this._checkClosed(); + + if (!this._pc.createdSender(sender)) { + throw new this._win.DOMException( + "This sender was not created by this PeerConnection", + "InvalidAccessError" + ); + } + + let transceiver = this.getTransceivers().find( + transceiver => !transceiver.stopped && transceiver.sender == sender + ); + + // If the transceiver was removed due to rollback, let it slide. + if (!transceiver || !sender.track) { + return; + } + + sender.setTrack(null); + if (transceiver.direction == "sendrecv") { + transceiver.setDirectionInternal("recvonly"); + } else if (transceiver.direction == "sendonly") { + transceiver.setDirectionInternal("inactive"); + } + + this.updateNegotiationNeeded(); + } + + _addTransceiverNoEvents(sendTrackOrKind, init, addTrackMagic) { + let sendTrack = null; + let kind; + if (typeof sendTrackOrKind == "string") { + kind = sendTrackOrKind; + switch (kind) { + case "audio": + case "video": + break; + default: + throw new this._win.TypeError("Invalid media kind"); + } + } else { + sendTrack = sendTrackOrKind; + kind = sendTrack.kind; + } + + try { + return this._pc.addTransceiver(init, kind, sendTrack, addTrackMagic); + } catch (e) { + // Exceptions thrown by c++ code do not propagate. In most cases, that's + // fine because we're using Promises, which can be copied. But this is + // not promise-based, so we have to do this sketchy stuff. + const holder = new StructuredCloneHolder( + "", + "", + new ClonedErrorHolder(e) + ); + throw holder.deserialize(this._win); + } + } + + addTransceiver(sendTrackOrKind, init) { + this._checkClosed(); + let transceiver = this._addTransceiverNoEvents(sendTrackOrKind, init); + this.updateNegotiationNeeded(); + return transceiver; + } + + updateNegotiationNeeded() { + this._pc.updateNegotiationNeeded(); + } + + close() { + if (this._closed) { + return; + } + this._closed = true; + this.changeIceConnectionState("closed"); + if (this._localIdp) { + this._localIdp.close(); + } + if (this._remoteIdp) { + this._remoteIdp.close(); + } + this._pc.close(); + this._suppressEvents = true; + } + + getLocalStreams() { + this._checkClosed(); + let localStreams = new Set(); + this.getTransceivers().forEach(transceiver => { + transceiver.sender.getStreams().forEach(stream => { + localStreams.add(stream); + }); + }); + return [...localStreams.values()]; + } + + getRemoteStreams() { + this._checkClosed(); + return this._pc.getRemoteStreams(); + } + + getSenders() { + return this.getTransceivers() + .filter(transceiver => !transceiver.stopped) + .map(transceiver => transceiver.sender); + } + + getReceivers() { + return this.getTransceivers() + .filter(transceiver => !transceiver.stopped) + .map(transceiver => transceiver.receiver); + } + + mozSetPacketCallback(callback) { + this._onPacket = callback; + } + + mozEnablePacketDump(level, type, sending) { + this._pc.enablePacketDump(level, type, sending); + } + + mozDisablePacketDump(level, type, sending) { + this._pc.disablePacketDump(level, type, sending); + } + + getTransceivers() { + return this._pc.getTransceivers(); + } + + get localDescription() { + return this.pendingLocalDescription || this.currentLocalDescription; + } + + get currentLocalDescription() { + this._checkClosed(); + const sdp = this._pc.currentLocalDescription; + if (!sdp.length) { + return null; + } + const type = this._pc.currentOfferer ? "offer" : "answer"; + return new this._win.RTCSessionDescription({ type, sdp }); + } + + get pendingLocalDescription() { + this._checkClosed(); + const sdp = this._pc.pendingLocalDescription; + if (!sdp.length) { + return null; + } + const type = this._pc.pendingOfferer ? "offer" : "answer"; + return new this._win.RTCSessionDescription({ type, sdp }); + } + + get remoteDescription() { + return this.pendingRemoteDescription || this.currentRemoteDescription; + } + + get currentRemoteDescription() { + this._checkClosed(); + const sdp = this._pc.currentRemoteDescription; + if (!sdp.length) { + return null; + } + const type = this._pc.currentOfferer ? "answer" : "offer"; + return new this._win.RTCSessionDescription({ type, sdp }); + } + + get pendingRemoteDescription() { + this._checkClosed(); + const sdp = this._pc.pendingRemoteDescription; + if (!sdp.length) { + return null; + } + const type = this._pc.pendingOfferer ? "answer" : "offer"; + return new this._win.RTCSessionDescription({ type, sdp }); + } + + get peerIdentity() { + return this._peerIdentity; + } + get idpLoginUrl() { + return this._localIdp.idpLoginUrl; + } + get id() { + return this._pc.id; + } + set id(s) { + this._pc.id = s; + } + get iceGatheringState() { + return this._pc.iceGatheringState; + } + get iceConnectionState() { + return this._iceConnectionState; + } + get connectionState() { + return this._pc.connectionState; + } + + get signalingState() { + // checking for our local pc closed indication + // before invoking the pc methods. + if (this._closed) { + return "closed"; + } + return this._pc.signalingState; + } + + handleIceGatheringStateChange() { + _globalPCList.notifyLifecycleObservers(this, "icegatheringstatechange"); + this.dispatchEvent(new this._win.Event("icegatheringstatechange")); + if (this.iceGatheringState === "complete") { + this.dispatchEvent( + new this._win.RTCPeerConnectionIceEvent("icecandidate", { + candidate: null, + }) + ); + } + } + + changeIceConnectionState(state) { + if (state != this._iceConnectionState) { + this._iceConnectionState = state; + _globalPCList.notifyLifecycleObservers(this, "iceconnectionstatechange"); + if (!this._closed) { + this.dispatchEvent(new this._win.Event("iceconnectionstatechange")); + } + } + } + + getStats(selector, onSucc, onErr) { + if (selector !== null) { + let matchingSenders = this.getSenders().filter(s => s.track === selector); + let matchingReceivers = this.getReceivers().filter( + r => r.track === selector + ); + + if (matchingSenders.length + matchingReceivers.length != 1) { + throw new this._win.DOMException( + "track must be associated with a unique sender or receiver, but " + + " is associated with " + + matchingSenders.length + + " senders and " + + matchingReceivers.length + + " receivers.", + "InvalidAccessError" + ); + } + } + + return this._auto(onSucc, onErr, () => this._pc.getStats(selector)); + } + + get sctp() { + return this._pc.sctp; + } + + createDataChannel( + label, + { + maxRetransmits, + ordered, + negotiated, + id = null, + maxRetransmitTime, + maxPacketLifeTime, + protocol, + } = {} + ) { + this._checkClosed(); + this._pcTelemetry.recordDataChannelInit( + maxRetransmitTime, + maxPacketLifeTime + ); + + if (maxPacketLifeTime === undefined) { + maxPacketLifeTime = maxRetransmitTime; + } + + if (maxRetransmitTime !== undefined) { + this.logWarning( + "Use maxPacketLifeTime instead of deprecated maxRetransmitTime which will stop working soon in createDataChannel!" + ); + } + + if (protocol.length > 32767) { + // At least 65536/2 UTF-16 characters. UTF-8 might be too long. + // Spec says to check how long |protocol| and |label| are in _bytes_. This + // is a little ambiguous. For now, examine the length of the utf-8 encoding. + const byteCounter = new TextEncoder(); + + if (byteCounter.encode(protocol).length > 65535) { + throw new this._win.TypeError( + "protocol cannot be longer than 65535 bytes" + ); + } + } + + if (label.length > 32767) { + const byteCounter = new TextEncoder(); + if (byteCounter.encode(label).length > 65535) { + throw new this._win.TypeError( + "label cannot be longer than 65535 bytes" + ); + } + } + + if (!negotiated) { + id = null; + } else if (id === null) { + throw new this._win.TypeError("id is required when negotiated is true"); + } + if (maxPacketLifeTime !== undefined && maxRetransmits !== undefined) { + throw new this._win.TypeError( + "Both maxPacketLifeTime and maxRetransmits cannot be provided" + ); + } + if (id == 65535) { + throw new this._win.TypeError("id cannot be 65535"); + } + // Must determine the type where we still know if entries are undefined. + let type; + if (maxPacketLifeTime !== undefined) { + type = Ci.IPeerConnection.kDataChannelPartialReliableTimed; + } else if (maxRetransmits !== undefined) { + type = Ci.IPeerConnection.kDataChannelPartialReliableRexmit; + } else { + type = Ci.IPeerConnection.kDataChannelReliable; + } + // Synchronous since it doesn't block. + let dataChannel; + try { + dataChannel = this._pc.createDataChannel( + label, + protocol, + type, + ordered, + maxPacketLifeTime, + maxRetransmits, + negotiated, + id + ); + } catch (e) { + if (e.result != Cr.NS_ERROR_NOT_AVAILABLE) { + throw e; + } + + const msg = + id === null ? "No available id could be generated" : "Id is in use"; + throw new this._win.DOMException(msg, "OperationError"); + } + + // Spec says to only do this if this is the first DataChannel created, + // but the c++ code that does the "is negotiation needed" checking will + // only ever return true on the first one. + this.updateNegotiationNeeded(); + + return dataChannel; + } +} + +setupPrototype(RTCPeerConnection, { + classID: PC_CID, + contractID: PC_CONTRACT, + QueryInterface: ChromeUtils.generateQI(["nsIDOMGlobalPropertyInitializer"]), + _actions: { + offer: Ci.IPeerConnection.kActionOffer, + answer: Ci.IPeerConnection.kActionAnswer, + pranswer: Ci.IPeerConnection.kActionPRAnswer, + rollback: Ci.IPeerConnection.kActionRollback, + }, +}); + +// This is a separate class because we don't want to expose it to DOM. + +export class PeerConnectionObserver { + init(win) { + this._win = win; + } + + __init(dompc) { + this._dompc = dompc._innerObject; + } + + newError({ message, name }) { + return new this._dompc._win.DOMException(message, name); + } + + dispatchEvent(event) { + this._dompc.dispatchEvent(event); + } + + onCreateOfferSuccess(sdp) { + this._dompc._onCreateOfferSuccess(sdp); + } + + onCreateOfferError(error) { + this._dompc._onCreateOfferFailure(this.newError(error)); + } + + onCreateAnswerSuccess(sdp) { + this._dompc._onCreateAnswerSuccess(sdp); + } + + onCreateAnswerError(error) { + this._dompc._onCreateAnswerFailure(this.newError(error)); + } + + onSetDescriptionSuccess() { + this._dompc._onSetDescriptionSuccess(); + } + + onSetDescriptionError(error) { + this._dompc._onSetDescriptionFailure(this.newError(error)); + } + + onAddIceCandidateSuccess() { + this._dompc._onAddIceCandidateSuccess(); + } + + onAddIceCandidateError(error) { + this._dompc._onAddIceCandidateError(this.newError(error)); + } + + onIceCandidate(sdpMLineIndex, sdpMid, candidate, usernameFragment) { + let win = this._dompc._win; + if (candidate || sdpMid || usernameFragment) { + if (candidate.includes(" typ relay ")) { + this._dompc._iceGatheredRelayCandidates = true; + } + candidate = new win.RTCIceCandidate({ + candidate, + sdpMid, + sdpMLineIndex, + usernameFragment, + }); + } + this.dispatchEvent( + new win.RTCPeerConnectionIceEvent("icecandidate", { candidate }) + ); + } + + // 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 (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); + } + + onStateChange(state) { + if (!this._dompc) { + return; + } + + if (state == "SignalingState") { + this.dispatchEvent(new this._win.Event("signalingstatechange")); + return; + } + + if (!this._dompc._pc) { + return; + } + + switch (state) { + case "IceConnectionState": + let connState = this._dompc._pc.iceConnectionState; + this._dompc._queueTaskWithClosedCheck(() => { + this.handleIceConnectionStateChange(connState); + }); + break; + + case "IceGatheringState": + this._dompc.handleIceGatheringStateChange(); + break; + + case "ConnectionState": + _globalPCList.notifyLifecycleObservers(this, "connectionstatechange"); + this.dispatchEvent(new this._win.Event("connectionstatechange")); + break; + + default: + this._dompc.logWarning("Unhandled state type: " + state); + break; + } + } + + onTransceiverNeeded(kind, transceiverImpl) { + this._dompc._onTransceiverNeeded(kind, transceiverImpl); + } + + notifyDataChannel(channel) { + this.dispatchEvent( + new this._dompc._win.RTCDataChannelEvent("datachannel", { channel }) + ); + } + + fireTrackEvent(receiver, streams) { + const pc = this._dompc; + const transceiver = pc.getTransceivers().find(t => t.receiver == receiver); + if (!transceiver) { + return; + } + const track = receiver.track; + this.dispatchEvent( + new this._win.RTCTrackEvent("track", { + transceiver, + receiver, + track, + streams, + }) + ); + // Fire legacy event as well for a little bit. + this.dispatchEvent( + new this._win.MediaStreamTrackEvent("addtrack", { track }) + ); + } + + fireStreamEvent(stream) { + const ev = new this._win.MediaStreamEvent("addstream", { stream }); + this.dispatchEvent(ev); + } + + fireNegotiationNeededEvent() { + this.dispatchEvent(new this._win.Event("negotiationneeded")); + } + + onPacket(level, type, sending, packet) { + var pc = this._dompc; + if (pc._onPacket) { + pc._onPacket(level, type, sending, packet); + } + } +} + +setupPrototype(PeerConnectionObserver, { + classID: PC_OBS_CID, + contractID: PC_OBS_CONTRACT, + QueryInterface: ChromeUtils.generateQI(["nsIDOMGlobalPropertyInitializer"]), +}); + +export class RTCPeerConnectionStatic { + init(win) { + this._winID = win.windowGlobalChild.innerWindowId; + } + + registerPeerConnectionLifecycleCallback(cb) { + _globalPCList._registerPeerConnectionLifecycleCallback(this._winID, cb); + } +} + +setupPrototype(RTCPeerConnectionStatic, { + classID: PC_STATIC_CID, + contractID: PC_STATIC_CONTRACT, + QueryInterface: ChromeUtils.generateQI(["nsIDOMGlobalPropertyInitializer"]), +}); + +export 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: ChromeUtils.generateQI([]), +}); -- cgit v1.2.3