Issue 3815 - Fix TabAllocator. Now it returns tab with initialized outerWindowID

lib/crawler.js

 /*
  * This Source Code is subject to the terms of the Mozilla Public License
  * version 2.0 (the "License"). You can obtain a copy of the License at
  * http://mozilla.org/MPL/2.0/.
  */
 
 /**
  * @module crawler
  */
 
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/Task.jsm");
 Cu.import("resource://gre/modules/Promise.jsm");
 
 function abprequire(module)
 {
   let result = {};
   result.wrappedJSObject = result;
   Services.obs.notifyObservers(result, "adblockplus-require", module);
   return result.exports;
 }
 
 let {RequestNotifier} = abprequire("requestNotifier");
 let {FilterNotifier} = abprequire("filterNotifier");
 let {FilterStorage} = abprequire("filterStorage");
 
 /**
- * Creates a pool of tabs and allocates them to tasks on request.
+ * Creates a blank tab in the browser.
+ *
+ * @param {tabbrowser} browser
+ *    The tabbed browser where the tab should be created.
+ * @return {Promise.<tab>} promise which resolves once the tab is fully initialized.
+ */
+function createTab(browser)
+{
+  let tab = browser.addTab("about:blank");
+  if (tab.linkedBrowser.outerWindowID)
+    return Promise.resolve(tab);
+  return new Promise((resolve, reject) =>
+  {
+    let onBrowserInit = (msg) =>
+    {
+      // https://bugzilla.mozilla.org/show_bug.cgi?id=1256602#c1
+      tab.linkedBrowser.messageManager.removeMessageListener("Browser:Init", onBrowserInit);
+      resolve(tab);
+    };
+    tab.linkedBrowser.messageManager.addMessageListener("Browser:Init", onBrowserInit);
+  });
+}
+
+/**
+ * Allocates tabs on request but not more than maxtabs at the same time.
  *
  * @param {tabbrowser} browser
  *    The tabbed browser where tabs should be created
  * @param {int} maxtabs
  *    The maximum number of tabs to be allocated
  * @constructor
  */
 function TabAllocator(browser, maxtabs)
 {
-  browser.removeAllTabsBut(browser.tabs[0])
-
-  this._tabs = [];
-  for (let i = 0; i < maxtabs; i++)
-    this._tabs.push(browser.addTab("about:blank"));
-
-  browser.removeTab(browser.tabs[0]);
-
-  this._deferred = [];
+  this._browser = browser;
+  this._tabs = 0;
+  this._maxtabs = maxtabs;
+  // The queue containing resolve functions of promises waiting for a tab.
+  this._resolvers = [];
+  // Keep at least one tab alive to prevent browser from closing itself.
+  // That tab will be removed when the first tab is requested.
+  browser.removeAllTabsBut(browser.tabs[0]);
 }
 TabAllocator.prototype = {
   /**
-   * Returns a promise that will resolve into a tab once a tab can be allocated.
+   * Returns a promise that will resolve into a tab once a tab is allocated.
    * The tab cannot be used by other tasks until releaseTab() is called.
    *
-   * @result {Promise}
+   * @result {Promise.<tab>}
    */
   getTab: function()
   {
-    if (this._tabs.length)
-      return this._tabs.shift();
-    else
+    if (this._tabs < this._maxtabs)
     {
-      let deferred = Promise.defer();
-      this._deferred.push(deferred);
-      return deferred.promise;
+      let tab = createTab(this._browser);
+      // Close initial tab, we don't need it anymore.
+      if (this._tabs == 0)
+        this._browser.removeTab(this._browser.tabs[0]);
+      this._tabs++;
+      return tab;
     }
+    return new Promise((resolve, reject) =>
+    {
+      this._resolvers.push(resolve);
+    });
   },
 
   /**
    * Adds a tab back to the pool so that it can be used by other tasks.
    *
    * @param {tab} tab
    */
   releaseTab: function(tab)
   {
     let browser = tab.parentNode.tabbrowser;
     browser.removeTab(tab);
-    tab = browser.addTab("about:blank");
 
-    if (this._deferred.length)
-      this._deferred.shift().resolve(tab);
+    if (this._resolvers.length)
+      this._resolvers.shift()(createTab(this._browser));
     else
-      this._tabs.push(tab);
+      this._tabs--;
   }
 };
 
 /**
  * Observes page loads in a particular tabbed browser.
  *
  * @param {tabbrowser} browser
  *    The tabbed browser to be observed
  * @param {int} timeout
  *    Load timeout in milliseconds
@@ skipping 132 matching lines @@
         resolve();
       }
     };
     FilterNotifier.addListener(onFiltersLoaded);
   }).then(() => crawl_urls(window, urls, timeout, maxtabs, targetURL, onDone))
   .catch(reportException);
 }
 exports.run = run;
 
 /**
- * Spawns a {Task} task to crawl each url from `urls` argument and calls
- * `onDone` when all tasks are finished.
+ * Spawns a {Task} task to crawl each url from urls argument and calls
+ * onDone when all tasks are finished.
  * @param {Window} window
  *   The browser window we're operating in
  * @param {String[]} urls
  *   URLs to be crawled
  * @param {int} timeout
  *    Load timeout in milliseconds
  * @param {int} maxtabs
  *    Maximum number of tabs to be opened
  * @param {String} targetURL
  *    URL that should receive the results
@@ skipping 110 matching lines @@
 
 function reportException(e)
 {
   let stack = "";
   if (e && typeof e == "object" && "stack" in e)
     stack = e.stack + "\n";
 
   Cu.reportError(e);
   dump(e + "\n" + stack + "\n");
 }