The Tor Browser: browser/modules/BrowserNewTabPreloader.jsm@b8a032363ba2 (annotated)

browser/modules/BrowserNewTabPreloader.jsm@b8a032363ba2 (annotated)

browser/modules/BrowserNewTabPreloader.jsm

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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";
 this.EXPORTED_SYMBOLS = ["BrowserNewTabPreloader"];
 const Cu = Components.utils;
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Promise.jsm");
 const HTML_NS = "http://www.w3.org/1999/xhtml";
 const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
 const XUL_PAGE = "data:application/vnd.mozilla.xul+xml;charset=utf-8,<window%20id='win'/>";
 const NEWTAB_URL = "about:newtab";
 const PREF_BRANCH = "browser.newtab.";
 // The interval between swapping in a preload docShell and kicking off the
 // next preload in the background.
 const PRELOADER_INTERVAL_MS = 600;
 // The initial delay before we start preloading our first new tab page. The
 // timer is started after the first 'browser-delayed-startup' has been sent.
 const PRELOADER_INIT_DELAY_MS = 5000;
 // The number of miliseconds we'll wait after we received a notification that
 // causes us to update our list of browsers and tabbrowser sizes. This acts as
 // kind of a damper when too many events are occuring in quick succession.
 const PRELOADER_UPDATE_DELAY_MS = 3000;
 const TOPIC_TIMER_CALLBACK = "timer-callback";
 const TOPIC_DELAYED_STARTUP = "browser-delayed-startup-finished";
 const TOPIC_XUL_WINDOW_CLOSED = "xul-window-destroyed";
 const FRAME_SCRIPT_URL = "chrome://browser/content/newtab/preloaderContent.js";
 function createTimer(obj, delay) {
   let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
   timer.init(obj, delay, Ci.nsITimer.TYPE_ONE_SHOT);
   return timer;
 }
 function clearTimer(timer) {
   if (timer) {
     timer.cancel();
   }
   return null;
 }
 this.BrowserNewTabPreloader = {
   init: function Preloader_init() {
     Initializer.start();
   },
   uninit: function Preloader_uninit() {
     Initializer.stop();
     HostFrame.destroy();
     Preferences.uninit();
     HiddenBrowsers.uninit();
   },
   newTab: function Preloader_newTab(aTab) {
     let swapped = false;
     let win = aTab.ownerDocument.defaultView;
     if (win.gBrowser) {
       let utils = win.QueryInterface(Ci.nsIInterfaceRequestor)
                      .getInterface(Ci.nsIDOMWindowUtils);
       let {width, height} = utils.getBoundsWithoutFlushing(win.gBrowser);
       let hiddenBrowser = HiddenBrowsers.get(width, height)
       if (hiddenBrowser) {
         swapped = hiddenBrowser.swapWithNewTab(aTab);
       }
       // aTab's browser is now visible and is therefore allowed to make
       // background captures.
       let msgMan = aTab.linkedBrowser.messageManager;
       msgMan.loadFrameScript(FRAME_SCRIPT_URL, false);
       msgMan.sendAsyncMessage("BrowserNewTabPreloader:allowBackgroundCaptures");
     }
     return swapped;
   }
 };
 Object.freeze(BrowserNewTabPreloader);
 let Initializer = {
   _timer: null,
   _observing: false,
   start: function Initializer_start() {
     Services.obs.addObserver(this, TOPIC_DELAYED_STARTUP, false);
     this._observing = true;
   },
   stop: function Initializer_stop() {
     this._timer = clearTimer(this._timer);
     if (this._observing) {
       Services.obs.removeObserver(this, TOPIC_DELAYED_STARTUP);
       this._observing = false;
     }
   },
   observe: function Initializer_observe(aSubject, aTopic, aData) {
     if (aTopic == TOPIC_DELAYED_STARTUP) {
       Services.obs.removeObserver(this, TOPIC_DELAYED_STARTUP);
       this._observing = false;
       this._startTimer();
     } else if (aTopic == TOPIC_TIMER_CALLBACK) {
       this._timer = null;
       this._startPreloader();
     }
   },
   _startTimer: function Initializer_startTimer() {
     this._timer = createTimer(this, PRELOADER_INIT_DELAY_MS);
   },
   _startPreloader: function Initializer_startPreloader() {
     Preferences.init();
     if (Preferences.enabled) {
       HiddenBrowsers.init();
     }
   }
 };
 let Preferences = {
   _enabled: null,
   _branch: null,
   get enabled() {
     if (this._enabled === null) {
       this._enabled = this._branch.getBoolPref("preload") &&
                       !this._branch.prefHasUserValue("url");
     }
     return this._enabled;
   },
   init: function Preferences_init() {
     this._branch = Services.prefs.getBranch(PREF_BRANCH);
     this._branch.addObserver("", this, false);
   },
   uninit: function Preferences_uninit() {
     if (this._branch) {
       this._branch.removeObserver("", this);
       this._branch = null;
     }
   },
   observe: function Preferences_observe() {
     let prevEnabled = this._enabled;
     this._enabled = null;
     if (prevEnabled && !this.enabled) {
       HiddenBrowsers.uninit();
     } else if (!prevEnabled && this.enabled) {
       HiddenBrowsers.init();
     }
   },
 };
 let HiddenBrowsers = {
   _browsers: null,
   _updateTimer: null,
   _topics: [
     TOPIC_DELAYED_STARTUP,
     TOPIC_XUL_WINDOW_CLOSED
   ],
   init: function () {
     this._browsers = new Map();
     this._updateBrowserSizes();
     this._topics.forEach(t => Services.obs.addObserver(this, t, false));
   },
   uninit: function () {
     if (this._browsers) {
       this._topics.forEach(t => Services.obs.removeObserver(this, t, false));
       this._updateTimer = clearTimer(this._updateTimer);
       for (let [key, browser] of this._browsers) {
         browser.destroy();
       }
       this._browsers = null;
     }
   },
   get: function (width, height) {
     // We haven't been initialized, yet.
     if (!this._browsers) {
       return null;
     }
     let key = width + "x" + height;
     if (!this._browsers.has(key)) {
       // Update all browsers' sizes if we can't find a matching one.
       this._updateBrowserSizes();
     }
     // We should now have a matching browser.
     if (this._browsers.has(key)) {
       return this._browsers.get(key);
     }
     // We should never be here. Return the first browser we find.
     Cu.reportError("NewTabPreloader: no matching browser found after updating");
     for (let [size, browser] of this._browsers) {
       return browser;
     }
     // We should really never be here.
     Cu.reportError("NewTabPreloader: not even a single browser was found?");
     return null;
   },
   observe: function (subject, topic, data) {
     if (topic === TOPIC_TIMER_CALLBACK) {
       this._updateTimer = null;
       this._updateBrowserSizes();
     } else {
       this._updateTimer = clearTimer(this._updateTimer);
       this._updateTimer = createTimer(this, PRELOADER_UPDATE_DELAY_MS);
     }
   },
   _updateBrowserSizes: function () {
     let sizes = this._collectTabBrowserSizes();
     let toRemove = [];
     // Iterate all browsers and check that they
     // each can be assigned to one of the sizes.
     for (let [key, browser] of this._browsers) {
       if (sizes.has(key)) {
         // We already have a browser for that size, great!
         sizes.delete(key);
       } else {
         // This browser is superfluous or needs to be resized.
         toRemove.push(browser);
         this._browsers.delete(key);
       }
     }
     // Iterate all sizes that we couldn't find a browser for.
     for (let [key, {width, height}] of sizes) {
       let browser;
       if (toRemove.length) {
         // Let's just resize one of the superfluous
         // browsers and put it back into the map.
         browser = toRemove.shift();
         browser.resize(width, height);
       } else {
         // No more browsers to reuse, create a new one.
         browser = new HiddenBrowser(width, height);
       }
       this._browsers.set(key, browser);
     }
     // Finally, remove all browsers we don't need anymore.
     toRemove.forEach(b => b.destroy());
   },
   _collectTabBrowserSizes: function () {
     let sizes = new Map();
     function tabBrowserBounds() {
       let wins = Services.ww.getWindowEnumerator("navigator:browser");
       while (wins.hasMoreElements()) {
         let win = wins.getNext();
         if (win.gBrowser) {
           let utils = win.QueryInterface(Ci.nsIInterfaceRequestor)
                          .getInterface(Ci.nsIDOMWindowUtils);
           yield utils.getBoundsWithoutFlushing(win.gBrowser);
         }
       }
     }
     // Collect the sizes of all <tabbrowser>s out there.
     for (let {width, height} of tabBrowserBounds()) {
       if (width > 0 && height > 0) {
         let key = width + "x" + height;
         if (!sizes.has(key)) {
           sizes.set(key, {width: width, height: height});
         }
       }
     }
     return sizes;
   }
 };
 function HiddenBrowser(width, height) {
   this.resize(width, height);
   this._createBrowser();
 }
 HiddenBrowser.prototype = {
   _width: null,
   _height: null,
   _timer: null,
   get isPreloaded() {
     return this._browser &&
            this._browser.contentDocument &&
            this._browser.contentDocument.readyState === "complete" &&
            this._browser.currentURI.spec === NEWTAB_URL;
   },
   swapWithNewTab: function (aTab) {
     if (!this.isPreloaded || this._timer) {
       return false;
     }
     let win = aTab.ownerDocument.defaultView;
     let tabbrowser = win.gBrowser;
     if (!tabbrowser) {
       return false;
     }
     // Swap docShells.
     tabbrowser.swapNewTabWithBrowser(aTab, this._browser);
     // Load all default frame scripts attached to the target window.
     let mm = aTab.linkedBrowser.messageManager;
     let scripts = win.messageManager.getDelayedFrameScripts();
     Array.forEach(scripts, ([script, runGlobal]) => mm.loadFrameScript(script, true, runGlobal));
     // Remove the browser, it will be recreated by a timer.
     this._removeBrowser();
     // Start a timer that will kick off preloading the next newtab page.
     this._timer = createTimer(this, PRELOADER_INTERVAL_MS);
     // Signal that we swapped docShells.
     return true;
   },
   observe: function () {
     this._timer = null;
     // Start pre-loading the new tab page.
     this._createBrowser();
   },
   resize: function (width, height) {
     this._width = width;
     this._height = height;
     this._applySize();
   },
   destroy: function () {
     this._removeBrowser();
     this._timer = clearTimer(this._timer);
   },
   _applySize: function () {
     if (this._browser) {
       this._browser.style.width = this._width + "px";
       this._browser.style.height = this._height + "px";
     }
   },
   _createBrowser: function () {
     HostFrame.get().then(aFrame => {
       let doc = aFrame.document;
       this._browser = doc.createElementNS(XUL_NS, "browser");
       this._browser.setAttribute("type", "content");
       this._browser.setAttribute("src", NEWTAB_URL);
       this._applySize();
       doc.getElementById("win").appendChild(this._browser);
     });
   },
   _removeBrowser: function () {
     if (this._browser) {
       this._browser.remove();
       this._browser = null;
     }
   }
 };
 let HostFrame = {
   _frame: null,
   _deferred: null,
   get hiddenDOMDocument() {
     return Services.appShell.hiddenDOMWindow.document;
   },
   get isReady() {
     return this.hiddenDOMDocument.readyState === "complete";
   },
   get: function () {
     if (!this._deferred) {
       this._deferred = Promise.defer();
       this._create();
     }
     return this._deferred.promise;
   },
   destroy: function () {
     if (this._frame) {
       if (!Cu.isDeadWrapper(this._frame)) {
         this._frame.removeEventListener("load", this, true);
         this._frame.remove();
       }
       this._frame = null;
       this._deferred = null;
     }
   },
   handleEvent: function () {
     let contentWindow = this._frame.contentWindow;
     if (contentWindow.location.href === XUL_PAGE) {
       this._frame.removeEventListener("load", this, true);
       this._deferred.resolve(contentWindow);
     } else {
       contentWindow.location = XUL_PAGE;
     }
   },
   _create: function () {
     if (this.isReady) {
       let doc = this.hiddenDOMDocument;
       this._frame = doc.createElementNS(HTML_NS, "iframe");
       this._frame.addEventListener("load", this, true);
       doc.documentElement.appendChild(this._frame);
     } else {
       let flags = Ci.nsIThread.DISPATCH_NORMAL;
       Services.tm.currentThread.dispatch(() => this._create(), flags);
     }
   }
 };

The Tor Browser / annotate

browser/modules/BrowserNewTabPreloader.jsm@b8a032363ba2 (annotated)

browser/modules/BrowserNewTabPreloader.jsm