1693 lines
58 KiB
JavaScript
1693 lines
58 KiB
JavaScript
/* 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");
|
|
|
|
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}");
|
|
|
|
// 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).
|
|
function GlobalPCList() {
|
|
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);
|
|
}
|
|
}
|
|
GlobalPCList.prototype = {
|
|
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);
|
|
}
|
|
},
|
|
|
|
notifyLifecycleObservers: function(pc, type) {
|
|
for (var key of Object.keys(this._lifecycleobservers)) {
|
|
this._lifecycleobservers[key](pc, pc._winID, type);
|
|
}
|
|
},
|
|
|
|
addPC: function(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: function(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: function(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: function(winID) {
|
|
this.removeNullRefs(winID);
|
|
return this._list[winID] ? true : false;
|
|
},
|
|
|
|
handleGMPCrash: function(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: function(message) {
|
|
if (message.name == "gmp-plugin-crash") {
|
|
this.handleGMPCrash(message.data);
|
|
}
|
|
},
|
|
|
|
observe: function(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") {
|
|
// Delete all peerconnections on shutdown - mostly synchronously (we
|
|
// need them to be done deleting transports and streams before we
|
|
// return)! All socket operations must be queued to STS thread
|
|
// before we return to here.
|
|
// Also kill them if "Work Offline" is selected - more can be created
|
|
// while offline, but attempts to connect them should fail.
|
|
for (let winId in this._list) {
|
|
cleanupWinId(this._list, winId);
|
|
}
|
|
this._networkdown = true;
|
|
}
|
|
else if (topic == "network:offline-status-changed") {
|
|
if (data == "offline") {
|
|
// this._list shold be empty here
|
|
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: function(winID, cb) {
|
|
this._lifecycleobservers[winID] = cb;
|
|
},
|
|
};
|
|
var _globalPCList = new GlobalPCList();
|
|
|
|
function RTCIceCandidate() {
|
|
this.candidate = this.sdpMid = this.sdpMLineIndex = null;
|
|
}
|
|
RTCIceCandidate.prototype = {
|
|
classDescription: "RTCIceCandidate",
|
|
classID: PC_ICE_CID,
|
|
contractID: PC_ICE_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports,
|
|
Ci.nsIDOMGlobalPropertyInitializer]),
|
|
|
|
init: function(win) { this._win = win; },
|
|
|
|
__init: function(dict) {
|
|
this.candidate = dict.candidate;
|
|
this.sdpMid = dict.sdpMid;
|
|
this.sdpMLineIndex = ("sdpMLineIndex" in dict)? dict.sdpMLineIndex : null;
|
|
}
|
|
};
|
|
|
|
function RTCSessionDescription() {
|
|
this.type = this.sdp = null;
|
|
}
|
|
RTCSessionDescription.prototype = {
|
|
classDescription: "RTCSessionDescription",
|
|
classID: PC_SESSION_CID,
|
|
contractID: PC_SESSION_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports,
|
|
Ci.nsIDOMGlobalPropertyInitializer]),
|
|
|
|
init: function(win) { this._win = win; },
|
|
|
|
__init: function(dict) {
|
|
this.type = dict.type;
|
|
this.sdp = dict.sdp;
|
|
}
|
|
};
|
|
|
|
function RTCStatsReport(win, dict) {
|
|
this._win = win;
|
|
this._pcid = dict.pcid;
|
|
this._report = convertToRTCStatsReport(dict);
|
|
}
|
|
RTCStatsReport.prototype = {
|
|
classDescription: "RTCStatsReport",
|
|
classID: PC_STATS_CID,
|
|
contractID: PC_STATS_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]),
|
|
|
|
setInternal: function(aKey, aObj) {
|
|
return this.__DOM_IMPL__.__set(aKey, aObj);
|
|
},
|
|
|
|
// TODO: Remove legacy API eventually
|
|
//
|
|
// 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: function(warnNullable) {
|
|
let legacyProps = {};
|
|
for (let key in this._report) {
|
|
let value = Cu.cloneInto(this._report[key], this._win);
|
|
this.setInternal(key, value);
|
|
|
|
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; }
|
|
};
|
|
|
|
function RTCPeerConnection() {
|
|
this._senders = [];
|
|
this._receivers = [];
|
|
|
|
this._pc = null;
|
|
this._observer = null;
|
|
this._closed = false;
|
|
|
|
this._onCreateOfferSuccess = null;
|
|
this._onCreateOfferFailure = null;
|
|
this._onCreateAnswerSuccess = null;
|
|
this._onCreateAnswerFailure = null;
|
|
this._onGetStatsSuccess = null;
|
|
this._onGetStatsFailure = null;
|
|
this._onReplaceTrackSender = null;
|
|
this._onReplaceTrackWithTrack = null;
|
|
this._onReplaceTrackSuccess = null;
|
|
this._onReplaceTrackFailure = null;
|
|
|
|
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";
|
|
}
|
|
RTCPeerConnection.prototype = {
|
|
classDescription: "RTCPeerConnection",
|
|
classID: PC_CID,
|
|
contractID: PC_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports,
|
|
Ci.nsIDOMGlobalPropertyInitializer]),
|
|
init: function(win) { this._win = win; },
|
|
|
|
__init: function(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("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! " +
|
|
"See http://w3c.github.io/webrtc-pc/#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._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: function() {
|
|
return this._config;
|
|
},
|
|
|
|
_initCertificate: function(certificates) {
|
|
let certPromise;
|
|
if (certificates && certificates.length > 0) {
|
|
if (certificates.length > 1) {
|
|
throw new this._win.DOMException(
|
|
"RTCPeerConnection does not currently support multiple certificates",
|
|
"NotSupportedError");
|
|
}
|
|
let cert = certificates.find(c => c.expires > Date.now());
|
|
if (!cert) {
|
|
throw new this._win.DOMException(
|
|
"Unable to create RTCPeerConnection with an expired certificate",
|
|
"InvalidParameterError");
|
|
}
|
|
certPromise = Promise.resolve(cert);
|
|
} else {
|
|
certPromise = this._win.RTCPeerConnection.generateCertificate({
|
|
name: "ECDSA", namedCurve: "P-256"
|
|
});
|
|
}
|
|
this._certificateReady = certPromise
|
|
.then(cert => this._impl.certificate = cert);
|
|
},
|
|
|
|
_initIdp: function() {
|
|
this._peerIdentity = new this._win.Promise((resolve, reject) => {
|
|
this._resolvePeerIdentity = resolve;
|
|
this._rejectPeerIdentity = reject;
|
|
});
|
|
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.
|
|
|
|
_chain: function(func) {
|
|
this._checkClosed(); // out here DOMException line-numbers work.
|
|
let p = this._operationsChain.then(() => {
|
|
// Don't _checkClosed() inside the chain, because it throws, and spec
|
|
// behavior as of this writing 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 func();
|
|
}
|
|
});
|
|
// don't propagate errors in the operations chain (this is a fork of p).
|
|
this._operationsChain = p.catch(() => {});
|
|
return p;
|
|
},
|
|
|
|
// This wrapper helps implement 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.
|
|
//
|
|
// It also serves as guard against settling promises past close().
|
|
|
|
_legacyCatchAndCloseGuard: function(onSuccess, onError, func) {
|
|
if (!onSuccess) {
|
|
return func().then(v => (this._closed ? new Promise(() => {}) : v),
|
|
e => (this._closed ? new Promise(() => {}) : Promise.reject(e)));
|
|
}
|
|
try {
|
|
return func().then(this._wrapLegacyCallback(onSuccess),
|
|
this._wrapLegacyCallback(onError));
|
|
} catch (e) {
|
|
this._wrapLegacyCallback(onError)(e);
|
|
return this._win.Promise.resolve(); // avoid webidl TypeError
|
|
}
|
|
},
|
|
|
|
_wrapLegacyCallback: function(func) {
|
|
return result => {
|
|
try {
|
|
func && func(result);
|
|
} catch (e) {
|
|
this.logErrorAndCallOnError(e);
|
|
}
|
|
};
|
|
},
|
|
|
|
// This implements the fairly common "Queue a task" logic
|
|
async _queueTaskWithClosedCheck(func) {
|
|
return new Promise(resolve => {
|
|
Services.tm.mainThread.dispatch({ run() {
|
|
if (!this._closed) {
|
|
func();
|
|
resolve();
|
|
}
|
|
}}, Ci.nsIThread.DISPATCH_NORMAL);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* 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: function(rtcConfig, msg) {
|
|
|
|
// Normalize iceServers input
|
|
rtcConfig.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, null, null);
|
|
} catch (e if (e.result == Cr.NS_ERROR_MALFORMED_URI)) {
|
|
throw new this._win.DOMException(msg + " - malformed URI: " + uriStr,
|
|
"SyntaxError");
|
|
}
|
|
};
|
|
|
|
rtcConfig.iceServers.forEach(server => {
|
|
if (!server.urls) {
|
|
throw new this._win.DOMException(msg + " - missing urls", "InvalidAccessError");
|
|
}
|
|
server.urls.forEach(urlStr => {
|
|
let url = nicerNewURI(urlStr);
|
|
if (url.scheme in { turn:1, turns:1 }) {
|
|
if (server.username == undefined) {
|
|
throw new this._win.DOMException(msg + " - missing username: " + urlStr,
|
|
"InvalidAccessError");
|
|
}
|
|
if (server.credential == undefined) {
|
|
throw new this._win.DOMException(msg + " - missing credential: " + urlStr,
|
|
"InvalidAccessError");
|
|
}
|
|
if (server.credentialType != "password") {
|
|
this.logWarning("RTCConfiguration TURN credentialType \""+
|
|
server.credentialType +
|
|
"\" is not yet implemented. Treating as password."+
|
|
" https://bugzil.la/1247616");
|
|
}
|
|
}
|
|
else if (!(url.scheme in { stun:1, stuns:1 })) {
|
|
throw new this._win.DOMException(msg + " - improper scheme: " + url.scheme,
|
|
"SyntaxError");
|
|
}
|
|
if (url.scheme in { stuns:1, turns:1 }) {
|
|
this.logWarning(url.scheme.toUpperCase() + " is not yet supported.");
|
|
}
|
|
});
|
|
});
|
|
},
|
|
|
|
// 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: function() {
|
|
if (this._closed) {
|
|
throw new this._win.DOMException("Peer connection is closed",
|
|
"InvalidStateError");
|
|
}
|
|
},
|
|
|
|
dispatchEvent: function(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: function(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: function(msg) {
|
|
this.logStackMsg(msg, Ci.nsIScriptError.errorFlag);
|
|
},
|
|
|
|
logWarning: function(msg) {
|
|
this.logStackMsg(msg, Ci.nsIScriptError.warningFlag);
|
|
},
|
|
|
|
logStackMsg: function(msg, flag) {
|
|
let err = this._win.Error();
|
|
this.logMsg(msg, err.fileName, err.lineNumber, flag);
|
|
},
|
|
|
|
logMsg: function(msg, file, line, flag) {
|
|
let scriptErrorClass = Cc["@mozilla.org/scripterror;1"];
|
|
let scriptError = scriptErrorClass.createInstance(Ci.nsIScriptError);
|
|
scriptError.initWithWindowID(msg, file, null, line, 0, flag,
|
|
"content javascript", this._winID);
|
|
let console = Cc["@mozilla.org/consoleservice;1"].
|
|
getService(Ci.nsIConsoleService);
|
|
console.logMessage(scriptError);
|
|
},
|
|
|
|
getEH: function(type) {
|
|
return this.__DOM_IMPL__.getEventHandler(type);
|
|
},
|
|
|
|
setEH: function(type, handler) {
|
|
this.__DOM_IMPL__.setEventHandler(type, handler);
|
|
},
|
|
|
|
makeGetterSetterEH: function(name) {
|
|
Object.defineProperty(this, name,
|
|
{
|
|
get:function() { return this.getEH(name); },
|
|
set:function(h) { return this.setEH(name, h); }
|
|
});
|
|
},
|
|
|
|
makeLegacyGetterSetterEH: function(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);
|
|
}
|
|
});
|
|
},
|
|
|
|
_addIdentityAssertion: function(sdpPromise, origin) {
|
|
if (!this._localIdp.enabled) {
|
|
return sdpPromise;
|
|
}
|
|
return Promise.all([
|
|
this._certificateReady
|
|
.then(() => this._localIdp.getIdentityAssertion(this._impl.fingerprint,
|
|
origin)),
|
|
sdpPromise
|
|
]).then(([,sdp]) => this._localIdp.addIdentityAttribute(sdp));
|
|
},
|
|
|
|
createOffer: function(optionsOrOnSuccess, onError, options) {
|
|
// This entry-point handles both new and legacy call sig. Decipher which one
|
|
let onSuccess;
|
|
if (typeof optionsOrOnSuccess == "function") {
|
|
onSuccess = optionsOrOnSuccess;
|
|
} else {
|
|
options = optionsOrOnSuccess;
|
|
}
|
|
return this._legacyCatchAndCloseGuard(onSuccess, onError, () => {
|
|
// TODO: Remove error on constraint-like RTCOptions next cycle (1197021).
|
|
// Note that webidl bindings make o.mandatory implicit but not o.optional.
|
|
function convertLegacyOptions(o) {
|
|
// Detect (mandatory OR optional) AND no other top-level members.
|
|
let lcy = ((o.mandatory && Object.keys(o.mandatory).length) || o.optional) &&
|
|
Object.keys(o).length == (o.mandatory? 1 : 0) + (o.optional? 1 : 0);
|
|
if (!lcy) {
|
|
return false;
|
|
}
|
|
let old = o.mandatory || {};
|
|
if (o.mandatory) {
|
|
delete o.mandatory;
|
|
}
|
|
if (o.optional) {
|
|
o.optional.forEach(one => {
|
|
// The old spec had optional as an array of objects w/1 attribute each.
|
|
// Assumes our JS-webidl bindings only populate passed-in properties.
|
|
let key = Object.keys(one)[0];
|
|
if (key && old[key] === undefined) {
|
|
old[key] = one[key];
|
|
}
|
|
});
|
|
delete o.optional;
|
|
}
|
|
o.offerToReceiveAudio = old.OfferToReceiveAudio;
|
|
o.offerToReceiveVideo = old.OfferToReceiveVideo;
|
|
o.mozDontOfferDataChannel = old.MozDontOfferDataChannel;
|
|
o.mozBundleOnly = old.MozBundleOnly;
|
|
Object.keys(o).forEach(k => {
|
|
if (o[k] === undefined) {
|
|
delete o[k];
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (options && convertLegacyOptions(options)) {
|
|
this.logError(
|
|
"Mandatory/optional in createOffer options no longer works! Use " +
|
|
JSON.stringify(options) + " instead (note the case difference)!");
|
|
options = {};
|
|
}
|
|
|
|
let origin = Cu.getWebIDLCallerPrincipal().origin;
|
|
return this._chain(() => {
|
|
let p = Promise.all([this.getPermission(), this._certificateReady])
|
|
.then(() => new this._win.Promise((resolve, reject) => {
|
|
this._onCreateOfferSuccess = resolve;
|
|
this._onCreateOfferFailure = reject;
|
|
this._impl.createOffer(options);
|
|
}));
|
|
p = this._addIdentityAssertion(p, origin);
|
|
return p.then(
|
|
sdp => new this._win.RTCSessionDescription({ type: "offer", sdp: sdp }));
|
|
});
|
|
});
|
|
},
|
|
|
|
createAnswer: function(optionsOrOnSuccess, onError) {
|
|
// This entry-point handles both new and legacy call sig. Decipher which one
|
|
let onSuccess, options;
|
|
if (typeof optionsOrOnSuccess == "function") {
|
|
onSuccess = optionsOrOnSuccess;
|
|
} else {
|
|
options = optionsOrOnSuccess;
|
|
}
|
|
return this._legacyCatchAndCloseGuard(onSuccess, onError, () => {
|
|
let origin = Cu.getWebIDLCallerPrincipal().origin;
|
|
return this._chain(() => {
|
|
let p = Promise.all([this.getPermission(), this._certificateReady])
|
|
.then(() => new this._win.Promise((resolve, reject) => {
|
|
// 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");
|
|
}
|
|
this._onCreateAnswerSuccess = resolve;
|
|
this._onCreateAnswerFailure = reject;
|
|
this._impl.createAnswer();
|
|
}));
|
|
p = this._addIdentityAssertion(p, origin);
|
|
return p.then(sdp => {
|
|
return new this._win.RTCSessionDescription({ type: "answer", sdp: sdp });
|
|
});
|
|
});
|
|
});
|
|
},
|
|
|
|
getPermission: function() {
|
|
if (this._havePermission) {
|
|
return this._havePermission;
|
|
}
|
|
if (this._isChrome ||
|
|
Services.prefs.getBoolPref("media.navigator.permission.disabled")) {
|
|
return this._havePermission = Promise.resolve();
|
|
}
|
|
return 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);
|
|
});
|
|
},
|
|
|
|
setLocalDescription: function(desc, onSuccess, onError) {
|
|
return this._legacyCatchAndCloseGuard(onSuccess, onError, () => {
|
|
this._localType = desc.type;
|
|
|
|
let type;
|
|
switch (desc.type) {
|
|
case "offer":
|
|
type = Ci.IPeerConnection.kActionOffer;
|
|
break;
|
|
case "answer":
|
|
type = Ci.IPeerConnection.kActionAnswer;
|
|
break;
|
|
case "pranswer":
|
|
throw new this._win.DOMException("pranswer not yet implemented",
|
|
"NotSupportedError");
|
|
case "rollback":
|
|
type = Ci.IPeerConnection.kActionRollback;
|
|
break;
|
|
default:
|
|
throw new this._win.DOMException(
|
|
"Invalid type " + desc.type + " provided to setLocalDescription",
|
|
"InvalidParameterError");
|
|
}
|
|
|
|
if (desc.type !== "rollback" && !desc.sdp) {
|
|
throw new this._win.DOMException(
|
|
"Empty or null SDP provided to setLocalDescription",
|
|
"InvalidParameterError");
|
|
}
|
|
|
|
return this._chain(() => this.getPermission()
|
|
.then(() => new this._win.Promise((resolve, reject) => {
|
|
this._onSetLocalDescriptionSuccess = resolve;
|
|
this._onSetLocalDescriptionFailure = reject;
|
|
this._impl.setLocalDescription(type, desc.sdp);
|
|
})));
|
|
});
|
|
},
|
|
|
|
_validateIdentity: function(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 validation = this._lastIdentityValidation
|
|
.then(() => this._remoteIdp.verifyIdentityFromSDP(sdp, origin))
|
|
.then(msg => {
|
|
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._peerIdentity = new this._win.Promise((resolve, reject) => {
|
|
this._resolvePeerIdentity = resolve;
|
|
this._rejectPeerIdentity = reject;
|
|
});
|
|
}
|
|
throw e;
|
|
});
|
|
this._lastIdentityValidation = validation.catch(() => {});
|
|
|
|
// Only wait for IdP validation if we need identity matching
|
|
return expectedIdentity ? validation : this._win.Promise.resolve();
|
|
},
|
|
|
|
setRemoteDescription: function(desc, onSuccess, onError) {
|
|
return this._legacyCatchAndCloseGuard(onSuccess, onError, () => {
|
|
this._remoteType = desc.type;
|
|
|
|
let type;
|
|
switch (desc.type) {
|
|
case "offer":
|
|
type = Ci.IPeerConnection.kActionOffer;
|
|
break;
|
|
case "answer":
|
|
type = Ci.IPeerConnection.kActionAnswer;
|
|
break;
|
|
case "pranswer":
|
|
throw new this._win.DOMException("pranswer not yet implemented",
|
|
"NotSupportedError");
|
|
case "rollback":
|
|
type = Ci.IPeerConnection.kActionRollback;
|
|
break;
|
|
default:
|
|
throw new this._win.DOMException(
|
|
"Invalid type " + desc.type + " provided to setRemoteDescription",
|
|
"InvalidParameterError");
|
|
}
|
|
|
|
if (!desc.sdp && desc.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 this._chain(() => {
|
|
let setRem = this.getPermission()
|
|
.then(() => new this._win.Promise((resolve, reject) => {
|
|
this._onSetRemoteDescriptionSuccess = resolve;
|
|
this._onSetRemoteDescriptionFailure = reject;
|
|
this._impl.setRemoteDescription(type, desc.sdp);
|
|
})).then(() => { this._updateCanTrickle(); });
|
|
|
|
if (desc.type === "rollback") {
|
|
return setRem;
|
|
}
|
|
|
|
// Do setRemoteDescription and identity validation in parallel
|
|
let validId = this._validateIdentity(desc.sdp, origin);
|
|
return this._win.Promise.all([setRem, validId])
|
|
.then(() => {}); // must return undefined
|
|
});
|
|
});
|
|
},
|
|
|
|
setIdentityProvider: function(provider, protocol, username) {
|
|
this._checkClosed();
|
|
this._localIdp.setIdentityProvider(provider, protocol, username);
|
|
},
|
|
|
|
getIdentityAssertion: function() {
|
|
let origin = Cu.getWebIDLCallerPrincipal().origin;
|
|
return this._chain(
|
|
() => this._certificateReady.then(
|
|
() => this._localIdp.getIdentityAssertion(this._impl.fingerprint, origin)
|
|
)
|
|
);
|
|
},
|
|
|
|
get canTrickleIceCandidates() {
|
|
return this._canTrickle;
|
|
},
|
|
|
|
_updateCanTrickle: function() {
|
|
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: function(c, onSuccess, onError) {
|
|
return this._legacyCatchAndCloseGuard(onSuccess, onError, () => {
|
|
if (!c.candidate && !c.sdpMLineIndex) {
|
|
throw new this._win.DOMException("Invalid candidate passed to addIceCandidate!",
|
|
"InvalidParameterError");
|
|
}
|
|
return this._chain(() => new this._win.Promise((resolve, reject) => {
|
|
this._onAddIceCandidateSuccess = resolve;
|
|
this._onAddIceCandidateError = reject;
|
|
this._impl.addIceCandidate(c.candidate, c.sdpMid || "", c.sdpMLineIndex);
|
|
}));
|
|
});
|
|
},
|
|
|
|
addStream: function(stream) {
|
|
stream.getTracks().forEach(track => this.addTrack(track, stream));
|
|
},
|
|
|
|
getStreamById: function(id) {
|
|
throw new this._win.DOMException("getStreamById not yet implemented",
|
|
"NotSupportedError");
|
|
},
|
|
|
|
addTrack: function(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: function(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: function(sender, tones, duration, interToneGap) {
|
|
return this._impl.insertDTMF(sender.__DOM_IMPL__, tones, duration, interToneGap);
|
|
},
|
|
|
|
_getDTMFToneBuffer: function(sender) {
|
|
return this._impl.getDTMFToneBuffer(sender.__DOM_IMPL__);
|
|
},
|
|
|
|
_replaceTrack: function(sender, withTrack) {
|
|
// TODO: Do a (sender._stream.getTracks().indexOf(track) < 0) check
|
|
// on both track args someday.
|
|
//
|
|
// The proposed API will be that both tracks must already be in the same
|
|
// stream. However, since our MediaStreams currently are limited to one
|
|
// track per type, we allow replacement with an outside track not already
|
|
// in the same stream.
|
|
//
|
|
// Since a track may be replaced more than once, the track being replaced
|
|
// may not be in the stream either, so we check neither arg right now.
|
|
|
|
return new this._win.Promise((resolve, reject) => {
|
|
this._onReplaceTrackSender = sender;
|
|
this._onReplaceTrackWithTrack = withTrack;
|
|
this._onReplaceTrackSuccess = resolve;
|
|
this._onReplaceTrackFailure = reject;
|
|
this._impl.replaceTrack(sender.track, withTrack);
|
|
});
|
|
},
|
|
|
|
_setParameters: function(sender, parameters) {
|
|
if (!Services.prefs.getBoolPref("media.peerconnection.simulcast")) {
|
|
return;
|
|
}
|
|
// validate parameters input
|
|
var encodings = parameters.encodings || [];
|
|
|
|
encodings.reduce((uniqueRids, encoding) => {
|
|
if (encoding.scaleResolutionDownBy < 1.0) {
|
|
throw new this._win.RangeError("scaleResolutionDownBy must be >= 1.0");
|
|
}
|
|
if (!encoding.rid && encodings.length > 1) {
|
|
throw new this._win.DOMException("Missing rid", "TypeError");
|
|
}
|
|
if (uniqueRids[encoding.rid]) {
|
|
throw new this._win.DOMException("Duplicate rid", "TypeError");
|
|
}
|
|
uniqueRids[encoding.rid] = true;
|
|
return uniqueRids;
|
|
}, {});
|
|
|
|
this._impl.setParameters(sender.track, parameters);
|
|
},
|
|
|
|
_getParameters: function(sender) {
|
|
if (!Services.prefs.getBoolPref("media.peerconnection.simulcast")) {
|
|
return;
|
|
}
|
|
return this._impl.getParameters(sender.track);
|
|
},
|
|
|
|
close: function() {
|
|
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: function() {
|
|
this._checkClosed();
|
|
return this._impl.getLocalStreams();
|
|
},
|
|
|
|
getRemoteStreams: function() {
|
|
this._checkClosed();
|
|
return this._impl.getRemoteStreams();
|
|
},
|
|
|
|
getSenders: function() {
|
|
return this._senders;
|
|
},
|
|
|
|
getReceivers: function() {
|
|
return this._receivers;
|
|
},
|
|
|
|
mozSelectSsrc: function(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: 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: 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: function(state) {
|
|
this._iceGatheringState = state;
|
|
_globalPCList.notifyLifecycleObservers(this, "icegatheringstatechange");
|
|
},
|
|
|
|
changeIceConnectionState: function(state) {
|
|
this._iceConnectionState = state;
|
|
_globalPCList.notifyLifecycleObservers(this, "iceconnectionstatechange");
|
|
this.dispatchEvent(new this._win.Event("iceconnectionstatechange"));
|
|
},
|
|
|
|
getStats: function(selector, onSuccess, onError) {
|
|
return this._legacyCatchAndCloseGuard(onSuccess, onError, () => {
|
|
return this._chain(() => new this._win.Promise((resolve, reject) => {
|
|
this._onGetStatsSuccess = resolve;
|
|
this._onGetStatsFailure = reject;
|
|
this._impl.getStats(selector);
|
|
}));
|
|
});
|
|
},
|
|
|
|
createDataChannel: function(label, dict) {
|
|
this._checkClosed();
|
|
if (dict == undefined) {
|
|
dict = {};
|
|
}
|
|
if (dict.maxRetransmitNum != undefined) {
|
|
dict.maxRetransmits = dict.maxRetransmitNum;
|
|
this.logWarning("Deprecated RTCDataChannelInit dictionary entry maxRetransmitNum used!");
|
|
}
|
|
if (dict.outOfOrderAllowed != undefined) {
|
|
dict.ordered = !dict.outOfOrderAllowed; // the meaning is swapped with
|
|
// the name change
|
|
this.logWarning("Deprecated RTCDataChannelInit dictionary entry outOfOrderAllowed used!");
|
|
}
|
|
|
|
if (dict.preset != undefined) {
|
|
dict.negotiated = dict.preset;
|
|
this.logWarning("Deprecated RTCDataChannelInit dictionary entry preset used!");
|
|
}
|
|
if (dict.stream != undefined) {
|
|
dict.id = dict.stream;
|
|
this.logWarning("Deprecated RTCDataChannelInit dictionary entry stream used!");
|
|
}
|
|
|
|
if (dict.maxRetransmitTime !== null && dict.maxRetransmits !== null) {
|
|
throw new this._win.DOMException(
|
|
"Both maxRetransmitTime and maxRetransmits cannot be provided",
|
|
"InvalidParameterError");
|
|
}
|
|
let protocol;
|
|
if (dict.protocol == undefined) {
|
|
protocol = "";
|
|
} else {
|
|
protocol = dict.protocol;
|
|
}
|
|
|
|
// Must determine the type where we still know if entries are undefined.
|
|
let type;
|
|
if (dict.maxRetransmitTime != undefined) {
|
|
type = Ci.IPeerConnection.kDataChannelPartialReliableTimed;
|
|
} else if (dict.maxRetransmits != undefined) {
|
|
type = Ci.IPeerConnection.kDataChannelPartialReliableRexmit;
|
|
} else {
|
|
type = Ci.IPeerConnection.kDataChannelReliable;
|
|
}
|
|
|
|
// Synchronous since it doesn't block.
|
|
let channel = this._impl.createDataChannel(
|
|
label, protocol, type, !dict.ordered, dict.maxRetransmitTime,
|
|
dict.maxRetransmits, dict.negotiated ? true : false,
|
|
dict.id != undefined ? dict.id : 0xFFFF
|
|
);
|
|
return channel;
|
|
}
|
|
};
|
|
|
|
// This is a separate object because we don't want to expose it to DOM.
|
|
function PeerConnectionObserver() {
|
|
this._dompc = null;
|
|
}
|
|
PeerConnectionObserver.prototype = {
|
|
classDescription: "PeerConnectionObserver",
|
|
classID: PC_OBS_CID,
|
|
contractID: PC_OBS_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports,
|
|
Ci.nsIDOMGlobalPropertyInitializer]),
|
|
init: function(win) { this._win = win; },
|
|
|
|
__init: function(dompc) {
|
|
this._dompc = dompc._innerObject;
|
|
},
|
|
|
|
newError: function(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: function(event) {
|
|
this._dompc.dispatchEvent(event);
|
|
},
|
|
|
|
onCreateOfferSuccess: function(sdp) {
|
|
this._dompc._onCreateOfferSuccess(sdp);
|
|
},
|
|
|
|
onCreateOfferError: function(code, message) {
|
|
this._dompc._onCreateOfferFailure(this.newError(message, code));
|
|
},
|
|
|
|
onCreateAnswerSuccess: function(sdp) {
|
|
this._dompc._onCreateAnswerSuccess(sdp);
|
|
},
|
|
|
|
onCreateAnswerError: function(code, message) {
|
|
this._dompc._onCreateAnswerFailure(this.newError(message, code));
|
|
},
|
|
|
|
onSetLocalDescriptionSuccess: function() {
|
|
this._dompc._onSetLocalDescriptionSuccess();
|
|
},
|
|
|
|
onSetRemoteDescriptionSuccess: function() {
|
|
this._dompc._onSetRemoteDescriptionSuccess();
|
|
},
|
|
|
|
onSetLocalDescriptionError: function(code, message) {
|
|
this._localType = null;
|
|
this._dompc._onSetLocalDescriptionFailure(this.newError(message, code));
|
|
},
|
|
|
|
onSetRemoteDescriptionError: function(code, message) {
|
|
this._remoteType = null;
|
|
this._dompc._onSetRemoteDescriptionFailure(this.newError(message, code));
|
|
},
|
|
|
|
onAddIceCandidateSuccess: function() {
|
|
this._dompc._onAddIceCandidateSuccess();
|
|
},
|
|
|
|
onAddIceCandidateError: function(code, message) {
|
|
this._dompc._onAddIceCandidateError(this.newError(message, code));
|
|
},
|
|
|
|
onIceCandidate: function(level, mid, candidate) {
|
|
if (candidate == "") {
|
|
this.foundIceCandidate(null);
|
|
} else {
|
|
this.foundIceCandidate(new this._dompc._win.RTCIceCandidate(
|
|
{
|
|
candidate: candidate,
|
|
sdpMid: mid,
|
|
sdpMLineIndex: level
|
|
}
|
|
));
|
|
}
|
|
},
|
|
|
|
onNegotiationNeeded: function() {
|
|
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 The ICE Agent is gathering addresses and/or waiting for
|
|
// remote candidates to be supplied.
|
|
//
|
|
// checking The ICE Agent has received remote candidates on at least
|
|
// one component, and is checking candidate pairs but has not
|
|
// yet found a connection. In addition to checking, it may
|
|
// also still be gathering.
|
|
//
|
|
// connected The ICE Agent has found a usable connection for all
|
|
// components but is still checking other candidate pairs to
|
|
// see if there is a better connection. It may also still be
|
|
// gathering.
|
|
//
|
|
// completed The ICE Agent has finished gathering and checking and found
|
|
// a connection for all components. Open issue: it is not
|
|
// clear how the non controlling ICE side knows it is in the
|
|
// state.
|
|
//
|
|
// failed The ICE Agent is finished checking all candidate pairs and
|
|
// failed to find a connection for at least one component.
|
|
// Connections may have been found for some components.
|
|
//
|
|
// disconnected Liveness checks have failed for one or more components.
|
|
// This is more aggressive than failed, and may trigger
|
|
// intermittently (and resolve itself without action) on a
|
|
// flaky network.
|
|
//
|
|
// closed The ICE Agent has shut down and is no longer responding to
|
|
// STUN requests.
|
|
|
|
handleIceConnectionStateChange: function(iceConnectionState) {
|
|
let pc = this._dompc;
|
|
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') {
|
|
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 engine is in the process of gathering candidates for
|
|
// this RTCPeerConnection.
|
|
//
|
|
// complete The ICE engine 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: function(gatheringState) {
|
|
this._dompc.changeIceGatheringState(gatheringState);
|
|
},
|
|
|
|
onStateChange: function(state) {
|
|
switch (state) {
|
|
case "SignalingState":
|
|
this.dispatchEvent(new this._win.Event("signalingstatechange"));
|
|
break;
|
|
|
|
case "IceConnectionState":
|
|
let connState = this._dompc._pc.iceConnectionState;
|
|
this._dompc._queueTaskWithClosedCheck(() => {
|
|
this.handleIceConnectionStateChange(connState);
|
|
});
|
|
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: function(dict) {
|
|
let pc = this._dompc;
|
|
let chromeobj = new RTCStatsReport(pc._win, dict);
|
|
let webidlobj = pc._win.RTCStatsReport._create(pc._win, chromeobj);
|
|
chromeobj.makeStatsPublic(pc._warnDeprecatedStatsAccessNullable);
|
|
pc._onGetStatsSuccess(webidlobj);
|
|
},
|
|
|
|
onGetStatsError: function(code, message) {
|
|
this._dompc._onGetStatsFailure(this.newError(message, code));
|
|
},
|
|
|
|
onAddStream: function(stream) {
|
|
let ev = new this._dompc._win.MediaStreamEvent("addstream",
|
|
{ stream: stream });
|
|
this.dispatchEvent(ev);
|
|
},
|
|
|
|
onRemoveStream: function(stream) {
|
|
this.dispatchEvent(new this._dompc._win.MediaStreamEvent("removestream",
|
|
{ stream: stream }));
|
|
},
|
|
|
|
onAddTrack: function(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: receiver,
|
|
track: track,
|
|
streams: streams });
|
|
this.dispatchEvent(ev);
|
|
|
|
// Fire legacy event as well for a little bit.
|
|
ev = new pc._win.MediaStreamTrackEvent("addtrack", { track: track });
|
|
this.dispatchEvent(ev);
|
|
},
|
|
|
|
onRemoveTrack: function(track) {
|
|
let pc = this._dompc;
|
|
let i = pc._receivers.findIndex(receiver => receiver.track == track);
|
|
if (i >= 0) {
|
|
pc._receivers.splice(i, 1);
|
|
}
|
|
},
|
|
|
|
onReplaceTrackSuccess: function() {
|
|
var pc = this._dompc;
|
|
pc._onReplaceTrackSender.track = pc._onReplaceTrackWithTrack;
|
|
pc._onReplaceTrackWithTrack = null;
|
|
pc._onReplaceTrackSender = null;
|
|
pc._onReplaceTrackSuccess();
|
|
},
|
|
|
|
onReplaceTrackError: function(code, message) {
|
|
var pc = this._dompc;
|
|
pc._onReplaceTrackWithTrack = null;
|
|
pc._onReplaceTrackSender = null;
|
|
pc._onReplaceTrackFailure(this.newError(message, code));
|
|
},
|
|
|
|
foundIceCandidate: function(cand) {
|
|
this.dispatchEvent(new this._dompc._win.RTCPeerConnectionIceEvent("icecandidate",
|
|
{ candidate: cand } ));
|
|
},
|
|
|
|
notifyDataChannel: function(channel) {
|
|
this.dispatchEvent(new this._dompc._win.RTCDataChannelEvent("datachannel",
|
|
{ channel: channel }));
|
|
},
|
|
|
|
onDTMFToneChange: function(trackId, tone) {
|
|
var pc = this._dompc;
|
|
var sender = pc._senders.find(sender => sender.track.id == trackId)
|
|
sender.dtmf.dispatchEvent(new pc._win.RTCDTMFToneChangeEvent("tonechange",
|
|
{ tone: tone }));
|
|
}
|
|
};
|
|
|
|
function RTCPeerConnectionStatic() {
|
|
}
|
|
RTCPeerConnectionStatic.prototype = {
|
|
classDescription: "RTCPeerConnectionStatic",
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports,
|
|
Ci.nsIDOMGlobalPropertyInitializer]),
|
|
|
|
classID: PC_STATIC_CID,
|
|
contractID: PC_STATIC_CONTRACT,
|
|
|
|
init: function(win) {
|
|
this._winID = win.QueryInterface(Ci.nsIInterfaceRequestor)
|
|
.getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
|
|
},
|
|
|
|
registerPeerConnectionLifecycleCallback: function(cb) {
|
|
_globalPCList._registerPeerConnectionLifecycleCallback(this._winID, cb);
|
|
},
|
|
};
|
|
|
|
function RTCDTMFSender(sender) {
|
|
this._sender = sender;
|
|
}
|
|
RTCDTMFSender.prototype = {
|
|
classDescription: "RTCDTMFSender",
|
|
classID: PC_DTMF_SENDER_CID,
|
|
contractID: PC_DTMF_SENDER_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]),
|
|
|
|
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: function(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);
|
|
},
|
|
};
|
|
|
|
function RTCRtpSender(pc, track, stream) {
|
|
this._pc = pc;
|
|
this.track = track;
|
|
this._stream = stream;
|
|
this.dtmf = pc._win.RTCDTMFSender._create(pc._win, new RTCDTMFSender(this));
|
|
}
|
|
RTCRtpSender.prototype = {
|
|
classDescription: "RTCRtpSender",
|
|
classID: PC_SENDER_CID,
|
|
contractID: PC_SENDER_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]),
|
|
|
|
replaceTrack: function(withTrack) {
|
|
return this._pc._chain(() => this._pc._replaceTrack(this, withTrack));
|
|
},
|
|
|
|
setParameters: function(parameters) {
|
|
return this._pc._win.Promise.resolve()
|
|
.then(() => this._pc._setParameters(this, parameters));
|
|
},
|
|
|
|
getParameters: function() {
|
|
return this._pc._getParameters(this);
|
|
}
|
|
};
|
|
|
|
function RTCRtpReceiver(pc, track) {
|
|
this._pc = pc;
|
|
this.track = track;
|
|
}
|
|
RTCRtpReceiver.prototype = {
|
|
classDescription: "RTCRtpReceiver",
|
|
classID: PC_RECEIVER_CID,
|
|
contractID: PC_RECEIVER_CONTRACT,
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]),
|
|
};
|
|
|
|
function CreateOfferRequest(windowID, innerWindowID, callID, isSecure) {
|
|
this.windowID = windowID;
|
|
this.innerWindowID = innerWindowID;
|
|
this.callID = callID;
|
|
this.isSecure = isSecure;
|
|
}
|
|
CreateOfferRequest.prototype = {
|
|
classDescription: "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]
|
|
);
|