diff options
Diffstat (limited to 'dom/browser-element/BrowserElementParent.js')
| -rw-r--r-- | dom/browser-element/BrowserElementParent.js | 1202 |
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]); |