dom/browser-element/BrowserElementChildPreload.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 "use strict";
   6
   7 /* eslint-env mozilla/frame-script */
   8
   9 function debug(msg) {
  10   // dump("BrowserElementChildPreload - " + msg + "\n");
  11 }
  12
  13 debug("loaded");
  14
  15 var BrowserElementIsReady;
  16
  17 var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
  18 var { BrowserElementPromptService } = ChromeUtils.import(
  19   "resource://gre/modules/BrowserElementPromptService.jsm"
  20 );
  21
  22 function sendAsyncMsg(msg, data) {
  23   // Ensure that we don't send any messages before BrowserElementChild.js
  24   // finishes loading.
  25   if (!BrowserElementIsReady) {
  26     return;
  27   }
  28
  29   if (!data) {
  30     data = {};
  31   }
  32
  33   data.msg_name = msg;
  34   sendAsyncMessage("browser-element-api:call", data);
  35 }
  36
  37 var LISTENED_EVENTS = [
  38   // This listens to unload events from our message manager, but /not/ from
  39   // the |content| window.  That's because the window's unload event doesn't
  40   // bubble, and we're not using a capturing listener.  If we'd used
  41   // useCapture == true, we /would/ hear unload events from the window, which
  42   // is not what we want!
  43   { type: "unload", useCapture: false, wantsUntrusted: false },
  44 ];
  45
  46 /**
  47  * The BrowserElementChild implements one half of <iframe mozbrowser>.
  48  * (The other half is, unsurprisingly, BrowserElementParent.)
  49  *
  50  * This script is injected into an <iframe mozbrowser> via
  51  * nsIMessageManager::LoadFrameScript().
  52  *
  53  * Our job here is to listen for events within this frame and bubble them up to
  54  * the parent process.
  55  */
  56
  57 var global = this;
  58
  59 function BrowserElementChild() {
  60   // Maps outer window id --> weak ref to window.  Used by modal dialog code.
  61   this._windowIDDict = {};
  62
  63   this._init();
  64 }
  65
  66 BrowserElementChild.prototype = {
  67   _init() {
  68     debug("Starting up.");
  69
  70     BrowserElementPromptService.mapWindowToBrowserElementChild(content, this);
  71
  72     this._shuttingDown = false;
  73
  74     LISTENED_EVENTS.forEach(event => {
  75       addEventListener(
  76         event.type,
  77         this,
  78         event.useCapture,
  79         event.wantsUntrusted
  80       );
  81     });
  82
  83     addMessageListener("browser-element-api:call", this);
  84   },
  85
  86   /**
  87    * Shut down the frame's side of the browser API.  This is called when:
  88    *   - our BrowserChildGlobal starts to die
  89    *   - the content is moved to frame without the browser API
  90    * This is not called when the page inside |content| unloads.
  91    */
  92   destroy() {
  93     debug("Destroying");
  94     this._shuttingDown = true;
  95
  96     BrowserElementPromptService.unmapWindowToBrowserElementChild(content);
  97
  98     LISTENED_EVENTS.forEach(event => {
  99       removeEventListener(
 100         event.type,
 101         this,
 102         event.useCapture,
 103         event.wantsUntrusted
 104       );
 105     });
 106
 107     removeMessageListener("browser-element-api:call", this);
 108   },
 109
 110   handleEvent(event) {
 111     switch (event.type) {
 112       case "unload":
 113         this.destroy(event);
 114         break;
 115     }
 116   },
 117
 118   receiveMessage(message) {
 119     let self = this;
 120
 121     let mmCalls = {
 122       "unblock-modal-prompt": this._recvStopWaiting,
 123     };
 124
 125     if (message.data.msg_name in mmCalls) {
 126       return mmCalls[message.data.msg_name].apply(self, arguments);
 127     }
 128     return undefined;
 129   },
 130
 131   get _windowUtils() {
 132     return content.document.defaultView.windowUtils;
 133   },
 134
 135   _tryGetInnerWindowID(win) {
 136     try {
 137       return win.windowGlobalChild.innerWindowId;
 138     } catch (e) {
 139       return null;
 140     }
 141   },
 142
 143   /**
 144    * Show a modal prompt.  Called by BrowserElementPromptService.
 145    */
 146   showModalPrompt(win, args) {
 147     args.windowID = {
 148       outer: win.docShell.outerWindowID,
 149       inner: this._tryGetInnerWindowID(win),
 150     };
 151     sendAsyncMsg("showmodalprompt", args);
 152
 153     let returnValue = this._waitForResult(win);
 154
 155     if (
 156       args.promptType == "prompt" ||
 157       args.promptType == "confirm" ||
 158       args.promptType == "custom-prompt"
 159     ) {
 160       return returnValue;
 161     }
 162     return undefined;
 163   },
 164
 165   /**
 166    * Spin in a nested event loop until we receive a unblock-modal-prompt message for
 167    * this window.
 168    */
 169   _waitForResult(win) {
 170     debug("_waitForResult(" + win + ")");
 171     let utils = win.windowUtils;
 172
 173     let outerWindowID = win.docShell.outerWindowID;
 174     let innerWindowID = this._tryGetInnerWindowID(win);
 175     if (innerWindowID === null) {
 176       // I have no idea what waiting for a result means when there's no inner
 177       // window, so let's just bail.
 178       debug("_waitForResult: No inner window. Bailing.");
 179       return undefined;
 180     }
 181
 182     this._windowIDDict[outerWindowID] = Cu.getWeakReference(win);
 183
 184     debug(
 185       "Entering modal state (outerWindowID=" +
 186         outerWindowID +
 187         ", " +
 188         "innerWindowID=" +
 189         innerWindowID +
 190         ")"
 191     );
 192
 193     utils.enterModalState();
 194
 195     // We'll decrement win.modalDepth when we receive a unblock-modal-prompt message
 196     // for the window.
 197     if (!win.modalDepth) {
 198       win.modalDepth = 0;
 199     }
 200     win.modalDepth++;
 201     let origModalDepth = win.modalDepth;
 202
 203     debug("Nested event loop - begin");
 204     Services.tm.spinEventLoopUntil(
 205       "BrowserElementChildPreload.js:_waitForResult",
 206       () => {
 207         // Bail out of the loop if the inner window changed; that means the
 208         // window navigated.  Bail out when we're shutting down because otherwise
 209         // we'll leak our window.
 210         if (this._tryGetInnerWindowID(win) !== innerWindowID) {
 211           debug(
 212             "_waitForResult: Inner window ID changed " +
 213               "while in nested event loop."
 214           );
 215           return true;
 216         }
 217
 218         return win.modalDepth !== origModalDepth || this._shuttingDown;
 219       }
 220     );
 221     debug("Nested event loop - finish");
 222
 223     if (win.modalDepth == 0) {
 224       delete this._windowIDDict[outerWindowID];
 225     }
 226
 227     // If we exited the loop because the inner window changed, then bail on the
 228     // modal prompt.
 229     if (innerWindowID !== this._tryGetInnerWindowID(win)) {
 230       throw Components.Exception(
 231         "Modal state aborted by navigation",
 232         Cr.NS_ERROR_NOT_AVAILABLE
 233       );
 234     }
 235
 236     let returnValue = win.modalReturnValue;
 237     delete win.modalReturnValue;
 238
 239     if (!this._shuttingDown) {
 240       utils.leaveModalState();
 241     }
 242
 243     debug(
 244       "Leaving modal state (outerID=" +
 245         outerWindowID +
 246         ", " +
 247         "innerID=" +
 248         innerWindowID +
 249         ")"
 250     );
 251     return returnValue;
 252   },
 253
 254   _recvStopWaiting(msg) {
 255     let outerID = msg.json.windowID.outer;
 256     let innerID = msg.json.windowID.inner;
 257     let returnValue = msg.json.returnValue;
 258     debug(
 259       "recvStopWaiting(outer=" +
 260         outerID +
 261         ", inner=" +
 262         innerID +
 263         ", returnValue=" +
 264         returnValue +
 265         ")"
 266     );
 267
 268     if (!this._windowIDDict[outerID]) {
 269       debug("recvStopWaiting: No record of outer window ID " + outerID);
 270       return;
 271     }
 272
 273     let win = this._windowIDDict[outerID].get();
 274
 275     if (!win) {
 276       debug("recvStopWaiting, but window is gone\n");
 277       return;
 278     }
 279
 280     if (innerID !== this._tryGetInnerWindowID(win)) {
 281       debug("recvStopWaiting, but inner ID has changed\n");
 282       return;
 283     }
 284
 285     debug("recvStopWaiting " + win);
 286     win.modalReturnValue = returnValue;
 287     win.modalDepth--;
 288   },
 289 };
 290
 291 var api = new BrowserElementChild();