summaryrefslogtreecommitdiffstats
path: root/dom/presentation/provider/LegacyPresentationControlService.js
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/presentation/provider/LegacyPresentationControlService.js
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/presentation/provider/LegacyPresentationControlService.js')
-rw-r--r--dom/presentation/provider/LegacyPresentationControlService.js488
1 files changed, 488 insertions, 0 deletions
diff --git a/dom/presentation/provider/LegacyPresentationControlService.js b/dom/presentation/provider/LegacyPresentationControlService.js
new file mode 100644
index 000000000..b27177b63
--- /dev/null
+++ b/dom/presentation/provider/LegacyPresentationControlService.js
@@ -0,0 +1,488 @@
+/* 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/. */
+/* jshint esnext:true, globalstrict:true, moz:true, undef:true, unused:true */
+/* globals Components, dump */
+"use strict";
+
+const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+/* globals XPCOMUtils */
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+/* globals Services */
+Cu.import("resource://gre/modules/Services.jsm");
+/* globals NetUtil */
+Cu.import("resource://gre/modules/NetUtil.jsm");
+
+const DEBUG = Services.prefs.getBoolPref("dom.presentation.tcp_server.debug");
+function log(aMsg) {
+ dump("-*- LegacyPresentationControlService.js: " + aMsg + "\n");
+}
+
+function LegacyPresentationControlService() {
+ DEBUG && log("LegacyPresentationControlService - ctor"); //jshint ignore:line
+ this._id = null;
+}
+
+LegacyPresentationControlService.prototype = {
+ startServer: function() {
+ DEBUG && log("LegacyPresentationControlService - doesn't support receiver mode"); //jshint ignore:line
+ throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+ },
+
+ get id() {
+ return this._id;
+ },
+
+ set id(aId) {
+ this._id = aId;
+ },
+
+ get port() {
+ return 0;
+ },
+
+ get version() {
+ return 0;
+ },
+
+ set listener(aListener) { //jshint ignore:line
+ DEBUG && log("LegacyPresentationControlService - doesn't support receiver mode"); //jshint ignore:line
+ throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+ },
+
+ get listener() {
+ return null;
+ },
+
+ connect: function(aDeviceInfo) {
+ if (!this.id) {
+ DEBUG && log("LegacyPresentationControlService - Id has not initialized; requestSession fails"); //jshint ignore:line
+ return null;
+ }
+ DEBUG && log("LegacyPresentationControlService - requestSession to " + aDeviceInfo.id); //jshint ignore:line
+
+ let sts = Cc["@mozilla.org/network/socket-transport-service;1"]
+ .getService(Ci.nsISocketTransportService);
+
+ let socketTransport;
+ try {
+ socketTransport = sts.createTransport(null,
+ 0,
+ aDeviceInfo.address,
+ aDeviceInfo.port,
+ null);
+ } catch (e) {
+ DEBUG && log("LegacyPresentationControlService - createTransport throws: " + e); //jshint ignore:line
+ // Pop the exception to |TCPDevice.establishControlChannel|
+ throw Cr.NS_ERROR_FAILURE;
+ }
+ return new LegacyTCPControlChannel(this.id,
+ socketTransport,
+ aDeviceInfo);
+ },
+
+ close: function() {
+ DEBUG && log("LegacyPresentationControlService - close"); //jshint ignore:line
+ },
+
+ classID: Components.ID("{b21816fe-8aff-4811-86d2-85a7444c557e}"),
+ QueryInterface : XPCOMUtils.generateQI([Ci.nsIPresentationControlService]),
+};
+
+function ChannelDescription(aInit) {
+ this._type = aInit.type;
+ switch (this._type) {
+ case Ci.nsIPresentationChannelDescription.TYPE_TCP:
+ this._tcpAddresses = Cc["@mozilla.org/array;1"]
+ .createInstance(Ci.nsIMutableArray);
+ for (let address of aInit.tcpAddress) {
+ let wrapper = Cc["@mozilla.org/supports-cstring;1"]
+ .createInstance(Ci.nsISupportsCString);
+ wrapper.data = address;
+ this._tcpAddresses.appendElement(wrapper, false);
+ }
+
+ this._tcpPort = aInit.tcpPort;
+ break;
+ case Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL:
+ this._dataChannelSDP = aInit.dataChannelSDP;
+ break;
+ }
+}
+
+ChannelDescription.prototype = {
+ _type: 0,
+ _tcpAddresses: null,
+ _tcpPort: 0,
+ _dataChannelSDP: "",
+
+ get type() {
+ return this._type;
+ },
+
+ get tcpAddress() {
+ return this._tcpAddresses;
+ },
+
+ get tcpPort() {
+ return this._tcpPort;
+ },
+
+ get dataChannelSDP() {
+ return this._dataChannelSDP;
+ },
+
+ classID: Components.ID("{d69fc81c-4f40-47a3-97e6-b4cf5db2294e}"),
+ QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationChannelDescription]),
+};
+
+// Helper function: transfer nsIPresentationChannelDescription to json
+function discriptionAsJson(aDescription) {
+ let json = {};
+ json.type = aDescription.type;
+ switch(aDescription.type) {
+ case Ci.nsIPresentationChannelDescription.TYPE_TCP:
+ let addresses = aDescription.tcpAddress.QueryInterface(Ci.nsIArray);
+ json.tcpAddress = [];
+ for (let idx = 0; idx < addresses.length; idx++) {
+ let address = addresses.queryElementAt(idx, Ci.nsISupportsCString);
+ json.tcpAddress.push(address.data);
+ }
+ json.tcpPort = aDescription.tcpPort;
+ break;
+ case Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL:
+ json.dataChannelSDP = aDescription.dataChannelSDP;
+ break;
+ }
+ return json;
+}
+
+function LegacyTCPControlChannel(id,
+ transport,
+ deviceInfo) {
+ DEBUG && log("create LegacyTCPControlChannel"); //jshint ignore:line
+ this._deviceInfo = deviceInfo;
+ this._transport = transport;
+
+ this._id = id;
+
+ let currentThread = Services.tm.currentThread;
+ transport.setEventSink(this, currentThread);
+
+ this._input = this._transport.openInputStream(0, 0, 0)
+ .QueryInterface(Ci.nsIAsyncInputStream);
+ this._input.asyncWait(this.QueryInterface(Ci.nsIStreamListener),
+ Ci.nsIAsyncInputStream.WAIT_CLOSURE_ONLY,
+ 0,
+ currentThread);
+
+ this._output = this._transport
+ .openOutputStream(Ci.nsITransport.OPEN_UNBUFFERED, 0, 0);
+}
+
+LegacyTCPControlChannel.prototype = {
+ _connected: false,
+ _pendingOpen: false,
+ _pendingAnswer: null,
+ _pendingClose: null,
+ _pendingCloseReason: null,
+
+ _sendMessage: function(aJSONData, aOnThrow) {
+ if (!aOnThrow) {
+ aOnThrow = function(e) {throw e.result;};
+ }
+
+ if (!aJSONData) {
+ aOnThrow();
+ return;
+ }
+
+ if (!this._connected) {
+ DEBUG && log("LegacyTCPControlChannel - send" + aJSONData.type + " fails"); //jshint ignore:line
+ throw Cr.NS_ERROR_FAILURE;
+ }
+
+ try {
+ this._send(aJSONData);
+ } catch (e) {
+ aOnThrow(e);
+ }
+ },
+
+ _sendInit: function() {
+ let msg = {
+ type: "requestSession:Init",
+ presentationId: this._presentationId,
+ url: this._url,
+ id: this._id,
+ };
+
+ this._sendMessage(msg, function(e) {
+ this.disconnect();
+ this._notifyDisconnected(e.result);
+ });
+ },
+
+ launch: function(aPresentationId, aUrl) {
+ this._presentationId = aPresentationId;
+ this._url = aUrl;
+
+ this._sendInit();
+ },
+
+ terminate: function() {
+ // Legacy protocol doesn't support extra terminate protocol.
+ // Trigger error handling for browser to shutdown all the resource locally.
+ throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+ },
+
+ sendOffer: function(aOffer) {
+ let msg = {
+ type: "requestSession:Offer",
+ presentationId: this._presentationId,
+ offer: discriptionAsJson(aOffer),
+ };
+ this._sendMessage(msg);
+ },
+
+ sendAnswer: function(aAnswer) { //jshint ignore:line
+ throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+ },
+
+ sendIceCandidate: function(aCandidate) {
+ let msg = {
+ type: "requestSession:IceCandidate",
+ presentationId: this._presentationId,
+ iceCandidate: aCandidate,
+ };
+ this._sendMessage(msg);
+ },
+ // may throw an exception
+ _send: function(aMsg) {
+ DEBUG && log("LegacyTCPControlChannel - Send: " + JSON.stringify(aMsg, null, 2)); //jshint ignore:line
+
+ /**
+ * XXX In TCP streaming, it is possible that more than one message in one
+ * TCP packet. We use line delimited JSON to identify where one JSON encoded
+ * object ends and the next begins. Therefore, we do not allow newline
+ * characters whithin the whole message, and add a newline at the end.
+ * Please see the parser code in |onDataAvailable|.
+ */
+ let message = JSON.stringify(aMsg).replace(["\n"], "") + "\n";
+ try {
+ this._output.write(message, message.length);
+ } catch(e) {
+ DEBUG && log("LegacyTCPControlChannel - Failed to send message: " + e.name); //jshint ignore:line
+ throw e;
+ }
+ },
+
+ // nsIAsyncInputStream (Triggered by nsIInputStream.asyncWait)
+ // Only used for detecting connection refused
+ onInputStreamReady: function(aStream) {
+ try {
+ aStream.available();
+ } catch (e) {
+ DEBUG && log("LegacyTCPControlChannel - onInputStreamReady error: " + e.name); //jshint ignore:line
+ // NS_ERROR_CONNECTION_REFUSED
+ this._listener.notifyDisconnected(e.result);
+ }
+ },
+
+ // nsITransportEventSink (Triggered by nsISocketTransport.setEventSink)
+ onTransportStatus: function(aTransport, aStatus, aProg, aProgMax) { //jshint ignore:line
+ DEBUG && log("LegacyTCPControlChannel - onTransportStatus: "
+ + aStatus.toString(16)); //jshint ignore:line
+ if (aStatus === Ci.nsISocketTransport.STATUS_CONNECTED_TO) {
+ this._connected = true;
+
+ if (!this._pump) {
+ this._createInputStreamPump();
+ }
+
+ this._notifyConnected();
+ }
+ },
+
+ // nsIRequestObserver (Triggered by nsIInputStreamPump.asyncRead)
+ onStartRequest: function() {
+ DEBUG && log("LegacyTCPControlChannel - onStartRequest"); //jshint ignore:line
+ },
+
+ // nsIRequestObserver (Triggered by nsIInputStreamPump.asyncRead)
+ onStopRequest: function(aRequest, aContext, aStatus) {
+ DEBUG && log("LegacyTCPControlChannel - onStopRequest: " + aStatus); //jshint ignore:line
+ this.disconnect(aStatus);
+ this._notifyDisconnected(aStatus);
+ },
+
+ // nsIStreamListener (Triggered by nsIInputStreamPump.asyncRead)
+ onDataAvailable: function(aRequest, aContext, aInputStream, aOffset, aCount) { //jshint ignore:line
+ let data = NetUtil.readInputStreamToString(aInputStream,
+ aInputStream.available());
+ DEBUG && log("LegacyTCPControlChannel - onDataAvailable: " + data); //jshint ignore:line
+
+ // Parser of line delimited JSON. Please see |_send| for more informaiton.
+ let jsonArray = data.split("\n");
+ jsonArray.pop();
+ for (let json of jsonArray) {
+ let msg;
+ try {
+ msg = JSON.parse(json);
+ } catch (e) {
+ DEBUG && log("LegacyTCPSignalingChannel - error in parsing json: " + e); //jshint ignore:line
+ }
+
+ this._handleMessage(msg);
+ }
+ },
+
+ _createInputStreamPump: function() {
+ DEBUG && log("LegacyTCPControlChannel - create pump"); //jshint ignore:line
+ this._pump = Cc["@mozilla.org/network/input-stream-pump;1"].
+ createInstance(Ci.nsIInputStreamPump);
+ this._pump.init(this._input, -1, -1, 0, 0, false);
+ this._pump.asyncRead(this, null);
+ },
+
+ // Handle command from remote side
+ _handleMessage: function(aMsg) {
+ DEBUG && log("LegacyTCPControlChannel - handleMessage from "
+ + JSON.stringify(this._deviceInfo) + ": " + JSON.stringify(aMsg)); //jshint ignore:line
+ switch (aMsg.type) {
+ case "requestSession:Answer": {
+ this._onAnswer(aMsg.answer);
+ break;
+ }
+ case "requestSession:IceCandidate": {
+ this._listener.onIceCandidate(aMsg.iceCandidate);
+ break;
+ }
+ case "requestSession:CloseReason": {
+ this._pendingCloseReason = aMsg.reason;
+ break;
+ }
+ }
+ },
+
+ get listener() {
+ return this._listener;
+ },
+
+ set listener(aListener) {
+ DEBUG && log("LegacyTCPControlChannel - set listener: " + aListener); //jshint ignore:line
+ if (!aListener) {
+ this._listener = null;
+ return;
+ }
+
+ this._listener = aListener;
+ if (this._pendingOpen) {
+ this._pendingOpen = false;
+ DEBUG && log("LegacyTCPControlChannel - notify pending opened"); //jshint ignore:line
+ this._listener.notifyConnected();
+ }
+
+ if (this._pendingAnswer) {
+ let answer = this._pendingAnswer;
+ DEBUG && log("LegacyTCPControlChannel - notify pending answer: " +
+ JSON.stringify(answer)); // jshint ignore:line
+ this._listener.onAnswer(new ChannelDescription(answer));
+ this._pendingAnswer = null;
+ }
+
+ if (this._pendingClose) {
+ DEBUG && log("LegacyTCPControlChannel - notify pending closed"); //jshint ignore:line
+ this._notifyDisconnected(this._pendingCloseReason);
+ this._pendingClose = null;
+ }
+ },
+
+ /**
+ * These functions are designed to handle the interaction with listener
+ * appropriately. |_FUNC| is to handle |this._listener.FUNC|.
+ */
+ _onAnswer: function(aAnswer) {
+ if (!this._connected) {
+ return;
+ }
+ if (!this._listener) {
+ this._pendingAnswer = aAnswer;
+ return;
+ }
+ DEBUG && log("LegacyTCPControlChannel - notify answer: " + JSON.stringify(aAnswer)); //jshint ignore:line
+ this._listener.onAnswer(new ChannelDescription(aAnswer));
+ },
+
+ _notifyConnected: function() {
+ this._connected = true;
+ this._pendingClose = false;
+ this._pendingCloseReason = Cr.NS_OK;
+
+ if (!this._listener) {
+ this._pendingOpen = true;
+ return;
+ }
+
+ DEBUG && log("LegacyTCPControlChannel - notify opened"); //jshint ignore:line
+ this._listener.notifyConnected();
+ },
+
+ _notifyDisconnected: function(aReason) {
+ this._connected = false;
+ this._pendingOpen = false;
+ this._pendingAnswer = null;
+
+ // Remote endpoint closes the control channel with abnormal reason.
+ if (aReason == Cr.NS_OK && this._pendingCloseReason != Cr.NS_OK) {
+ aReason = this._pendingCloseReason;
+ }
+
+ if (!this._listener) {
+ this._pendingClose = true;
+ this._pendingCloseReason = aReason;
+ return;
+ }
+
+ DEBUG && log("LegacyTCPControlChannel - notify closed"); //jshint ignore:line
+ this._listener.notifyDisconnected(aReason);
+ },
+
+ disconnect: function(aReason) {
+ DEBUG && log("LegacyTCPControlChannel - close with reason: " + aReason); //jshint ignore:line
+
+ if (this._connected) {
+ // default reason is NS_OK
+ if (typeof aReason !== "undefined" && aReason !== Cr.NS_OK) {
+ let msg = {
+ type: "requestSession:CloseReason",
+ presentationId: this._presentationId,
+ reason: aReason,
+ };
+ this._sendMessage(msg);
+ this._pendingCloseReason = aReason;
+ }
+
+ this._transport.setEventSink(null, null);
+ this._pump = null;
+
+ this._input.close();
+ this._output.close();
+
+ this._connected = false;
+ }
+ },
+
+ reconnect: function() {
+ // Legacy protocol doesn't support extra reconnect protocol.
+ // Trigger error handling for browser to shutdown all the resource locally.
+ throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+ },
+
+ classID: Components.ID("{4027ce3d-06e3-4d06-a235-df329cb0d411}"),
+ QueryInterface: XPCOMUtils.generateQI([Ci.nsIPresentationControlChannel,
+ Ci.nsIStreamListener]),
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([LegacyPresentationControlService]); //jshint ignore:line