Bug 1353013 - create preloaded newtab browser from an idle task, only in top window(s), r=dthayer

This limits us to 1 preloaded browser per window, in the top 3 normal windows + top 3 private windows.
If we try to create additional browsers beyond that, we instead move a pre-existing browser across.

Differential Revision: https://phabricator.services.mozilla.com/D21129

--HG--
extra : moz-landing-system : lando

Author: gijsk

accessible/tests/mochitest/relations/test_tabbrowser.xul

@@ -48,8 +48,10 @@
         ////////////////////////////////////////////////////////////////////////
         // 'labelled by'/'label for' relations for xul:tab and xul:tabpanel
 
-        var tabs = tabBrowser().tabContainer.children;
-        var panels = tabBrowser().tabbox.tabpanels.children;
+        var tabs = Array.from(tabBrowser().tabContainer.children);
+        // For preloaded tabs, there might be items in this array where this relation
+        // doesn't hold, so just deal with that:
+        var panels = tabs.map(t => t.linkedBrowser.closest("tabpanels > *"));
 
         testRelation(panels[0], RELATION_LABELLED_BY, tabs[0]);
         testRelation(tabs[0], RELATION_LABEL_FOR, panels[0]);

browser/base/content/browser.js

@@ -1931,6 +1931,10 @@ var gBrowserInit = {
       }, 300 * 1000);
     });
 
+    scheduleIdleTask(async () => {
+      NewTabPagePreloading.maybeCreatePreloadedBrowser(window);
+    });
+
     // This should always go last, since the idle tasks (except for the ones with
     // timeouts) should execute in order. Note that this observer notification is
     // not guaranteed to fire, since the window could close before we get here.
@@ -2058,6 +2062,8 @@ var gBrowserInit = {
 
     BrowserSearch.uninit();
 
+    NewTabPagePreloading.removePreloadedBrowser(window);
+
     // Now either cancel delayedStartup, or clean up the services initialized from
     // it.
     if (this._boundDelayedStartup) {

browser/base/content/test/statuspanel/head.js

@@ -14,6 +14,7 @@
  */
 async function promiseStatusPanelShown(win, value) {
   let panel = win.StatusPanel.panel;
+  info("Waiting to show panel");
   await BrowserTestUtils.waitForEvent(panel, "transitionend", (e) => {
     return e.propertyName === "opacity" &&
            win.getComputedStyle(e.target).opacity == "1";
@@ -31,8 +32,18 @@ async function promiseStatusPanelShown(win, value) {
  */
 async function promiseStatusPanelHidden(win) {
   let panel = win.StatusPanel.panel;
-  await BrowserTestUtils.waitForEvent(panel, "transitionend", (e) => {
-    return e.propertyName === "opacity" &&
-           win.getComputedStyle(e.target).opacity == "0";
+  info("Waiting to hide panel");
+  await new Promise(resolve => {
+    let l = e => {
+      if (e.propertyName === "opacity" &&
+          win.getComputedStyle(e.target).opacity == "0") {
+        info("Panel hid after " + e.type + " event");
+        panel.removeEventListener("transitionend", l);
+        panel.removeEventListener("transitioncancel", l);
+        resolve();
+      }
+    };
+    panel.addEventListener("transitionend", l);
+    panel.addEventListener("transitioncancel", l);
   });
 }

browser/components/originattributes/test/browser/browser_firstPartyIsolation_about_newtab.js

@@ -1,9 +1,8 @@
 add_task(async function setup() {
-  Services.prefs.setBoolPref("privacy.firstparty.isolate", true);
-
-  registerCleanupFunction(function() {
-    Services.prefs.clearUserPref("privacy.firstparty.isolate");
-  });
+  await SpecialPowers.pushPrefEnv({set: [
+    ["browser.newtab.preload", false],
+    ["privacy.firstparty.isolate", true],
+  ]});
 });
 
 /**

browser/components/tests/browser/browser_initial_tab_remoteType.js

@@ -148,6 +148,7 @@ add_task(async function setup() {
   NewTabPagePreloading.removePreloadedBrowser(window);
 
   await SpecialPowers.pushPrefEnv({"set": [
+    ["browser.newtab.preload", false],
     ["browser.startup.homepage", "about:home"],
     ["browser.startup.page", 1],
   ]});

browser/modules/NewTabPagePreloading.jsm

@@ -12,24 +12,39 @@ var EXPORTED_SYMBOLS = ["NewTabPagePreloading"];
 const {XPCOMUtils} = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
 const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
 
-ChromeUtils.defineModuleGetter(this, "E10SUtils", "resource://gre/modules/E10SUtils.jsm");
+XPCOMUtils.defineLazyModuleGetters(this, {
+  BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.jsm",
+  E10SUtils: "resource://gre/modules/E10SUtils.jsm",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.jsm",
+});
 
 XPCOMUtils.defineLazyServiceGetters(this, {
   gAboutNewTabService: ["@mozilla.org/browser/aboutnewtab-service;1", "nsIAboutNewTabService"],
 });
 
 let NewTabPagePreloading = {
+  // Maximum number of instances of a given page we'll preload at any time.
+  // Because we preload about:newtab for normal windows, and about:privatebrowsing
+  // for private ones, we could have 3 of each.
+  MAX_COUNT: 3,
+
+  // How many preloaded tabs we have, across all windows, for the private and non-private
+  // case:
+  browserCounts: {
+    normal: 0,
+    private: 0,
+  },
+
   get enabled() {
     return this.prefEnabled && this.newTabEnabled &&
       !gAboutNewTabService.overridden;
   },
 
-  maybeCreatePreloadedBrowser(window) {
-    if (!this.enabled || window.gBrowser.preloadedBrowser) {
-      return;
-    }
-
-    const {gBrowser, gMultiProcessBrowser, BROWSER_NEW_TAB_URL} = window;
+  /**
+   * Create a browser in the right process type.
+   */
+  _createBrowser(win) {
+    const {gBrowser, gMultiProcessBrowser, BROWSER_NEW_TAB_URL} = win;
     let remoteType =
       E10SUtils.getRemoteTypeForURI(BROWSER_NEW_TAB_URL, gMultiProcessBrowser);
     let browser = gBrowser.createBrowser({ isPreloadBrowser: true, remoteType });
@@ -44,16 +59,86 @@ let NewTabPagePreloading = {
       // of the preloaded browser until it gets attached to a tab.
       browser.webProgress;
     }
+    return browser;
+  },
+
+  /**
+   * Move the contents of a preload browser across to a different window.
+   */
+  _adoptBrowserFromOtherWindow(window) {
+    let winPrivate = PrivateBrowsingUtils.isWindowPrivate(window);
+    // Grab the least-recently-focused window with a preloaded browser:
+    let oldWin = BrowserWindowTracker.orderedWindows.filter(w => {
+      return winPrivate == PrivateBrowsingUtils.isWindowPrivate(w) &&
+        w.gBrowser && w.gBrowser.preloadedBrowser;
+    }).pop();
+    if (!oldWin) {
+      return null;
+    }
+    // Don't call getPreloadedBrowser because it'll consume the browser:
+    let oldBrowser = oldWin.gBrowser.preloadedBrowser;
+    oldWin.gBrowser.preloadedBrowser = null;
+
+    let newBrowser = this._createBrowser(window);
+
+    oldWin.gBrowser._outerWindowIDBrowserMap.delete(oldBrowser.outerWindowID);
+    window.gBrowser._outerWindowIDBrowserMap.delete(newBrowser.outerWindowID);
+
+    oldBrowser.swapBrowsers(newBrowser);
+
+    // Switch outerWindowIDs for remote browsers.
+    if (newBrowser.isRemoteBrowser) {
+      newBrowser._outerWindowID = oldBrowser._outerWindowID;
+    }
+
+    window.gBrowser._outerWindowIDBrowserMap.set(newBrowser.outerWindowID, newBrowser);
+    newBrowser.permanentKey = oldBrowser.permanentKey;
+
+    oldWin.gBrowser.getPanel(oldBrowser).remove();
+    return newBrowser;
+  },
 
-    browser.loadURI(BROWSER_NEW_TAB_URL, {
+  maybeCreatePreloadedBrowser(window) {
+    // If we're not enabled, have already got one, or are in a popup window,
+    // don't bother creating a preload browser - there's no point.
+    if (!this.enabled || window.gBrowser.preloadedBrowser ||
+        !window.toolbar.visible) {
+      return;
+    }
+
+    // Don't bother creating a preload browser if we're not in the top set of windows:
+    let windowPrivate = PrivateBrowsingUtils.isWindowPrivate(window);
+    let countKey = windowPrivate ? "private" : "normal";
+    let topWindows = BrowserWindowTracker.orderedWindows.filter(w =>
+      PrivateBrowsingUtils.isWindowPrivate(w) == windowPrivate);
+    if (topWindows.indexOf(window) >= this.MAX_COUNT) {
+      return;
+    }
+
+    // If we're in the top set of windows, and we already have enough preloaded
+    // tabs, don't create yet another one, just steal an existing one:
+    if (this.browserCounts[countKey] >= this.MAX_COUNT) {
+      let browser = this._adoptBrowserFromOtherWindow(window);
+      // We can potentially get null here if we couldn't actually find another
+      // browser to adopt from. This can be the case when there's a mix of
+      // private and non-private windows, for instance.
+      if (browser) {
+        return;
+      }
+    }
+
+    let browser = this._createBrowser(window);
+    browser.loadURI(window.BROWSER_NEW_TAB_URL, {
       triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
     });
     browser.docShellIsActive = false;
     browser._urlbarFocused = true;
 
     // Make sure the preloaded browser is loaded with desired zoom level
-    let tabURI = Services.io.newURI(BROWSER_NEW_TAB_URL);
+    let tabURI = Services.io.newURI(window.BROWSER_NEW_TAB_URL);
     window.FullZoom.onLocationChange(tabURI, false, browser);
+
+    this.browserCounts[countKey]++;
   },
 
   getPreloadedBrowser(window) {
@@ -74,6 +159,8 @@ let NewTabPagePreloading = {
     // in the case that the browser is remote, as remote browsers take
     // care of that themselves.
     if (browser) {
+      let countKey = PrivateBrowsingUtils.isWindowPrivate(window) ? "private" : "normal";
+      this.browserCounts[countKey]--;
       browser.setAttribute("preloadedState", "consumed");
       browser.setAttribute("autocompletepopup", "PopupAutoComplete");
     }

browser/modules/test/browser/browser.ini

@@ -18,6 +18,7 @@ support-files =
 [browser_PageActions.js]
 [browser_PermissionUI.js]
 [browser_PermissionUI_prompts.js]
+[browser_preloading_tab_moving.js]
 [browser_ProcessHangNotifications.js]
 skip-if = !e10s
 [browser_SitePermissions.js]

browser/modules/test/browser/browser_preloading_tab_moving.js

@@ -0,0 +1,91 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+var gOldCount = NewTabPagePreloading.MAX_COUNT;
+registerCleanupFunction(() => {
+  NewTabPagePreloading.MAX_COUNT = gOldCount;
+});
+
+async function openWinWithPreloadBrowser(options = {}) {
+  let idleFinishedPromise = TestUtils.topicObserved("browser-idle-startup-tasks-finished", w => {
+    return w != window;
+  });
+  let newWin = await BrowserTestUtils.openNewBrowserWindow(options);
+  await idleFinishedPromise;
+  await TestUtils.waitForCondition(() => newWin.gBrowser.preloadedBrowser);
+  return newWin;
+}
+
+/**
+ * Verify that moving a preloaded browser's content from one window to the next
+ * works correctly.
+ */
+add_task(async function moving_works() {
+  NewTabPagePreloading.MAX_COUNT = 1;
+
+  NewTabPagePreloading.removePreloadedBrowser(window);
+
+  NewTabPagePreloading.maybeCreatePreloadedBrowser(window);
+  isnot(gBrowser.preloadedBrowser, null, "Should have preloaded browser");
+
+  let oldKey = gBrowser.preloadedBrowser.permanentKey;
+
+  let newWin = await openWinWithPreloadBrowser();
+  is(gBrowser.preloadedBrowser, null, "Preloaded browser should be gone");
+  isnot(newWin.gBrowser.preloadedBrowser, null, "Should have moved the preload browser");
+  is(newWin.gBrowser.preloadedBrowser.permanentKey, oldKey, "Should have the same permanent key");
+  let browser = newWin.gBrowser.preloadedBrowser;
+  let tab = BrowserTestUtils.addTab(newWin.gBrowser, newWin.BROWSER_NEW_TAB_URL);
+  is(tab.linkedBrowser, browser, "Preloaded browser is usable when opening a new tab.");
+  await ContentTask.spawn(browser, null, function() {
+    return ContentTaskUtils.waitForCondition(() => {
+      return content.document.readyState == "complete";
+    });
+  });
+  ok(true, "Successfully loaded the tab.");
+
+  tab = browser = null;
+  await BrowserTestUtils.closeWindow(newWin);
+
+  tab = BrowserTestUtils.addTab(gBrowser, BROWSER_NEW_TAB_URL);
+  await ContentTask.spawn(tab.linkedBrowser, null, function() {
+    return ContentTaskUtils.waitForCondition(() => {
+      return content.document.readyState == "complete";
+    });
+  });
+
+  ok(true, "Managed to open a tab in the original window still.");
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+add_task(async function moving_shouldnt_move_across_private_state() {
+  NewTabPagePreloading.MAX_COUNT = 1;
+
+  NewTabPagePreloading.removePreloadedBrowser(window);
+
+  NewTabPagePreloading.maybeCreatePreloadedBrowser(window);
+  isnot(gBrowser.preloadedBrowser, null, "Should have preloaded browser");
+
+  let oldKey = gBrowser.preloadedBrowser.permanentKey;
+  let newWin = await openWinWithPreloadBrowser({private: true});
+
+  isnot(gBrowser.preloadedBrowser, null, "Preloaded browser in original window should persist");
+  isnot(newWin.gBrowser.preloadedBrowser, null, "Should have created another preload browser");
+  isnot(newWin.gBrowser.preloadedBrowser.permanentKey, oldKey, "Should not have the same permanent key");
+  let browser = newWin.gBrowser.preloadedBrowser;
+  let tab = BrowserTestUtils.addTab(newWin.gBrowser, newWin.BROWSER_NEW_TAB_URL);
+  is(tab.linkedBrowser, browser, "Preloaded browser is usable when opening a new tab.");
+  await ContentTask.spawn(browser, null, function() {
+    return ContentTaskUtils.waitForCondition(() => {
+      return content.document.readyState == "complete";
+    });
+  });
+  ok(true, "Successfully loaded the tab.");
+
+  tab = browser = null;
+  await BrowserTestUtils.closeWindow(newWin);
+});
+

startupcache/test/browser_startupcache_telemetry.js

@@ -10,6 +10,11 @@ const LABELS_STARTUP_CACHE_REQUESTS = {
 };
 
 add_task(async function() {
+  // Turn off tab preloading to avoid issues with RemoteController.js
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.newtab.preload", false]],
+  });
+
   Services.obs.notifyObservers(null, "startupcache-invalidate");
   Services.telemetry.getSnapshotForHistograms("main", true);
   let newWin = await BrowserTestUtils.openNewBrowserWindow();