Add m-esr52 at 52.6.0

1 files changed, 1087 insertions, 0 deletions

diff --git a/testing/mochitest/browser-test.js b/testing/mochitest/browser-test.js
new file mode 100644
index 000000000..dbaaf29a8
--- /dev/null
+++ b/testing/mochitest/browser-test.js
@@ -0,0 +1,1087 @@
+/* -*- js-indent-level: 2; tab-width: 2; indent-tabs-mode: nil -*- */
+// Test timeout (seconds)
+var gTimeoutSeconds = 45;
+var gConfig;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/AppConstants.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "ContentSearch",
+  "resource:///modules/ContentSearch.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "SelfSupportBackend",
+  "resource:///modules/SelfSupportBackend.jsm");
+
+const SIMPLETEST_OVERRIDES =
+  ["ok", "is", "isnot", "todo", "todo_is", "todo_isnot", "info", "expectAssertions", "requestCompleteLog"];
+
+// non-android is bootstrapped by marionette
+if (Services.appinfo.OS == 'Android') {
+  window.addEventListener("load", function testOnLoad() {
+    window.removeEventListener("load", testOnLoad);
+    window.addEventListener("MozAfterPaint", function testOnMozAfterPaint() {
+      window.removeEventListener("MozAfterPaint", testOnMozAfterPaint);
+      setTimeout(testInit, 0);
+    });
+  });
+} else {
+  setTimeout(testInit, 0);
+}
+
+var TabDestroyObserver = {
+  outstanding: new Set(),
+  promiseResolver: null,
+
+  init: function() {
+    Services.obs.addObserver(this, "message-manager-close", false);
+    Services.obs.addObserver(this, "message-manager-disconnect", false);
+  },
+
+  destroy: function() {
+    Services.obs.removeObserver(this, "message-manager-close");
+    Services.obs.removeObserver(this, "message-manager-disconnect");
+  },
+
+  observe: function(subject, topic, data) {
+    if (topic == "message-manager-close") {
+      this.outstanding.add(subject);
+    } else if (topic == "message-manager-disconnect") {
+      this.outstanding.delete(subject);
+      if (!this.outstanding.size && this.promiseResolver) {
+        this.promiseResolver();
+      }
+    }
+  },
+
+  wait: function() {
+    if (!this.outstanding.size) {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve) => {
+      this.promiseResolver = resolve;
+    });
+  },
+};
+
+function testInit() {
+  gConfig = readConfig();
+  if (gConfig.testRoot == "browser") {
+    // Make sure to launch the test harness for the first opened window only
+    var prefs = Services.prefs;
+    if (prefs.prefHasUserValue("testing.browserTestHarness.running"))
+      return;
+
+    prefs.setBoolPref("testing.browserTestHarness.running", true);
+
+    if (prefs.prefHasUserValue("testing.browserTestHarness.timeout"))
+      gTimeoutSeconds = prefs.getIntPref("testing.browserTestHarness.timeout");
+
+    var sstring = Cc["@mozilla.org/supports-string;1"].
+                  createInstance(Ci.nsISupportsString);
+    sstring.data = location.search;
+
+    Services.ww.openWindow(window, "chrome://mochikit/content/browser-harness.xul", "browserTest",
+                           "chrome,centerscreen,dialog=no,resizable,titlebar,toolbar=no,width=800,height=600", sstring);
+  } else {
+    // This code allows us to redirect without requiring specialpowers for chrome and a11y tests.
+    let messageHandler = function(m) {
+      messageManager.removeMessageListener("chromeEvent", messageHandler);
+      var url = m.json.data;
+
+      // Window is the [ChromeWindow] for messageManager, so we need content.window
+      // Currently chrome tests are run in a content window instead of a ChromeWindow
+      var webNav = content.window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
+                         .getInterface(Components.interfaces.nsIWebNavigation);
+      webNav.loadURI(url, null, null, null, null);
+    };
+
+    var listener = 'data:,function doLoad(e) { var data=e.detail&&e.detail.data;removeEventListener("contentEvent", function (e) { doLoad(e); }, false, true);sendAsyncMessage("chromeEvent", {"data":data}); };addEventListener("contentEvent", function (e) { doLoad(e); }, false, true);';
+    messageManager.addMessageListener("chromeEvent", messageHandler);
+    messageManager.loadFrameScript(listener, true);
+  }
+  if (gConfig.e10s) {
+    e10s_init();
+
+    let processCount = prefs.getIntPref("dom.ipc.processCount", 1);
+    if (processCount > 1) {
+      // Currently starting a content process is slow, to aviod timeouts, let's
+      // keep alive content processes.
+      prefs.setIntPref("dom.ipc.keepProcessesAlive", processCount);
+    }
+
+    let globalMM = Cc["@mozilla.org/globalmessagemanager;1"]
+                     .getService(Ci.nsIMessageListenerManager);
+    globalMM.loadFrameScript("chrome://mochikit/content/shutdown-leaks-collector.js", true);
+  } else {
+    // In non-e10s, only run the ShutdownLeaksCollector in the parent process.
+    Components.utils.import("chrome://mochikit/content/ShutdownLeaksCollector.jsm");
+  }
+
+  let gmm = Cc["@mozilla.org/globalmessagemanager;1"].getService(Ci.nsIMessageListenerManager);
+  gmm.loadFrameScript("chrome://mochikit/content/tests/SimpleTest/AsyncUtilsContent.js", true);
+}
+
+function Tester(aTests, structuredLogger, aCallback) {
+  this.structuredLogger = structuredLogger;
+  this.tests = aTests;
+  this.callback = aCallback;
+
+  this._scriptLoader = Services.scriptloader;
+  this.EventUtils = {};
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/EventUtils.js", this.EventUtils);
+  var simpleTestScope = {};
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/specialpowersAPI.js", simpleTestScope);
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/SpecialPowersObserverAPI.js", simpleTestScope);
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/ChromePowers.js", simpleTestScope);
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/SimpleTest.js", simpleTestScope);
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/MemoryStats.js", simpleTestScope);
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/chrome-harness.js", simpleTestScope);
+  this.SimpleTest = simpleTestScope.SimpleTest;
+
+  var extensionUtilsScope = {
+    registerCleanupFunction: (fn) => {
+      this.currentTest.scope.registerCleanupFunction(fn);
+    },
+  };
+  extensionUtilsScope.SimpleTest = this.SimpleTest;
+  this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/ExtensionTestUtils.js", extensionUtilsScope);
+  this.ExtensionTestUtils = extensionUtilsScope.ExtensionTestUtils;
+
+  this.SimpleTest.harnessParameters = gConfig;
+
+  this.MemoryStats = simpleTestScope.MemoryStats;
+  this.Task = Task;
+  this.ContentTask = Components.utils.import("resource://testing-common/ContentTask.jsm", null).ContentTask;
+  this.BrowserTestUtils = Components.utils.import("resource://testing-common/BrowserTestUtils.jsm", null).BrowserTestUtils;
+  this.TestUtils = Components.utils.import("resource://testing-common/TestUtils.jsm", null).TestUtils;
+  this.Task.Debugging.maintainStack = true;
+  this.Promise = Components.utils.import("resource://gre/modules/Promise.jsm", null).Promise;
+  this.Assert = Components.utils.import("resource://testing-common/Assert.jsm", null).Assert;
+
+  this.SimpleTestOriginal = {};
+  SIMPLETEST_OVERRIDES.forEach(m => {
+    this.SimpleTestOriginal[m] = this.SimpleTest[m];
+  });
+
+  this._coverageCollector = null;
+
+  this._toleratedUncaughtRejections = null;
+  this._uncaughtErrorObserver = function({message, date, fileName, stack, lineNumber}) {
+    let error = message;
+    if (fileName || lineNumber) {
+      error = {
+        fileName: fileName,
+        lineNumber: lineNumber,
+        message: message,
+        toString: function() {
+          return message;
+        }
+      };
+    }
+
+    // We may have a whitelist of rejections we wish to tolerate.
+    let tolerate = this._toleratedUncaughtRejections &&
+      this._toleratedUncaughtRejections.indexOf(message) != -1;
+    let name = "A promise chain failed to handle a rejection: ";
+    if (tolerate) {
+      name = "WARNING: (PLEASE FIX THIS AS PART OF BUG 1077403) " + name;
+    }
+
+    this.currentTest.addResult(
+      new testResult(
+	      /*success*/tolerate,
+        /*name*/name,
+        /*error*/error,
+        /*known*/tolerate,
+        /*stack*/stack));
+    }.bind(this);
+}
+Tester.prototype = {
+  EventUtils: {},
+  SimpleTest: {},
+  Task: null,
+  ContentTask: null,
+  ExtensionTestUtils: null,
+  Assert: null,
+
+  repeat: 0,
+  runUntilFailure: false,
+  checker: null,
+  currentTestIndex: -1,
+  lastStartTime: null,
+  lastAssertionCount: 0,
+  failuresFromInitialWindowState: 0,
+
+  get currentTest() {
+    return this.tests[this.currentTestIndex];
+  },
+  get done() {
+    return this.currentTestIndex == this.tests.length - 1;
+  },
+
+  start: function Tester_start() {
+    TabDestroyObserver.init();
+
+    //if testOnLoad was not called, then gConfig is not defined
+    if (!gConfig)
+      gConfig = readConfig();
+
+    if (gConfig.runUntilFailure)
+      this.runUntilFailure = true;
+
+    if (gConfig.repeat)
+      this.repeat = gConfig.repeat;
+
+    if (gConfig.jscovDirPrefix) {
+      let coveragePath = gConfig.jscovDirPrefix;
+      let {CoverageCollector} = Cu.import("resource://testing-common/CoverageUtils.jsm",
+                                          {});
+      this._coverageCollector = new CoverageCollector(coveragePath);
+    }
+
+    this.structuredLogger.info("*** Start BrowserChrome Test Results ***");
+    Services.console.registerListener(this);
+    this._globalProperties = Object.keys(window);
+    this._globalPropertyWhitelist = [
+      "navigator", "constructor", "top",
+      "Application",
+      "__SS_tabsToRestore", "__SSi",
+      "webConsoleCommandController",
+    ];
+
+    this.Promise.Debugging.clearUncaughtErrorObservers();
+    this.Promise.Debugging.addUncaughtErrorObserver(this._uncaughtErrorObserver);
+
+    if (this.tests.length)
+      this.waitForGraphicsTestWindowToBeGone(this.nextTest.bind(this));
+    else
+      this.finish();
+  },
+
+  waitForGraphicsTestWindowToBeGone(aCallback) {
+    let windowsEnum = Services.wm.getEnumerator(null);
+    while (windowsEnum.hasMoreElements()) {
+      let win = windowsEnum.getNext();
+      if (win != window && !win.closed &&
+          win.document.documentURI == "chrome://gfxsanity/content/sanityparent.html") {
+        this.BrowserTestUtils.domWindowClosed(win).then(aCallback);
+        return;
+      }
+    }
+    // graphics test window is already gone, just call callback immediately
+    aCallback();
+  },
+
+  waitForWindowsState: function Tester_waitForWindowsState(aCallback) {
+    let timedOut = this.currentTest && this.currentTest.timedOut;
+    let startTime = Date.now();
+    let baseMsg = timedOut ? "Found a {elt} after previous test timed out"
+                           : this.currentTest ? "Found an unexpected {elt} at the end of test run"
+                                              : "Found an unexpected {elt}";
+
+    // Remove stale tabs
+    if (this.currentTest && window.gBrowser && gBrowser.tabs.length > 1) {
+      while (gBrowser.tabs.length > 1) {
+        let lastTab = gBrowser.tabContainer.lastChild;
+        let msg = baseMsg.replace("{elt}", "tab") +
+                  ": " + lastTab.linkedBrowser.currentURI.spec;
+        this.currentTest.addResult(new testResult(false, msg, "", false));
+        gBrowser.removeTab(lastTab);
+      }
+    }
+
+    // Replace the last tab with a fresh one
+    if (window.gBrowser) {
+      let newTab = gBrowser.addTab("about:blank", { skipAnimation: true });
+      gBrowser.removeTab(gBrowser.selectedTab, { skipPermitUnload: true });
+      gBrowser.stop();
+    }
+
+    // Remove stale windows
+    this.structuredLogger.info("checking window state");
+    let windowsEnum = Services.wm.getEnumerator(null);
+    let createdFakeTestForLogging = false;
+    while (windowsEnum.hasMoreElements()) {
+      let win = windowsEnum.getNext();
+      if (win != window && !win.closed &&
+          win.document.documentElement.getAttribute("id") != "browserTestHarness") {
+        let type = win.document.documentElement.getAttribute("windowtype");
+        switch (type) {
+        case "navigator:browser":
+          type = "browser window";
+          break;
+        case null:
+          type = "unknown window with document URI: " + win.document.documentURI +
+                 " and title: " + win.document.title;
+          break;
+        }
+        let msg = baseMsg.replace("{elt}", type);
+        if (this.currentTest) {
+          this.currentTest.addResult(new testResult(false, msg, "", false));
+        } else {
+          if (!createdFakeTestForLogging) {
+            createdFakeTestForLogging = true;
+            this.structuredLogger.testStart("browser-test.js");
+          }
+          this.failuresFromInitialWindowState++;
+          this.structuredLogger.testStatus("browser-test.js",
+                                           msg, "FAIL", false, "");
+        }
+
+        win.close();
+      }
+    }
+    if (createdFakeTestForLogging) {
+      let time = Date.now() - startTime;
+      this.structuredLogger.testEnd("browser-test.js",
+                                    "OK",
+                                    undefined,
+                                    "finished window state check in " + time + "ms");
+    }
+
+    // Make sure the window is raised before each test.
+    this.SimpleTest.waitForFocus(aCallback);
+  },
+
+  finish: function Tester_finish(aSkipSummary) {
+    this.Promise.Debugging.flushUncaughtErrors();
+
+    var passCount = this.tests.reduce((a, f) => a + f.passCount, 0);
+    var failCount = this.tests.reduce((a, f) => a + f.failCount, 0);
+    var todoCount = this.tests.reduce((a, f) => a + f.todoCount, 0);
+
+    // Include failures from window state checking prior to running the first test
+    failCount += this.failuresFromInitialWindowState;
+
+    if (this.repeat > 0) {
+      --this.repeat;
+      this.currentTestIndex = -1;
+      this.nextTest();
+    } else {
+      TabDestroyObserver.destroy();
+      Services.console.unregisterListener(this);
+      this.Promise.Debugging.clearUncaughtErrorObservers();
+      this._treatUncaughtRejectionsAsFailures = false;
+
+      // In the main process, we print the ShutdownLeaksCollector message here.
+      let pid = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime).processID;
+      dump("Completed ShutdownLeaks collections in process " + pid + "\n");
+
+      this.structuredLogger.info("TEST-START | Shutdown");
+
+      if (this.tests.length) {
+        let e10sMode = gMultiProcessBrowser ? "e10s" : "non-e10s";
+        this.structuredLogger.info("Browser Chrome Test Summary");
+        this.structuredLogger.info("Passed:  " + passCount);
+        this.structuredLogger.info("Failed:  " + failCount);
+        this.structuredLogger.info("Todo:    " + todoCount);
+        this.structuredLogger.info("Mode:    " + e10sMode);
+      } else {
+        this.structuredLogger.testEnd("browser-test.js",
+                                      "FAIL",
+                                      "PASS",
+                                      "No tests to run. Did you pass invalid test_paths?");
+      }
+      this.structuredLogger.info("*** End BrowserChrome Test Results ***");
+
+      // Tests complete, notify the callback and return
+      this.callback(this.tests);
+      this.callback = null;
+      this.tests = null;
+    }
+  },
+
+  haltTests: function Tester_haltTests() {
+    // Do not run any further tests
+    this.currentTestIndex = this.tests.length - 1;
+    this.repeat = 0;
+  },
+
+  observe: function Tester_observe(aSubject, aTopic, aData) {
+    if (!aTopic) {
+      this.onConsoleMessage(aSubject);
+    }
+  },
+
+  onConsoleMessage: function Tester_onConsoleMessage(aConsoleMessage) {
+    // Ignore empty messages.
+    if (!aConsoleMessage.message)
+      return;
+
+    try {
+      var msg = "Console message: " + aConsoleMessage.message;
+      if (this.currentTest)
+        this.currentTest.addResult(new testMessage(msg));
+      else
+        this.structuredLogger.info("TEST-INFO | (browser-test.js) | " + msg.replace(/\n$/, "") + "\n");
+    } catch (ex) {
+      // Swallow exception so we don't lead to another error being reported,
+      // throwing us into an infinite loop
+    }
+  },
+
+  nextTest: Task.async(function*() {
+    if (this.currentTest) {
+      this.Promise.Debugging.flushUncaughtErrors();
+      if (this._coverageCollector) {
+        this._coverageCollector.recordTestCoverage(this.currentTest.path);
+      }
+
+      // Run cleanup functions for the current test before moving on to the
+      // next one.
+      let testScope = this.currentTest.scope;
+      while (testScope.__cleanupFunctions.length > 0) {
+        let func = testScope.__cleanupFunctions.shift();
+        try {
+          yield func.apply(testScope);
+        }
+        catch (ex) {
+          this.currentTest.addResult(new testResult(false, "Cleanup function threw an exception", ex, false));
+        }
+      }
+
+      if (this.currentTest.passCount === 0 &&
+          this.currentTest.failCount === 0 &&
+          this.currentTest.todoCount === 0) {
+        this.currentTest.addResult(new testResult(false, "This test contains no passes, no fails and no todos. Maybe it threw a silent exception? Make sure you use waitForExplicitFinish() if you need it.", "", false));
+      }
+
+      if (testScope.__expected == 'fail' && testScope.__num_failed <= 0) {
+        this.currentTest.addResult(new testResult(false, "We expected at least one assertion to fail because this test file was marked as fail-if in the manifest!", "", true));
+      }
+
+      this.Promise.Debugging.flushUncaughtErrors();
+
+      let winUtils = window.QueryInterface(Ci.nsIInterfaceRequestor)
+                           .getInterface(Ci.nsIDOMWindowUtils);
+      if (winUtils.isTestControllingRefreshes) {
+        this.currentTest.addResult(new testResult(false, "test left refresh driver under test control", "", false));
+        winUtils.restoreNormalRefresh();
+      }
+
+      if (this.SimpleTest.isExpectingUncaughtException()) {
+        this.currentTest.addResult(new testResult(false, "expectUncaughtException was called but no uncaught exception was detected!", "", false));
+      }
+
+      Object.keys(window).forEach(function (prop) {
+        if (parseInt(prop) == prop) {
+          // This is a string which when parsed as an integer and then
+          // stringified gives the original string.  As in, this is in fact a
+          // string representation of an integer, so an index into
+          // window.frames.  Skip those.
+          return;
+        }
+        if (this._globalProperties.indexOf(prop) == -1) {
+          this._globalProperties.push(prop);
+          if (this._globalPropertyWhitelist.indexOf(prop) == -1)
+            this.currentTest.addResult(new testResult(false, "test left unexpected property on window: " + prop, "", false));
+        }
+      }, this);
+
+      // Clear document.popupNode.  The test could have set it to a custom value
+      // for its own purposes, nulling it out it will go back to the default
+      // behavior of returning the last opened popup.
+      document.popupNode = null;
+
+      yield new Promise(resolve => SpecialPowers.flushPrefEnv(resolve));
+
+      // Notify a long running test problem if it didn't end up in a timeout.
+      if (this.currentTest.unexpectedTimeouts && !this.currentTest.timedOut) {
+        let msg = "This test exceeded the timeout threshold. It should be " +
+                  "rewritten or split up. If that's not possible, use " +
+                  "requestLongerTimeout(N), but only as a last resort.";
+        this.currentTest.addResult(new testResult(false, msg, "", false));
+      }
+
+      // If we're in a debug build, check assertion counts.  This code
+      // is similar to the code in TestRunner.testUnloaded in
+      // TestRunner.js used for all other types of mochitests.
+      let debugsvc = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2);
+      if (debugsvc.isDebugBuild) {
+        let newAssertionCount = debugsvc.assertionCount;
+        let numAsserts = newAssertionCount - this.lastAssertionCount;
+        this.lastAssertionCount = newAssertionCount;
+
+        let max = testScope.__expectedMaxAsserts;
+        let min = testScope.__expectedMinAsserts;
+        if (numAsserts > max) {
+          let msg = "Assertion count " + numAsserts +
+                    " is greater than expected range " +
+                    min + "-" + max + " assertions.";
+          // TEST-UNEXPECTED-FAIL (TEMPORARILY TEST-KNOWN-FAIL)
+          //this.currentTest.addResult(new testResult(false, msg, "", false));
+          this.currentTest.addResult(new testResult(true, msg, "", true));
+        } else if (numAsserts < min) {
+          let msg = "Assertion count " + numAsserts +
+                    " is less than expected range " +
+                    min + "-" + max + " assertions.";
+          // TEST-UNEXPECTED-PASS
+          this.currentTest.addResult(new testResult(false, msg, "", true));
+        } else if (numAsserts > 0) {
+          let msg = "Assertion count " + numAsserts +
+                    " is within expected range " +
+                    min + "-" + max + " assertions.";
+          // TEST-KNOWN-FAIL
+          this.currentTest.addResult(new testResult(true, msg, "", true));
+        }
+      }
+
+      // Dump memory stats for main thread.
+      if (Cc["@mozilla.org/xre/runtime;1"]
+          .getService(Ci.nsIXULRuntime)
+          .processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT)
+      {
+        this.MemoryStats.dump(this.currentTestIndex,
+                              this.currentTest.path,
+                              gConfig.dumpOutputDirectory,
+                              gConfig.dumpAboutMemoryAfterTest,
+                              gConfig.dumpDMDAfterTest);
+      }
+
+      // Note the test run time
+      let time = Date.now() - this.lastStartTime;
+      this.structuredLogger.testEnd(this.currentTest.path,
+                                           "OK",
+                                           undefined,
+                                           "finished in " + time + "ms");
+      this.currentTest.setDuration(time);
+
+      if (this.runUntilFailure && this.currentTest.failCount > 0) {
+        this.haltTests();
+      }
+
+      // Restore original SimpleTest methods to avoid leaks.
+      SIMPLETEST_OVERRIDES.forEach(m => {
+        this.SimpleTest[m] = this.SimpleTestOriginal[m];
+      });
+
+      this.ContentTask.setTestScope(null);
+      testScope.destroy();
+      this.currentTest.scope = null;
+    }
+
+    // Check the window state for the current test before moving to the next one.
+    // This also causes us to check before starting any tests, since nextTest()
+    // is invoked to start the tests.
+    this.waitForWindowsState((function () {
+      if (this.done) {
+        if (this._coverageCollector) {
+          this._coverageCollector.finalize();
+        }
+
+        // Uninitialize a few things explicitly so that they can clean up
+        // frames and browser intentionally kept alive until shutdown to
+        // eliminate false positives.
+        if (gConfig.testRoot == "browser") {
+          //Skip if SeaMonkey
+          if (AppConstants.MOZ_APP_NAME != "seamonkey") {
+            // Replace the document currently loaded in the browser's sidebar.
+            // This will prevent false positives for tests that were the last
+            // to touch the sidebar. They will thus not be blamed for leaking
+            // a document.
+            let sidebar = document.getElementById("sidebar");
+            sidebar.setAttribute("src", "data:text/html;charset=utf-8,");
+            sidebar.docShell.createAboutBlankContentViewer(null);
+            sidebar.setAttribute("src", "about:blank");
+
+            SelfSupportBackend.uninit();
+            SocialShare.uninit();
+          }
+
+          // Destroy BackgroundPageThumbs resources.
+          let {BackgroundPageThumbs} =
+            Cu.import("resource://gre/modules/BackgroundPageThumbs.jsm", {});
+          BackgroundPageThumbs._destroy();
+
+          // Destroy preloaded browsers.
+          if (gBrowser._preloadedBrowser) {
+            let browser = gBrowser._preloadedBrowser;
+            gBrowser._preloadedBrowser = null;
+            gBrowser.getNotificationBox(browser).remove();
+          }
+        }
+
+        // Schedule GC and CC runs before finishing in order to detect
+        // DOM windows leaked by our tests or the tested code. Note that we
+        // use a shrinking GC so that the JS engine will discard JIT code and
+        // JIT caches more aggressively.
+
+        let shutdownCleanup = aCallback => {
+          Cu.schedulePreciseShrinkingGC(() => {
+            // Run the GC and CC a few times to make sure that as much
+            // as possible is freed.
+            let numCycles = 3;
+            for (let i = 0; i < numCycles; i++) {
+              Cu.forceGC();
+              Cu.forceCC();
+            }
+            aCallback();
+          });
+        };
+
+
+        let {AsyncShutdown} =
+          Cu.import("resource://gre/modules/AsyncShutdown.jsm", {});
+
+        let barrier = new AsyncShutdown.Barrier(
+          "ShutdownLeaks: Wait for cleanup to be finished before checking for leaks");
+        Services.obs.notifyObservers({wrappedJSObject: barrier},
+          "shutdown-leaks-before-check", null);
+
+        barrier.client.addBlocker("ShutdownLeaks: Wait for tabs to finish closing",
+                                  TabDestroyObserver.wait());
+
+        barrier.wait().then(() => {
+          // Simulate memory pressure so that we're forced to free more resources
+          // and thus get rid of more false leaks like already terminated workers.
+          Services.obs.notifyObservers(null, "memory-pressure", "heap-minimize");
+
+          Services.ppmm.broadcastAsyncMessage("browser-test:collect-request");
+
+          shutdownCleanup(() => {
+            setTimeout(() => {
+              shutdownCleanup(() => {
+                this.finish();
+              });
+            }, 1000);
+          });
+        });
+
+        return;
+      }
+
+      this.currentTestIndex++;
+      this.execTest();
+    }).bind(this));
+  }),
+
+  execTest: function Tester_execTest() {
+    this.structuredLogger.testStart(this.currentTest.path);
+
+    this.SimpleTest.reset();
+
+    // Load the tests into a testscope
+    let currentScope = this.currentTest.scope = new testScope(this, this.currentTest, this.currentTest.expected);
+    let currentTest = this.currentTest;
+
+    // Import utils in the test scope.
+    this.currentTest.scope.EventUtils = this.EventUtils;
+    this.currentTest.scope.SimpleTest = this.SimpleTest;
+    this.currentTest.scope.gTestPath = this.currentTest.path;
+    this.currentTest.scope.Task = this.Task;
+    this.currentTest.scope.ContentTask = this.ContentTask;
+    this.currentTest.scope.BrowserTestUtils = this.BrowserTestUtils;
+    this.currentTest.scope.TestUtils = this.TestUtils;
+    this.currentTest.scope.ExtensionTestUtils = this.ExtensionTestUtils;
+    // Pass a custom report function for mochitest style reporting.
+    this.currentTest.scope.Assert = new this.Assert(function(err, message, stack) {
+      let res;
+      if (err) {
+        res = new testResult(false, err.message, err.stack, false, err.stack);
+      } else {
+        res = new testResult(true, message, "", false, stack);
+      }
+      currentTest.addResult(res);
+    });
+
+    this.ContentTask.setTestScope(currentScope);
+
+    // Allow Assert.jsm methods to be tacked to the current scope.
+    this.currentTest.scope.export_assertions = function() {
+      for (let func in this.Assert) {
+        this[func] = this.Assert[func].bind(this.Assert);
+      }
+    };
+
+    // Override SimpleTest methods with ours.
+    SIMPLETEST_OVERRIDES.forEach(function(m) {
+      this.SimpleTest[m] = this[m];
+    }, this.currentTest.scope);
+
+    //load the tools to work with chrome .jar and remote
+    try {
+      this._scriptLoader.loadSubScript("chrome://mochikit/content/chrome-harness.js", this.currentTest.scope);
+    } catch (ex) { /* no chrome-harness tools */ }
+
+    // Import head.js script if it exists.
+    var currentTestDirPath =
+      this.currentTest.path.substr(0, this.currentTest.path.lastIndexOf("/"));
+    var headPath = currentTestDirPath + "/head.js";
+    try {
+      this._scriptLoader.loadSubScript(headPath, this.currentTest.scope);
+    } catch (ex) {
+      // Ignore if no head.js exists, but report all other errors.  Note this
+      // will also ignore an existing head.js attempting to import a missing
+      // module - see bug 755558 for why this strategy is preferred anyway.
+      if (!/^Error opening input stream/.test(ex.toString())) {
+       this.currentTest.addResult(new testResult(false, "head.js import threw an exception", ex, false));
+      }
+    }
+
+    // Import the test script.
+    try {
+      this._scriptLoader.loadSubScript(this.currentTest.path,
+                                       this.currentTest.scope);
+      this.Promise.Debugging.flushUncaughtErrors();
+      // Run the test
+      this.lastStartTime = Date.now();
+      if (this.currentTest.scope.__tasks) {
+        // This test consists of tasks, added via the `add_task()` API.
+        if ("test" in this.currentTest.scope) {
+          throw "Cannot run both a add_task test and a normal test at the same time.";
+        }
+        let Promise = this.Promise;
+        this.Task.spawn(function*() {
+          let task;
+          while ((task = this.__tasks.shift())) {
+            this.SimpleTest.info("Entering test " + task.name);
+            try {
+              yield task();
+            } catch (ex) {
+              let isExpected = !!this.SimpleTest.isExpectingUncaughtException();
+              let stack = (typeof ex == "object" && "stack" in ex)?ex.stack:null;
+              let name = "Uncaught exception";
+              let result = new testResult(isExpected, name, ex, false, stack);
+              currentTest.addResult(result);
+            }
+            Promise.Debugging.flushUncaughtErrors();
+            this.SimpleTest.info("Leaving test " + task.name);
+          }
+          this.finish();
+        }.bind(currentScope));
+      } else if (typeof this.currentTest.scope.test == "function") {
+        this.currentTest.scope.test();
+      } else {
+        throw "This test didn't call add_task, nor did it define a generatorTest() function, nor did it define a test() function, so we don't know how to run it.";
+      }
+    } catch (ex) {
+      let isExpected = !!this.SimpleTest.isExpectingUncaughtException();
+      if (!this.SimpleTest.isIgnoringAllUncaughtExceptions()) {
+        this.currentTest.addResult(new testResult(isExpected, "Exception thrown", ex, false));
+        this.SimpleTest.expectUncaughtException(false);
+      } else {
+        this.currentTest.addResult(new testMessage("Exception thrown: " + ex));
+      }
+      this.currentTest.scope.finish();
+    }
+
+    // If the test ran synchronously, move to the next test, otherwise the test
+    // will trigger the next test when it is done.
+    if (this.currentTest.scope.__done) {
+      this.nextTest();
+    }
+    else {
+      var self = this;
+      var timeoutExpires = Date.now() + gTimeoutSeconds * 1000;
+      var waitUntilAtLeast = timeoutExpires - 1000;
+      this.currentTest.scope.__waitTimer =
+        this.SimpleTest._originalSetTimeout.apply(window, [function timeoutFn() {
+        // We sometimes get woken up long before the gTimeoutSeconds
+        // have elapsed (when running in chaos mode for example). This
+        // code ensures that we don't wrongly time out in that case.
+        if (Date.now() < waitUntilAtLeast) {
+          self.currentTest.scope.__waitTimer =
+            setTimeout(timeoutFn, timeoutExpires - Date.now());
+          return;
+        }
+
+        if (--self.currentTest.scope.__timeoutFactor > 0) {
+          // We were asked to wait a bit longer.
+          self.currentTest.scope.info(
+            "Longer timeout required, waiting longer...  Remaining timeouts: " +
+            self.currentTest.scope.__timeoutFactor);
+          self.currentTest.scope.__waitTimer =
+            setTimeout(timeoutFn, gTimeoutSeconds * 1000);
+          return;
+        }
+
+        // If the test is taking longer than expected, but it's not hanging,
+        // mark the fact, but let the test continue.  At the end of the test,
+        // if it didn't timeout, we will notify the problem through an error.
+        // To figure whether it's an actual hang, compare the time of the last
+        // result or message to half of the timeout time.
+        // Though, to protect against infinite loops, limit the number of times
+        // we allow the test to proceed.
+        const MAX_UNEXPECTED_TIMEOUTS = 10;
+        if (Date.now() - self.currentTest.lastOutputTime < (gTimeoutSeconds / 2) * 1000 &&
+            ++self.currentTest.unexpectedTimeouts <= MAX_UNEXPECTED_TIMEOUTS) {
+            self.currentTest.scope.__waitTimer =
+              setTimeout(timeoutFn, gTimeoutSeconds * 1000);
+          return;
+        }
+
+        self.currentTest.addResult(new testResult(false, "Test timed out", null, false));
+        self.currentTest.timedOut = true;
+        self.currentTest.scope.__waitTimer = null;
+        self.nextTest();
+      }, gTimeoutSeconds * 1000]);
+    }
+  },
+
+  QueryInterface: function(aIID) {
+    if (aIID.equals(Ci.nsIConsoleListener) ||
+        aIID.equals(Ci.nsISupports))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+};
+
+function testResult(aCondition, aName, aDiag, aIsTodo, aStack) {
+  this.name = aName;
+  this.msg = "";
+
+  this.info = false;
+  this.pass = !!aCondition;
+  this.todo = aIsTodo;
+
+  if (this.pass) {
+    if (aIsTodo) {
+      this.status = "FAIL";
+      this.expected = "FAIL";
+    } else {
+      this.status = "PASS";
+      this.expected = "PASS";
+    }
+
+  } else {
+    if (aDiag) {
+      if (typeof aDiag == "object" && "fileName" in aDiag) {
+        // we have an exception - print filename and linenumber information
+        this.msg += "at " + aDiag.fileName + ":" + aDiag.lineNumber + " - ";
+      }
+      this.msg += String(aDiag);
+    }
+    if (aStack) {
+      this.msg += "\nStack trace:\n";
+      let normalized;
+      if (aStack instanceof Components.interfaces.nsIStackFrame) {
+        let frames = [];
+        for (let frame = aStack; frame; frame = frame.caller) {
+          frames.push(frame.filename + ":" + frame.name + ":" + frame.lineNumber);
+        }
+        normalized = frames.join("\n");
+      } else {
+        normalized = "" + aStack;
+      }
+      this.msg += Task.Debugging.generateReadableStack(normalized, "    ");
+    }
+    if (aIsTodo) {
+      this.status = "PASS";
+      this.expected = "FAIL";
+    } else {
+      this.status = "FAIL";
+      this.expected = "PASS";
+    }
+
+    if (gConfig.debugOnFailure) {
+      // You've hit this line because you requested to break into the
+      // debugger upon a testcase failure on your test run.
+      debugger;
+    }
+  }
+}
+
+function testMessage(aName) {
+  this.msg = aName || "";
+  this.info = true;
+}
+
+// Need to be careful adding properties to this object, since its properties
+// cannot conflict with global variables used in tests.
+function testScope(aTester, aTest, expected) {
+  this.__tester = aTester;
+  this.__expected = expected;
+  this.__num_failed = 0;
+
+  var self = this;
+  this.ok = function test_ok(condition, name, diag, stack) {
+    if (self.__expected == 'fail') {
+        if (!condition) {
+          self.__num_failed++;
+          condition = true;
+        }
+    }
+
+    aTest.addResult(new testResult(condition, name, diag, false,
+                                   stack ? stack : Components.stack.caller));
+  };
+  this.is = function test_is(a, b, name) {
+    self.ok(a == b, name, "Got " + a + ", expected " + b, false,
+            Components.stack.caller);
+  };
+  this.isnot = function test_isnot(a, b, name) {
+    self.ok(a != b, name, "Didn't expect " + a + ", but got it", false,
+            Components.stack.caller);
+  };
+  this.todo = function test_todo(condition, name, diag, stack) {
+    aTest.addResult(new testResult(!condition, name, diag, true,
+                                   stack ? stack : Components.stack.caller));
+  };
+  this.todo_is = function test_todo_is(a, b, name) {
+    self.todo(a == b, name, "Got " + a + ", expected " + b,
+              Components.stack.caller);
+  };
+  this.todo_isnot = function test_todo_isnot(a, b, name) {
+    self.todo(a != b, name, "Didn't expect " + a + ", but got it",
+              Components.stack.caller);
+  };
+  this.info = function test_info(name) {
+    aTest.addResult(new testMessage(name));
+  };
+
+  this.executeSoon = function test_executeSoon(func) {
+    Services.tm.mainThread.dispatch({
+      run: function() {
+        func();
+      }
+    }, Ci.nsIThread.DISPATCH_NORMAL);
+  };
+
+  this.waitForExplicitFinish = function test_waitForExplicitFinish() {
+    self.__done = false;
+  };
+
+  this.waitForFocus = function test_waitForFocus(callback, targetWindow, expectBlankPage) {
+    self.SimpleTest.waitForFocus(callback, targetWindow, expectBlankPage);
+  };
+
+  this.waitForClipboard = function test_waitForClipboard(expected, setup, success, failure, flavor) {
+    self.SimpleTest.waitForClipboard(expected, setup, success, failure, flavor);
+  };
+
+  this.registerCleanupFunction = function test_registerCleanupFunction(aFunction) {
+    self.__cleanupFunctions.push(aFunction);
+  };
+
+  this.requestLongerTimeout = function test_requestLongerTimeout(aFactor) {
+    self.__timeoutFactor = aFactor;
+  };
+
+  this.copyToProfile = function test_copyToProfile(filename) {
+    self.SimpleTest.copyToProfile(filename);
+  };
+
+  this.expectUncaughtException = function test_expectUncaughtException(aExpecting) {
+    self.SimpleTest.expectUncaughtException(aExpecting);
+  };
+
+  this.ignoreAllUncaughtExceptions = function test_ignoreAllUncaughtExceptions(aIgnoring) {
+    self.SimpleTest.ignoreAllUncaughtExceptions(aIgnoring);
+  };
+
+  this.thisTestLeaksUncaughtRejectionsAndShouldBeFixed = function(...rejections) {
+    if (!aTester._toleratedUncaughtRejections) {
+      aTester._toleratedUncaughtRejections = [];
+    }
+    aTester._toleratedUncaughtRejections.push(...rejections);
+  };
+
+  this.expectAssertions = function test_expectAssertions(aMin, aMax) {
+    let min = aMin;
+    let max = aMax;
+    if (typeof(max) == "undefined") {
+      max = min;
+    }
+    if (typeof(min) != "number" || typeof(max) != "number" ||
+        min < 0 || max < min) {
+      throw "bad parameter to expectAssertions";
+    }
+    self.__expectedMinAsserts = min;
+    self.__expectedMaxAsserts = max;
+  };
+
+  this.setExpected = function test_setExpected() {
+    self.__expected = 'fail';
+  };
+
+  this.finish = function test_finish() {
+    self.__done = true;
+    if (self.__waitTimer) {
+      self.executeSoon(function() {
+        if (self.__done && self.__waitTimer) {
+          clearTimeout(self.__waitTimer);
+          self.__waitTimer = null;
+          self.__tester.nextTest();
+        }
+      });
+    }
+  };
+
+  this.requestCompleteLog = function test_requestCompleteLog() {
+    self.__tester.structuredLogger.deactivateBuffering();
+    self.registerCleanupFunction(function() {
+      self.__tester.structuredLogger.activateBuffering();
+    })
+  };
+}
+testScope.prototype = {
+  __done: true,
+  __tasks: null,
+  __waitTimer: null,
+  __cleanupFunctions: [],
+  __timeoutFactor: 1,
+  __expectedMinAsserts: 0,
+  __expectedMaxAsserts: 0,
+  __expected: 'pass',
+
+  EventUtils: {},
+  SimpleTest: {},
+  Task: null,
+  ContentTask: null,
+  BrowserTestUtils: null,
+  TestUtils: null,
+  ExtensionTestUtils: null,
+  Assert: null,
+
+  /**
+   * Add a test function which is a Task function.
+   *
+   * Task functions are functions fed into Task.jsm's Task.spawn(). They are
+   * generators that emit promises.
+   *
+   * If an exception is thrown, an assertion fails, or if a rejected
+   * promise is yielded, the test function aborts immediately and the test is
+   * reported as a failure. Execution continues with the next test function.
+   *
+   * To trigger premature (but successful) termination of the function, simply
+   * return or throw a Task.Result instance.
+   *
+   * Example usage:
+   *
+   * add_task(function test() {
+   *   let result = yield Promise.resolve(true);
+   *
+   *   ok(result);
+   *
+   *   let secondary = yield someFunctionThatReturnsAPromise(result);
+   *   is(secondary, "expected value");
+   * });
+   *
+   * add_task(function test_early_return() {
+   *   let result = yield somethingThatReturnsAPromise();
+   *
+   *   if (!result) {
+   *     // Test is ended immediately, with success.
+   *     return;
+   *   }
+   *
+   *   is(result, "foo");
+   * });
+   */
+  add_task: function(aFunction) {
+    if (!this.__tasks) {
+      this.waitForExplicitFinish();
+      this.__tasks = [];
+    }
+    this.__tasks.push(aFunction.bind(this));
+  },
+
+  destroy: function test_destroy() {
+    for (let prop in this)
+      delete this[prop];
+  }
+};