зеркало из https://github.com/mozilla/gecko-dev.git
2402 строки
75 KiB
JavaScript
2402 строки
75 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 {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
|
|
const {XPCOMUtils} = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
ChromeUtils.defineModuleGetter(this, "PeerConnectionIdp",
|
|
"resource://gre/modules/media/PeerConnectionIdp.jsm");
|
|
ChromeUtils.defineModuleGetter(this, "convertToRTCStatsReport",
|
|
"resource://gre/modules/media/RTCStatsReport.jsm");
|
|
ChromeUtils.defineModuleGetter(this, "AppConstants",
|
|
"resource://gre/modules/AppConstants.jsm");
|
|
|
|
const PC_CONTRACT = "@mozilla.org/dom/peerconnection;1";
|
|
const PC_OBS_CONTRACT = "@mozilla.org/dom/peerconnectionobserver;1";
|
|
const PC_ICE_CONTRACT = "@mozilla.org/dom/rtcicecandidate;1";
|
|
const PC_SESSION_CONTRACT = "@mozilla.org/dom/rtcsessiondescription;1";
|
|
const PC_MANAGER_CONTRACT = "@mozilla.org/dom/peerconnectionmanager;1";
|
|
const PC_STATS_CONTRACT = "@mozilla.org/dom/rtcstatsreport;1";
|
|
const PC_STATIC_CONTRACT = "@mozilla.org/dom/peerconnectionstatic;1";
|
|
const PC_SENDER_CONTRACT = "@mozilla.org/dom/rtpsender;1";
|
|
const PC_RECEIVER_CONTRACT = "@mozilla.org/dom/rtpreceiver;1";
|
|
const PC_TRANSCEIVER_CONTRACT = "@mozilla.org/dom/rtptransceiver;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_TRANSCEIVER_CID = Components.ID("{09475754-103a-41f5-a2d0-e1f27eb0b537}");
|
|
const PC_COREQUEST_CID = Components.ID("{74b2122d-65a8-4824-aa9e-3d664cb75dc2}");
|
|
const PC_DTMF_SENDER_CID = Components.ID("{3610C242-654E-11E6-8EC0-6D1BE389A607}");
|
|
|
|
const TELEMETRY_PC_CONNECTED = "webrtc.peerconnection.connected";
|
|
const TELEMETRY_PC_PROMISE_GETSTATS = "webrtc.peerconnection.promise_stats_used";
|
|
function logMsg(msg, file, line, flag, winID) {
|
|
let scriptErrorClass = Cc["@mozilla.org/scripterror;1"];
|
|
let scriptError = scriptErrorClass.createInstance(Ci.nsIScriptError);
|
|
scriptError.initWithWindowID(msg, file, null, line, 0, flag,
|
|
"content javascript", winID);
|
|
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).
|
|
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([Ci.nsIObserver,
|
|
Ci.nsISupportsWeakReference]),
|
|
classID: PC_MANAGER_CID,
|
|
_xpcom_factory: {
|
|
createInstance(outer, iid) {
|
|
if (outer) {
|
|
throw Cr.NS_ERROR_NO_AGGREGATION;
|
|
}
|
|
return _globalPCList.QueryInterface(iid);
|
|
},
|
|
},
|
|
});
|
|
|
|
var _globalPCList = new GlobalPCList();
|
|
|
|
class RTCIceCandidate {
|
|
init(win) {
|
|
this._win = win;
|
|
}
|
|
|
|
__init(dict) {
|
|
Object.assign(this, dict);
|
|
}
|
|
}
|
|
setupPrototype(RTCIceCandidate, {
|
|
classID: PC_ICE_CID,
|
|
contractID: PC_ICE_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([Ci.nsIDOMGlobalPropertyInitializer]),
|
|
});
|
|
|
|
class RTCSessionDescription {
|
|
init(win) {
|
|
this._win = win;
|
|
this._winID = this._win.windowUtils.currentInnerWindowID;
|
|
}
|
|
|
|
__init({ type, sdp }) {
|
|
Object.assign(this, { _type: type, _sdp: sdp });
|
|
}
|
|
|
|
get type() { return this._type; }
|
|
set type(type) {
|
|
this.warn();
|
|
this._type = type;
|
|
}
|
|
|
|
get sdp() { return this._sdp; }
|
|
set sdp(sdp) {
|
|
this.warn();
|
|
this._sdp = sdp;
|
|
}
|
|
|
|
warn() {
|
|
if (!this._warned) {
|
|
// Warn once per RTCSessionDescription about deprecated writable usage.
|
|
this.logWarning("RTCSessionDescription's members are readonly! " +
|
|
"Writing to them is deprecated and will break soon!");
|
|
this._warned = true;
|
|
}
|
|
}
|
|
|
|
logWarning(msg) {
|
|
let err = this._win.Error();
|
|
logMsg(msg, err.fileName, err.lineNumber, Ci.nsIScriptError.warningFlag,
|
|
this._winID);
|
|
}
|
|
}
|
|
setupPrototype(RTCSessionDescription, {
|
|
classID: PC_SESSION_CID,
|
|
contractID: PC_SESSION_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([Ci.nsIDOMGlobalPropertyInitializer]),
|
|
});
|
|
|
|
class RTCStatsReport {
|
|
constructor(pc, dict) {
|
|
this._pc = pc;
|
|
this._win = pc._win;
|
|
this._pcid = dict.pcid;
|
|
this._report = convertToRTCStatsReport(dict);
|
|
}
|
|
|
|
setInternal(aKey, aObj) {
|
|
return this.__DOM_IMPL__.__set(aKey, aObj);
|
|
}
|
|
|
|
// Must be called after our webidl sandwich is made.
|
|
|
|
makeStatsPublic() {
|
|
for (const key in this._report) {
|
|
const value = this._report[key];
|
|
if (value.type == "local-candidate" || value.type == "remote-candidate") {
|
|
delete value.transportId;
|
|
}
|
|
this.setInternal(key, Cu.cloneInto(value, this._win));
|
|
}
|
|
}
|
|
|
|
get mozPcid() { return this._pcid; }
|
|
|
|
__onget(key, stat) {
|
|
return stat;
|
|
}
|
|
}
|
|
setupPrototype(RTCStatsReport, {
|
|
classID: PC_STATS_CID,
|
|
contractID: PC_STATS_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([]),
|
|
});
|
|
|
|
// This is its own class so that it does not need to be exposed to the client.
|
|
class PeerConnectionTelemetry {
|
|
// Record which style(s) of invocation for getStats are used
|
|
recordGetStats() {
|
|
Services.telemetry.scalarAdd(TELEMETRY_PC_PROMISE_GETSTATS, 1);
|
|
this.recordGetStats = () => {};
|
|
}
|
|
// ICE connection state enters connected or completed.
|
|
recordConnected() {
|
|
Services.telemetry.scalarAdd(TELEMETRY_PC_CONNECTED, 1);
|
|
this.recordConnected = () => {};
|
|
}
|
|
}
|
|
|
|
// Cache for RTPSourceEntries
|
|
// Note: each cache is only valid for one JS event loop execution
|
|
class RTCRtpSourceCache {
|
|
constructor() {
|
|
// The time in RTP source time (ms)
|
|
this.tsNowInRtpSourceTime = null;
|
|
// The time in JS
|
|
this.jsTimestamp = null;
|
|
// Time difference between JS time and RTP source time
|
|
this.timestampOffset = null;
|
|
// RTPSourceEntries cached by track id
|
|
this.rtpSourcesByTrackId = new Map();
|
|
// Has a cache wipe already been scheduled
|
|
this.scheduledClear = null;
|
|
}
|
|
}
|
|
|
|
class RTCPeerConnection {
|
|
constructor() {
|
|
this._receiveStreams = new Map();
|
|
// Used to fire onaddstream, remove when we don't do that anymore.
|
|
this._newStreams = [];
|
|
this._transceivers = [];
|
|
|
|
this._pc = null;
|
|
this._closed = false;
|
|
|
|
this._localType = null;
|
|
this._remoteType = null;
|
|
// http://rtcweb-wg.github.io/jsep/#rfc.section.4.1.9
|
|
// canTrickle == null means unknown; when a remote description is received it
|
|
// is set to true or false based on the presence of the "trickle" ice-option
|
|
this._canTrickle = null;
|
|
|
|
// States
|
|
this._iceGatheringState = this._iceConnectionState = "new";
|
|
|
|
this._hasStunServer = this._hasTurnServer = false;
|
|
this._iceGatheredRelayCandidates = false;
|
|
// Stored webrtc timing information
|
|
this._storedRtpSourceReferenceTime = null;
|
|
// Stores cached RTP sources state
|
|
this._rtpSourceCache = new RTCRtpSourceCache();
|
|
// Records telemetry
|
|
this._pcTelemetry = new PeerConnectionTelemetry();
|
|
}
|
|
|
|
init(win) {
|
|
this._win = win;
|
|
}
|
|
|
|
__init(rtcConfig) {
|
|
this._winID = this._win.windowUtils.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("ondatachannel");
|
|
this.makeGetterSetterEH("oniceconnectionstatechange");
|
|
this.makeGetterSetterEH("onicegatheringstatechange");
|
|
this.makeGetterSetterEH("onidentityresult");
|
|
this.makeGetterSetterEH("onpeeridentity");
|
|
this.makeGetterSetterEH("onidpassertionerror");
|
|
this.makeGetterSetterEH("onidpvalidationerror");
|
|
|
|
this._pc = new this._win.PeerConnectionImpl();
|
|
this._operationsChain = this._win.Promise.resolve();
|
|
|
|
this.__DOM_IMPL__._innerObject = this;
|
|
this._observer = new this._win.PeerConnectionObserver(this.__DOM_IMPL__);
|
|
|
|
this._warnDeprecatedStatsRemoteAccessNullable = { warn: (key) =>
|
|
this.logWarning(`Detected soon-to-break getStats() use with key="${key}"! stat.isRemote goes away in Firefox 66, but won't warn there!\
|
|
- See https://blog.mozilla.org/webrtc/getstats-isremote-66/`) };
|
|
|
|
// Add a reference to the PeerConnection to global list (before init).
|
|
_globalPCList.addPC(this);
|
|
|
|
this._impl.initialize(this._observer, this._win, rtcConfig,
|
|
Services.tm.currentThread);
|
|
|
|
this._certificateReady = this._initCertificate(rtcConfig.certificates);
|
|
this._initIdp();
|
|
_globalPCList.notifyLifecycleObservers(this, "initialized");
|
|
}
|
|
|
|
get _impl() {
|
|
if (!this._pc) {
|
|
throw new this._win.DOMException(
|
|
"RTCPeerConnection is gone (did you enter Offline mode?)",
|
|
"InvalidStateError");
|
|
}
|
|
return this._pc;
|
|
}
|
|
|
|
getConfiguration() {
|
|
return this._config;
|
|
}
|
|
|
|
async _initCertificate(certificates = []) {
|
|
let certificate;
|
|
if (certificates.length > 1) {
|
|
throw new this._win.DOMException(
|
|
"RTCPeerConnection does not currently support multiple certificates",
|
|
"NotSupportedError");
|
|
}
|
|
if (certificates.length) {
|
|
certificate = certificates.find(c => c.expires > Date.now());
|
|
if (!certificate) {
|
|
throw new this._win.DOMException(
|
|
"Unable to create RTCPeerConnection with an expired certificate",
|
|
"InvalidParameterError");
|
|
}
|
|
}
|
|
|
|
if (!certificate) {
|
|
certificate = await this._win.RTCPeerConnection.generateCertificate({
|
|
name: "ECDSA", namedCurve: "P-256",
|
|
});
|
|
}
|
|
// Is the PC still around after the await?
|
|
if (!this._closed) {
|
|
this._impl.certificate = certificate;
|
|
}
|
|
}
|
|
|
|
_resetPeerIdentityPromise() {
|
|
this._peerIdentity = new this._win.Promise((resolve, reject) => {
|
|
this._resolvePeerIdentity = resolve;
|
|
this._rejectPeerIdentity = reject;
|
|
});
|
|
}
|
|
|
|
_initIdp() {
|
|
this._resetPeerIdentityPromise();
|
|
this._lastIdentityValidation = this._win.Promise.resolve();
|
|
|
|
let prefName = "media.peerconnection.identity.timeout";
|
|
let idpTimeout = Services.prefs.getIntPref(prefName);
|
|
this._localIdp = new PeerConnectionIdp(this._win, idpTimeout);
|
|
this._remoteIdp = new PeerConnectionIdp(this._win, idpTimeout);
|
|
}
|
|
|
|
// Add a function to the internal operations chain.
|
|
|
|
async _chain(func) {
|
|
let p = (async () => {
|
|
await this._operationsChain;
|
|
// Don't _checkClosed() inside the chain, because it throws, and spec
|
|
// behavior is to NOT reject outstanding promises on close. This is what
|
|
// happens most of the time anyways, as the c++ code stops calling us once
|
|
// closed, hanging the chain. However, c++ may already have queued tasks
|
|
// on us, so if we're one of those then sit back.
|
|
if (this._closed) {
|
|
return null;
|
|
}
|
|
return func();
|
|
})();
|
|
// don't propagate errors in the operations chain (this is a fork of p).
|
|
this._operationsChain = p.catch(() => {});
|
|
return p;
|
|
}
|
|
|
|
// It's basically impossible to use async directly in JSImplemented code,
|
|
// because the implicit promise must be wrapped to the right type for content.
|
|
//
|
|
// The _async wrapper takes care of this. The _legacy wrapper implements
|
|
// legacy callbacks in a manner that produces correct line-numbers in errors,
|
|
// provided that methods validate their inputs before putting themselves on
|
|
// the pc's operations chain.
|
|
//
|
|
// These wrappers also serve as guards against settling promises past close().
|
|
|
|
_async(func) {
|
|
return this._win.Promise.resolve(this._closeWrapper(func));
|
|
}
|
|
|
|
_legacy(...args) {
|
|
return this._win.Promise.resolve(this._legacyCloseWrapper(...args));
|
|
}
|
|
|
|
_auto(onSucc, onErr, func) {
|
|
return (typeof onSucc == "function") ? this._legacy(onSucc, onErr, func)
|
|
: this._async(func);
|
|
}
|
|
|
|
async _closeWrapper(func) {
|
|
let closed = this._closed;
|
|
try {
|
|
let result = await func();
|
|
if (!closed && this._closed) {
|
|
await new Promise(() => {});
|
|
}
|
|
return result;
|
|
} catch (e) {
|
|
if (!closed && this._closed) {
|
|
await new Promise(() => {});
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
async _legacyCloseWrapper(onSucc, onErr, func) {
|
|
let wrapCallback = cb => result => {
|
|
try {
|
|
cb && cb(result);
|
|
} catch (e) {
|
|
this.logErrorAndCallOnError(e);
|
|
}
|
|
};
|
|
|
|
try {
|
|
wrapCallback(onSucc)(await func());
|
|
} catch (e) {
|
|
wrapCallback(onErr)(e);
|
|
}
|
|
}
|
|
|
|
// This implements the fairly common "Queue a task" logic
|
|
async _queueTaskWithClosedCheck(func) {
|
|
return new this._win.Promise(resolve => {
|
|
Services.tm.dispatchToMainThread({ run() {
|
|
if (!this._closed) {
|
|
func();
|
|
resolve();
|
|
}
|
|
}});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* An RTCConfiguration may look like this:
|
|
*
|
|
* { "iceServers": [ { urls: "stun:stun.example.org", },
|
|
* { url: "stun:stun.example.org", }, // deprecated version
|
|
* { urls: ["turn:turn1.x.org", "turn:turn2.x.org"],
|
|
* username:"jib", credential:"mypass"} ] }
|
|
*
|
|
* This function normalizes the structure of the input for rtcConfig.iceServers for us,
|
|
* so we test well-formed stun/turn urls before passing along to C++.
|
|
* msg - Error message to detail which array-entry failed, if any.
|
|
*/
|
|
_mustValidateRTCConfiguration({ iceServers }, msg) {
|
|
// Normalize iceServers input
|
|
iceServers.forEach(server => {
|
|
if (typeof server.urls === "string") {
|
|
server.urls = [server.urls];
|
|
} else if (!server.urls && server.url) {
|
|
// TODO: Remove support for legacy iceServer.url eventually (Bug 1116766)
|
|
server.urls = [server.url];
|
|
this.logWarning("RTCIceServer.url is deprecated! Use urls instead.");
|
|
}
|
|
});
|
|
|
|
let nicerNewURI = uriStr => {
|
|
try {
|
|
return Services.io.newURI(uriStr);
|
|
} catch (e) {
|
|
if (e.result == Cr.NS_ERROR_MALFORMED_URI) {
|
|
throw new this._win.SyntaxError(`${msg} - malformed URI: ${uriStr}`);
|
|
}
|
|
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 == 0) {
|
|
throw new this._win.SyntaxError(`${msg} - urls is empty`);
|
|
}
|
|
urls.map(url => nicerNewURI(url)).forEach(({ scheme, spec }) => {
|
|
if (scheme in { turn: 1, turns: 1 }) {
|
|
if (username == undefined) {
|
|
throw new this._win.DOMException(`${msg} - missing username: ${spec}`,
|
|
"InvalidAccessError");
|
|
}
|
|
if (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;
|
|
stunServers += 1;
|
|
} else if (scheme in { stun: 1, stuns: 1 }) {
|
|
this._hasStunServer = true;
|
|
stunServers += 1;
|
|
} else {
|
|
throw new this._win.SyntaxError(`${msg} - improper scheme: ${scheme}`);
|
|
}
|
|
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.exceptionFlag);
|
|
|
|
// Safely call onerror directly if present (necessary for testing)
|
|
try {
|
|
if (typeof this._win.onerror === "function") {
|
|
this._win.onerror(e.message, e.fileName, e.lineNumber);
|
|
}
|
|
} catch (e) {
|
|
// If onerror itself throws, service it.
|
|
try {
|
|
this.logMsg(e.message, e.fileName, e.lineNumber, Ci.nsIScriptError.errorFlag);
|
|
} catch (e) {}
|
|
}
|
|
}
|
|
|
|
logError(msg) {
|
|
this.logStackMsg(msg, Ci.nsIScriptError.errorFlag);
|
|
}
|
|
|
|
logWarning(msg) {
|
|
this.logStackMsg(msg, Ci.nsIScriptError.warningFlag);
|
|
}
|
|
|
|
logStackMsg(msg, flag) {
|
|
let err = this._win.Error();
|
|
this.logMsg(msg, err.fileName, err.lineNumber, flag);
|
|
}
|
|
|
|
logMsg(msg, file, line, flag) {
|
|
return logMsg(msg, file, line, flag, this._winID);
|
|
}
|
|
|
|
getEH(type) {
|
|
return this.__DOM_IMPL__.getEventHandler(type);
|
|
}
|
|
|
|
setEH(type, handler) {
|
|
this.__DOM_IMPL__.setEventHandler(type, handler);
|
|
}
|
|
|
|
makeGetterSetterEH(name) {
|
|
Object.defineProperty(this, name,
|
|
{
|
|
get() { return this.getEH(name); },
|
|
set(h) { return this.setEH(name, h); },
|
|
});
|
|
}
|
|
|
|
makeLegacyGetterSetterEH(name, msg) {
|
|
Object.defineProperty(this, name,
|
|
{
|
|
get() { return this.getEH(name); },
|
|
set(h) {
|
|
this.logWarning(name + " is deprecated! " + msg);
|
|
return 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._transceivers.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._transceivers
|
|
.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");
|
|
}
|
|
});
|
|
}
|
|
|
|
async _createOffer(options) {
|
|
this._checkClosed();
|
|
this._ensureTransceiversForOfferToReceive(options);
|
|
this._syncTransceivers();
|
|
let origin = Cu.getWebIDLCallerPrincipal().origin;
|
|
return this._chain(async () => {
|
|
let haveAssertion;
|
|
if (this._localIdp.enabled) {
|
|
haveAssertion = this._getIdentityAssertion(origin);
|
|
}
|
|
await this._getPermission();
|
|
await this._certificateReady;
|
|
let sdp = await new Promise((resolve, reject) => {
|
|
this._onCreateOfferSuccess = resolve;
|
|
this._onCreateOfferFailure = reject;
|
|
this._impl.createOffer(options);
|
|
});
|
|
if (haveAssertion) {
|
|
await haveAssertion;
|
|
sdp = this._localIdp.addIdentityAttribute(sdp);
|
|
}
|
|
return Cu.cloneInto({ type: "offer", sdp }, this._win);
|
|
});
|
|
}
|
|
|
|
createAnswer(optionsOrOnSucc, onErr) {
|
|
// This entry-point handles both new and legacy call sig. Decipher which one
|
|
if (typeof optionsOrOnSucc == "function") {
|
|
return this._legacy(optionsOrOnSucc, onErr, () => this._createAnswer({}));
|
|
}
|
|
return this._async(() => this._createAnswer(optionsOrOnSucc));
|
|
}
|
|
|
|
async _createAnswer(options) {
|
|
this._checkClosed();
|
|
this._syncTransceivers();
|
|
let origin = Cu.getWebIDLCallerPrincipal().origin;
|
|
return this._chain(async () => {
|
|
// We give up line-numbers in errors by doing this here, but do all
|
|
// state-checks inside the chain, to support the legacy feature that
|
|
// callers don't have to wait for setRemoteDescription to finish.
|
|
if (!this.remoteDescription) {
|
|
throw new this._win.DOMException("setRemoteDescription not called",
|
|
"InvalidStateError");
|
|
}
|
|
if (this.remoteDescription.type != "offer") {
|
|
throw new this._win.DOMException("No outstanding offer",
|
|
"InvalidStateError");
|
|
}
|
|
let haveAssertion;
|
|
if (this._localIdp.enabled) {
|
|
haveAssertion = this._getIdentityAssertion(origin);
|
|
}
|
|
await this._getPermission();
|
|
await this._certificateReady;
|
|
let sdp = await new Promise((resolve, reject) => {
|
|
this._onCreateAnswerSuccess = resolve;
|
|
this._onCreateAnswerFailure = reject;
|
|
this._impl.createAnswer();
|
|
});
|
|
if (haveAssertion) {
|
|
await haveAssertion;
|
|
sdp = this._localIdp.addIdentityAttribute(sdp);
|
|
}
|
|
return Cu.cloneInto({ type: "answer", sdp }, this._win);
|
|
});
|
|
}
|
|
|
|
async _getPermission() {
|
|
if (!this._havePermission) {
|
|
let privileged = this._isChrome ||
|
|
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.windowUtils.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(action, type, sdp) {
|
|
if (action === undefined) {
|
|
throw new this._win.DOMException(
|
|
"Invalid type " + type + " provided to setLocalDescription",
|
|
"InvalidParameterError");
|
|
}
|
|
if (action == Ci.IPeerConnection.kActionPRAnswer) {
|
|
throw new this._win.DOMException("pranswer not yet implemented",
|
|
"NotSupportedError");
|
|
}
|
|
|
|
if (!sdp && action != Ci.IPeerConnection.kActionRollback) {
|
|
throw new this._win.DOMException(
|
|
"Empty or null SDP provided to setLocalDescription",
|
|
"InvalidParameterError");
|
|
}
|
|
|
|
// 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));
|
|
}
|
|
|
|
async _setLocalDescription({ type, sdp }) {
|
|
this._checkClosed();
|
|
|
|
this._localType = type;
|
|
|
|
let action = this._actions[type];
|
|
|
|
this._sanityCheckSdp(action, type, sdp);
|
|
|
|
return this._chain(async () => {
|
|
await this._getPermission();
|
|
await new Promise((resolve, reject) => {
|
|
this._onSetLocalDescriptionSuccess = resolve;
|
|
this._onSetLocalDescriptionFailure = reject;
|
|
this._impl.setLocalDescription(action, sdp);
|
|
});
|
|
this._negotiationNeeded = false;
|
|
this.updateNegotiationNeeded();
|
|
});
|
|
}
|
|
|
|
async _validateIdentity(sdp, origin) {
|
|
let expectedIdentity;
|
|
|
|
// Only run a single identity verification at a time. We have to do this to
|
|
// avoid problems with the fact that identity validation doesn't block the
|
|
// resolution of setRemoteDescription().
|
|
let p = (async () => {
|
|
try {
|
|
await this._lastIdentityValidation;
|
|
let msg = await this._remoteIdp.verifyIdentityFromSDP(sdp, origin);
|
|
expectedIdentity = this._impl.peerIdentity;
|
|
// If this pc has an identity already, then the identity in sdp must match
|
|
if (expectedIdentity && (!msg || msg.identity !== expectedIdentity)) {
|
|
this.close();
|
|
throw new this._win.DOMException(
|
|
"Peer Identity mismatch, expected: " + expectedIdentity,
|
|
"IncompatibleSessionDescriptionError");
|
|
}
|
|
if (msg) {
|
|
// Set new identity and generate an event.
|
|
this._impl.peerIdentity = msg.identity;
|
|
this._resolvePeerIdentity(Cu.cloneInto({
|
|
idp: this._remoteIdp.provider,
|
|
name: msg.identity,
|
|
}, this._win));
|
|
}
|
|
} catch (e) {
|
|
this._rejectPeerIdentity(e);
|
|
// If we don't expect a specific peer identity, failure to get a valid
|
|
// peer identity is not a terminal state, so replace the promise to
|
|
// allow another attempt.
|
|
if (!this._impl.peerIdentity) {
|
|
this._resetPeerIdentityPromise();
|
|
}
|
|
throw e;
|
|
}
|
|
})();
|
|
this._lastIdentityValidation = p.catch(() => {});
|
|
|
|
// Only wait for IdP validation if we need identity matching
|
|
if (expectedIdentity) {
|
|
await p;
|
|
}
|
|
}
|
|
|
|
setRemoteDescription(desc, onSucc, onErr) {
|
|
return this._auto(onSucc, onErr, () => this._setRemoteDescription(desc));
|
|
}
|
|
|
|
async _setRemoteDescription({ type, sdp }) {
|
|
this._checkClosed();
|
|
this._remoteType = type;
|
|
|
|
let action = this._actions[type];
|
|
|
|
this._sanityCheckSdp(action, type, sdp);
|
|
|
|
// Get caller's origin before hitting the promise chain
|
|
let origin = Cu.getWebIDLCallerPrincipal().origin;
|
|
|
|
return this._chain(async () => {
|
|
let haveSetRemote = (async () => {
|
|
await this._getPermission();
|
|
await new Promise((resolve, reject) => {
|
|
this._onSetRemoteDescriptionSuccess = resolve;
|
|
this._onSetRemoteDescriptionFailure = reject;
|
|
this._impl.setRemoteDescription(action, sdp);
|
|
});
|
|
this._updateCanTrickle();
|
|
})();
|
|
|
|
if (action != Ci.IPeerConnection.kActionRollback) {
|
|
// Do setRemoteDescription and identity validation in parallel
|
|
await this._validateIdentity(sdp, origin);
|
|
}
|
|
await haveSetRemote;
|
|
this._negotiationNeeded = false;
|
|
this.updateNegotiationNeeded();
|
|
});
|
|
}
|
|
|
|
setIdentityProvider(provider,
|
|
{protocol, usernameHint, peerIdentity} = {}) {
|
|
this._checkClosed();
|
|
this._localIdp.setIdentityProvider(provider,
|
|
protocol, usernameHint, peerIdentity);
|
|
}
|
|
|
|
async _getIdentityAssertion(origin) {
|
|
await this._certificateReady;
|
|
return this._localIdp.getIdentityAssertion(this._impl.fingerprint, origin);
|
|
}
|
|
|
|
getIdentityAssertion() {
|
|
this._checkClosed();
|
|
let origin = Cu.getWebIDLCallerPrincipal().origin;
|
|
return this._win.Promise.resolve(this._chain(() =>
|
|
this._getIdentityAssertion(origin)));
|
|
}
|
|
|
|
get canTrickleIceCandidates() {
|
|
return this._canTrickle;
|
|
}
|
|
|
|
_updateCanTrickle() {
|
|
let containsTrickle = section => {
|
|
let lines = section.toLowerCase().split(/(?:\r\n?|\n)/);
|
|
return lines.some(line => {
|
|
let prefix = "a=ice-options:";
|
|
if (line.substring(0, prefix.length) !== prefix) {
|
|
return false;
|
|
}
|
|
let tokens = line.substring(prefix.length).split(" ");
|
|
return tokens.some(x => x === "trickle");
|
|
});
|
|
};
|
|
|
|
let desc = null;
|
|
try {
|
|
// The getter for remoteDescription can throw if the pc is closed.
|
|
desc = this.remoteDescription;
|
|
} catch (e) {}
|
|
if (!desc) {
|
|
this._canTrickle = null;
|
|
return;
|
|
}
|
|
|
|
let sections = desc.sdp.split(/(?:\r\n?|\n)m=/);
|
|
let topSection = sections.shift();
|
|
this._canTrickle =
|
|
containsTrickle(topSection) || sections.every(containsTrickle);
|
|
}
|
|
|
|
// TODO: Implement processing for end-of-candidates (bug 1318167)
|
|
addIceCandidate(cand, onSucc, onErr) {
|
|
if (cand === null) {
|
|
throw new this._win.DOMException(
|
|
"Empty candidate can not be added.",
|
|
"TypeError");
|
|
}
|
|
return this._auto(onSucc, onErr, () => cand && this._addIceCandidate(cand));
|
|
}
|
|
|
|
async _addIceCandidate({ candidate, sdpMid, sdpMLineIndex }) {
|
|
this._checkClosed();
|
|
return this._chain(() => {
|
|
return new Promise((resolve, reject) => {
|
|
this._onAddIceCandidateSuccess = resolve;
|
|
this._onAddIceCandidateError = reject;
|
|
this._impl.addIceCandidate(candidate, sdpMid || "", sdpMLineIndex);
|
|
});
|
|
});
|
|
}
|
|
|
|
addStream(stream) {
|
|
stream.getTracks().forEach(track => this.addTrack(track, stream));
|
|
}
|
|
|
|
addTrack(track, stream) {
|
|
this._checkClosed();
|
|
|
|
if (this._transceivers.some(
|
|
transceiver => transceiver.sender.track == track)) {
|
|
throw new this._win.DOMException("This track is already set on a sender.",
|
|
"InvalidAccessError");
|
|
}
|
|
|
|
let transceiver = this._transceivers.find(transceiver => {
|
|
return transceiver.sender.track == null &&
|
|
transceiver.getKind() == track.kind &&
|
|
!transceiver.stopped &&
|
|
!transceiver.hasBeenUsedToSend();
|
|
});
|
|
|
|
if (transceiver) {
|
|
transceiver.sender.setTrack(track);
|
|
transceiver.sender.setStreams([stream]);
|
|
if (transceiver.direction == "recvonly") {
|
|
transceiver.setDirectionInternal("sendrecv");
|
|
} else if (transceiver.direction == "inactive") {
|
|
transceiver.setDirectionInternal("sendonly");
|
|
}
|
|
} else {
|
|
transceiver = this._addTransceiverNoEvents(track, {
|
|
streams: [stream],
|
|
direction: "sendrecv",
|
|
});
|
|
}
|
|
|
|
transceiver.setAddTrackMagic();
|
|
transceiver.sync();
|
|
this.updateNegotiationNeeded();
|
|
return transceiver.sender;
|
|
}
|
|
|
|
removeTrack(sender) {
|
|
this._checkClosed();
|
|
|
|
sender.checkWasCreatedByPc(this.__DOM_IMPL__);
|
|
|
|
let transceiver =
|
|
this._transceivers.find(transceiver => 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");
|
|
}
|
|
|
|
transceiver.sync();
|
|
this.updateNegotiationNeeded();
|
|
}
|
|
|
|
_addTransceiverNoEvents(sendTrackOrKind, init) {
|
|
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;
|
|
}
|
|
|
|
let transceiverImpl = this._impl.createTransceiverImpl(kind, sendTrack);
|
|
let transceiver = this._win.RTCRtpTransceiver._create(
|
|
this._win,
|
|
new RTCRtpTransceiver(this, transceiverImpl, init, kind, sendTrack));
|
|
transceiver.sync();
|
|
this._transceivers.push(transceiver);
|
|
return transceiver;
|
|
}
|
|
|
|
_onTransceiverNeeded(kind, transceiverImpl) {
|
|
let init = {direction: "recvonly"};
|
|
let transceiver = this._win.RTCRtpTransceiver._create(
|
|
this._win,
|
|
new RTCRtpTransceiver(this, transceiverImpl, init, kind, null));
|
|
transceiver.sync();
|
|
this._transceivers.push(transceiver);
|
|
}
|
|
|
|
/* Returns a dictionary with three keys:
|
|
* sources: a list of contributing and synchronization sources
|
|
* sourceClockOffset: an offset to apply to the source timestamp to get a
|
|
* very close approximation of the sample time with respect to the local
|
|
* clock.
|
|
* jsTimestamp: the current JS time
|
|
* Note: because the two clocks can drift with respect to each other, once
|
|
* a timestamp offset has been calculated it should not be recalculated
|
|
* until the timestamp changes, this way it will not appear as if a new
|
|
* audio level sample has arrived.
|
|
*/
|
|
_getRtpSources(receiver) {
|
|
let cache = this._rtpSourceCache;
|
|
// Schedule cache invalidation
|
|
if (!cache.scheduledClear) {
|
|
cache.scheduledClear = true;
|
|
Promise.resolve().then(() => {
|
|
this._rtpSourceCache = new RTCRtpSourceCache();
|
|
});
|
|
}
|
|
// Fetch the RTP source local time, store it for reuse, calculate
|
|
// the local offset, likewise store it for reuse.
|
|
if (cache.tsNowInRtpSourceTime !== undefined) {
|
|
cache.tsNowInRtpSourceTime = this._impl.getNowInRtpSourceReferenceTime();
|
|
cache.jsTimestamp = this._win.performance.now() + this._win.performance.timeOrigin;
|
|
cache.timestampOffset = cache.jsTimestamp - cache.tsNowInRtpSourceTime;
|
|
}
|
|
let id = receiver.track.id;
|
|
if (cache.rtpSourcesByTrackId[id] === undefined) {
|
|
cache.rtpSourcesByTrackId[id] =
|
|
this._impl.getRtpSources(receiver.track, cache.tsNowInRtpSourceTime);
|
|
}
|
|
return {
|
|
sources: cache.rtpSourcesByTrackId[id],
|
|
sourceClockOffset: cache.timestampOffset,
|
|
jsTimestamp: cache.jsTimestamp,
|
|
};
|
|
}
|
|
|
|
addTransceiver(sendTrackOrKind, init) {
|
|
this._checkClosed();
|
|
let transceiver = this._addTransceiverNoEvents(sendTrackOrKind, init);
|
|
this.updateNegotiationNeeded();
|
|
return transceiver;
|
|
}
|
|
|
|
_syncTransceivers() {
|
|
this._transceivers.forEach(transceiver => transceiver.sync());
|
|
}
|
|
|
|
updateNegotiationNeeded() {
|
|
if (this._closed || this.signalingState != "stable") {
|
|
return;
|
|
}
|
|
|
|
let negotiationNeeded = this._impl.checkNegotiationNeeded();
|
|
if (!negotiationNeeded) {
|
|
this._negotiationNeeded = false;
|
|
return;
|
|
}
|
|
|
|
if (this._negotiationNeeded) {
|
|
return;
|
|
}
|
|
|
|
this._negotiationNeeded = true;
|
|
|
|
this._queueTaskWithClosedCheck(() => {
|
|
if (this._negotiationNeeded) {
|
|
this.dispatchEvent(new this._win.Event("negotiationneeded"));
|
|
}
|
|
});
|
|
}
|
|
|
|
_processTrackAdditionsAndRemovals() {
|
|
let postProcessing = {
|
|
updateStreamFunctions: [],
|
|
muteTracks: [],
|
|
trackEvents: [],
|
|
};
|
|
|
|
for (let transceiver of this._transceivers) {
|
|
transceiver.receiver.processTrackAdditionsAndRemovals(transceiver,
|
|
postProcessing);
|
|
}
|
|
|
|
for (let f of postProcessing.updateStreamFunctions) {
|
|
f();
|
|
}
|
|
|
|
for (let t of postProcessing.muteTracks) {
|
|
t.mutedChanged(true);
|
|
}
|
|
|
|
for (let ev of postProcessing.trackEvents) {
|
|
this.dispatchEvent(ev);
|
|
}
|
|
}
|
|
|
|
// TODO(Bug 1241291): Legacy event, remove eventually
|
|
_fireLegacyAddStreamEvents() {
|
|
for (let stream of this._newStreams) {
|
|
let ev = new this._win.MediaStreamEvent("addstream", { stream });
|
|
this.dispatchEvent(ev);
|
|
}
|
|
this._newStreams = [];
|
|
}
|
|
|
|
_getOrCreateStream(id) {
|
|
if (!this._receiveStreams.has(id)) {
|
|
let stream = new this._win.MediaStream();
|
|
stream.assignId(id);
|
|
this._newStreams.push(stream);
|
|
this._receiveStreams.set(id, stream);
|
|
}
|
|
|
|
return this._receiveStreams.get(id);
|
|
}
|
|
|
|
_insertDTMF(transceiverImpl, tones, duration, interToneGap) {
|
|
return this._impl.insertDTMF(transceiverImpl, tones, duration, interToneGap);
|
|
}
|
|
|
|
_getDTMFToneBuffer(sender) {
|
|
return this._impl.getDTMFToneBuffer(sender.__DOM_IMPL__);
|
|
}
|
|
|
|
_replaceTrackNoRenegotiation(transceiverImpl, withTrack) {
|
|
this._impl.replaceTrackNoRenegotiation(transceiverImpl, withTrack);
|
|
}
|
|
|
|
close() {
|
|
if (this._closed) {
|
|
return;
|
|
}
|
|
this._closed = true;
|
|
this.changeIceConnectionState("closed");
|
|
if (this._localIdp) {
|
|
this._localIdp.close();
|
|
}
|
|
if (this._remoteIdp) {
|
|
this._remoteIdp.close();
|
|
}
|
|
this._impl.close();
|
|
this._suppressEvents = true;
|
|
delete this._pc;
|
|
delete this._observer;
|
|
}
|
|
|
|
getLocalStreams() {
|
|
this._checkClosed();
|
|
let localStreams = new Set();
|
|
this._transceivers.forEach(transceiver => {
|
|
transceiver.sender.getStreams().forEach(stream => {
|
|
localStreams.add(stream);
|
|
});
|
|
});
|
|
return [...localStreams.values()];
|
|
}
|
|
|
|
getRemoteStreams() {
|
|
this._checkClosed();
|
|
return [...this._receiveStreams.values()];
|
|
}
|
|
|
|
getSenders() {
|
|
return this.getTransceivers().map(transceiver => transceiver.sender);
|
|
}
|
|
|
|
getReceivers() {
|
|
return this.getTransceivers().map(transceiver => transceiver.receiver);
|
|
}
|
|
|
|
// test-only: get the current time using the webrtc clock
|
|
mozGetNowInRtpSourceReferenceTime() {
|
|
return this._impl.getNowInRtpSourceReferenceTime();
|
|
}
|
|
|
|
// test-only: insert a contributing source entry for a track
|
|
mozInsertAudioLevelForContributingSource(receiver,
|
|
source,
|
|
timestamp,
|
|
hasLevel,
|
|
level) {
|
|
this._impl.insertAudioLevelForContributingSource(receiver.track,
|
|
source,
|
|
timestamp,
|
|
hasLevel,
|
|
level);
|
|
}
|
|
|
|
mozAddRIDExtension(receiver, extensionId) {
|
|
this._impl.addRIDExtension(receiver.track, extensionId);
|
|
}
|
|
|
|
mozAddRIDFilter(receiver, rid) {
|
|
this._impl.addRIDFilter(receiver.track, rid);
|
|
}
|
|
|
|
mozSetPacketCallback(callback) {
|
|
this._onPacket = callback;
|
|
}
|
|
|
|
mozEnablePacketDump(level, type, sending) {
|
|
this._impl.enablePacketDump(level, type, sending);
|
|
}
|
|
|
|
mozDisablePacketDump(level, type, sending) {
|
|
this._impl.disablePacketDump(level, type, sending);
|
|
}
|
|
|
|
getTransceivers() {
|
|
return this._transceivers;
|
|
}
|
|
|
|
get localDescription() {
|
|
this._checkClosed();
|
|
let sdp = this._impl.localDescription;
|
|
if (sdp.length == 0) {
|
|
return null;
|
|
}
|
|
return new this._win.RTCSessionDescription({ type: this._localType, sdp });
|
|
}
|
|
|
|
get currentLocalDescription() {
|
|
this._checkClosed();
|
|
let sdp = this._impl.currentLocalDescription;
|
|
if (sdp.length == 0) {
|
|
return null;
|
|
}
|
|
return new this._win.RTCSessionDescription({ type: this._localType, sdp });
|
|
}
|
|
|
|
get pendingLocalDescription() {
|
|
this._checkClosed();
|
|
let sdp = this._impl.pendingLocalDescription;
|
|
if (sdp.length == 0) {
|
|
return null;
|
|
}
|
|
return new this._win.RTCSessionDescription({ type: this._localType, sdp });
|
|
}
|
|
|
|
get remoteDescription() {
|
|
this._checkClosed();
|
|
let sdp = this._impl.remoteDescription;
|
|
if (sdp.length == 0) {
|
|
return null;
|
|
}
|
|
return new this._win.RTCSessionDescription({ type: this._remoteType, sdp });
|
|
}
|
|
|
|
get currentRemoteDescription() {
|
|
this._checkClosed();
|
|
let sdp = this._impl.currentRemoteDescription;
|
|
if (sdp.length == 0) {
|
|
return null;
|
|
}
|
|
return new this._win.RTCSessionDescription({ type: this._remoteType, sdp });
|
|
}
|
|
|
|
get pendingRemoteDescription() {
|
|
this._checkClosed();
|
|
let sdp = this._impl.pendingRemoteDescription;
|
|
if (sdp.length == 0) {
|
|
return null;
|
|
}
|
|
return new this._win.RTCSessionDescription({ type: this._remoteType, sdp });
|
|
}
|
|
|
|
get peerIdentity() { return this._peerIdentity; }
|
|
get idpLoginUrl() { return this._localIdp.idpLoginUrl; }
|
|
get id() { return this._impl.id; }
|
|
set id(s) { this._impl.id = s; }
|
|
get iceGatheringState() { return this._iceGatheringState; }
|
|
get iceConnectionState() { return this._iceConnectionState; }
|
|
|
|
get signalingState() {
|
|
// checking for our local pc closed indication
|
|
// before invoking the pc methods.
|
|
if (this._closed) {
|
|
return "closed";
|
|
}
|
|
return {
|
|
"SignalingInvalid": "",
|
|
"SignalingStable": "stable",
|
|
"SignalingHaveLocalOffer": "have-local-offer",
|
|
"SignalingHaveRemoteOffer": "have-remote-offer",
|
|
"SignalingHaveLocalPranswer": "have-local-pranswer",
|
|
"SignalingHaveRemotePranswer": "have-remote-pranswer",
|
|
"SignalingClosed": "closed",
|
|
}[this._impl.signalingState];
|
|
}
|
|
|
|
changeIceGatheringState(state) {
|
|
this._iceGatheringState = state;
|
|
_globalPCList.notifyLifecycleObservers(this, "icegatheringstatechange");
|
|
this.dispatchEvent(new this._win.Event("icegatheringstatechange"));
|
|
}
|
|
|
|
changeIceConnectionState(state) {
|
|
if (state != this._iceConnectionState) {
|
|
this._iceConnectionState = state;
|
|
_globalPCList.notifyLifecycleObservers(this, "iceconnectionstatechange");
|
|
this.dispatchEvent(new this._win.Event("iceconnectionstatechange"));
|
|
}
|
|
}
|
|
|
|
getStats(selector, onSucc, onErr) {
|
|
if (this._iceConnectionState === "completed" ||
|
|
this._iceConnectionState === "connected") {
|
|
this._pcTelemetry.recordGetStats();
|
|
}
|
|
return this._auto(onSucc, onErr, () => this._getStats(selector));
|
|
}
|
|
|
|
async _getStats(selector) {
|
|
// getStats is allowed even in closed state.
|
|
return this._chain(() => new Promise((resolve, reject) => {
|
|
this._onGetStatsSuccess = resolve;
|
|
this._onGetStatsFailure = reject;
|
|
this._impl.getStats(selector);
|
|
}));
|
|
}
|
|
|
|
createDataChannel(label, {
|
|
maxRetransmits, ordered, negotiated, id = 0xFFFF,
|
|
maxRetransmitTime, maxPacketLifeTime = maxRetransmitTime,
|
|
protocol,
|
|
} = {}) {
|
|
this._checkClosed();
|
|
|
|
if (maxRetransmitTime !== undefined) {
|
|
this.logWarning("Use maxPacketLifeTime instead of deprecated maxRetransmitTime which will stop working soon in createDataChannel!");
|
|
}
|
|
if (maxPacketLifeTime !== undefined && maxRetransmits !== undefined) {
|
|
throw new this._win.DOMException(
|
|
"Both maxPacketLifeTime and maxRetransmits cannot be provided",
|
|
"InvalidParameterError");
|
|
}
|
|
// Must determine the type where we still know if entries are undefined.
|
|
let type;
|
|
if (maxPacketLifeTime !== 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 =
|
|
this._impl.createDataChannel(label, protocol, type, ordered,
|
|
maxPacketLifeTime, maxRetransmits,
|
|
negotiated, id);
|
|
|
|
// 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([Ci.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.
|
|
|
|
class PeerConnectionObserver {
|
|
init(win) {
|
|
this._win = win;
|
|
}
|
|
|
|
__init(dompc) {
|
|
this._dompc = dompc._innerObject;
|
|
}
|
|
|
|
newError(message, code) {
|
|
// These strings must match those defined in the WebRTC spec.
|
|
const reasonName = [
|
|
"",
|
|
"InternalError",
|
|
"InternalError",
|
|
"InvalidParameterError",
|
|
"InvalidStateError",
|
|
"InvalidSessionDescriptionError",
|
|
"IncompatibleSessionDescriptionError",
|
|
"InternalError",
|
|
"IncompatibleMediaStreamTrackError",
|
|
"InternalError",
|
|
"TypeError",
|
|
"OperationError",
|
|
];
|
|
let name = reasonName[Math.min(code, reasonName.length - 1)];
|
|
return new this._dompc._win.DOMException(message, name);
|
|
}
|
|
|
|
dispatchEvent(event) {
|
|
this._dompc.dispatchEvent(event);
|
|
}
|
|
|
|
onCreateOfferSuccess(sdp) {
|
|
this._dompc._onCreateOfferSuccess(sdp);
|
|
}
|
|
|
|
onCreateOfferError(code, message) {
|
|
this._dompc._onCreateOfferFailure(this.newError(message, code));
|
|
}
|
|
|
|
onCreateAnswerSuccess(sdp) {
|
|
this._dompc._onCreateAnswerSuccess(sdp);
|
|
}
|
|
|
|
onCreateAnswerError(code, message) {
|
|
this._dompc._onCreateAnswerFailure(this.newError(message, code));
|
|
}
|
|
|
|
onSetLocalDescriptionSuccess() {
|
|
this._dompc._syncTransceivers();
|
|
this._dompc._onSetLocalDescriptionSuccess();
|
|
}
|
|
|
|
onSetRemoteDescriptionSuccess() {
|
|
this._dompc._syncTransceivers();
|
|
this._dompc._processTrackAdditionsAndRemovals();
|
|
this._dompc._fireLegacyAddStreamEvents();
|
|
this._dompc._transceivers = this._dompc._transceivers.filter(t => !t.shouldRemove);
|
|
this._dompc._onSetRemoteDescriptionSuccess();
|
|
}
|
|
|
|
onSetLocalDescriptionError(code, message) {
|
|
this._localType = null;
|
|
this._dompc._onSetLocalDescriptionFailure(this.newError(message, code));
|
|
}
|
|
|
|
onSetRemoteDescriptionError(code, message) {
|
|
this._remoteType = null;
|
|
this._dompc._onSetRemoteDescriptionFailure(this.newError(message, code));
|
|
}
|
|
|
|
onAddIceCandidateSuccess() {
|
|
this._dompc._onAddIceCandidateSuccess();
|
|
}
|
|
|
|
onAddIceCandidateError(code, message) {
|
|
this._dompc._onAddIceCandidateError(this.newError(message, code));
|
|
}
|
|
|
|
onIceCandidate(sdpMLineIndex, sdpMid, candidate) {
|
|
let win = this._dompc._win;
|
|
if (candidate) {
|
|
if (candidate.includes(" typ relay ")) {
|
|
this._dompc._iceGatheredRelayCandidates = true;
|
|
}
|
|
candidate = new win.RTCIceCandidate({ candidate, sdpMid, sdpMLineIndex });
|
|
} else {
|
|
candidate = null;
|
|
}
|
|
this.dispatchEvent(new win.RTCPeerConnectionIceEvent("icecandidate",
|
|
{ candidate }));
|
|
}
|
|
|
|
// This method is primarily responsible for updating iceConnectionState.
|
|
// This state is defined in the WebRTC specification as follows:
|
|
//
|
|
// iceConnectionState:
|
|
// -------------------
|
|
// new Any of the RTCIceTransports are in the new state and none
|
|
// of them are in the checking, failed or disconnected state.
|
|
//
|
|
// checking Any of the RTCIceTransports are in the checking state and
|
|
// none of them are in the failed or disconnected state.
|
|
//
|
|
// connected All RTCIceTransports are in the connected, completed or
|
|
// closed state and at least one of them is in the connected
|
|
// state.
|
|
//
|
|
// completed All RTCIceTransports are in the completed or closed state
|
|
// and at least one of them is in the completed state.
|
|
//
|
|
// failed Any of the RTCIceTransports are in the failed state.
|
|
//
|
|
// disconnected Any of the RTCIceTransports are in the disconnected state
|
|
// and none of them are in the failed state.
|
|
//
|
|
// closed All of the RTCIceTransports are in the closed state.
|
|
|
|
handleIceConnectionStateChange(iceConnectionState) {
|
|
let pc = this._dompc;
|
|
if (pc.iceConnectionState === iceConnectionState) {
|
|
return;
|
|
}
|
|
if (pc.iceConnectionState === "new") {
|
|
var checking_histogram = Services.telemetry.getHistogramById("WEBRTC_ICE_CHECKING_RATE");
|
|
if (iceConnectionState === "checking") {
|
|
checking_histogram.add(true);
|
|
} else if (iceConnectionState === "failed") {
|
|
checking_histogram.add(false);
|
|
}
|
|
} else if (pc.iceConnectionState === "checking") {
|
|
var success_histogram = Services.telemetry.getHistogramById("WEBRTC_ICE_SUCCESS_RATE");
|
|
if (iceConnectionState === "completed" ||
|
|
iceConnectionState === "connected") {
|
|
success_histogram.add(true);
|
|
pc._pcTelemetry.recordConnected();
|
|
} else if (iceConnectionState === "failed") {
|
|
success_histogram.add(false);
|
|
}
|
|
}
|
|
|
|
if (iceConnectionState === "failed") {
|
|
if (!pc._hasStunServer) {
|
|
pc.logError("ICE failed, add a STUN server and see about:webrtc for more details");
|
|
} else if (!pc._hasTurnServer) {
|
|
pc.logError("ICE failed, add a TURN server and see about:webrtc for more details");
|
|
} else if (pc._hasTurnServer && !pc._iceGatheredRelayCandidates) {
|
|
pc.logError("ICE failed, your TURN server appears to be broken, see about:webrtc for more details");
|
|
} else {
|
|
pc.logError("ICE failed, see about:webrtc for more details");
|
|
}
|
|
}
|
|
|
|
pc.changeIceConnectionState(iceConnectionState);
|
|
}
|
|
|
|
// This method is responsible for updating iceGatheringState. This
|
|
// state is defined in the WebRTC specification as follows:
|
|
//
|
|
// iceGatheringState:
|
|
// ------------------
|
|
// new The object was just created, and no networking has occurred
|
|
// yet.
|
|
//
|
|
// gathering The ICE agent is in the process of gathering candidates for
|
|
// this RTCPeerConnection.
|
|
//
|
|
// complete The ICE agent has completed gathering. Events such as adding
|
|
// a new interface or a new TURN server will cause the state to
|
|
// go back to gathering.
|
|
//
|
|
handleIceGatheringStateChange(gatheringState) {
|
|
let pc = this._dompc;
|
|
if (pc.iceGatheringState === gatheringState) {
|
|
return;
|
|
}
|
|
pc.changeIceGatheringState(gatheringState);
|
|
}
|
|
|
|
onStateChange(state) {
|
|
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.handleIceGatheringStateChange(this._dompc._pc.iceGatheringState);
|
|
break;
|
|
|
|
default:
|
|
this._dompc.logWarning("Unhandled state type: " + state);
|
|
break;
|
|
}
|
|
}
|
|
|
|
onGetStatsSuccess(dict) {
|
|
let pc = this._dompc;
|
|
let chromeobj = new RTCStatsReport(pc, dict);
|
|
let webidlobj = pc._win.RTCStatsReport._create(pc._win, chromeobj);
|
|
chromeobj.makeStatsPublic();
|
|
pc._onGetStatsSuccess(webidlobj);
|
|
}
|
|
|
|
onGetStatsError(code, message) {
|
|
this._dompc._onGetStatsFailure(this.newError(message, code));
|
|
}
|
|
|
|
_getTransceiverWithRecvTrack(webrtcTrackId) {
|
|
return this._dompc.getTransceivers().find(
|
|
transceiver => transceiver.remoteTrackIdIs(webrtcTrackId));
|
|
}
|
|
|
|
onTransceiverNeeded(kind, transceiverImpl) {
|
|
this._dompc._onTransceiverNeeded(kind, transceiverImpl);
|
|
}
|
|
|
|
notifyDataChannel(channel) {
|
|
this.dispatchEvent(new this._dompc._win.RTCDataChannelEvent("datachannel",
|
|
{ channel }));
|
|
}
|
|
|
|
onDTMFToneChange(track, tone) {
|
|
var pc = this._dompc;
|
|
var sender = pc.getSenders().find(sender => sender.track == track);
|
|
sender.dtmf.dispatchEvent(new pc._win.RTCDTMFToneChangeEvent("tonechange",
|
|
{ tone }));
|
|
}
|
|
|
|
onPacket(level, type, sending, packet) {
|
|
var pc = this._dompc;
|
|
if (pc._onPacket) {
|
|
pc._onPacket(level, type, sending, packet);
|
|
}
|
|
}
|
|
|
|
syncTransceivers() {
|
|
this._dompc._syncTransceivers();
|
|
}
|
|
}
|
|
setupPrototype(PeerConnectionObserver, {
|
|
classID: PC_OBS_CID,
|
|
contractID: PC_OBS_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([Ci.nsIDOMGlobalPropertyInitializer]),
|
|
});
|
|
|
|
class RTCPeerConnectionStatic {
|
|
init(win) {
|
|
this._winID = win.windowUtils.currentInnerWindowID;
|
|
}
|
|
|
|
registerPeerConnectionLifecycleCallback(cb) {
|
|
_globalPCList._registerPeerConnectionLifecycleCallback(this._winID, cb);
|
|
}
|
|
}
|
|
setupPrototype(RTCPeerConnectionStatic, {
|
|
classID: PC_STATIC_CID,
|
|
contractID: PC_STATIC_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([Ci.nsIDOMGlobalPropertyInitializer]),
|
|
});
|
|
|
|
class RTCDTMFSender {
|
|
constructor(sender) {
|
|
this._sender = sender;
|
|
}
|
|
|
|
get toneBuffer() {
|
|
return this._sender._pc._getDTMFToneBuffer(this._sender);
|
|
}
|
|
|
|
get ontonechange() {
|
|
return this.__DOM_IMPL__.getEventHandler("ontonechange");
|
|
}
|
|
|
|
set ontonechange(handler) {
|
|
this.__DOM_IMPL__.setEventHandler("ontonechange", handler);
|
|
}
|
|
|
|
insertDTMF(tones, duration, interToneGap) {
|
|
this._sender._pc._checkClosed();
|
|
this._sender._transceiver.insertDTMF(tones, duration, interToneGap);
|
|
}
|
|
}
|
|
setupPrototype(RTCDTMFSender, {
|
|
classID: PC_DTMF_SENDER_CID,
|
|
contractID: PC_DTMF_SENDER_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([]),
|
|
});
|
|
|
|
class RTCRtpSender {
|
|
constructor(pc, transceiverImpl, transceiver, track, kind, streams) {
|
|
let dtmf = null;
|
|
if (kind == "audio") {
|
|
dtmf = pc._win.RTCDTMFSender._create(pc._win, new RTCDTMFSender(this));
|
|
}
|
|
|
|
Object.assign(this, {
|
|
_pc: pc,
|
|
_transceiverImpl: transceiverImpl,
|
|
_transceiver: transceiver,
|
|
track,
|
|
_streams: streams,
|
|
dtmf });
|
|
}
|
|
|
|
replaceTrack(withTrack) {
|
|
// async functions in here return a chrome promise, which is not something
|
|
// content can use. This wraps that promise in something content can use.
|
|
return this._pc._win.Promise.resolve(this._replaceTrack(withTrack));
|
|
}
|
|
|
|
async _replaceTrack(withTrack) {
|
|
this._pc._checkClosed();
|
|
|
|
if (this._transceiver.stopped) {
|
|
throw new this._pc._win.DOMException(
|
|
"Cannot call replaceTrack when transceiver is stopped",
|
|
"InvalidStateError");
|
|
}
|
|
|
|
if (withTrack && (withTrack.kind != this._transceiver.getKind())) {
|
|
throw new this._pc._win.DOMException(
|
|
"Cannot replaceTrack with a different kind!",
|
|
"TypeError");
|
|
}
|
|
|
|
// Updates the track on the MediaPipeline; this is needed whether or not
|
|
// we've associated this transceiver, the spec language notwithstanding.
|
|
// Synchronous, and will throw on failure.
|
|
this._pc._replaceTrackNoRenegotiation(this._transceiverImpl, withTrack);
|
|
|
|
let setTrack = () => {
|
|
this.track = withTrack;
|
|
this._transceiver.sync();
|
|
};
|
|
|
|
// Spec is a little weird here; we only queue if the transceiver was
|
|
// associated, otherwise we update the track synchronously.
|
|
if (this._transceiver.mid == null) {
|
|
setTrack();
|
|
} else {
|
|
// We're supposed to queue a task if the transceiver is associated
|
|
await this._pc._queueTaskWithClosedCheck(setTrack);
|
|
}
|
|
}
|
|
|
|
setParameters(parameters) {
|
|
return this._pc._win.Promise.resolve(this._setParameters(parameters));
|
|
}
|
|
|
|
async _setParameters(parameters) {
|
|
this._pc._checkClosed();
|
|
|
|
if (this._transceiver.stopped) {
|
|
throw new this._pc._win.DOMException(
|
|
"This sender's transceiver is stopped", "InvalidStateError");
|
|
}
|
|
|
|
if (!Services.prefs.getBoolPref("media.peerconnection.simulcast")) {
|
|
return;
|
|
}
|
|
|
|
parameters.encodings = parameters.encodings || [];
|
|
|
|
parameters.encodings.reduce((uniqueRids, { rid, scaleResolutionDownBy }) => {
|
|
if (scaleResolutionDownBy < 1.0) {
|
|
throw new this._pc._win.RangeError("scaleResolutionDownBy must be >= 1.0");
|
|
}
|
|
if (!rid && parameters.encodings.length > 1) {
|
|
throw new this._pc._win.DOMException("Missing rid", "TypeError");
|
|
}
|
|
if (uniqueRids[rid]) {
|
|
throw new this._pc._win.DOMException("Duplicate rid", "TypeError");
|
|
}
|
|
uniqueRids[rid] = true;
|
|
return uniqueRids;
|
|
}, {});
|
|
|
|
// TODO(bug 1401592): transaction ids, timing changes
|
|
|
|
await this._pc._queueTaskWithClosedCheck(() => {
|
|
this.parameters = parameters;
|
|
this._transceiver.sync();
|
|
});
|
|
}
|
|
|
|
getParameters() {
|
|
// TODO(bug 1401592): transaction ids
|
|
|
|
// All the other stuff that the spec says to update is handled when
|
|
// transceivers are synced.
|
|
return this.parameters;
|
|
}
|
|
|
|
setStreams(streams) {
|
|
this._streams = streams;
|
|
}
|
|
|
|
getStreams() {
|
|
return this._streams;
|
|
}
|
|
|
|
setTrack(track) {
|
|
this._pc._replaceTrackNoRenegotiation(this._transceiverImpl, track);
|
|
this.track = track;
|
|
}
|
|
|
|
getStats() {
|
|
if (this.track) {
|
|
return this._pc._async(
|
|
async () => this._pc._getStats(this.track));
|
|
}
|
|
return this._pc._win.Promise.resolve().then(
|
|
() => this._pc._win.RTCStatsReport._create(this._pc._win, new Map())
|
|
);
|
|
}
|
|
|
|
checkWasCreatedByPc(pc) {
|
|
if (pc != this._pc.__DOM_IMPL__) {
|
|
throw new this._pc._win.DOMException(
|
|
"This sender was not created by this PeerConnection",
|
|
"InvalidAccessError");
|
|
}
|
|
}
|
|
}
|
|
setupPrototype(RTCRtpSender, {
|
|
classID: PC_SENDER_CID,
|
|
contractID: PC_SENDER_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([]),
|
|
});
|
|
|
|
class RTCRtpReceiver {
|
|
constructor(pc, transceiverImpl) {
|
|
// We do not set the track here; that is done when _transceiverImpl is set
|
|
Object.assign(this,
|
|
{
|
|
_pc: pc,
|
|
_transceiverImpl: transceiverImpl,
|
|
track: transceiverImpl.getReceiveTrack(),
|
|
_remoteSetSendBit: false,
|
|
_ontrackFired: false,
|
|
streamIds: [],
|
|
// Sync and contributing sources must be kept cached so that timestamps
|
|
// remain stable, as the timestamp offset can vary
|
|
// note key = entry.source + entry.sourceType
|
|
_rtpSources: new Map(),
|
|
_rtpSourcesJsTimestamp: null,
|
|
});
|
|
}
|
|
|
|
// TODO(bug 1401983): Create a getStats binding on TransceiverImpl, and use
|
|
// that here.
|
|
getStats() {
|
|
return this._pc._async(
|
|
async () => this._pc.getStats(this.track));
|
|
}
|
|
|
|
_getRtpSource(source, type) {
|
|
this._fetchRtpSources();
|
|
return this._rtpSources.get(type + source).entry;
|
|
}
|
|
|
|
/* Fetch all of the RTP Contributing and Sync sources for the receiver
|
|
* and store them so they are available when asked for.
|
|
*/
|
|
_fetchRtpSources() {
|
|
if (this._rtpSourcesJsTimestamp !== null) {
|
|
return;
|
|
}
|
|
// Queue microtask to mark the cache as stale after this task completes
|
|
Promise.resolve().then(() => this._rtpSourcesJsTimestamp = null);
|
|
let {sources, sourceClockOffset, jsTimestamp} =
|
|
this._pc._getRtpSources(this);
|
|
this._rtpSourcesJsTimestamp = jsTimestamp;
|
|
for (let entry of sources) {
|
|
// Set the clock offset for calculating the 10-second window
|
|
entry.sourceClockOffset = sourceClockOffset;
|
|
// Store the new entries or update existing entries
|
|
let key = entry.source + entry.sourceType;
|
|
let cached = this._rtpSources.get(key);
|
|
if (cached === undefined) {
|
|
this._rtpSources.set(key, entry);
|
|
} else if (cached.timestamp != entry.timestamp) {
|
|
// Only update if the timestamp has changed
|
|
// This also prevents the sourceClockOffset from changing unecessarily
|
|
// which could cause a value to flutter at the edge of the 10 second
|
|
// window.
|
|
this._rtpSources.set(key, entry);
|
|
}
|
|
}
|
|
// Clear old entries
|
|
let cutoffTime = this._rtpSourcesJsTimestamp - 10 * 1000;
|
|
let removeKeys = [];
|
|
for (let entry of this._rtpSources.values()) {
|
|
if ((entry.timestamp + entry.sourceClockOffset) < cutoffTime) {
|
|
removeKeys.push(entry.source + entry.sourceType);
|
|
}
|
|
}
|
|
for (let delKey of removeKeys) {
|
|
this._rtpSources.delete(delKey);
|
|
}
|
|
}
|
|
|
|
_getRtpSourcesByType(type) {
|
|
this._fetchRtpSources();
|
|
// Only return the values from within the last 10 seconds as per the spec
|
|
let cutoffTime = this._rtpSourcesJsTimestamp - 10 * 1000;
|
|
let sources = [...this._rtpSources.values()].filter(
|
|
(entry) => {
|
|
return entry.sourceType == type &&
|
|
(entry.timestamp + entry.sourceClockOffset) >= cutoffTime;
|
|
}).map(e => {
|
|
let newEntry = {
|
|
source: e.source,
|
|
timestamp: e.timestamp + e.sourceClockOffset,
|
|
audioLevel: e.audioLevel,
|
|
};
|
|
if (e.voiceActivityFlag !== undefined) {
|
|
Object.assign(newEntry, {voiceActivityFlag: e.voiceActivityFlag});
|
|
}
|
|
return newEntry;
|
|
});
|
|
return sources;
|
|
}
|
|
|
|
getContributingSources() {
|
|
return this._getRtpSourcesByType("contributing");
|
|
}
|
|
|
|
getSynchronizationSources() {
|
|
return this._getRtpSourcesByType("synchronization");
|
|
}
|
|
|
|
setStreamIds(streamIds) {
|
|
this.streamIds = streamIds;
|
|
}
|
|
|
|
setRemoteSendBit(sendBit) {
|
|
this._remoteSetSendBit = sendBit;
|
|
}
|
|
|
|
processTrackAdditionsAndRemovals(transceiver,
|
|
{updateStreamFunctions, muteTracks, trackEvents}) {
|
|
let streamsWithTrack = this.streamIds
|
|
.map(id => this._pc._getOrCreateStream(id));
|
|
|
|
let streamsWithoutTrack = this._pc.getRemoteStreams()
|
|
.filter(s => !this.streamIds.includes(s.id));
|
|
|
|
updateStreamFunctions.push(...streamsWithTrack.map(stream => () => {
|
|
if (!stream.getTracks().includes(this.track)) {
|
|
stream.addTrack(this.track);
|
|
// Adding tracks from JS does not result in the stream getting
|
|
// onaddtrack, so we need to do that here.
|
|
stream.dispatchEvent(
|
|
new this._pc._win.MediaStreamTrackEvent(
|
|
"addtrack", { track: this.track }));
|
|
}
|
|
}));
|
|
|
|
updateStreamFunctions.push(...streamsWithoutTrack.map(stream => () => {
|
|
// Content JS might remove this track from the stream before this function fires (ugh)
|
|
if (stream.getTracks().includes(this.track)) {
|
|
stream.removeTrack(this.track);
|
|
// Removing tracks from JS does not result in the stream getting
|
|
// onremovetrack, so we need to do that here.
|
|
stream.dispatchEvent(
|
|
new this._pc._win.MediaStreamTrackEvent(
|
|
"removetrack", { track: this.track }));
|
|
}
|
|
}));
|
|
|
|
if (!this._remoteSetSendBit) {
|
|
// remote used "recvonly" or "inactive"
|
|
this._ontrackFired = false;
|
|
if (!this.track.muted) {
|
|
muteTracks.push(this.track);
|
|
}
|
|
} else if (!this._ontrackFired) {
|
|
// remote used "sendrecv" or "sendonly", and we haven't fired ontrack
|
|
let ev = new this._pc._win.RTCTrackEvent("track", {
|
|
receiver: this.__DOM_IMPL__,
|
|
track: this.track,
|
|
streams: streamsWithTrack,
|
|
transceiver });
|
|
trackEvents.push(ev);
|
|
this._ontrackFired = true;
|
|
|
|
// Fire legacy event as well for a little bit.
|
|
ev = new this._pc._win.MediaStreamTrackEvent("addtrack",
|
|
{ track: this.track });
|
|
trackEvents.push(ev);
|
|
}
|
|
}
|
|
}
|
|
setupPrototype(RTCRtpReceiver, {
|
|
classID: PC_RECEIVER_CID,
|
|
contractID: PC_RECEIVER_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([]),
|
|
});
|
|
|
|
class RTCRtpTransceiver {
|
|
constructor(pc, transceiverImpl, init, kind, sendTrack) {
|
|
let receiver = pc._win.RTCRtpReceiver._create(
|
|
pc._win, new RTCRtpReceiver(pc, transceiverImpl, kind));
|
|
let streams = (init && init.streams) || [];
|
|
let sender = pc._win.RTCRtpSender._create(
|
|
pc._win, new RTCRtpSender(pc, transceiverImpl, this, sendTrack, kind, streams));
|
|
|
|
let direction = (init && init.direction) || "sendrecv";
|
|
Object.assign(this,
|
|
{
|
|
_pc: pc,
|
|
mid: null,
|
|
sender,
|
|
receiver,
|
|
stopped: false,
|
|
_direction: direction,
|
|
currentDirection: null,
|
|
_remoteTrackId: null,
|
|
addTrackMagic: false,
|
|
shouldRemove: false,
|
|
_hasBeenUsedToSend: false,
|
|
// the receiver starts out without a track, so record this here
|
|
_kind: kind,
|
|
_transceiverImpl: transceiverImpl,
|
|
});
|
|
}
|
|
|
|
set direction(direction) {
|
|
this._pc._checkClosed();
|
|
|
|
if (this.stopped) {
|
|
throw new this._pc._win.DOMException("Transceiver is stopped!",
|
|
"InvalidStateError");
|
|
}
|
|
|
|
if (this._direction == direction) {
|
|
return;
|
|
}
|
|
|
|
this._direction = direction;
|
|
this.sync();
|
|
this._pc.updateNegotiationNeeded();
|
|
}
|
|
|
|
get direction() {
|
|
return this._direction;
|
|
}
|
|
|
|
setDirectionInternal(direction) {
|
|
this._direction = direction;
|
|
}
|
|
|
|
stop() {
|
|
if (this.stopped) {
|
|
return;
|
|
}
|
|
|
|
this._pc._checkClosed();
|
|
|
|
this.setStopped();
|
|
this.sync();
|
|
this._pc.updateNegotiationNeeded();
|
|
}
|
|
|
|
setStopped() {
|
|
this.stopped = true;
|
|
this.currentDirection = null;
|
|
}
|
|
|
|
getKind() {
|
|
return this._kind;
|
|
}
|
|
|
|
hasBeenUsedToSend() {
|
|
return this._hasBeenUsedToSend;
|
|
}
|
|
|
|
setRemoteTrackId(webrtcTrackId) {
|
|
this._remoteTrackId = webrtcTrackId;
|
|
}
|
|
|
|
remoteTrackIdIs(webrtcTrackId) {
|
|
return this._remoteTrackId == webrtcTrackId;
|
|
}
|
|
|
|
getRemoteTrackId() {
|
|
return this._remoteTrackId;
|
|
}
|
|
|
|
setAddTrackMagic() {
|
|
this.addTrackMagic = true;
|
|
}
|
|
|
|
sync() {
|
|
if (this._syncing) {
|
|
throw new DOMException("Reentrant sync! This is a bug!", "InternalError");
|
|
}
|
|
this._syncing = true;
|
|
this._transceiverImpl.syncWithJS(this.__DOM_IMPL__);
|
|
this._syncing = false;
|
|
}
|
|
|
|
// Used by _transceiverImpl.syncWithJS, don't call sync again!
|
|
setCurrentDirection(direction) {
|
|
if (this.stopped) {
|
|
return;
|
|
}
|
|
|
|
switch (direction) {
|
|
case "sendrecv":
|
|
case "sendonly":
|
|
this._hasBeenUsedToSend = true;
|
|
break;
|
|
default:
|
|
}
|
|
|
|
this.currentDirection = direction;
|
|
}
|
|
|
|
// Used by _transceiverImpl.syncWithJS, don't call sync again!
|
|
setMid(mid) {
|
|
this.mid = mid;
|
|
}
|
|
|
|
// Used by _transceiverImpl.syncWithJS, don't call sync again!
|
|
unsetMid() {
|
|
this.mid = null;
|
|
}
|
|
|
|
insertDTMF(tones, duration, interToneGap) {
|
|
if (this.stopped) {
|
|
throw new this._pc._win.DOMException("Transceiver is stopped!",
|
|
"InvalidStateError");
|
|
}
|
|
|
|
if (!this.sender.track) {
|
|
throw new this._pc._win.DOMException("RTCRtpSender has no track",
|
|
"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._pc._win.DOMException("Invalid DTMF characters",
|
|
"InvalidCharacterError");
|
|
}
|
|
|
|
// TODO (bug 1401983): Move this API to TransceiverImpl so we don't need the
|
|
// extra hops through RTCPeerConnection and PeerConnectionImpl
|
|
this._pc._insertDTMF(this._transceiverImpl, tones, duration, interToneGap);
|
|
}
|
|
}
|
|
|
|
setupPrototype(RTCRtpTransceiver, {
|
|
classID: PC_TRANSCEIVER_CID,
|
|
contractID: PC_TRANSCEIVER_CONTRACT,
|
|
QueryInterface: ChromeUtils.generateQI([]),
|
|
});
|
|
|
|
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([]),
|
|
});
|
|
|
|
this.NSGetFactory = XPCOMUtils.generateNSGetFactory(
|
|
[GlobalPCList,
|
|
RTCDTMFSender,
|
|
RTCIceCandidate,
|
|
RTCSessionDescription,
|
|
RTCPeerConnection,
|
|
RTCPeerConnectionStatic,
|
|
RTCRtpReceiver,
|
|
RTCRtpSender,
|
|
RTCRtpTransceiver,
|
|
RTCStatsReport,
|
|
PeerConnectionObserver,
|
|
CreateOfferRequest]
|
|
);
|