The Tor Browser: comparison dom/media/tests/mochitest/pc.js

comparison: dom/media/tests/mochitest/pc.js

dom/media/tests/mochitest/pc.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:c067eeaf2aca
+/* 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";
+/**
+* This class mimics a state machine and handles a list of commands by
+* executing them synchronously.
+*
+* @constructor
+* @param {object} framework
+*        A back reference to the framework which makes use of the class. It's
+*        getting passed in as parameter to each command callback.
+* @param {Array[]} [commandList=[]]
+*        Default commands to set during initialization
+*/
+function CommandChain(framework, commandList) {
+this._framework = framework;
+this._commands = commandList || [ ];
+this._current = 0;
+this.onFinished = null;
+}
+CommandChain.prototype = {
+/**
+* Returns the index of the current command of the chain
+*
+* @returns {number} Index of the current command
+*/
+get current() {
+return this._current;
+},
+/**
+* Checks if the chain has already processed all the commands
+*
+* @returns {boolean} True, if all commands have been processed
+*/
+get finished() {
+return this._current === this._commands.length;
+},
+/**
+* Returns the assigned commands of the chain.
+*
+* @returns {Array[]} Commands of the chain
+*/
+get commands() {
+return this._commands;
+},
+/**
+* Sets new commands for the chain. All existing commands will be replaced.
+*
+* @param {Array[]} commands
+*        List of commands
+*/
+set commands(commands) {
+this._commands = commands;
+},
+/**
+* Execute the next command in the chain.
+*/
+executeNext : function () {
+var self = this;
+function _executeNext() {
+if (!self.finished) {
+var step = self._commands[self._current];
+self._current++;
+self.currentStepLabel = step[0];
+info("Run step: " + self.currentStepLabel);
+step[1](self._framework);      // Execute step
+}
+else if (typeof(self.onFinished) === 'function') {
+self.onFinished();
+}
+}
+// To prevent building up the stack we have to execute the next
+// step asynchronously
+window.setTimeout(_executeNext, 0);
+},
+/**
+* Add new commands to the end of the chain
+*
+* @param {Array[]} commands
+*        List of commands
+*/
+append: function (commands) {
+this._commands = this._commands.concat(commands);
+},
+/**
+* Returns the index of the specified command in the chain.
+*
+* @param {string} id
+*        Identifier of the command
+* @returns {number} Index of the command
+*/
+indexOf: function (id) {
+for (var i = 0; i < this._commands.length; i++) {
+if (this._commands[i][0] === id) {
+return i;
+}
+}
+return -1;
+},
+/**
+* Inserts the new commands after the specified command.
+*
+* @param {string} id
+*        Identifier of the command
+* @param {Array[]} commands
+*        List of commands
+*/
+insertAfter: function (id, commands) {
+var index = this.indexOf(id);
+if (index > -1) {
+var tail = this.removeAfter(id);
+this.append(commands);
+this.append(tail);
+}
+},
+/**
+* Inserts the new commands before the specified command.
+*
+* @param {string} id
+*        Identifier of the command
+* @param {Array[]} commands
+*        List of commands
+*/
+insertBefore: function (id, commands) {
+var index = this.indexOf(id);
+if (index > -1) {
+var tail = this.removeAfter(id);
+var object = this.remove(id);
+this.append(commands);
+this.append(object);
+this.append(tail);
+}
+},
+/**
+* Removes the specified command
+*
+* @param {string} id
+*        Identifier of the command
+* @returns {object[]} Removed command
+*/
+remove : function (id) {
+return this._commands.splice(this.indexOf(id), 1);
+},
+/**
+* Removes all commands after the specified one.
+*
+* @param {string} id
+*        Identifier of the command
+* @returns {object[]} Removed commands
+*/
+removeAfter : function (id) {
+var index = this.indexOf(id);
+if (index > -1) {
+return this._commands.splice(index + 1);
+}
+return null;
+},
+/**
+* Removes all commands before the specified one.
+*
+* @param {string} id
+*        Identifier of the command
+* @returns {object[]} Removed commands
+*/
+removeBefore : function (id) {
+var index = this.indexOf(id);
+if (index > -1) {
+return this._commands.splice(0, index);
+}
+return null;
+},
+/**
+* Replaces all commands after the specified one.
+*
+* @param {string} id
+*        Identifier of the command
+* @returns {object[]} Removed commands
+*/
+replaceAfter : function (id, commands) {
+var oldCommands = this.removeAfter(id);
+this.append(commands);
+return oldCommands;
+},
+/**
+* Replaces all commands before the specified one.
+*
+* @param {string} id
+*        Identifier of the command
+* @returns {object[]} Removed commands
+*/
+replaceBefore : function (id, commands) {
+var oldCommands = this.removeBefore(id);
+this.insertBefore(id, commands);
+return oldCommands;
+},
+/**
+* Remove all commands whose identifiers match the specified regex.
+*
+* @param {regex} id_match
+*        Regular expression to match command identifiers.
+*/
+filterOut : function (id_match) {
+for (var i = this._commands.length - 1; i >= 0; i--) {
+if (id_match.test(this._commands[i][0])) {
+this._commands.splice(i, 1);
+}
+}
+}
+};
+/**
+* This class provides a state checker for media elements which store
+* a media stream to check for media attribute state and events fired.
+* When constructed by a caller, an object instance is created with
+* a media element, event state checkers for canplaythrough, timeupdate, and
+* time changing on the media element and stream.
+*
+* @param {HTMLMediaElement} element the media element being analyzed
+*/
+function MediaElementChecker(element) {
+this.element = element;
+this.canPlayThroughFired = false;
+this.timeUpdateFired = false;
+this.timePassed = false;
+var self = this;
+var elementId = self.element.getAttribute('id');
+// When canplaythrough fires, we track that it's fired and remove the
+// event listener.
+var canPlayThroughCallback = function() {
+info('canplaythrough fired for media element ' + elementId);
+self.canPlayThroughFired = true;
+self.element.removeEventListener('canplaythrough', canPlayThroughCallback,
+false);
+};
+// When timeupdate fires, we track that it's fired and check if time
+// has passed on the media stream and media element.
+var timeUpdateCallback = function() {
+self.timeUpdateFired = true;
+info('timeupdate fired for media element ' + elementId);
+// If time has passed, then track that and remove the timeupdate event
+// listener.
+if(element.mozSrcObject && element.mozSrcObject.currentTime > 0 &&
+element.currentTime > 0) {
+info('time passed for media element ' + elementId);
+self.timePassed = true;
+self.element.removeEventListener('timeupdate', timeUpdateCallback,
+false);
+}
+};
+element.addEventListener('canplaythrough', canPlayThroughCallback, false);
+element.addEventListener('timeupdate', timeUpdateCallback, false);
+}
+MediaElementChecker.prototype = {
+/**
+* Waits until the canplaythrough & timeupdate events to fire along with
+* ensuring time has passed on the stream and media element.
+*
+* @param {Function} onSuccess the success callback when media flow is
+*                             established
+*/
+waitForMediaFlow : function MEC_WaitForMediaFlow(onSuccess) {
+var self = this;
+var elementId = self.element.getAttribute('id');
+info('Analyzing element: ' + elementId);
+if(self.canPlayThroughFired && self.timeUpdateFired && self.timePassed) {
+ok(true, 'Media flowing for ' + elementId);
+onSuccess();
+} else {
+setTimeout(function() {
+self.waitForMediaFlow(onSuccess);
+}, 100);
+}
+},
+/**
+* Checks if there is no media flow present by checking that the ready
+* state of the media element is HAVE_METADATA.
+*/
+checkForNoMediaFlow : function MEC_CheckForNoMediaFlow() {
+ok(this.element.readyState === HTMLMediaElement.HAVE_METADATA,
+'Media element has a ready state of HAVE_METADATA');
+}
+};
+/**
+* Query function for determining if any IP address is available for
+* generating SDP.
+*
+* @return false if required additional network setup.
+*/
+function isNetworkReady() {
+// for gonk platform
+if ("nsINetworkInterfaceListService" in SpecialPowers.Ci) {
+var listService = SpecialPowers.Cc["@mozilla.org/network/interface-list-service;1"]
+.getService(SpecialPowers.Ci.nsINetworkInterfaceListService);
+var itfList = listService.getDataInterfaceList(
+SpecialPowers.Ci.nsINetworkInterfaceListService.LIST_NOT_INCLUDE_MMS_INTERFACES |
+SpecialPowers.Ci.nsINetworkInterfaceListService.LIST_NOT_INCLUDE_SUPL_INTERFACES |
+SpecialPowers.Ci.nsINetworkInterfaceListService.LIST_NOT_INCLUDE_IMS_INTERFACES |
+SpecialPowers.Ci.nsINetworkInterfaceListService.LIST_NOT_INCLUDE_DUN_INTERFACES);
+var num = itfList.getNumberOfInterface();
+for (var i = 0; i < num; i++) {
+var ips = {};
+var prefixLengths = {};
+var length = itfList.getInterface(i).getAddresses(ips, prefixLengths);
+for (var j = 0; j < length; j++) {
+var ip = ips.value[j];
+// skip IPv6 address
+if (ip.indexOf(":") < 0) {
+info("Network interface is ready with address: " + ip);
+return true;
+}
+}
+}
+// ip address is not available
+info("Network interface is not ready, required additional network setup");
+return false;
+}
+info("Network setup is not required");
+return true;
+}
+/**
+* Network setup utils for Gonk
+*
+* @return {object} providing functions for setup/teardown data connection
+*/
+function getNetworkUtils() {
+var url = SimpleTest.getTestFileURL("NetworkPreparationChromeScript.js");
+var script = SpecialPowers.loadChromeScript(url);
+var utils = {
+/**
+* Utility for setting up data connection.
+*
+* @param aCallback callback after data connection is ready.
+*/
+prepareNetwork: function(aCallback) {
+script.addMessageListener('network-ready', function (message) {
+info("Network interface is ready");
+aCallback();
+});
+info("Setup network interface");
+script.sendAsyncMessage("prepare-network", true);
+},
+/**
+* Utility for tearing down data connection.
+*
+* @param aCallback callback after data connection is closed.
+*/
+tearDownNetwork: function(aCallback) {
+script.addMessageListener('network-disabled', function (message) {
+ok(true, 'network-disabled');
+script.destroy();
+aCallback();
+});
+script.sendAsyncMessage("network-cleanup", true);
+}
+};
+return utils;
+}
+/**
+* This class handles tests for peer connections.
+*
+* @constructor
+* @param {object} [options={}]
+*        Optional options for the peer connection test
+* @param {object} [options.commands=commandsPeerConnection]
+*        Commands to run for the test
+* @param {bool}   [options.is_local=true]
+*        true if this test should run the tests for the "local" side.
+* @param {bool}   [options.is_remote=true]
+*        true if this test should run the tests for the "remote" side.
+* @param {object} [options.config_pc1=undefined]
+*        Configuration for the local peer connection instance
+* @param {object} [options.config_pc2=undefined]
+*        Configuration for the remote peer connection instance. If not defined
+*        the configuration from the local instance will be used
+*/
+function PeerConnectionTest(options) {
+// If no options are specified make it an empty object
+options = options || { };
+options.commands = options.commands || commandsPeerConnection;
+options.is_local = "is_local" in options ? options.is_local : true;
+options.is_remote = "is_remote" in options ? options.is_remote : true;
+var netTeardownCommand = null;
+if (!isNetworkReady()) {
+var utils = getNetworkUtils();
+// Trigger network setup to obtain IP address before creating any PeerConnection.
+utils.prepareNetwork(function() {
+ok(isNetworkReady(),'setup network connection successfully');
+});
+netTeardownCommand = [
+[
+'TEARDOWN_NETWORK',
+function(test) {
+utils.tearDownNetwork(function() {
+info('teardown network connection');
+test.next();
+});
+}
+]
+];
+}
+if (options.is_local)
+this.pcLocal = new PeerConnectionWrapper('pcLocal', options.config_pc1);
+else
+this.pcLocal = null;
+if (options.is_remote)
+this.pcRemote = new PeerConnectionWrapper('pcRemote', options.config_pc2 || options.config_pc1);
+else
+this.pcRemote = null;
+this.connected = false;
+// Create command chain instance and assign default commands
+this.chain = new CommandChain(this, options.commands);
+if (!options.is_local) {
+this.chain.filterOut(/^PC_LOCAL/);
+}
+if (!options.is_remote) {
+this.chain.filterOut(/^PC_REMOTE/);
+}
+// Insert network teardown after testcase execution.
+if (netTeardownCommand) {
+this.chain.append(netTeardownCommand);
+}
+var self = this;
+this.chain.onFinished = function () {
+self.teardown();
+};
+}
+/**
+* Closes the peer connection if it is active
+*
+* @param {Function} onSuccess
+*        Callback to execute when the peer connection has been closed successfully
+*/
+PeerConnectionTest.prototype.close = function PCT_close(onSuccess) {
+info("Closing peer connections. Connection state=" + this.connected);
+function signalingstatechangeClose(state) {
+info("'onsignalingstatechange' event '" + state + "' received");
+is(state, "closed", "onsignalingstatechange event is closed");
+}
+// There is no onclose event for the remote peer existent yet. So close it
+// side-by-side with the local peer.
+if (this.pcLocal) {
+this.pcLocal.onsignalingstatechange = signalingstatechangeClose;
+this.pcLocal.close();
+}
+if (this.pcRemote) {
+this.pcRemote.onsignalingstatechange = signalingstatechangeClose;
+this.pcRemote.close();
+}
+this.connected = false;
+onSuccess();
+};
+/**
+* Executes the next command.
+*/
+PeerConnectionTest.prototype.next = function PCT_next() {
+if (this._stepTimeout) {
+clearTimeout(this._stepTimeout);
+this._stepTimeout = null;
+}
+this.chain.executeNext();
+};
+/**
+* Set a timeout for the current step.
+* @param {long] ms the number of milliseconds to allow for this step
+*/
+PeerConnectionTest.prototype.setStepTimeout = function(ms) {
+this._stepTimeout = setTimeout(function() {
+ok(false, "Step timed out: " + this.chain.currentStepLabel);
+this.next();
+}.bind(this), ms);
+};
+/**
+* Creates an answer for the specified peer connection instance
+* and automatically handles the failure case.
+*
+* @param {PeerConnectionWrapper} peer
+*        The peer connection wrapper to run the command on
+* @param {function} onSuccess
+*        Callback to execute if the offer was created successfully
+*/
+PeerConnectionTest.prototype.createAnswer =
+function PCT_createAnswer(peer, onSuccess) {
+peer.createAnswer(function (answer) {
+onSuccess(answer);
+});
+};
+/**
+* Creates an offer for the specified peer connection instance
+* and automatically handles the failure case.
+*
+* @param {PeerConnectionWrapper} peer
+*        The peer connection wrapper to run the command on
+* @param {function} onSuccess
+*        Callback to execute if the offer was created successfully
+*/
+PeerConnectionTest.prototype.createOffer =
+function PCT_createOffer(peer, onSuccess) {
+peer.createOffer(function (offer) {
+onSuccess(offer);
+});
+};
+PeerConnectionTest.prototype.setIdentityProvider =
+function(peer, provider, protocol, identity) {
+peer.setIdentityProvider(provider, protocol, identity);
+};
+/**
+* Sets the local description for the specified peer connection instance
+* and automatically handles the failure case.
+*
+* @param {PeerConnectionWrapper} peer
+The peer connection wrapper to run the command on
+* @param {mozRTCSessionDescription} desc
+*        Session description for the local description request
+* @param {function} onSuccess
+*        Callback to execute if the local description was set successfully
+*/
+PeerConnectionTest.prototype.setLocalDescription =
+function PCT_setLocalDescription(peer, desc, stateExpected, onSuccess) {
+var eventFired = false;
+var stateChanged = false;
+function check_next_test() {
+if (eventFired && stateChanged) {
+onSuccess();
+}
+}
+peer.onsignalingstatechange = function (state) {
+//info(peer + ": 'onsignalingstatechange' event registered, signalingState: " + peer.signalingState);
+info(peer + ": 'onsignalingstatechange' event '" + state + "' received");
+if(stateExpected === state && eventFired == false) {
+eventFired = true;
+check_next_test();
+} else {
+ok(false, "This event has either already fired or there has been a " +
+"mismatch between event received " + state +
+" and event expected " + stateExpected);
+}
+};
+peer.setLocalDescription(desc, function () {
+stateChanged = true;
+check_next_test();
+});
+};
+/**
+* Sets the media constraints for both peer connection instances.
+*
+* @param {object} constraintsLocal
+*        Media constrains for the local peer connection instance
+* @param constraintsRemote
+*/
+PeerConnectionTest.prototype.setMediaConstraints =
+function PCT_setMediaConstraints(constraintsLocal, constraintsRemote) {
+if (this.pcLocal)
+this.pcLocal.constraints = constraintsLocal;
+if (this.pcRemote)
+this.pcRemote.constraints = constraintsRemote;
+};
+/**
+* Sets the media constraints used on a createOffer call in the test.
+*
+* @param {object} constraints the media constraints to use on createOffer
+*/
+PeerConnectionTest.prototype.setOfferConstraints =
+function PCT_setOfferConstraints(constraints) {
+if (this.pcLocal)
+this.pcLocal.offerConstraints = constraints;
+};
+/**
+* Sets the remote description for the specified peer connection instance
+* and automatically handles the failure case.
+*
+* @param {PeerConnectionWrapper} peer
+The peer connection wrapper to run the command on
+* @param {mozRTCSessionDescription} desc
+*        Session description for the remote description request
+* @param {function} onSuccess
+*        Callback to execute if the local description was set successfully
+*/
+PeerConnectionTest.prototype.setRemoteDescription =
+function PCT_setRemoteDescription(peer, desc, stateExpected, onSuccess) {
+var eventFired = false;
+var stateChanged = false;
+function check_next_test() {
+if (eventFired && stateChanged) {
+onSuccess();
+}
+}
+peer.onsignalingstatechange = function (state) {
+info(peer + ": 'onsignalingstatechange' event '" + state + "' received");
+if(stateExpected === state && eventFired == false) {
+eventFired = true;
+check_next_test();
+} else {
+ok(false, "This event has either already fired or there has been a " +
+"mismatch between event received " + state +
+" and event expected " + stateExpected);
+}
+};
+peer.setRemoteDescription(desc, function () {
+stateChanged = true;
+check_next_test();
+});
+};
+/**
+* Start running the tests as assigned to the command chain.
+*/
+PeerConnectionTest.prototype.run = function PCT_run() {
+this.next();
+};
+/**
+* Clean up the objects used by the test
+*/
+PeerConnectionTest.prototype.teardown = function PCT_teardown() {
+this.close(function () {
+info("Test finished");
+if (window.SimpleTest)
+SimpleTest.finish();
+else
+finish();
+});
+};
+/**
+* This class handles tests for data channels.
+*
+* @constructor
+* @param {object} [options={}]
+*        Optional options for the peer connection test
+* @param {object} [options.commands=commandsDataChannel]
+*        Commands to run for the test
+* @param {object} [options.config_pc1=undefined]
+*        Configuration for the local peer connection instance
+* @param {object} [options.config_pc2=undefined]
+*        Configuration for the remote peer connection instance. If not defined
+*        the configuration from the local instance will be used
+*/
+function DataChannelTest(options) {
+options = options || { };
+options.commands = options.commands || commandsDataChannel;
+PeerConnectionTest.call(this, options);
+}
+DataChannelTest.prototype = Object.create(PeerConnectionTest.prototype, {
+close : {
+/**
+* Close the open data channels, followed by the underlying peer connection
+*
+* @param {Function} onSuccess
+*        Callback to execute when the connection has been closed
+*/
+value : function DCT_close(onSuccess) {
+var self = this;
+function _closeChannels() {
+var length = self.pcLocal.dataChannels.length;
+if (length > 0) {
+self.closeDataChannel(length - 1, function () {
+_closeChannels();
+});
+}
+else {
+PeerConnectionTest.prototype.close.call(self, onSuccess);
+}
+}
+_closeChannels();
+}
+},
+closeDataChannel : {
+/**
+* Close the specified data channel
+*
+* @param {Number} index
+*        Index of the data channel to close on both sides
+* @param {Function} onSuccess
+*        Callback to execute when the data channel has been closed
+*/
+value : function DCT_closeDataChannel(index, onSuccess) {
+var localChannel = this.pcLocal.dataChannels[index];
+var remoteChannel = this.pcRemote.dataChannels[index];
+var self = this;
+// Register handler for remote channel, cause we have to wait until
+// the current close operation has been finished.
+remoteChannel.onclose = function () {
+self.pcRemote.dataChannels.splice(index, 1);
+onSuccess(remoteChannel);
+};
+localChannel.close();
+this.pcLocal.dataChannels.splice(index, 1);
+}
+},
+createDataChannel : {
+/**
+* Create a data channel
+*
+* @param {Dict} options
+*        Options for the data channel (see nsIPeerConnection)
+* @param {Function} onSuccess
+*        Callback when the creation was successful
+*/
+value : function DCT_createDataChannel(options, onSuccess) {
+var localChannel = null;
+var remoteChannel = null;
+var self = this;
+// Method to synchronize all asynchronous events.
+function check_next_test() {
+if (self.connected && localChannel && remoteChannel) {
+onSuccess(localChannel, remoteChannel);
+}
+}
+if (!options.negotiated) {
+// Register handlers for the remote peer
+this.pcRemote.registerDataChannelOpenEvents(function (channel) {
+remoteChannel = channel;
+check_next_test();
+});
+}
+// Create the datachannel and handle the local 'onopen' event
+this.pcLocal.createDataChannel(options, function (channel) {
+localChannel = channel;
+if (options.negotiated) {
+// externally negotiated - we need to open from both ends
+options.id = options.id || channel.id;  // allow for no id to let the impl choose
+self.pcRemote.createDataChannel(options, function (channel) {
+remoteChannel = channel;
+check_next_test();
+});
+} else {
+check_next_test();
+}
+});
+}
+},
+send : {
+/**
+* Send data (message or blob) to the other peer
+*
+* @param {String|Blob} data
+*        Data to send to the other peer. For Blobs the MIME type will be lost.
+* @param {Function} onSuccess
+*        Callback to execute when data has been sent
+* @param {Object} [options={ }]
+*        Options to specify the data channels to be used
+* @param {DataChannelWrapper} [options.sourceChannel=pcLocal.dataChannels[length - 1]]
+*        Data channel to use for sending the message
+* @param {DataChannelWrapper} [options.targetChannel=pcRemote.dataChannels[length - 1]]
+*        Data channel to use for receiving the message
+*/
+value : function DCT_send(data, onSuccess, options) {
+options = options || { };
+var source = options.sourceChannel ||
+this.pcLocal.dataChannels[this.pcLocal.dataChannels.length - 1];
+var target = options.targetChannel ||
+this.pcRemote.dataChannels[this.pcRemote.dataChannels.length - 1];
+// Register event handler for the target channel
+target.onmessage = function (recv_data) {
+onSuccess(target, recv_data);
+};
+source.send(data);
+}
+},
+setLocalDescription : {
+/**
+* Sets the local description for the specified peer connection instance
+* and automatically handles the failure case. In case for the final call
+* it will setup the requested datachannel.
+*
+* @param {PeerConnectionWrapper} peer
+The peer connection wrapper to run the command on
+* @param {mozRTCSessionDescription} desc
+*        Session description for the local description request
+* @param {function} onSuccess
+*        Callback to execute if the local description was set successfully
+*/
+value : function DCT_setLocalDescription(peer, desc, state, onSuccess) {
+// If the peer has a remote offer we are in the final call, and have
+// to wait for the datachannel connection to be open. It will also set
+// the local description internally.
+if (peer.signalingState === 'have-remote-offer') {
+this.waitForInitialDataChannel(peer, desc, state, onSuccess);
+}
+else {
+PeerConnectionTest.prototype.setLocalDescription.call(this, peer,
+desc, state, onSuccess);
+}
+}
+},
+waitForInitialDataChannel : {
+/**
+* Create an initial data channel before the peer connection has been connected
+*
+* @param {PeerConnectionWrapper} peer
+The peer connection wrapper to run the command on
+* @param {mozRTCSessionDescription} desc
+*        Session description for the local description request
+* @param {Function} onSuccess
+*        Callback when the creation was successful
+*/
+value : function DCT_waitForInitialDataChannel(peer, desc, state, onSuccess) {
+var self = this;
+var targetPeer = peer;
+var targetChannel = null;
+var sourcePeer = (peer == this.pcLocal) ? this.pcRemote : this.pcLocal;
+var sourceChannel = null;
+// Method to synchronize all asynchronous events which current happen
+// due to a non-predictable flow. With bug 875346 fixed we will be able
+// to simplify this code.
+function check_next_test() {
+if (self.connected && sourceChannel && targetChannel) {
+onSuccess(sourceChannel, targetChannel);
+}
+}
+// Register 'onopen' handler for the first local data channel
+sourcePeer.dataChannels[0].onopen = function (channel) {
+sourceChannel = channel;
+check_next_test();
+};
+// Register handlers for the target peer
+targetPeer.registerDataChannelOpenEvents(function (channel) {
+targetChannel = channel;
+check_next_test();
+});
+PeerConnectionTest.prototype.setLocalDescription.call(this, targetPeer, desc,
+state,
+function () {
+self.connected = true;
+check_next_test();
+}
+);
+}
+}
+});
+/**
+* This class acts as a wrapper around a DataChannel instance.
+*
+* @param dataChannel
+* @param peerConnectionWrapper
+* @constructor
+*/
+function DataChannelWrapper(dataChannel, peerConnectionWrapper) {
+this._channel = dataChannel;
+this._pc = peerConnectionWrapper;
+info("Creating " + this);
+/**
+* Setup appropriate callbacks
+*/
+this.onclose = unexpectedEventAndFinish(this, 'onclose');
+this.onerror = unexpectedEventAndFinish(this, 'onerror');
+this.onmessage = unexpectedEventAndFinish(this, 'onmessage');
+this.onopen = unexpectedEventAndFinish(this, 'onopen');
+var self = this;
+/**
+* Callback for native data channel 'onclose' events. If no custom handler
+* has been specified via 'this.onclose', a failure will be raised if an
+* event of this type gets caught.
+*/
+this._channel.onclose = function () {
+info(self + ": 'onclose' event fired");
+self.onclose(self);
+self.onclose = unexpectedEventAndFinish(self, 'onclose');
+};
+/**
+* Callback for native data channel 'onmessage' events. If no custom handler
+* has been specified via 'this.onmessage', a failure will be raised if an
+* event of this type gets caught.
+*
+* @param {Object} event
+*        Event data which includes the sent message
+*/
+this._channel.onmessage = function (event) {
+info(self + ": 'onmessage' event fired for '" + event.data + "'");
+self.onmessage(event.data);
+self.onmessage = unexpectedEventAndFinish(self, 'onmessage');
+};
+/**
+* Callback for native data channel 'onopen' events. If no custom handler
+* has been specified via 'this.onopen', a failure will be raised if an
+* event of this type gets caught.
+*/
+this._channel.onopen = function () {
+info(self + ": 'onopen' event fired");
+self.onopen(self);
+self.onopen = unexpectedEventAndFinish(self, 'onopen');
+};
+}
+DataChannelWrapper.prototype = {
+/**
+* Returns the binary type of the channel
+*
+* @returns {String} The binary type
+*/
+get binaryType() {
+return this._channel.binaryType;
+},
+/**
+* Sets the binary type of the channel
+*
+* @param {String} type
+*        The new binary type of the channel
+*/
+set binaryType(type) {
+this._channel.binaryType = type;
+},
+/**
+* Returns the label of the underlying data channel
+*
+* @returns {String} The label
+*/
+get label() {
+return this._channel.label;
+},
+/**
+* Returns the protocol of the underlying data channel
+*
+* @returns {String} The protocol
+*/
+get protocol() {
+return this._channel.protocol;
+},
+/**
+* Returns the id of the underlying data channel
+*
+* @returns {number} The stream id
+*/
+get id() {
+return this._channel.id;
+},
+/**
+* Returns the reliable state of the underlying data channel
+*
+* @returns {bool} The stream's reliable state
+*/
+get reliable() {
+return this._channel.reliable;
+},
+// ordered, maxRetransmits and maxRetransmitTime not exposed yet
+/**
+* Returns the readyState bit of the data channel
+*
+* @returns {String} The state of the channel
+*/
+get readyState() {
+return this._channel.readyState;
+},
+/**
+* Close the data channel
+*/
+close : function () {
+info(this + ": Closing channel");
+this._channel.close();
+},
+/**
+* Send data through the data channel
+*
+* @param {String|Object} data
+*        Data which has to be sent through the data channel
+*/
+send: function DCW_send(data) {
+info(this + ": Sending data '" + data + "'");
+this._channel.send(data);
+},
+/**
+* Returns the string representation of the class
+*
+* @returns {String} The string representation
+*/
+toString: function DCW_toString() {
+return "DataChannelWrapper (" + this._pc.label + '_' + this._channel.label + ")";
+}
+};
+/**
+* This class acts as a wrapper around a PeerConnection instance.
+*
+* @constructor
+* @param {string} label
+*        Description for the peer connection instance
+* @param {object} configuration
+*        Configuration for the peer connection instance
+*/
+function PeerConnectionWrapper(label, configuration) {
+this.configuration = configuration;
+this.label = label;
+this.whenCreated = Date.now();
+this.constraints = [ ];
+this.offerConstraints = {};
+this.streams = [ ];
+this.mediaCheckers = [ ];
+this.dataChannels = [ ];
+info("Creating " + this);
+this._pc = new mozRTCPeerConnection(this.configuration);
+is(this._pc.iceConnectionState, "new", "iceConnectionState starts at 'new'");
+/**
+* Setup callback handlers
+*/
+var self = this;
+// This enables tests to validate that the next ice state is the one they expect to happen
+this.next_ice_state = ""; // in most cases, the next state will be "checking", but in some tests "closed"
+// This allows test to register their own callbacks for ICE connection state changes
+this.ice_connection_callbacks = {};
+this._pc.oniceconnectionstatechange = function() {
+ok(self._pc.iceConnectionState !== undefined, "iceConnectionState should not be undefined");
+info(self + ": oniceconnectionstatechange fired, new state is: " + self._pc.iceConnectionState);
+Object.keys(self.ice_connection_callbacks).forEach(function(name) {
+self.ice_connection_callbacks[name]();
+});
+if (self.next_ice_state !== "") {
+is(self._pc.iceConnectionState, self.next_ice_state, "iceConnectionState changed to '" +
+self.next_ice_state + "'");
+self.next_ice_state = "";
+}
+};
+this.ondatachannel = unexpectedEventAndFinish(this, 'ondatachannel');
+this.onsignalingstatechange = unexpectedEventAndFinish(this, 'onsignalingstatechange');
+/**
+* Callback for native peer connection 'onaddstream' events.
+*
+* @param {Object} event
+*        Event data which includes the stream to be added
+*/
+this._pc.onaddstream = function (event) {
+info(self + ": 'onaddstream' event fired for " + JSON.stringify(event.stream));
+var type = '';
+if (event.stream.getAudioTracks().length > 0) {
+type = 'audio';
+}
+if (event.stream.getVideoTracks().length > 0) {
+type += 'video';
+}
+self.attachMedia(event.stream, type, 'remote');
+};
+/**
+* Callback for native peer connection 'ondatachannel' events. If no custom handler
+* has been specified via 'this.ondatachannel', a failure will be raised if an
+* event of this type gets caught.
+*
+* @param {Object} event
+*        Event data which includes the newly created data channel
+*/
+this._pc.ondatachannel = function (event) {
+info(self + ": 'ondatachannel' event fired for " + event.channel.label);
+self.ondatachannel(new DataChannelWrapper(event.channel, self));
+self.ondatachannel = unexpectedEventAndFinish(self, 'ondatachannel');
+};
+/**
+* Callback for native peer connection 'onsignalingstatechange' events. If no
+* custom handler has been specified via 'this.onsignalingstatechange', a
+* failure will be raised if an event of this type is caught.
+*
+* @param {Object} aEvent
+*        Event data which includes the newly created data channel
+*/
+this._pc.onsignalingstatechange = function (aEvent) {
+info(self + ": 'onsignalingstatechange' event fired");
+// this calls the eventhandler only once and then overwrites it with the
+// default unexpectedEvent handler
+self.onsignalingstatechange(aEvent);
+self.onsignalingstatechange = unexpectedEventAndFinish(self, 'onsignalingstatechange');
+};
+}
+PeerConnectionWrapper.prototype = {
+/**
+* Returns the local description.
+*
+* @returns {object} The local description
+*/
+get localDescription() {
+return this._pc.localDescription;
+},
+/**
+* Sets the local description.
+*
+* @param {object} desc
+*        The new local description
+*/
+set localDescription(desc) {
+this._pc.localDescription = desc;
+},
+/**
+* Returns the readyState.
+*
+* @returns {string}
+*/
+get readyState() {
+return this._pc.readyState;
+},
+/**
+* Returns the remote description.
+*
+* @returns {object} The remote description
+*/
+get remoteDescription() {
+return this._pc.remoteDescription;
+},
+/**
+* Sets the remote description.
+*
+* @param {object} desc
+*        The new remote description
+*/
+set remoteDescription(desc) {
+this._pc.remoteDescription = desc;
+},
+/**
+* Returns the signaling state.
+*
+* @returns {object} The local description
+*/
+get signalingState() {
+return this._pc.signalingState;
+},
+/**
+* Returns the ICE connection state.
+*
+* @returns {object} The local description
+*/
+get iceConnectionState() {
+return this._pc.iceConnectionState;
+},
+setIdentityProvider: function(provider, protocol, identity) {
+this._pc.setIdentityProvider(provider, protocol, identity);
+},
+/**
+* Callback when we get media from either side. Also an appropriate
+* HTML media element will be created.
+*
+* @param {MediaStream} stream
+*        Media stream to handle
+* @param {string} type
+*        The type of media stream ('audio' or 'video')
+* @param {string} side
+*        The location the stream is coming from ('local' or 'remote')
+*/
+attachMedia : function PCW_attachMedia(stream, type, side) {
+info("Got media stream: " + type + " (" + side + ")");
+this.streams.push(stream);
+if (side === 'local') {
+this._pc.addStream(stream);
+}
+var element = createMediaElement(type, this.label + '_' + side);
+this.mediaCheckers.push(new MediaElementChecker(element));
+element.mozSrcObject = stream;
+element.play();
+},
+/**
+* Requests all the media streams as specified in the constrains property.
+*
+* @param {function} onSuccess
+*        Callback to execute if all media has been requested successfully
+*/
+getAllUserMedia : function PCW_GetAllUserMedia(onSuccess) {
+var self = this;
+function _getAllUserMedia(constraintsList, index) {
+if (index < constraintsList.length) {
+var constraints = constraintsList[index];
+getUserMedia(constraints, function (stream) {
+var type = '';
+if (constraints.audio) {
+type = 'audio';
+}
+if (constraints.video) {
+type += 'video';
+}
+self.attachMedia(stream, type, 'local');
+_getAllUserMedia(constraintsList, index + 1);
+}, generateErrorCallback());
+} else {
+onSuccess();
+}
+}
+info("Get " + this.constraints.length + " local streams");
+_getAllUserMedia(this.constraints, 0);
+},
+/**
+* Create a new data channel instance
+*
+* @param {Object} options
+*        Options which get forwarded to nsIPeerConnection.createDataChannel
+* @param {function} [onCreation=undefined]
+*        Callback to execute when the local data channel has been created
+* @returns {DataChannelWrapper} The created data channel
+*/
+createDataChannel : function PCW_createDataChannel(options, onCreation) {
+var label = 'channel_' + this.dataChannels.length;
+info(this + ": Create data channel '" + label);
+var channel = this._pc.createDataChannel(label, options);
+var wrapper = new DataChannelWrapper(channel, this);
+if (onCreation) {
+wrapper.onopen = function () {
+onCreation(wrapper);
+};
+}
+this.dataChannels.push(wrapper);
+return wrapper;
+},
+/**
+* Creates an offer and automatically handles the failure case.
+*
+* @param {function} onSuccess
+*        Callback to execute if the offer was created successfully
+*/
+createOffer : function PCW_createOffer(onSuccess) {
+var self = this;
+this._pc.createOffer(function (offer) {
+info("Got offer: " + JSON.stringify(offer));
+self._last_offer = offer;
+onSuccess(offer);
+}, generateErrorCallback(), this.offerConstraints);
+},
+/**
+* Creates an answer and automatically handles the failure case.
+*
+* @param {function} onSuccess
+*        Callback to execute if the answer was created successfully
+*/
+createAnswer : function PCW_createAnswer(onSuccess) {
+var self = this;
+this._pc.createAnswer(function (answer) {
+info(self + ": Got answer: " + JSON.stringify(answer));
+self._last_answer = answer;
+onSuccess(answer);
+}, generateErrorCallback());
+},
+/**
+* Sets the local description and automatically handles the failure case.
+*
+* @param {object} desc
+*        mozRTCSessionDescription for the local description request
+* @param {function} onSuccess
+*        Callback to execute if the local description was set successfully
+*/
+setLocalDescription : function PCW_setLocalDescription(desc, onSuccess) {
+var self = this;
+this._pc.setLocalDescription(desc, function () {
+info(self + ": Successfully set the local description");
+onSuccess();
+}, generateErrorCallback());
+},
+/**
+* Tries to set the local description and expect failure. Automatically
+* causes the test case to fail if the call succeeds.
+*
+* @param {object} desc
+*        mozRTCSessionDescription for the local description request
+* @param {function} onFailure
+*        Callback to execute if the call fails.
+*/
+setLocalDescriptionAndFail : function PCW_setLocalDescriptionAndFail(desc, onFailure) {
+var self = this;
+this._pc.setLocalDescription(desc,
+generateErrorCallback("setLocalDescription should have failed."),
+function (err) {
+info(self + ": As expected, failed to set the local description");
+onFailure(err);
+});
+},
+/**
+* Sets the remote description and automatically handles the failure case.
+*
+* @param {object} desc
+*        mozRTCSessionDescription for the remote description request
+* @param {function} onSuccess
+*        Callback to execute if the remote description was set successfully
+*/
+setRemoteDescription : function PCW_setRemoteDescription(desc, onSuccess) {
+var self = this;
+this._pc.setRemoteDescription(desc, function () {
+info(self + ": Successfully set remote description");
+onSuccess();
+}, generateErrorCallback());
+},
+/**
+* Tries to set the remote description and expect failure. Automatically
+* causes the test case to fail if the call succeeds.
+*
+* @param {object} desc
+*        mozRTCSessionDescription for the remote description request
+* @param {function} onFailure
+*        Callback to execute if the call fails.
+*/
+setRemoteDescriptionAndFail : function PCW_setRemoteDescriptionAndFail(desc, onFailure) {
+var self = this;
+this._pc.setRemoteDescription(desc,
+generateErrorCallback("setRemoteDescription should have failed."),
+function (err) {
+info(self + ": As expected, failed to set the remote description");
+onFailure(err);
+});
+},
+/**
+* Adds an ICE candidate and automatically handles the failure case.
+*
+* @param {object} candidate
+*        SDP candidate
+* @param {function} onSuccess
+*        Callback to execute if the local description was set successfully
+*/
+addIceCandidate : function PCW_addIceCandidate(candidate, onSuccess) {
+var self = this;
+this._pc.addIceCandidate(candidate, function () {
+info(self + ": Successfully added an ICE candidate");
+onSuccess();
+}, generateErrorCallback());
+},
+/**
+* Tries to add an ICE candidate and expects failure. Automatically
+* causes the test case to fail if the call succeeds.
+*
+* @param {object} candidate
+*        SDP candidate
+* @param {function} onFailure
+*        Callback to execute if the call fails.
+*/
+addIceCandidateAndFail : function PCW_addIceCandidateAndFail(candidate, onFailure) {
+var self = this;
+this._pc.addIceCandidate(candidate,
+generateErrorCallback("addIceCandidate should have failed."),
+function (err) {
+info(self + ": As expected, failed to add an ICE candidate");
+onFailure(err);
+}) ;
+},
+/**
+* Returns if the ICE the connection state is "connected".
+*
+* @returns {boolean} True if the connection state is "connected", otherwise false.
+*/
+isIceConnected : function PCW_isIceConnected() {
+info("iceConnectionState: " + this.iceConnectionState);
+return this.iceConnectionState === "connected";
+},
+/**
+* Returns if the ICE the connection state is "checking".
+*
+* @returns {boolean} True if the connection state is "checking", otherwise false.
+*/
+isIceChecking : function PCW_isIceChecking() {
+return this.iceConnectionState === "checking";
+},
+/**
+* Returns if the ICE the connection state is "new".
+*
+* @returns {boolean} True if the connection state is "new", otherwise false.
+*/
+isIceNew : function PCW_isIceNew() {
+return this.iceConnectionState === "new";
+},
+/**
+* Checks if the ICE connection state still waits for a connection to get
+* established.
+*
+* @returns {boolean} True if the connection state is "checking" or "new",
+*  otherwise false.
+*/
+isIceConnectionPending : function PCW_isIceConnectionPending() {
+return (this.isIceChecking() || this.isIceNew());
+},
+/**
+* Registers a callback for the ICE connection state change and
+* reports success (=connected) or failure via the callbacks.
+* States "new" and "checking" are ignored.
+*
+* @param {function} onSuccess
+*        Callback if ICE connection status is "connected".
+* @param {function} onFailure
+*        Callback if ICE connection reaches a different state than
+*        "new", "checking" or "connected".
+*/
+waitForIceConnected : function PCW_waitForIceConnected(onSuccess, onFailure) {
+var self = this;
+var mySuccess = onSuccess;
+var myFailure = onFailure;
+function iceConnectedChanged () {
+if (self.isIceConnected()) {
+delete self.ice_connection_callbacks.waitForIceConnected;
+mySuccess();
+} else if (! self.isIceConnectionPending()) {
+delete self.ice_connection_callbacks.waitForIceConnected;
+myFailure();
+}
+}
+self.ice_connection_callbacks.waitForIceConnected = iceConnectedChanged;
+},
+/**
+* Checks that we are getting the media streams we expect.
+*
+* @param {object} constraintsRemote
+*        The media constraints of the remote peer connection object
+*/
+checkMediaStreams : function PCW_checkMediaStreams(constraintsRemote) {
+is(this._pc.getLocalStreams().length, this.constraints.length,
+this + ' has ' + this.constraints.length + ' local streams');
+// TODO: change this when multiple incoming streams are supported (bug 834835)
+is(this._pc.getRemoteStreams().length, 1,
+this + ' has ' + 1 + ' remote streams');
+},
+/**
+* Check that media flow is present on all media elements involved in this
+* test by waiting for confirmation that media flow is present.
+*
+* @param {Function} onSuccess the success callback when media flow
+*                             is confirmed on all media elements
+*/
+checkMediaFlowPresent : function PCW_checkMediaFlowPresent(onSuccess) {
+var self = this;
+function _checkMediaFlowPresent(index, onSuccess) {
+if(index >= self.mediaCheckers.length) {
+onSuccess();
+} else {
+var mediaChecker = self.mediaCheckers[index];
+mediaChecker.waitForMediaFlow(function() {
+_checkMediaFlowPresent(index + 1, onSuccess);
+});
+}
+}
+_checkMediaFlowPresent(0, onSuccess);
+},
+/**
+* Check that stats are present by checking for known stats.
+*
+* @param {Function} onSuccess the success callback to return stats to
+*/
+getStats : function PCW_getStats(selector, onSuccess) {
+var self = this;
+this._pc.getStats(selector, function(stats) {
+info(self + ": Got stats: " + JSON.stringify(stats));
+self._last_stats = stats;
+onSuccess(stats);
+}, generateErrorCallback());
+},
+/**
+* Checks that we are getting the media streams we expect.
+*
+* @param {object} stats
+*        The stats to check from this PeerConnectionWrapper
+*/
+checkStats : function PCW_checkStats(stats) {
+function toNum(obj) {
+return obj? obj : 0;
+}
+function numTracks(streams) {
+var n = 0;
+streams.forEach(function(stream) {
+n += stream.getAudioTracks().length + stream.getVideoTracks().length;
+});
+return n;
+}
+const isWinXP = navigator.userAgent.indexOf("Windows NT 5.1") != -1;
+// Use spec way of enumerating stats
+var counters = {};
+for (var key in stats) {
+if (stats.hasOwnProperty(key)) {
+var res = stats[key];
+// validate stats
+ok(res.id == key, "Coherent stats id");
+var nowish = Date.now() + 1000;        // TODO: clock drift observed
+var minimum = this.whenCreated - 1000; // on Windows XP (Bug 979649)
+if (isWinXP) {
+todo(false, "Can't reliably test rtcp timestamps on WinXP (Bug 979649)");
+} else {
+ok(res.timestamp >= minimum,
+"Valid " + (res.isRemote? "rtcp" : "rtp") + " timestamp " +
+res.timestamp + " >= " + minimum + " (" +
+(res.timestamp - minimum) + " ms)");
+ok(res.timestamp <= nowish,
+"Valid " + (res.isRemote? "rtcp" : "rtp") + " timestamp " +
+res.timestamp + " <= " + nowish + " (" +
+(res.timestamp - nowish) + " ms)");
+}
+if (!res.isRemote) {
+counters[res.type] = toNum(counters[res.type]) + 1;
+switch (res.type) {
+case "inboundrtp":
+case "outboundrtp": {
+// ssrc is a 32 bit number returned as a string by spec
+ok(res.ssrc.length > 0, "Ssrc has length");
+ok(res.ssrc.length < 11, "Ssrc not lengthy");
+ok(!/[^0-9]/.test(res.ssrc), "Ssrc numeric");
+ok(parseInt(res.ssrc) < Math.pow(2,32), "Ssrc within limits");
+if (res.type == "outboundrtp") {
+ok(res.packetsSent !== undefined, "Rtp packetsSent");
+// minimum fragment is 8 (from RFC 791)
+ok(res.bytesSent >= res.packetsSent * 8, "Rtp bytesSent");
+} else {
+ok(res.packetsReceived !== undefined, "Rtp packetsReceived");
+ok(res.bytesReceived >= res.packetsReceived * 8, "Rtp bytesReceived");
+}
+if (res.remoteId) {
+var rem = stats[res.remoteId];
+ok(rem.isRemote, "Remote is rtcp");
+ok(rem.remoteId == res.id, "Remote backlink match");
+if(res.type == "outboundrtp") {
+ok(rem.type == "inboundrtp", "Rtcp is inbound");
+ok(rem.packetsReceived !== undefined, "Rtcp packetsReceived");
+ok(rem.packetsReceived <= res.packetsSent, "No more than sent");
+ok(rem.packetsLost !== undefined, "Rtcp packetsLost");
+ok(rem.bytesReceived >= rem.packetsReceived * 8, "Rtcp bytesReceived");
+ok(rem.bytesReceived <= res.bytesSent, "No more than sent bytes");
+ok(rem.jitter !== undefined, "Rtcp jitter");
+ok(rem.mozRtt !== undefined, "Rtcp rtt");
+ok(rem.mozRtt >= 0, "Rtcp rtt " + rem.mozRtt + " >= 0");
+ok(rem.mozRtt < 60000, "Rtcp rtt " + rem.mozRtt + " < 1 min");
+} else {
+ok(rem.type == "outboundrtp", "Rtcp is outbound");
+ok(rem.packetsSent !== undefined, "Rtcp packetsSent");
+// We may have received more than outdated Rtcp packetsSent
+ok(rem.bytesSent >= rem.packetsSent * 8, "Rtcp bytesSent");
+}
+ok(rem.ssrc == res.ssrc, "Remote ssrc match");
+} else {
+info("No rtcp info received yet");
+}
+}
+break;
+}
+}
+}
+}
+// Use MapClass way of enumerating stats
+var counters2 = {};
+stats.forEach(function(res) {
+if (!res.isRemote) {
+counters2[res.type] = toNum(counters2[res.type]) + 1;
+}
+});
+is(JSON.stringify(counters), JSON.stringify(counters2),
+"Spec and MapClass variant of RTCStatsReport enumeration agree");
+var nin = numTracks(this._pc.getRemoteStreams());
+var nout = numTracks(this._pc.getLocalStreams());
+// TODO(Bug 957145): Restore stronger inboundrtp test once Bug 948249 is fixed
+//is(toNum(counters["inboundrtp"]), nin, "Have " + nin + " inboundrtp stat(s)");
+ok(toNum(counters.inboundrtp) >= nin, "Have at least " + nin + " inboundrtp stat(s) *");
+is(toNum(counters.outboundrtp), nout, "Have " + nout + " outboundrtp stat(s)");
+var numLocalCandidates  = toNum(counters.localcandidate);
+var numRemoteCandidates = toNum(counters.remotecandidate);
+// If there are no tracks, there will be no stats either.
+if (nin + nout > 0) {
+ok(numLocalCandidates, "Have localcandidate stat(s)");
+ok(numRemoteCandidates, "Have remotecandidate stat(s)");
+} else {
+is(numLocalCandidates, 0, "Have no localcandidate stats");
+is(numRemoteCandidates, 0, "Have no remotecandidate stats");
+}
+},
+/**
+* Closes the connection
+*/
+close : function PCW_close() {
+// It might be that a test has already closed the pc. In those cases
+// we should not fail.
+try {
+this._pc.close();
+info(this + ": Closed connection.");
+}
+catch (e) {
+info(this + ": Failure in closing connection - " + e.message);
+}
+},
+/**
+* Register all events during the setup of the data channel
+*
+* @param {Function} onDataChannelOpened
+*        Callback to execute when the data channel has been opened
+*/
+registerDataChannelOpenEvents : function (onDataChannelOpened) {
+info(this + ": Register callbacks for 'ondatachannel' and 'onopen'");
+this.ondatachannel = function (targetChannel) {
+targetChannel.onopen = function (targetChannel) {
+onDataChannelOpened(targetChannel);
+};
+this.dataChannels.push(targetChannel);
+};
+},
+/**
+* Returns the string representation of the class
+*
+* @returns {String} The string representation
+*/
+toString : function PCW_toString() {
+return "PeerConnectionWrapper (" + this.label + ")";
+}
+};