The Tor Browser: dom/browser-element/BrowserElementParent.jsm@7e26c7da4463 (annotated)

dom/browser-element/BrowserElementParent.jsm@7e26c7da4463 (annotated)

dom/browser-element/BrowserElementParent.jsm

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* 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";
 let Cu = Components.utils;
 let Ci = Components.interfaces;
 let Cc = Components.classes;
 let 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.
  */
 this.EXPORTED_SYMBOLS = ["BrowserElementParentBuilder"];
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/BrowserElementPromptService.jsm");
 XPCOMUtils.defineLazyGetter(this, "DOMApplicationRegistry", function () {
   Cu.import("resource://gre/modules/Webapps.jsm");
   return DOMApplicationRegistry;
 });
 const TOUCH_EVENTS_ENABLED_PREF = "dom.w3c_touch_events.enabled";
 function debug(msg) {
   //dump("BrowserElementParent.jsm - " + msg + "\n");
 }
 function getIntPref(prefName, def) {
   try {
     return Services.prefs.getIntPref(prefName);
   }
   catch(err) {
     return def;
   }
 }
 function exposeAll(obj) {
   // Filter for Objects and Arrays.
   if (typeof obj !== "object" || !obj)
     return;
   // Recursively expose our children.
   Object.keys(obj).forEach(function(key) {
     exposeAll(obj[key]);
   });
   // If we're not an Array, generate an __exposedProps__ object for ourselves.
   if (obj instanceof Array)
     return;
   var exposed = {};
   Object.keys(obj).forEach(function(key) {
     exposed[key] = 'rw';
   });
   obj.__exposedProps__ = exposed;
 }
 function defineAndExpose(obj, name, value) {
   obj[name] = value;
   if (!('__exposedProps__' in obj))
     obj.__exposedProps__ = {};
   obj.__exposedProps__[name] = 'r';
 }
 function visibilityChangeHandler(e) {
   // The visibilitychange event's target is the document.
   let win = e.target.defaultView;
   if (!win._browserElementParents) {
     return;
   }
   let beps = Cu.nondeterministicGetWeakMapKeys(win._browserElementParents);
   if (beps.length == 0) {
     win.removeEventListener('visibilitychange', visibilityChangeHandler);
     return;
   }
   for (let i = 0; i < beps.length; i++) {
     beps[i]._ownerVisibilityChange();
   }
 }
 this.BrowserElementParentBuilder = {
   create: function create(frameLoader, hasRemoteFrame, isPendingFrame) {
     return new BrowserElementParent(frameLoader, hasRemoteFrame);
   }
 }
 // The active input method iframe.
 let activeInputFrame = null;
 function BrowserElementParent(frameLoader, hasRemoteFrame, isPendingFrame) {
   debug("Creating new BrowserElementParent object for " + frameLoader);
   this._domRequestCounter = 0;
   this._pendingDOMRequests = {};
   this._hasRemoteFrame = hasRemoteFrame;
   this._nextPaintListeners = [];
   this._frameLoader = frameLoader;
   this._frameElement = frameLoader.QueryInterface(Ci.nsIFrameLoader).ownerElement;
   let self = this;
   if (!this._frameElement) {
     debug("No frame element?");
     return;
   }
   Services.obs.addObserver(this, 'ask-children-to-exit-fullscreen', /* ownsWeak = */ true);
   Services.obs.addObserver(this, 'oop-frameloader-crashed', /* ownsWeak = */ true);
   let defineMethod = function(name, fn) {
     XPCNativeWrapper.unwrap(self._frameElement)[name] = function() {
       if (self._isAlive()) {
         return fn.apply(self, arguments);
       }
     };
   }
   let defineNoReturnMethod = function(name, fn) {
     XPCNativeWrapper.unwrap(self._frameElement)[name] = function method() {
       if (!self._mm) {
         // Remote browser haven't been created, we just queue the API call.
         let args = Array.slice(arguments);
         args.unshift(self);
         self._pendingAPICalls.push(method.bind.apply(fn, args));
         return;
       }
       if (self._isAlive()) {
         fn.apply(self, arguments);
       }
     };
   };
   let defineDOMRequestMethod = function(domName, msgName) {
     XPCNativeWrapper.unwrap(self._frameElement)[domName] = function() {
       if (!self._mm) {
         return self._queueDOMRequest;
       }
       if (self._isAlive()) {
         return self._sendDOMRequest(msgName);
       }
     };
   }
   // Define methods on the frame element.
   defineNoReturnMethod('setVisible', this._setVisible);
   defineDOMRequestMethod('getVisible', 'get-visible');
   defineNoReturnMethod('sendMouseEvent', this._sendMouseEvent);
   // 0 = disabled, 1 = enabled, 2 - auto detect
   if (getIntPref(TOUCH_EVENTS_ENABLED_PREF, 0) != 0) {
     defineNoReturnMethod('sendTouchEvent', this._sendTouchEvent);
   }
   defineNoReturnMethod('goBack', this._goBack);
   defineNoReturnMethod('goForward', this._goForward);
   defineNoReturnMethod('reload', this._reload);
   defineNoReturnMethod('stop', this._stop);
   defineDOMRequestMethod('purgeHistory', 'purge-history');
   defineMethod('getScreenshot', this._getScreenshot);
   defineMethod('addNextPaintListener', this._addNextPaintListener);
   defineMethod('removeNextPaintListener', this._removeNextPaintListener);
   defineDOMRequestMethod('getCanGoBack', 'get-can-go-back');
   defineDOMRequestMethod('getCanGoForward', 'get-can-go-forward');
   let principal = this._frameElement.ownerDocument.nodePrincipal;
   let perm = Services.perms
              .testExactPermissionFromPrincipal(principal, "input-manage");
   if (perm === Ci.nsIPermissionManager.ALLOW_ACTION) {
     defineMethod('setInputMethodActive', this._setInputMethodActive);
   }
   // 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();
     this._window.addEventListener('visibilitychange',
                                   visibilityChangeHandler,
                                   /* useCapture = */ false,
                                   /* wantsUntrusted = */ false);
   }
   this._window._browserElementParents.set(this, null);
   // Insert ourself into the prompt service.
   BrowserElementPromptService.mapFrameToBrowserElementParent(this._frameElement, this);
   if (!isPendingFrame) {
     this._setupMessageListener();
     this._registerAppManifest();
   } else {
     // if we are a pending frame, we setup message manager after
     // observing remote-browser-frame-shown
     this._pendingAPICalls = [];
     Services.obs.addObserver(this, 'remote-browser-frame-shown', /* ownsWeak = */ true);
   }
 }
 BrowserElementParent.prototype = {
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver,
                                          Ci.nsISupportsWeakReference]),
   _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;
   },
   _registerAppManifest: function() {
     // If this browser represents an app then let the Webapps module register for
     // any messages that it needs.
     let appManifestURL =
           this._frameElement.QueryInterface(Ci.nsIMozBrowserFrame).appManifestURL;
     if (appManifestURL) {
       let appId =
             DOMApplicationRegistry.getAppLocalIdByManifestURL(appManifestURL);
       if (appId != Ci.nsIScriptSecurityManager.NO_APP_ID) {
         DOMApplicationRegistry.registerBrowserElementParentForApp(this, appId);
       }
     }
   },
   _setupMessageListener: function() {
     this._mm = this._frameLoader.messageManager;
     let self = this;
     // 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,
       "contextmenu": this._fireCtxMenuEvent,
       "locationchange": this._fireEventFromMsg,
       "loadstart": this._fireEventFromMsg,
       "loadend": this._fireEventFromMsg,
       "titlechange": this._fireEventFromMsg,
       "iconchange": this._fireEventFromMsg,
       "manifestchange": this._fireEventFromMsg,
       "metachange": this._fireEventFromMsg,
       "close": this._fireEventFromMsg,
       "resize": this._fireEventFromMsg,
       "activitydone": this._fireEventFromMsg,
       "opensearch": this._fireEventFromMsg,
       "securitychange": this._fireEventFromMsg,
       "error": this._fireEventFromMsg,
       "scroll": this._fireEventFromMsg,
       "firstpaint": this._fireEventFromMsg,
       "documentfirstpaint": this._fireEventFromMsg,
       "nextpaint": this._recvNextPaint,
       "keyevent": this._fireKeyEvent,
       "showmodalprompt": this._handleShowModalPrompt,
       "got-purge-history": this._gotDOMRequestResult,
       "got-screenshot": this._gotDOMRequestResult,
       "got-can-go-back": this._gotDOMRequestResult,
       "got-can-go-forward": this._gotDOMRequestResult,
       "fullscreen-origin-change": this._remoteFullscreenOriginChange,
       "rollback-fullscreen": this._remoteFrameFullscreenReverted,
       "exit-fullscreen": this._exitFullscreen,
       "got-visible": this._gotDOMRequestResult,
       "visibilitychange": this._childVisibilityChange,
       "got-set-input-method-active": this._gotDOMRequestResult
     };
     this._mm.addMessageListener('browser-element-api:call', function(aMsg) {
       if (self._isAlive() && (aMsg.data.msg_name in mmCalls)) {
         return mmCalls[aMsg.data.msg_name].apply(self, arguments);
       }
     });
   },
   /**
    * 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);
       }
     };
     if (authDetail.isOnlyPassword) {
       // We don't handle password-only prompts, so just cancel it.
       cancelCallback();
       return;
     } else { /* username and password */
       let detail = {
         host:     authDetail.host,
         realm:    authDetail.realm
       };
       evt = this._createEvent('usernameandpasswordrequired', detail,
                               /* cancelable */ true);
       defineAndExpose(evt.detail, 'authenticate', function(username, password) {
         if (callbackCalled)
           return;
         callbackCalled = true;
         callback(true, username, password);
       });
     }
     defineAndExpose(evt.detail, 'cancel', function() {
       cancelCallback();
     });
     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");
     this._ready = true;
     // 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();
     }
     return {
       name: this._frameElement.getAttribute('name'),
       fullscreenAllowed:
         this._frameElement.hasAttribute('allowfullscreen') ||
         this._frameElement.hasAttribute('mozallowfullscreen')
     };
   },
   _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;
       defineAndExpose(evt.detail, 'contextMenuItemSelected', function(id) {
         self._sendAsyncMsg('fire-ctx-callback', {menuitem: id});
       });
     }
     // 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);
   },
   /**
    * 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);
     }
     defineAndExpose(evt.detail, 'unblock', function() {
       sendUnblockMsg();
     });
     this._frameElement.dispatchEvent(evt);
     if (!evt.defaultPrevented) {
       // Unblock the inner frame immediately.  Otherwise we'll unblock upon
       // evt.detail.unblock().
       sendUnblockMsg();
     }
   },
   _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) {
       exposeAll(detail);
       return new this._window.CustomEvent('mozbrowser' + evtName,
                                           { bubbles: true,
                                             cancelable: cancelable,
                                             detail: detail });
     }
     return new this._window.Event('mozbrowser' + evtName,
                                   { bubbles: true,
                                     cancelable: cancelable });
   },
   /**
    * If remote frame haven't been set up, we enqueue a function that get a
    * DOMRequest until the remote frame is ready and return another DOMRequest
    * to caller. When we get the real DOMRequest, we will help forward the
    * success/error callback to the DOMRequest that caller got.
    */
   _queueDOMRequest: function(msgName, args) {
     if (!this._pendingAPICalls) {
       return;
     }
     let req = Services.DOMRequest.createRequest(this._window);
     let self = this;
     let getRealDOMRequest = function() {
       let realReq = self._sendDOMRequest(msgName, args);
       realReq.onsuccess = function(v) {
         Services.DOMRequest.fireSuccess(req, v);
       };
       realReq.onerror = function(v) {
         Services.DOMRequest.fireError(req, v);
       };
     };
     this._pendingAPICalls.push(getRealDOMRequest);
     return req;
   },
   /**
    * 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);
     if (this._sendAsyncMsg(msgName, {id: id, args: args})) {
       this._pendingDOMRequests[id] = req;
     } else {
       Services.DOMRequest.fireErrorAsync(req, "fail");
     }
     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.");
       Services.DOMRequest.fireSuccess(req, data.json.successRv);
     }
     else {
       debug("Got error in gotDOMRequestResult.");
       Services.DOMRequest.fireErrorAsync(req, data.json.errorMsg);
     }
   },
   _setVisible: function(visible) {
     this._sendAsyncMsg('set-visible', {visible: visible});
     this._frameLoader.visible = visible;
   },
   _sendMouseEvent: function(type, x, y, button, clickCount, modifiers) {
     this._sendAsyncMsg("send-mouse-event", {
       "type": type,
       "x": x,
       "y": y,
       "button": button,
       "clickCount": clickCount,
       "modifiers": modifiers
     });
   },
   _sendTouchEvent: function(type, identifiers, touchesX, touchesY,
                             radiisX, radiisY, rotationAngles, forces,
                             count, modifiers) {
     let tabParent = this._frameLoader.tabParent;
     if (tabParent && tabParent.useAsyncPanZoom) {
       tabParent.injectTouchEvent(type,
                                  identifiers,
                                  touchesX,
                                  touchesY,
                                  radiisX,
                                  radiisY,
                                  rotationAngles,
                                  forces,
                                  count,
                                  modifiers);
     } else {
       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
       });
     }
   },
   _goBack: function() {
     this._sendAsyncMsg('go-back');
   },
   _goForward: function() {
     this._sendAsyncMsg('go-forward');
   },
   _reload: function(hardReload) {
     this._sendAsyncMsg('reload', {hardReload: hardReload});
   },
   _stop: function() {
     this._sendAsyncMsg('stop');
   },
   _getScreenshot: function(_width, _height, _mimeType) {
     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);
     }
     if (!this._mm) {
       // Child haven't been loaded.
       return this._queueDOMRequest('get-screenshot',
                                    {width: width, height: height,
                                     mimeType: mimeType});
     }
     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();
       } catch (e) {
         // If a listener throws we'll continue.
       }
     }
   },
   _addNextPaintListener: function(listener) {
     if (typeof listener != 'function')
       throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
     let self = this;
     let run = function() {
       if (self._nextPaintListeners.push(listener) == 1)
         self._sendAsyncMsg('activate-next-paint-listener');
     };
     if (!this._mm) {
       this._pendingAPICalls.push(run);
     } else {
       run();
     }
   },
   _removeNextPaintListener: function(listener) {
     if (typeof listener != 'function')
       throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
     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._mm) {
       this._pendingAPICalls.push(run);
     } else {
       run();
     }
   },
   _setInputMethodActive: function(isActive) {
     if (typeof isActive !== 'boolean') {
       throw Components.Exception("Invalid argument",
                                  Cr.NS_ERROR_INVALID_ARG);
     }
     let req = Services.DOMRequest.createRequest(this._window);
     // Deactivate the old input method if needed.
     if (activeInputFrame && isActive) {
       if (Cu.isDeadWrapper(activeInputFrame)) {
         // If the activeInputFrame is already a dead object,
         // we should simply set it to null directly.
         activeInputFrame = null;
         this._sendSetInputMethodActiveDOMRequest(req, isActive);
       } else {
         let reqOld = XPCNativeWrapper.unwrap(activeInputFrame)
                                      .setInputMethodActive(false);
         // We wan't to continue regardless whether this req succeeded
         reqOld.onsuccess = reqOld.onerror = function() {
           let setActive = function() {
             activeInputFrame = null;
             this._sendSetInputMethodActiveDOMRequest(req, isActive);
           }.bind(this);
           if (this._ready) {
             setActive();
             return;
           }
           // Wait for the hello event from BrowserElementChild
           let onReady = function(aMsg) {
             if (this._isAlive() && (aMsg.data.msg_name === 'hello')) {
               setActive();
               this._mm.removeMessageListener('browser-element-api:call',
                 onReady);
             }
           }.bind(this);
           this._mm.addMessageListener('browser-element-api:call', onReady);
         }.bind(this);
       }
     } else {
       this._sendSetInputMethodActiveDOMRequest(req, isActive);
     }
     return req;
   },
   _sendSetInputMethodActiveDOMRequest: function(req, isActive) {
     let id = 'req_' + this._domRequestCounter++;
     let data = {
       id : id,
       args: { isActive: isActive }
     };
     if (this._sendAsyncMsg('set-input-method-active', data)) {
       activeInputFrame = this._frameElement;
       this._pendingDOMRequests[id] = req;
     } else {
       Services.DOMRequest.fireErrorAsync(req, 'fail');
     }
   },
   _fireKeyEvent: function(data) {
     let evt = this._window.document.createEvent("KeyboardEvent");
     evt.initKeyEvent(data.json.type, true, true, this._window,
                      false, false, false, false, // modifiers
                      data.json.keyCode,
                      data.json.charCode);
     this._frameElement.dispatchEvent(evt);
   },
   /**
    * 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);
   },
   _exitFullscreen: function() {
     this._windowUtils.exitFullscreen();
   },
   _remoteFullscreenOriginChange: function(data) {
     let origin = data.json._payload_;
     this._windowUtils.remoteFrameFullscreenChanged(this._frameElement, origin);
   },
   _remoteFrameFullscreenReverted: function(data) {
     this._windowUtils.remoteFrameFullscreenReverted();
   },
   _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-exit-fullscreen':
       if (this._isAlive() &&
           this._frameElement.ownerDocument == subject &&
           this._hasRemoteFrame) {
         this._sendAsyncMsg('exit-fullscreen');
       }
       break;
     case 'remote-browser-frame-shown':
       if (this._frameLoader == subject) {
         if (!this._mm) {
           this._setupMessageListener();
           this._registerAppManifest();
           this._runPendingAPICall();
         }
         Services.obs.removeObserver(this, 'remote-browser-frame-shown');
       }
     default:
       debug('Unknown topic: ' + topic);
       break;
     };
   },
 };

The Tor Browser / annotate

dom/browser-element/BrowserElementParent.jsm@7e26c7da4463 (annotated)

dom/browser-element/BrowserElementParent.jsm