summaryrefslogtreecommitdiffstats
path: root/dom/browser-element/BrowserElementParent.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/browser-element/BrowserElementParent.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/browser-element/BrowserElementParent.js')
-rw-r--r--dom/browser-element/BrowserElementParent.js1202
1 files changed, 1202 insertions, 0 deletions
diff --git a/dom/browser-element/BrowserElementParent.js b/dom/browser-element/BrowserElementParent.js
new file mode 100644
index 000000000..67d05f0ab
--- /dev/null
+++ b/dom/browser-element/BrowserElementParent.js
@@ -0,0 +1,1202 @@
+/* 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";
+
+var Cu = Components.utils;
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+
+/* BrowserElementParent injects script to listen for certain events in the
+ * child. We then listen to messages from the child script and take
+ * appropriate action here in the parent.
+ */
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/BrowserElementPromptService.jsm");
+
+function debug(msg) {
+ //dump("BrowserElementParent - " + msg + "\n");
+}
+
+function getIntPref(prefName, def) {
+ try {
+ return Services.prefs.getIntPref(prefName);
+ }
+ catch(err) {
+ return def;
+ }
+}
+
+function handleWindowEvent(e) {
+ if (this._browserElementParents) {
+ let beps = ThreadSafeChromeUtils.nondeterministicGetWeakMapKeys(this._browserElementParents);
+ beps.forEach(bep => bep._handleOwnerEvent(e));
+ }
+}
+
+function defineNoReturnMethod(fn) {
+ return function method() {
+ if (!this._domRequestReady) {
+ // Remote browser haven't been created, we just queue the API call.
+ let args = Array.slice(arguments);
+ args.unshift(this);
+ this._pendingAPICalls.push(method.bind.apply(fn, args));
+ return;
+ }
+ if (this._isAlive()) {
+ fn.apply(this, arguments);
+ }
+ };
+}
+
+function defineDOMRequestMethod(msgName) {
+ return function() {
+ return this._sendDOMRequest(msgName);
+ };
+}
+
+function BrowserElementParentProxyCallHandler() {
+}
+
+BrowserElementParentProxyCallHandler.prototype = {
+ _frameElement: null,
+ _mm: null,
+
+ MOZBROWSER_EVENT_NAMES: Object.freeze([
+ "loadstart", "loadend", "close", "error", "firstpaint",
+ "documentfirstpaint", "audioplaybackchange",
+ "contextmenu", "securitychange", "locationchange",
+ "iconchange", "scrollareachanged", "titlechange",
+ "opensearch", "manifestchange", "metachange",
+ "resize", "scrollviewchange",
+ "caretstatechanged", "activitydone", "scroll", "opentab"]),
+
+ init: function(frameElement, mm) {
+ this._frameElement = frameElement;
+ this._mm = mm;
+ this.innerWindowIDSet = new Set();
+
+ mm.addMessageListener("browser-element-api:proxy-call", this);
+ },
+
+ // Message manager callback receives messages from BrowserElementProxy.js
+ receiveMessage: function(mmMsg) {
+ let data = mmMsg.json;
+
+ let mm;
+ try {
+ mm = mmMsg.target.QueryInterface(Ci.nsIFrameLoaderOwner)
+ .frameLoader.messageManager;
+ } catch(e) {
+ mm = mmMsg.target;
+ }
+ if (!mm.assertPermission("browser:embedded-system-app")) {
+ dump("BrowserElementParent.js: Method call " + data.methodName +
+ " from a content process with no 'browser:embedded-system-app'" +
+ " privileges.\n");
+ return;
+ }
+
+ switch (data.methodName) {
+ case '_proxyInstanceInit':
+ if (!this.innerWindowIDSet.size) {
+ this._attachEventListeners();
+ }
+ this.innerWindowIDSet.add(data.innerWindowID);
+
+ break;
+
+ case '_proxyInstanceUninit':
+ this.innerWindowIDSet.delete(data.innerWindowID);
+ if (!this.innerWindowIDSet.size) {
+ this._detachEventListeners();
+ }
+
+ break;
+
+ // void methods
+ case 'setVisible':
+ case 'setActive':
+ case 'sendMouseEvent':
+ case 'sendTouchEvent':
+ case 'goBack':
+ case 'goForward':
+ case 'reload':
+ case 'stop':
+ case 'zoom':
+ case 'findAll':
+ case 'findNext':
+ case 'clearMatch':
+ case 'mute':
+ case 'unmute':
+ case 'setVolume':
+ this._frameElement[data.methodName]
+ .apply(this._frameElement, data.args);
+
+ break;
+
+ // DOMRequest methods
+ case 'getVisible':
+ case 'download':
+ case 'purgeHistory':
+ case 'getCanGoBack':
+ case 'getCanGoForward':
+ case 'getContentDimensions':
+ case 'setInputMethodActive':
+ case 'executeScript':
+ case 'getMuted':
+ case 'getVolume':
+ let req = this._frameElement[data.methodName]
+ .apply(this._frameElement, data.args);
+ req.onsuccess = () => {
+ this._sendToProxy({
+ domRequestId: data.domRequestId,
+ innerWindowID: data.innerWindowID,
+ result: req.result
+ });
+ };
+ req.onerror = () => {
+ this._sendToProxy({
+ domRequestId: data.domRequestId,
+ innerWindowID: data.innerWindowID,
+ err: req.error
+ });
+ };
+
+ break;
+
+ // Not implemented
+ case 'getActive': // Sync ???
+ case 'addNextPaintListener': // Takes a callback
+ case 'removeNextPaintListener': // Takes a callback
+ case 'getScreenshot': // Need to pass a blob back
+ dump("BrowserElementParentProxyCallHandler Error:" +
+ "Attempt to call unimplemented method " + data.methodName + ".\n");
+ break;
+
+ default:
+ dump("BrowserElementParentProxyCallHandler Error:" +
+ "Attempt to call non-exist method " + data.methodName + ".\n");
+ break;
+ }
+ },
+
+ // Receving events from the frame element and forward it.
+ handleEvent: function(evt) {
+ // Ignore the events from nested mozbrowser iframes
+ if (evt.target !== this._frameElement) {
+ return;
+ }
+
+ let detailString;
+ try {
+ detailString = JSON.stringify(evt.detail);
+ } catch (e) {
+ dump("BrowserElementParentProxyCallHandler Error:" +
+ "Event detail of " + evt.type + " can't be stingified.\n");
+ return;
+ }
+
+ this.innerWindowIDSet.forEach((innerWindowID) => {
+ this._sendToProxy({
+ eventName: evt.type,
+ innerWindowID: innerWindowID,
+ eventDetailString: detailString
+ });
+ });
+ },
+
+ _sendToProxy: function(data) {
+ this._mm.sendAsyncMessage("browser-element-api:proxy", data);
+ },
+
+ _attachEventListeners: function() {
+ this.MOZBROWSER_EVENT_NAMES.forEach(function(eventName) {
+ this._frameElement.addEventListener(
+ "mozbrowser" + eventName, this, true);
+ }, this);
+ },
+
+ _detachEventListeners: function() {
+ this.MOZBROWSER_EVENT_NAMES.forEach(function(eventName) {
+ this._frameElement.removeEventListener(
+ "mozbrowser" + eventName, this, true);
+ }, this);
+ }
+};
+
+function BrowserElementParent() {
+ debug("Creating new BrowserElementParent object");
+ this._domRequestCounter = 0;
+ this._domRequestReady = false;
+ this._pendingAPICalls = [];
+ this._pendingDOMRequests = {};
+ this._pendingSetInputMethodActive = [];
+ this._nextPaintListeners = [];
+ this._pendingDOMFullscreen = false;
+
+ Services.obs.addObserver(this, 'oop-frameloader-crashed', /* ownsWeak = */ true);
+ Services.obs.addObserver(this, 'ask-children-to-execute-copypaste-command', /* ownsWeak = */ true);
+ Services.obs.addObserver(this, 'back-docommand', /* ownsWeak = */ true);
+
+ this.proxyCallHandler = new BrowserElementParentProxyCallHandler();
+}
+
+BrowserElementParent.prototype = {
+
+ classDescription: "BrowserElementAPI implementation",
+ classID: Components.ID("{9f171ac4-0939-4ef8-b360-3408aedc3060}"),
+ contractID: "@mozilla.org/dom/browser-element-api;1",
+ QueryInterface: XPCOMUtils.generateQI([Ci.nsIBrowserElementAPI,
+ Ci.nsIObserver,
+ Ci.nsISupportsWeakReference]),
+
+ setFrameLoader: function(frameLoader) {
+ debug("Setting frameLoader");
+ this._frameLoader = frameLoader;
+ this._frameElement = frameLoader.QueryInterface(Ci.nsIFrameLoader).ownerElement;
+ if (!this._frameElement) {
+ debug("No frame element?");
+ return;
+ }
+ // Listen to visibilitychange on the iframe's owner window, and forward
+ // changes down to the child. We want to do this while registering as few
+ // visibilitychange listeners on _window as possible, because such a listener
+ // may live longer than this BrowserElementParent object.
+ //
+ // To accomplish this, we register just one listener on the window, and have
+ // it reference a WeakMap whose keys are all the BrowserElementParent objects
+ // on the window. Then when the listener fires, we iterate over the
+ // WeakMap's keys (which we can do, because we're chrome) to notify the
+ // BrowserElementParents.
+ if (!this._window._browserElementParents) {
+ this._window._browserElementParents = new WeakMap();
+ let handler = handleWindowEvent.bind(this._window);
+ let windowEvents = ['visibilitychange', 'fullscreenchange'];
+ let els = Cc["@mozilla.org/eventlistenerservice;1"]
+ .getService(Ci.nsIEventListenerService);
+ for (let event of windowEvents) {
+ els.addSystemEventListener(this._window, event, handler,
+ /* useCapture = */ true);
+ }
+ }
+
+ this._window._browserElementParents.set(this, null);
+
+ // Insert ourself into the prompt service.
+ BrowserElementPromptService.mapFrameToBrowserElementParent(this._frameElement, this);
+ this._setupMessageListener();
+
+ this.proxyCallHandler.init(
+ this._frameElement, this._frameLoader.messageManager);
+ },
+
+ destroyFrameScripts() {
+ debug("Destroying frame scripts");
+ this._mm.sendAsyncMessage("browser-element-api:destroy");
+ },
+
+ _runPendingAPICall: function() {
+ if (!this._pendingAPICalls) {
+ return;
+ }
+ for (let i = 0; i < this._pendingAPICalls.length; i++) {
+ try {
+ this._pendingAPICalls[i]();
+ } catch (e) {
+ // throw the expections from pending functions.
+ debug('Exception when running pending API call: ' + e);
+ }
+ }
+ delete this._pendingAPICalls;
+ },
+
+ _setupMessageListener: function() {
+ this._mm = this._frameLoader.messageManager;
+ this._mm.addMessageListener('browser-element-api:call', this);
+ this._mm.loadFrameScript("chrome://global/content/extensions.js", true);
+ },
+
+ receiveMessage: function(aMsg) {
+ if (!this._isAlive()) {
+ return;
+ }
+
+ // Messages we receive are handed to functions which take a (data) argument,
+ // where |data| is the message manager's data object.
+ // We use a single message and dispatch to various function based
+ // on data.msg_name
+ let mmCalls = {
+ "hello": this._recvHello,
+ "loadstart": this._fireProfiledEventFromMsg,
+ "loadend": this._fireProfiledEventFromMsg,
+ "close": this._fireEventFromMsg,
+ "error": this._fireEventFromMsg,
+ "firstpaint": this._fireProfiledEventFromMsg,
+ "documentfirstpaint": this._fireProfiledEventFromMsg,
+ "nextpaint": this._recvNextPaint,
+ "got-purge-history": this._gotDOMRequestResult,
+ "got-screenshot": this._gotDOMRequestResult,
+ "got-contentdimensions": this._gotDOMRequestResult,
+ "got-can-go-back": this._gotDOMRequestResult,
+ "got-can-go-forward": this._gotDOMRequestResult,
+ "got-muted": this._gotDOMRequestResult,
+ "got-volume": this._gotDOMRequestResult,
+ "requested-dom-fullscreen": this._requestedDOMFullscreen,
+ "fullscreen-origin-change": this._fullscreenOriginChange,
+ "exit-dom-fullscreen": this._exitDomFullscreen,
+ "got-visible": this._gotDOMRequestResult,
+ "visibilitychange": this._childVisibilityChange,
+ "got-set-input-method-active": this._gotDOMRequestResult,
+ "scrollviewchange": this._handleScrollViewChange,
+ "caretstatechanged": this._handleCaretStateChanged,
+ "findchange": this._handleFindChange,
+ "execute-script-done": this._gotDOMRequestResult,
+ "got-audio-channel-volume": this._gotDOMRequestResult,
+ "got-set-audio-channel-volume": this._gotDOMRequestResult,
+ "got-audio-channel-muted": this._gotDOMRequestResult,
+ "got-set-audio-channel-muted": this._gotDOMRequestResult,
+ "got-is-audio-channel-active": this._gotDOMRequestResult,
+ "got-web-manifest": this._gotDOMRequestResult,
+ };
+
+ let mmSecuritySensitiveCalls = {
+ "audioplaybackchange": this._fireEventFromMsg,
+ "showmodalprompt": this._handleShowModalPrompt,
+ "contextmenu": this._fireCtxMenuEvent,
+ "securitychange": this._fireEventFromMsg,
+ "locationchange": this._fireEventFromMsg,
+ "iconchange": this._fireEventFromMsg,
+ "scrollareachanged": this._fireEventFromMsg,
+ "titlechange": this._fireProfiledEventFromMsg,
+ "opensearch": this._fireEventFromMsg,
+ "manifestchange": this._fireEventFromMsg,
+ "metachange": this._fireEventFromMsg,
+ "resize": this._fireEventFromMsg,
+ "activitydone": this._fireEventFromMsg,
+ "scroll": this._fireEventFromMsg,
+ "opentab": this._fireEventFromMsg
+ };
+
+ if (aMsg.data.msg_name in mmCalls) {
+ return mmCalls[aMsg.data.msg_name].apply(this, arguments);
+ } else if (aMsg.data.msg_name in mmSecuritySensitiveCalls) {
+ return mmSecuritySensitiveCalls[aMsg.data.msg_name].apply(this, arguments);
+ }
+ },
+
+ _removeMessageListener: function() {
+ this._mm.removeMessageListener('browser-element-api:call', this);
+ },
+
+ /**
+ * You shouldn't touch this._frameElement or this._window if _isAlive is
+ * false. (You'll likely get an exception if you do.)
+ */
+ _isAlive: function() {
+ return !Cu.isDeadWrapper(this._frameElement) &&
+ !Cu.isDeadWrapper(this._frameElement.ownerDocument) &&
+ !Cu.isDeadWrapper(this._frameElement.ownerDocument.defaultView);
+ },
+
+ get _window() {
+ return this._frameElement.ownerDocument.defaultView;
+ },
+
+ get _windowUtils() {
+ return this._window.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils);
+ },
+
+ promptAuth: function(authDetail, callback) {
+ let evt;
+ let self = this;
+ let callbackCalled = false;
+ let cancelCallback = function() {
+ if (!callbackCalled) {
+ callbackCalled = true;
+ callback(false, null, null);
+ }
+ };
+
+ // We don't handle password-only prompts.
+ if (authDetail.isOnlyPassword) {
+ cancelCallback();
+ return;
+ }
+
+ /* username and password */
+ let detail = {
+ host: authDetail.host,
+ path: authDetail.path,
+ realm: authDetail.realm,
+ isProxy: authDetail.isProxy
+ };
+
+ evt = this._createEvent('usernameandpasswordrequired', detail,
+ /* cancelable */ true);
+ Cu.exportFunction(function(username, password) {
+ if (callbackCalled)
+ return;
+ callbackCalled = true;
+ callback(true, username, password);
+ }, evt.detail, { defineAs: 'authenticate' });
+
+ Cu.exportFunction(cancelCallback, evt.detail, { defineAs: 'cancel' });
+
+ this._frameElement.dispatchEvent(evt);
+
+ if (!evt.defaultPrevented) {
+ cancelCallback();
+ }
+ },
+
+ _sendAsyncMsg: function(msg, data) {
+ try {
+ if (!data) {
+ data = { };
+ }
+
+ data.msg_name = msg;
+ this._mm.sendAsyncMessage('browser-element-api:call', data);
+ } catch (e) {
+ return false;
+ }
+ return true;
+ },
+
+ _recvHello: function() {
+ debug("recvHello");
+
+ // Inform our child if our owner element's document is invisible. Note
+ // that we must do so here, rather than in the BrowserElementParent
+ // constructor, because the BrowserElementChild may not be initialized when
+ // we run our constructor.
+ if (this._window.document.hidden) {
+ this._ownerVisibilityChange();
+ }
+
+ if (!this._domRequestReady) {
+ // At least, one message listener such as for hello is registered.
+ // So we can use sendAsyncMessage now.
+ this._domRequestReady = true;
+ this._runPendingAPICall();
+ }
+ },
+
+ _fireCtxMenuEvent: function(data) {
+ let detail = data.json;
+ let evtName = detail.msg_name;
+
+ debug('fireCtxMenuEventFromMsg: ' + evtName + ' ' + detail);
+ let evt = this._createEvent(evtName, detail, /* cancellable */ true);
+
+ if (detail.contextmenu) {
+ var self = this;
+ Cu.exportFunction(function(id) {
+ self._sendAsyncMsg('fire-ctx-callback', {menuitem: id});
+ }, evt.detail, { defineAs: 'contextMenuItemSelected' });
+ }
+
+ // The embedder may have default actions on context menu events, so
+ // we fire a context menu event even if the child didn't define a
+ // custom context menu
+ return !this._frameElement.dispatchEvent(evt);
+ },
+
+ /**
+ * add profiler marker for each event fired.
+ */
+ _fireProfiledEventFromMsg: function(data) {
+ if (Services.profiler !== undefined) {
+ Services.profiler.AddMarker(data.json.msg_name);
+ }
+ this._fireEventFromMsg(data);
+ },
+
+ /**
+ * Fire either a vanilla or a custom event, depending on the contents of
+ * |data|.
+ */
+ _fireEventFromMsg: function(data) {
+ let detail = data.json;
+ let name = detail.msg_name;
+
+ // For events that send a "_payload_" property, we just want to transmit
+ // this in the event.
+ if ("_payload_" in detail) {
+ detail = detail._payload_;
+ }
+
+ debug('fireEventFromMsg: ' + name + ', ' + JSON.stringify(detail));
+ let evt = this._createEvent(name, detail,
+ /* cancelable = */ false);
+ this._frameElement.dispatchEvent(evt);
+ },
+
+ _handleShowModalPrompt: function(data) {
+ // Fire a showmodalprmopt event on the iframe. When this method is called,
+ // the child is spinning in a nested event loop waiting for an
+ // unblock-modal-prompt message.
+ //
+ // If the embedder calls preventDefault() on the showmodalprompt event,
+ // we'll block the child until event.detail.unblock() is called.
+ //
+ // Otherwise, if preventDefault() is not called, we'll send the
+ // unblock-modal-prompt message to the child as soon as the event is done
+ // dispatching.
+
+ let detail = data.json;
+ debug('handleShowPrompt ' + JSON.stringify(detail));
+
+ // Strip off the windowID property from the object we send along in the
+ // event.
+ let windowID = detail.windowID;
+ delete detail.windowID;
+ debug("Event will have detail: " + JSON.stringify(detail));
+ let evt = this._createEvent('showmodalprompt', detail,
+ /* cancelable = */ true);
+
+ let self = this;
+ let unblockMsgSent = false;
+ function sendUnblockMsg() {
+ if (unblockMsgSent) {
+ return;
+ }
+ unblockMsgSent = true;
+
+ // We don't need to sanitize evt.detail.returnValue (e.g. converting the
+ // return value of confirm() to a boolean); Gecko does that for us.
+
+ let data = { windowID: windowID,
+ returnValue: evt.detail.returnValue };
+ self._sendAsyncMsg('unblock-modal-prompt', data);
+ }
+
+ Cu.exportFunction(sendUnblockMsg, evt.detail, { defineAs: 'unblock' });
+
+ this._frameElement.dispatchEvent(evt);
+
+ if (!evt.defaultPrevented) {
+ // Unblock the inner frame immediately. Otherwise we'll unblock upon
+ // evt.detail.unblock().
+ sendUnblockMsg();
+ }
+ },
+
+ // Called when state of accessible caret in child has changed.
+ // The fields of data is as following:
+ // - rect: Contains bounding rectangle of selection, Include width, height,
+ // top, bottom, left and right.
+ // - commands: Describe what commands can be executed in child. Include canSelectAll,
+ // canCut, canCopy and canPaste. For example: if we want to check if cut
+ // command is available, using following code, if (data.commands.canCut) {}.
+ // - zoomFactor: Current zoom factor in child frame.
+ // - reason: The reason causes the state changed. Include "visibilitychange",
+ // "updateposition", "longpressonemptycontent", "taponcaret", "presscaret",
+ // "releasecaret".
+ // - collapsed: Indicate current selection is collapsed or not.
+ // - caretVisible: Indicate the caret visiibility.
+ // - selectionVisible: Indicate current selection is visible or not.
+ // - selectionEditable: Indicate current selection is editable or not.
+ // - selectedTextContent: Contains current selected text content, which is
+ // equivalent to the string returned by Selection.toString().
+ _handleCaretStateChanged: function(data) {
+ let evt = this._createEvent('caretstatechanged', data.json,
+ /* cancelable = */ false);
+
+ let self = this;
+ function sendDoCommandMsg(cmd) {
+ let data = { command: cmd };
+ self._sendAsyncMsg('copypaste-do-command', data);
+ }
+ Cu.exportFunction(sendDoCommandMsg, evt.detail, { defineAs: 'sendDoCommandMsg' });
+
+ this._frameElement.dispatchEvent(evt);
+ },
+
+ _handleScrollViewChange: function(data) {
+ let evt = this._createEvent("scrollviewchange", data.json,
+ /* cancelable = */ false);
+ this._frameElement.dispatchEvent(evt);
+ },
+
+ _handleFindChange: function(data) {
+ let evt = this._createEvent("findchange", data.json,
+ /* cancelable = */ false);
+ this._frameElement.dispatchEvent(evt);
+ },
+
+ _createEvent: function(evtName, detail, cancelable) {
+ // This will have to change if we ever want to send a CustomEvent with null
+ // detail. For now, it's OK.
+ if (detail !== undefined && detail !== null) {
+ detail = Cu.cloneInto(detail, this._window);
+ return new this._window.CustomEvent('mozbrowser' + evtName,
+ { bubbles: true,
+ cancelable: cancelable,
+ detail: detail });
+ }
+
+ return new this._window.Event('mozbrowser' + evtName,
+ { bubbles: true,
+ cancelable: cancelable });
+ },
+
+ /**
+ * Kick off a DOMRequest in the child process.
+ *
+ * We'll fire an event called |msgName| on the child process, passing along
+ * an object with two fields:
+ *
+ * - id: the ID of this request.
+ * - arg: arguments to pass to the child along with this request.
+ *
+ * We expect the child to pass the ID back to us upon completion of the
+ * request. See _gotDOMRequestResult.
+ */
+ _sendDOMRequest: function(msgName, args) {
+ let id = 'req_' + this._domRequestCounter++;
+ let req = Services.DOMRequest.createRequest(this._window);
+ let self = this;
+ let send = function() {
+ if (!self._isAlive()) {
+ return;
+ }
+ if (self._sendAsyncMsg(msgName, {id: id, args: args})) {
+ self._pendingDOMRequests[id] = req;
+ } else {
+ Services.DOMRequest.fireErrorAsync(req, "fail");
+ }
+ };
+ if (this._domRequestReady) {
+ send();
+ } else {
+ // Child haven't been loaded.
+ this._pendingAPICalls.push(send);
+ }
+ return req;
+ },
+
+ /**
+ * Called when the child process finishes handling a DOMRequest. data.json
+ * must have the fields [id, successRv], if the DOMRequest was successful, or
+ * [id, errorMsg], if the request was not successful.
+ *
+ * The fields have the following meanings:
+ *
+ * - id: the ID of the DOM request (see _sendDOMRequest)
+ * - successRv: the request's return value, if the request succeeded
+ * - errorMsg: the message to pass to DOMRequest.fireError(), if the request
+ * failed.
+ *
+ */
+ _gotDOMRequestResult: function(data) {
+ let req = this._pendingDOMRequests[data.json.id];
+ delete this._pendingDOMRequests[data.json.id];
+
+ if ('successRv' in data.json) {
+ debug("Successful gotDOMRequestResult.");
+ let clientObj = Cu.cloneInto(data.json.successRv, this._window);
+ Services.DOMRequest.fireSuccess(req, clientObj);
+ }
+ else {
+ debug("Got error in gotDOMRequestResult.");
+ Services.DOMRequest.fireErrorAsync(req,
+ Cu.cloneInto(data.json.errorMsg, this._window));
+ }
+ },
+
+ setVisible: defineNoReturnMethod(function(visible) {
+ this._sendAsyncMsg('set-visible', {visible: visible});
+ this._frameLoader.visible = visible;
+ }),
+
+ getVisible: defineDOMRequestMethod('get-visible'),
+
+ setActive: defineNoReturnMethod(function(active) {
+ this._frameLoader.visible = active;
+ }),
+
+ getActive: function() {
+ if (!this._isAlive()) {
+ throw Components.Exception("Dead content process",
+ Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ return this._frameLoader.visible;
+ },
+
+ getChildProcessOffset: function() {
+ let offset = { x: 0, y: 0 };
+ let tabParent = this._frameLoader.tabParent;
+ if (tabParent) {
+ let offsetX = {};
+ let offsetY = {};
+ tabParent.getChildProcessOffset(offsetX, offsetY);
+ offset.x = offsetX.value;
+ offset.y = offsetY.value;
+ }
+ return offset;
+ },
+
+ sendMouseEvent: defineNoReturnMethod(function(type, x, y, button, clickCount, modifiers) {
+ let offset = this.getChildProcessOffset();
+ x += offset.x;
+ y += offset.y;
+
+ this._sendAsyncMsg("send-mouse-event", {
+ "type": type,
+ "x": x,
+ "y": y,
+ "button": button,
+ "clickCount": clickCount,
+ "modifiers": modifiers
+ });
+ }),
+
+ sendTouchEvent: defineNoReturnMethod(function(type, identifiers, touchesX, touchesY,
+ radiisX, radiisY, rotationAngles, forces,
+ count, modifiers) {
+
+ let offset = this.getChildProcessOffset();
+ for (var i = 0; i < touchesX.length; i++) {
+ touchesX[i] += offset.x;
+ }
+ for (var i = 0; i < touchesY.length; i++) {
+ touchesY[i] += offset.y;
+ }
+ this._sendAsyncMsg("send-touch-event", {
+ "type": type,
+ "identifiers": identifiers,
+ "touchesX": touchesX,
+ "touchesY": touchesY,
+ "radiisX": radiisX,
+ "radiisY": radiisY,
+ "rotationAngles": rotationAngles,
+ "forces": forces,
+ "count": count,
+ "modifiers": modifiers
+ });
+ }),
+
+ getCanGoBack: defineDOMRequestMethod('get-can-go-back'),
+ getCanGoForward: defineDOMRequestMethod('get-can-go-forward'),
+ getContentDimensions: defineDOMRequestMethod('get-contentdimensions'),
+
+ findAll: defineNoReturnMethod(function(searchString, caseSensitivity) {
+ return this._sendAsyncMsg('find-all', {
+ searchString,
+ caseSensitive: caseSensitivity == Ci.nsIBrowserElementAPI.FIND_CASE_SENSITIVE
+ });
+ }),
+
+ findNext: defineNoReturnMethod(function(direction) {
+ return this._sendAsyncMsg('find-next', {
+ backward: direction == Ci.nsIBrowserElementAPI.FIND_BACKWARD
+ });
+ }),
+
+ clearMatch: defineNoReturnMethod(function() {
+ return this._sendAsyncMsg('clear-match');
+ }),
+
+ mute: defineNoReturnMethod(function() {
+ this._sendAsyncMsg('mute');
+ }),
+
+ unmute: defineNoReturnMethod(function() {
+ this._sendAsyncMsg('unmute');
+ }),
+
+ getMuted: defineDOMRequestMethod('get-muted'),
+
+ getVolume: defineDOMRequestMethod('get-volume'),
+
+ setVolume: defineNoReturnMethod(function(volume) {
+ this._sendAsyncMsg('set-volume', {volume});
+ }),
+
+ goBack: defineNoReturnMethod(function() {
+ this._sendAsyncMsg('go-back');
+ }),
+
+ goForward: defineNoReturnMethod(function() {
+ this._sendAsyncMsg('go-forward');
+ }),
+
+ reload: defineNoReturnMethod(function(hardReload) {
+ this._sendAsyncMsg('reload', {hardReload: hardReload});
+ }),
+
+ stop: defineNoReturnMethod(function() {
+ this._sendAsyncMsg('stop');
+ }),
+
+ executeScript: function(script, options) {
+ if (!this._isAlive()) {
+ throw Components.Exception("Dead content process",
+ Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ // Enforcing options.url or options.origin
+ if (!options.url && !options.origin) {
+ throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
+ }
+ return this._sendDOMRequest('execute-script', {script, options});
+ },
+
+ /*
+ * The valid range of zoom scale is defined in preference "zoom.maxPercent" and "zoom.minPercent".
+ */
+ zoom: defineNoReturnMethod(function(zoom) {
+ zoom *= 100;
+ zoom = Math.min(getIntPref("zoom.maxPercent", 300), zoom);
+ zoom = Math.max(getIntPref("zoom.minPercent", 50), zoom);
+ this._sendAsyncMsg('zoom', {zoom: zoom / 100.0});
+ }),
+
+ purgeHistory: defineDOMRequestMethod('purge-history'),
+
+
+ download: function(_url, _options) {
+ if (!this._isAlive()) {
+ return null;
+ }
+
+ let uri = Services.io.newURI(_url, null, null);
+ let url = uri.QueryInterface(Ci.nsIURL);
+
+ debug('original _options = ' + uneval(_options));
+
+ // Ensure we have _options, we always use it to send the filename.
+ _options = _options || {};
+ if (!_options.filename) {
+ _options.filename = url.fileName;
+ }
+
+ debug('final _options = ' + uneval(_options));
+
+ // Ensure we have a filename.
+ if (!_options.filename) {
+ throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
+ }
+
+ let interfaceRequestor =
+ this._frameLoader.loadContext.QueryInterface(Ci.nsIInterfaceRequestor);
+ let req = Services.DOMRequest.createRequest(this._window);
+
+ function DownloadListener() {
+ debug('DownloadListener Constructor');
+ }
+ DownloadListener.prototype = {
+ extListener: null,
+ onStartRequest: function(aRequest, aContext) {
+ debug('DownloadListener - onStartRequest');
+ let extHelperAppSvc =
+ Cc['@mozilla.org/uriloader/external-helper-app-service;1'].
+ getService(Ci.nsIExternalHelperAppService);
+ let channel = aRequest.QueryInterface(Ci.nsIChannel);
+
+ // First, we'll ensure the filename doesn't have any leading
+ // periods. We have to do it here to avoid ending up with a filename
+ // that's only an extension with no extension (e.g. Sending in
+ // '.jpeg' without stripping the '.' would result in a filename of
+ // 'jpeg' where we want 'jpeg.jpeg'.
+ _options.filename = _options.filename.replace(/^\.+/, "");
+
+ let ext = null;
+ let mimeSvc = extHelperAppSvc.QueryInterface(Ci.nsIMIMEService);
+ try {
+ ext = '.' + mimeSvc.getPrimaryExtension(channel.contentType, '');
+ } catch (e) { ext = null; }
+
+ // Check if we need to add an extension to the filename.
+ if (ext && !_options.filename.endsWith(ext)) {
+ _options.filename += ext;
+ }
+ // Set the filename to use when saving to disk.
+ channel.contentDispositionFilename = _options.filename;
+
+ this.extListener =
+ extHelperAppSvc.doContent(
+ channel.contentType,
+ aRequest,
+ interfaceRequestor,
+ true);
+ this.extListener.onStartRequest(aRequest, aContext);
+ },
+ onStopRequest: function(aRequest, aContext, aStatusCode) {
+ debug('DownloadListener - onStopRequest (aStatusCode = ' +
+ aStatusCode + ')');
+ if (aStatusCode == Cr.NS_OK) {
+ // Everything looks great.
+ debug('DownloadListener - Download Successful.');
+ Services.DOMRequest.fireSuccess(req, aStatusCode);
+ }
+ else {
+ // In case of failure, we'll simply return the failure status code.
+ debug('DownloadListener - Download Failed!');
+ Services.DOMRequest.fireError(req, aStatusCode);
+ }
+
+ if (this.extListener) {
+ this.extListener.onStopRequest(aRequest, aContext, aStatusCode);
+ }
+ },
+ onDataAvailable: function(aRequest, aContext, aInputStream,
+ aOffset, aCount) {
+ this.extListener.onDataAvailable(aRequest, aContext, aInputStream,
+ aOffset, aCount);
+ },
+ QueryInterface: XPCOMUtils.generateQI([Ci.nsIStreamListener,
+ Ci.nsIRequestObserver])
+ };
+
+ let referrer = Services.io.newURI(_options.referrer, null, null);
+ let principal =
+ Services.scriptSecurityManager.createCodebasePrincipal(
+ referrer, this._frameLoader.loadContext.originAttributes);
+
+ let channel = NetUtil.newChannel({
+ uri: url,
+ loadingPrincipal: principal,
+ securityFlags: SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS,
+ contentPolicyType: Ci.nsIContentPolicy.TYPE_OTHER
+ });
+
+ // XXX We would set private browsing information prior to calling this.
+ channel.notificationCallbacks = interfaceRequestor;
+
+ // Since we're downloading our own local copy we'll want to bypass the
+ // cache and local cache if the channel let's us specify this.
+ let flags = Ci.nsIChannel.LOAD_CALL_CONTENT_SNIFFERS |
+ Ci.nsIChannel.LOAD_BYPASS_CACHE;
+ if (channel instanceof Ci.nsICachingChannel) {
+ debug('This is a caching channel. Forcing bypass.');
+ flags |= Ci.nsICachingChannel.LOAD_BYPASS_LOCAL_CACHE_IF_BUSY;
+ }
+
+ channel.loadFlags |= flags;
+
+ if (channel instanceof Ci.nsIHttpChannel) {
+ debug('Setting HTTP referrer = ' + (referrer && referrer.spec));
+ channel.referrer = referrer;
+ if (channel instanceof Ci.nsIHttpChannelInternal) {
+ channel.forceAllowThirdPartyCookie = true;
+ }
+ }
+
+ // Set-up complete, let's get things started.
+ channel.asyncOpen2(new DownloadListener());
+
+ return req;
+ },
+
+ getScreenshot: function(_width, _height, _mimeType) {
+ if (!this._isAlive()) {
+ throw Components.Exception("Dead content process",
+ Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ let width = parseInt(_width);
+ let height = parseInt(_height);
+ let mimeType = (typeof _mimeType === 'string') ?
+ _mimeType.trim().toLowerCase() : 'image/jpeg';
+ if (isNaN(width) || isNaN(height) || width < 0 || height < 0) {
+ throw Components.Exception("Invalid argument",
+ Cr.NS_ERROR_INVALID_ARG);
+ }
+
+ return this._sendDOMRequest('get-screenshot',
+ {width: width, height: height,
+ mimeType: mimeType});
+ },
+
+ _recvNextPaint: function(data) {
+ let listeners = this._nextPaintListeners;
+ this._nextPaintListeners = [];
+ for (let listener of listeners) {
+ try {
+ listener.recvNextPaint();
+ } catch (e) {
+ // If a listener throws we'll continue.
+ }
+ }
+ },
+
+ addNextPaintListener: function(listener) {
+ if (!this._isAlive()) {
+ throw Components.Exception("Dead content process",
+ Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ let self = this;
+ let run = function() {
+ if (self._nextPaintListeners.push(listener) == 1)
+ self._sendAsyncMsg('activate-next-paint-listener');
+ };
+ if (!this._domRequestReady) {
+ this._pendingAPICalls.push(run);
+ } else {
+ run();
+ }
+ },
+
+ removeNextPaintListener: function(listener) {
+ if (!this._isAlive()) {
+ throw Components.Exception("Dead content process",
+ Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ let self = this;
+ let run = function() {
+ for (let i = self._nextPaintListeners.length - 1; i >= 0; i--) {
+ if (self._nextPaintListeners[i] == listener) {
+ self._nextPaintListeners.splice(i, 1);
+ break;
+ }
+ }
+
+ if (self._nextPaintListeners.length == 0)
+ self._sendAsyncMsg('deactivate-next-paint-listener');
+ };
+ if (!this._domRequestReady) {
+ this._pendingAPICalls.push(run);
+ } else {
+ run();
+ }
+ },
+
+ setInputMethodActive: function(isActive) {
+ if (!this._isAlive()) {
+ throw Components.Exception("Dead content process",
+ Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ if (typeof isActive !== 'boolean') {
+ throw Components.Exception("Invalid argument",
+ Cr.NS_ERROR_INVALID_ARG);
+ }
+
+ return this._sendDOMRequest('set-input-method-active',
+ {isActive: isActive});
+ },
+
+ getAudioChannelVolume: function(aAudioChannel) {
+ return this._sendDOMRequest('get-audio-channel-volume',
+ {audioChannel: aAudioChannel});
+ },
+
+ setAudioChannelVolume: function(aAudioChannel, aVolume) {
+ return this._sendDOMRequest('set-audio-channel-volume',
+ {audioChannel: aAudioChannel,
+ volume: aVolume});
+ },
+
+ getAudioChannelMuted: function(aAudioChannel) {
+ return this._sendDOMRequest('get-audio-channel-muted',
+ {audioChannel: aAudioChannel});
+ },
+
+ setAudioChannelMuted: function(aAudioChannel, aMuted) {
+ return this._sendDOMRequest('set-audio-channel-muted',
+ {audioChannel: aAudioChannel,
+ muted: aMuted});
+ },
+
+ isAudioChannelActive: function(aAudioChannel) {
+ return this._sendDOMRequest('get-is-audio-channel-active',
+ {audioChannel: aAudioChannel});
+ },
+
+ getWebManifest: defineDOMRequestMethod('get-web-manifest'),
+ /**
+ * Called when the visibility of the window which owns this iframe changes.
+ */
+ _ownerVisibilityChange: function() {
+ this._sendAsyncMsg('owner-visibility-change',
+ {visible: !this._window.document.hidden});
+ },
+
+ /*
+ * Called when the child notices that its visibility has changed.
+ *
+ * This is sometimes redundant; for example, the child's visibility may
+ * change in response to a setVisible request that we made here! But it's
+ * not always redundant; for example, the child's visibility may change in
+ * response to its parent docshell being hidden.
+ */
+ _childVisibilityChange: function(data) {
+ debug("_childVisibilityChange(" + data.json.visible + ")");
+ this._frameLoader.visible = data.json.visible;
+
+ this._fireEventFromMsg(data);
+ },
+
+ _requestedDOMFullscreen: function() {
+ this._pendingDOMFullscreen = true;
+ this._windowUtils.remoteFrameFullscreenChanged(this._frameElement);
+ },
+
+ _fullscreenOriginChange: function(data) {
+ Services.obs.notifyObservers(
+ this._frameElement, "fullscreen-origin-change", data.json.originNoSuffix);
+ },
+
+ _exitDomFullscreen: function(data) {
+ this._windowUtils.remoteFrameFullscreenReverted();
+ },
+
+ _handleOwnerEvent: function(evt) {
+ switch (evt.type) {
+ case 'visibilitychange':
+ this._ownerVisibilityChange();
+ break;
+ case 'fullscreenchange':
+ if (!this._window.document.fullscreenElement) {
+ this._sendAsyncMsg('exit-fullscreen');
+ } else if (this._pendingDOMFullscreen) {
+ this._pendingDOMFullscreen = false;
+ this._sendAsyncMsg('entered-fullscreen');
+ }
+ break;
+ }
+ },
+
+ _fireFatalError: function() {
+ let evt = this._createEvent('error', {type: 'fatal'},
+ /* cancelable = */ false);
+ this._frameElement.dispatchEvent(evt);
+ },
+
+ observe: function(subject, topic, data) {
+ switch(topic) {
+ case 'oop-frameloader-crashed':
+ if (this._isAlive() && subject == this._frameLoader) {
+ this._fireFatalError();
+ }
+ break;
+ case 'ask-children-to-execute-copypaste-command':
+ if (this._isAlive() && this._frameElement == subject.wrappedJSObject) {
+ this._sendAsyncMsg('copypaste-do-command', { command: data });
+ }
+ break;
+ case 'back-docommand':
+ if (this._isAlive() && this._frameLoader.visible) {
+ this.goBack();
+ }
+ break;
+ default:
+ debug('Unknown topic: ' + topic);
+ break;
+ };
+ },
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([BrowserElementParent]);