--- a/toolkit/components/url-classifier/nsUrlClassifierHashCompleter.js
+++ b/toolkit/components/url-classifier/nsUrlClassifierHashCompleter.js
@@ -39,16 +39,17 @@ function log(...stuff) {
 
   var d = new Date();
   let msg = "hashcompleter: " + d.toTimeString() + ": " + stuff.join(" ");
   dump(Services.urlFormatter.trimSensitiveURLs(msg) + "\n");
 }
 
 // Map the HTTP response code to a Telemetry bucket
 // https://developers.google.com/safe-browsing/developers_guide_v2?hl=en
+// eslint-disable-next-line complexity
 function httpStatusToBucket(httpStatus) {
   var statusBucket;
   switch (httpStatus) {
   case 100:
   case 101:
     // Unexpected 1xx return code
     statusBucket = 0;
     break;
@@ -542,17 +543,18 @@ HashCompleterRequest.prototype = {
   // Parses the response body and eventually adds items to the |response.matches| array
   // for elements of |this._requests|.
   handleResponse: function HCR_handleResponse() {
     if (this._response == "") {
       return;
     }
 
     if (this.isV4) {
-      return this.handleResponseV4();
+      this.handleResponseV4();
+      return;
     }
 
     let start = 0;
 
     let length = this._response.length;
     while (start != length) {
       start = this.handleTable(start);
     }
@@ -792,17 +794,17 @@ HashCompleterRequest.prototype = {
     }
   },
 
   observe: function HCR_observe(aSubject, aTopic, aData) {
     if (aTopic == "quit-application") {
       this._shuttingDown = true;
       if (this._channel) {
         this._channel.cancel(Cr.NS_ERROR_ABORT);
-        telemetryClockStart = 0;
+        this.telemetryClockStart = 0;
       }
 
       Services.obs.removeObserver(this, "quit-application");
     }
   },
 };
 
 // Converts a URL safe base64 string to a normal base64 string. Will not change

--- a/toolkit/components/url-classifier/nsUrlClassifierListManager.js
+++ b/toolkit/components/url-classifier/nsUrlClassifierListManager.js
@@ -96,17 +96,17 @@ PROT_ListManager.prototype.registerTable
 
   // Keep track of all of our update URLs.
   if (!this.needsUpdate_[updateUrl]) {
     this.needsUpdate_[updateUrl] = {};
 
     // Using the V4 backoff algorithm for both V2 and V4. See bug 1273398.
     this.requestBackoffs_[updateUrl] = new RequestBackoffV4(
                                             4 /* num requests */,
-                                   60*60*1000 /* request time, 60 min */);
+                               60 * 60 * 1000 /* request time, 60 min */);
   }
   this.needsUpdate_[updateUrl][tableName] = false;
 
   return true;
 }
 
 /**
  * Delete all of our data tables which seem to leak otherwise.
@@ -255,21 +255,17 @@ PROT_ListManager.prototype.kickoffUpdate
       log("Initializing update checker for " + updateUrl
           + " provided by " + provider);
 
       // Use the initialUpdateDelay + fuzz unless we had previous updates
       // and the server told us when to try again.
       let updateDelay = initialUpdateDelay;
       let nextUpdatePref = "browser.safebrowsing.provider." + provider +
                            ".nextupdatetime";
-      let nextUpdate;
-      try {
-        nextUpdate = Services.prefs.getCharPref(nextUpdatePref);
-      } catch (ex) {
-      }
+      let nextUpdate = Services.prefs.getCharPref(nextUpdatePref, "");
 
       if (nextUpdate) {
         updateDelay = Math.min(maxDelayMs, Math.max(0, nextUpdate - Date.now()));
         log("Next update at " + nextUpdate);
       }
       log("Next update " + updateDelay / 60000 + "min from now");
 
       this.setUpdateCheckTimer(updateUrl, updateDelay);
@@ -634,16 +630,17 @@ PROT_ListManager.prototype.QueryInterfac
   throw Components.results.NS_ERROR_NO_INTERFACE;
 }
 
 var modScope = this;
 function Init() {
   // Pull the library in.
   var jslib = Cc["@mozilla.org/url-classifier/jslib;1"]
               .getService().wrappedJSObject;
+  /* global BindToObject, RequestBackoffV4 */
   modScope.BindToObject = jslib.BindToObject;
   modScope.RequestBackoffV4 = jslib.RequestBackoffV4;
 
   // We only need to call Init once.
   modScope.Init = function() {};
 }
 
 function RegistrationData() {

--- a/toolkit/components/url-classifier/tests/UrlClassifierTestUtils.jsm
+++ b/toolkit/components/url-classifier/tests/UrlClassifierTestUtils.jsm
@@ -46,17 +46,17 @@ this.UrlClassifierTestUtils = {
         name: WHITELIST_TABLE_NAME,
         update: whitelistUpdate
       }
     ];
 
     let tableIndex = 0
     let doOneUpdate = () => {
       if (tableIndex == tables.length) {
-        return;
+        return Promise.resolve();
       }
       return this.useTestDatabase(tables[tableIndex])
         .then(() => {
           tableIndex++;
           return doOneUpdate();
         }, aErrMsg => {
           dump("Rejected: " + aErrMsg + ". Retry later.\n");
           return new Promise(resolve => {

new file mode 100644
--- /dev/null
+++ b/toolkit/components/url-classifier/tests/browser/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "plugin:mozilla/browser-test"
+  ]
+};

--- a/toolkit/components/url-classifier/tests/browser/browser_flashblock_off_with_always_activate.js
+++ b/toolkit/components/url-classifier/tests/browser/browser_flashblock_off_with_always_activate.js
@@ -3,19 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 requestLongerTimeout(3);
 
 var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
 
 const scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                      getService(Ci.mozIJSSubScriptLoader);
+/* import-globals-from classifierHelper.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierHelper.js",
   this);
+  /* import-globals-from classifierTester.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierTester.js",
   this);
 
 add_task(async function checkFlashBlockLists() {
   classifierTester.setPrefs({
     setDBs: true,
     flashBlockEnable: false,

--- a/toolkit/components/url-classifier/tests/browser/browser_flashblock_off_with_ask_to_activate.js
+++ b/toolkit/components/url-classifier/tests/browser/browser_flashblock_off_with_ask_to_activate.js
@@ -3,19 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 requestLongerTimeout(3);
 
 var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
 
 const scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                      getService(Ci.mozIJSSubScriptLoader);
+/* import-globals-from classifierHelper.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierHelper.js",
   this);
+  /* import-globals-from classifierTester.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierTester.js",
   this);
 
 add_task(async function checkFlashBlockLists() {
   classifierTester.setPrefs({
     setDBs: true,
     flashBlockEnable: false,

--- a/toolkit/components/url-classifier/tests/browser/browser_flashblock_off_with_never_activate.js
+++ b/toolkit/components/url-classifier/tests/browser/browser_flashblock_off_with_never_activate.js
@@ -3,19 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 requestLongerTimeout(3);
 
 var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
 
 const scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                      getService(Ci.mozIJSSubScriptLoader);
+/* import-globals-from classifierHelper.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierHelper.js",
   this);
+  /* import-globals-from classifierTester.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierTester.js",
   this);
 
 add_task(async function checkFlashBlockLists() {
   classifierTester.setPrefs({
     setDBs: true,
     flashBlockEnable: false,

--- a/toolkit/components/url-classifier/tests/browser/browser_flashblock_on_with_always_activate.js
+++ b/toolkit/components/url-classifier/tests/browser/browser_flashblock_on_with_always_activate.js
@@ -3,19 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 requestLongerTimeout(3);
 
 var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
 
 const scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                      getService(Ci.mozIJSSubScriptLoader);
+/* import-globals-from classifierHelper.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierHelper.js",
   this);
+  /* import-globals-from classifierTester.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierTester.js",
   this);
 
 add_task(async function checkFlashBlockLists() {
   classifierTester.setPrefs({
     setDBs: true,
     flashBlockEnable: true,

--- a/toolkit/components/url-classifier/tests/browser/browser_flashblock_on_with_ask_to_activate.js
+++ b/toolkit/components/url-classifier/tests/browser/browser_flashblock_on_with_ask_to_activate.js
@@ -3,19 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 requestLongerTimeout(3);
 
 var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
 
 const scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                      getService(Ci.mozIJSSubScriptLoader);
+/* import-globals-from classifierHelper.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierHelper.js",
   this);
+  /* import-globals-from classifierTester.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierTester.js",
   this);
 
 add_task(async function checkFlashBlockLists() {
   classifierTester.setPrefs({
     setDBs: true,
     flashBlockEnable: true,

--- a/toolkit/components/url-classifier/tests/browser/browser_flashblock_on_with_never_activate.js
+++ b/toolkit/components/url-classifier/tests/browser/browser_flashblock_on_with_never_activate.js
@@ -3,19 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 requestLongerTimeout(3);
 
 var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
 
 const scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                      getService(Ci.mozIJSSubScriptLoader);
+/* import-globals-from classifierHelper.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierHelper.js",
   this);
+  /* import-globals-from classifierTester.js */
 scriptLoader.loadSubScript(
   "chrome://mochitests/content/browser/toolkit/components/url-classifier/tests/browser/classifierTester.js",
   this);
 
 add_task(async function checkFlashBlockLists() {
   classifierTester.setPrefs({
     setDBs: true,
     flashBlockEnable: true,

--- a/toolkit/components/url-classifier/tests/mochitest/classifiedAnnotatedFrame.html
+++ b/toolkit/components/url-classifier/tests/mochitest/classifiedAnnotatedFrame.html
@@ -58,35 +58,35 @@ function checkLoads() {
     "Should identify all tracking elements");
 
   var blockedTrackingNodes = window.document.blockedTrackingNodes;
 
   // Make sure that every node in blockedTrackingNodes exists in the tree
   // (that may not always be the case but do not expect any nodes to disappear
   // from the tree here)
   var allNodeMatch = true;
-  for (var i = 0; i < blockedTrackingNodes.length; i++) {
-    var nodeMatch = false;
-    for (var j = 0; j < badids.length && !nodeMatch; j++) {
+  for (let i = 0; i < blockedTrackingNodes.length; i++) {
+    let nodeMatch = false;
+    for (let j = 0; j < badids.length && !nodeMatch; j++) {
       nodeMatch = nodeMatch ||
         (blockedTrackingNodes[i] == document.getElementById(badids[j]));
     }
 
     allNodeMatch = allNodeMatch && nodeMatch;
   }
   window.parent.ok(allNodeMatch,
     "All annotated nodes are expected in the tree");
 
   // Make sure that every node with a badid (see badids) is found in the
   // blockedTrackingNodes. This tells us if we are neglecting to annotate
   // some nodes
   allNodeMatch = true;
-  for (var j = 0; j < badids.length; j++) {
-    var nodeMatch = false;
-    for (var i = 0; i < blockedTrackingNodes.length && !nodeMatch; i++) {
+  for (let j = 0; j < badids.length; j++) {
+    let nodeMatch = false;
+    for (let i = 0; i < blockedTrackingNodes.length && !nodeMatch; i++) {
       nodeMatch = nodeMatch ||
         (blockedTrackingNodes[i] == document.getElementById(badids[j]));
     }
 
     if (!nodeMatch) {
       console.log(badids[j] + " was not found in blockedTrackingNodes");
     }
     allNodeMatch = allNodeMatch && nodeMatch;

--- a/toolkit/components/url-classifier/tests/mochitest/classifierCommon.js
+++ b/toolkit/components/url-classifier/tests/mochitest/classifierCommon.js
@@ -1,11 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 
+/* eslint-env mozilla/frame-script */
+
 const { classes: Cc, interfaces: Ci, results: Cr } = Components;
 
 var dbService = Cc["@mozilla.org/url-classifier/dbservice;1"]
                 .getService(Ci.nsIUrlClassifierDBService);
 
 var timer;
 function setTimeout(callback, delay) {
   timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
@@ -28,19 +30,16 @@ function doUpdate(update) {
     updateError(errorCode) {
       sendAsyncMessage("updateError", errorCode);
     },
     updateSuccess(requestedTimeout) {
       sendAsyncMessage("updateSuccess");
     }
   };
 
-  let dbService = Cc["@mozilla.org/url-classifier/dbservice;1"]
-                  .getService(Ci.nsIUrlClassifierDBService);
-
   try {
     dbService.beginUpdate(listener, "test-malware-simple,test-unwanted-simple", "");
     dbService.beginStream("", "");
     dbService.updateStream(update);
     dbService.finishStream();
     dbService.finishUpdate();
   } catch (e) {
     // beginUpdate may fail if there's an existing update in progress

--- a/toolkit/components/url-classifier/tests/mochitest/classifierFrame.html
+++ b/toolkit/components/url-classifier/tests/mochitest/classifierFrame.html
@@ -31,16 +31,17 @@ function checkLoads() {
     window.parent.loadTestFrame();
     return;
   }
 
   let dwu = window.parent.SpecialPowers.getDOMWindowUtils(window);
   let timer1 = window.setTimeout(function() {}, 0);
   window.parent.ok(!dwu.isTimeoutTracking(timer1),
                    "Timeout set from main script should not be considered as tracking");
+  /* global getTrackerTimeout */
   let timer2 = getTrackerTimeout();
   window.parent.ok(dwu.isTimeoutTracking(timer2),
                    "Timeout set from included script should be considered as tracking");
   window.clearTimeout(timer1);
   window.clearTimeout(timer2);
 
   // End (parent) test.
   window.parent.SimpleTest.finish();

--- a/toolkit/components/url-classifier/tests/mochitest/classifierHelper.js
+++ b/toolkit/components/url-classifier/tests/mochitest/classifierHelper.js
@@ -1,17 +1,15 @@
 if (typeof(classifierHelper) == "undefined") {
   var classifierHelper = {};
 }
 
 const CLASSIFIER_COMMON_URL = SimpleTest.getTestFileURL("classifierCommon.js");
 var gScript = SpecialPowers.loadChromeScript(CLASSIFIER_COMMON_URL);
 
-const HASHLEN = 32;
-
 const PREFS = {
   PROVIDER_LISTS: "browser.safebrowsing.provider.mozilla.lists",
   DISALLOW_COMPLETIONS: "urlclassifier.disallow_completions",
   PROVIDER_GETHASHURL: "browser.safebrowsing.provider.mozilla.gethashURL"
 };
 
 classifierHelper._curAddChunkNum = 1;
 

--- a/toolkit/components/url-classifier/tests/mochitest/cleanWorker.js
+++ b/toolkit/components/url-classifier/tests/mochitest/cleanWorker.js
@@ -1,8 +1,10 @@
+/* eslint-env worker */
+
 onmessage = function() {
   try {
     importScripts("evilWorker.js");
   } catch (ex) {
     postMessage("success");
     return;
   }
 

--- a/toolkit/components/url-classifier/tests/mochitest/evil.js
+++ b/toolkit/components/url-classifier/tests/mochitest/evil.js
@@ -1,1 +1,3 @@
+/* global scriptItem:true */
+
 scriptItem = "loaded malware javascript!";

--- a/toolkit/components/url-classifier/tests/mochitest/evilWorker.js
+++ b/toolkit/components/url-classifier/tests/mochitest/evilWorker.js
@@ -1,3 +1,5 @@
+/* eslint-env worker */
+
 onmessage = function() {
   postMessage("loaded bad file");
 }

--- a/toolkit/components/url-classifier/tests/mochitest/gethashFrame.html
+++ b/toolkit/components/url-classifier/tests/mochitest/gethashFrame.html
@@ -4,19 +4,19 @@
 
 <script type="text/javascript">
 
 var scriptItem = "untouched";
 
 function checkLoads() {
 
   var title = document.getElementById("title");
-  title.innerHTML = window.parent.shouldLoad ?
-                    "The following should be hidden:" :
-                    "The following should not be hidden:"
+  title.textContent = window.parent.shouldLoad ?
+                      "The following should be hidden:" :
+                      "The following should not be hidden:"
 
   if (window.parent.shouldLoad) {
     window.parent.is(scriptItem, "loaded malware javascript!", "Should load bad javascript");
   } else {
     window.parent.is(scriptItem, "untouched", "Should not load bad javascript");
   }
 
   var elt = document.getElementById("styleImport");

--- a/toolkit/components/url-classifier/tests/mochitest/good.js
+++ b/toolkit/components/url-classifier/tests/mochitest/good.js
@@ -1,1 +1,3 @@
+/* global scriptItem:true */
+
 scriptItem = "loaded whitelisted javascript!";

--- a/toolkit/components/url-classifier/tests/mochitest/head.js
+++ b/toolkit/components/url-classifier/tests/mochitest/head.js
@@ -12,22 +12,22 @@ function addCompletionToServer(list, url
         resolve();
       }
     };
     xhr.send();
   });
 }
 
 function hash(str) {
-  function bytesFromString(str) {
+  function bytesFromString(str1) {
     var converter =
       SpecialPowers.Cc["@mozilla.org/intl/scriptableunicodeconverter"]
                        .createInstance(SpecialPowers.Ci.nsIScriptableUnicodeConverter);
     converter.charset = "UTF-8";
-    return converter.convertToByteArray(str);
+    return converter.convertToByteArray(str1);
   }
 
   var hasher = SpecialPowers.Cc["@mozilla.org/security/hash;1"]
                                .createInstance(SpecialPowers.Ci.nsICryptoHash);
 
   var data = bytesFromString(str);
   hasher.init(hasher.SHA256);
   hasher.update(data, data.length);

--- a/toolkit/components/url-classifier/tests/mochitest/test_advisory_link.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_advisory_link.html
@@ -14,17 +14,19 @@
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script class="testbody" type="text/javascript">
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://testing-common/TestUtils.jsm");
 Cu.import("resource://testing-common/BrowserTestUtils.jsm");
+/* import-globals-from classifierHelper.js */
 
 var mainWindow = window.QueryInterface(Ci.nsIInterfaceRequestor)
                     .getInterface(Ci.nsIWebNavigation)
                     .QueryInterface(Ci.nsIDocShellTreeItem)
                     .rootTreeItem
                     .QueryInterface(Ci.nsIInterfaceRequestor)
                     .getInterface(Ci.nsIDOMWindow);
 
@@ -42,25 +44,16 @@ var testDatas = [
   { url: "phishing.example.com/test.html",
     list: "mochi2-phish-simple",
     provider: "google4",
   },
 ];
 
 let pushPrefs = (...p) => SpecialPowers.pushPrefEnv({set: p});
 
-function whenDelayedStartupFinished(aWindow, aCallback) {
-  Services.obs.addObserver(function observer(aSubject, aTopic) {
-    if (aWindow == aSubject) {
-      Services.obs.removeObserver(observer, aTopic);
-      setTimeout(aCallback, 0);
-    }
-  }, "browser-delayed-startup-finished");
-}
-
 function addUrlToDB(list, url) {
   let testData = [{ db: list, url}];
 
   return classifierHelper.addUrlToDB(testData)
     .catch(function(err) {
       ok(false, "Couldn't update classifier. Error code: " + err);
       // Abort test.
       SimpleTest.finish();
@@ -81,17 +74,18 @@ function setupTestData(data) {
   return Promise.all(promises);
 }
 
 function testOnWindow(aTestData) {
   return new Promise(resolve => {
     let win = mainWindow.OpenBrowserWindow();
 
     (async function() {
-      await new Promise(resolve => whenDelayedStartupFinished(win, resolve));
+      await TestUtils.topicObserved("browser-delayed-startup-finished",
+                                    subject => subject == win);
 
       let browser = win.gBrowser.selectedBrowser;
       await BrowserTestUtils.loadURI(browser, aTestData.url);
       await BrowserTestUtils.waitForContentEvent(browser, "DOMContentLoaded")
 
       let doc = win.gBrowser.contentDocument;
       let advisoryEl = doc.getElementById("advisory_provider");
       if (aTestData.provider != "google" && aTestData.provider != "google4") {

--- a/toolkit/components/url-classifier/tests/mochitest/test_bug1254766.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_bug1254766.html
@@ -10,16 +10,17 @@
 <body>
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script src="head.js"></script>
 <script class="testbody" type="text/javascript">
+/* import-globals-from classifierHelper.js */
 
 const MALWARE_LIST = "test-malware-simple";
 const MALWARE_HOST1 = "malware.example.com/";
 const MALWARE_HOST2 = "test1.example.com/";
 
 const UNWANTED_LIST = "test-unwanted-simple";
 const UNWANTED_HOST1 = "unwanted.example.com/";
 const UNWANTED_HOST2 = "test2.example.com/";
@@ -77,17 +78,17 @@ function setup() {
     addCompletionToServer(UNWANTED_LIST, UNWANTED_HOST2, GETHASH_URL),
   ]);
 }
 
 // Reset function in helper try to simulate the behavior we restart firefox
 function reset() {
   return classifierHelper.resetDatabase()
     .catch(err => {
-      ok(false, "Couldn't update classifier. Error code: " + errorCode);
+      ok(false, "Couldn't update classifier. Error code: " + err);
       // Abort test.
       SimpleTest.finish();
     });
 }
 
 function updateUnusedUrl() {
   var testData  = [
     { url: UNUSED_MALWARE_HOST,  db: MALWARE_LIST },
@@ -116,17 +117,17 @@ function update(prefix = false) {
     { url: MALWARE_HOST1,  db: MALWARE_LIST,  len: length },
     { url: MALWARE_HOST2,  db: MALWARE_LIST,  len: length },
     { url: UNWANTED_HOST1, db: UNWANTED_LIST, len: length },
     { url: UNWANTED_HOST2, db: UNWANTED_LIST, len: length }
   ];
 
   return classifierHelper.addUrlToDB(testData)
     .catch(err => {
-      ok(false, "Couldn't update classifier. Error code: " + errorCode);
+      ok(false, "Couldn't update classifier. Error code: " + err);
       // Abort test.
       SimpleTest.finish();
     });
 }
 
 // This testcase is to make sure gethash works:
 // 1. Add prefixes to DB.
 // 2. Load test frame contains malware & unwanted url, those urls should be blocked.

--- a/toolkit/components/url-classifier/tests/mochitest/test_cachemiss.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_cachemiss.html
@@ -10,16 +10,17 @@
 <body>
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script src="head.js"></script>
 <script class="testbody" type="text/javascript">
+/* import-globals-from classifierHelper.js */
 
 const MALWARE_LIST = "test-malware-simple";
 const MALWARE_HOST = "malware.example.com/";
 
 const UNWANTED_LIST = "test-unwanted-simple";
 const UNWANTED_HOST = "unwanted.example.com/";
 
 const GETHASH_URL = "http://mochi.test:8888/tests/toolkit/components/url-classifier/tests/mochitest/cache.sjs";

--- a/toolkit/components/url-classifier/tests/mochitest/test_classifier.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_classifier.html
@@ -8,16 +8,17 @@
 </head>
 
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script class="testbody" type="text/javascript">
+/* import-globals-from classifierHelper.js */
 
 var firstLoad = true;
 
 // Add some URLs to the malware database.
 // Note that we intentionally don't touch test-phish-simple, and will
 // use the URL registered by addMozEntries().  Otherwise, classifierHelper.resetDatabase()
 // will reset this table, and waitForInit() can't find the known phishing
 // URL in test-phish-simple, breaking the tests following this one.
@@ -148,23 +149,23 @@ function testService() {
         return;
       }
       let test = testURLs.shift();
       let tables = "test-malware-simple,test-unwanted-simple,test-phish-simple,test-track-simple,test-block-simple,test-harmful-simple";
       let uri = ios.newURI(test.url);
       let prin = ssm.createCodebasePrincipal(uri, {});
       is(service.classifyLocal(uri, tables), test.table,
          `Successful synchronous classification of ${test.url} with TP=${test.trackingProtection}`);
-      let result = SpecialPowers.doUrlClassify(prin, null, test.trackingProtection, function(errorCode) {
+      SpecialPowers.doUrlClassify(prin, null, test.trackingProtection, function(errorCode) {
         is(errorCode, test.result,
            `Successful asynchronous classification of ${test.url} with TP=${test.trackingProtection}`);
 
         // Same as classifyLocal except for the 'async' call.
-        SpecialPowers.doUrlClassifyLocal(uri, tables, function(errorCode, tables) {
-          is(tables, test.table,
+        SpecialPowers.doUrlClassifyLocal(uri, tables, function(errorCode1, tables1) {
+          is(tables1, test.table,
              `Successful asynchronous local classification of ${test.url} with TP=${test.trackingProtection}`);
           runNextTest();
         });
 
       });
     }
     runNextTest(resolve);
   });

--- a/toolkit/components/url-classifier/tests/mochitest/test_classifier_match.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_classifier_match.html
@@ -9,16 +9,17 @@
 
 <body>
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script class="testbody" type="application/javascript">
+/* import-globals-from classifierHelper.js */
 var Cc = SpecialPowers.Cc;
 var Ci = SpecialPowers.Ci;
 var Cr = SpecialPowers.Cr;
 
 var inputDatas = [
   { url: "malware.example.com/",
     db: "mochi-block-simple",
   },
@@ -43,22 +44,22 @@ var inputDatas = [
   },
   { url: "malware3.example.com/",
     db: "mochim3-malware-simple",
     provider: "mozilla"
   },
 ];
 
 function hashPrefix(str) {
-  function bytesFromString(str) {
+  function bytesFromString(str1) {
     let converter =
       Cc["@mozilla.org/intl/scriptableunicodeconverter"]
                        .createInstance(Ci.nsIScriptableUnicodeConverter);
     converter.charset = "UTF-8";
-    return converter.convertToByteArray(str);
+    return converter.convertToByteArray(str1);
   }
 
   let hasher = Cc["@mozilla.org/security/hash;1"]
                                .createInstance(Ci.nsICryptoHash);
 
   let data = bytesFromString(str);
   hasher.init(hasher.SHA256);
   hasher.update(data, data.length);

--- a/toolkit/components/url-classifier/tests/mochitest/test_classifier_worker.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_classifier_worker.html
@@ -8,16 +8,17 @@
 </head>
 
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script class="testbody" type="text/javascript">
+/* import-globals-from classifierHelper.js */
 
 // Add some URLs to the malware database.
 var testData = [
   { url: "example.com/tests/toolkit/components/url-classifier/tests/mochitest/evilWorker.js",
     db: "test-malware-simple"
   },
   { url: "example.com/tests/toolkit/components/url-classifier/tests/mochitest/unwantedWorker.js",
     db: "test-unwanted-simple"

--- a/toolkit/components/url-classifier/tests/mochitest/test_classify_ping.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_classify_ping.html
@@ -10,16 +10,17 @@
 <body>
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script class="testbody" type="text/javascript">
   SimpleTest.requestFlakyTimeout("Delay to make sure ping is made prior than XHR");
+  /* import-globals-from classifierHelper.js */
 
   const timeout = 200;
   const host_nottrack = "http://not-tracking.example.com/";
   const host_track = "http://trackertest.org/";
   const path_ping = "tests/toolkit/components/url-classifier/tests/mochitest/ping.sjs";
   const TP_ENABLE_PREF = "privacy.trackingprotection.enabled";
   const RETRY_TIMEOUT_MS = 200;
 
@@ -84,20 +85,20 @@
     document.body.removeChild(elm);
   }
 
   function isPingedWithRetry(id, expected, msg, callback, retryCnt) {
     var url = "http://mochi.test:8888/" + path_ping;
     var xhr = new XMLHttpRequest();
     xhr.open("GET", url + "?id=" + id);
     xhr.onload = function() {
-      var isPinged = xhr.response === "ping";
-      let success = isPinged === expected;
+      let pinged = xhr.response === "ping";
+      let success = pinged === expected;
       if (success || 0 === retryCnt) {
-        is(expected, isPinged, msg);
+        is(expected, pinged, msg);
         callback();
         return;
       }
       // Retry on failure.
       setTimeout(() => {
         isPingedWithRetry(id, expected, msg, callback, retryCnt - 1);
       }, RETRY_TIMEOUT_MS);
     };

--- a/toolkit/components/url-classifier/tests/mochitest/test_classify_track.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_classify_track.html
@@ -13,16 +13,17 @@
 </div>
 <pre id="test">
 
 <script class="testbody" type="text/javascript">
   const PREF = "browser.safebrowsing.malware.enabled";
   const track_path = "tests/toolkit/components/url-classifier/tests/mochitest/basic.vtt";
   const malware_url = "http://malware.example.com/" + track_path;
   const validtrack_url = "http://mochi.test:8888/" + track_path;
+  /* import-globals-from classifierHelper.js */
 
   var video = document.createElement("video");
   video.src = "seek.webm";
   video.crossOrigin = "anonymous";
 
   document.body.appendChild(video);
 
   function testValidTrack() {

--- a/toolkit/components/url-classifier/tests/mochitest/test_donottrack.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_donottrack.html
@@ -69,38 +69,31 @@ const tests = [
 const DNT_PREF = "privacy.donottrackheader.enabled";
 const TP_PREF = "privacy.trackingprotection.enabled";
 const TP_PB_PREF = "privacy.trackingprotection.pbmode.enabled";
 
 const contentPage =
   "http://mochi.test:8888/tests/toolkit/components/url-classifier/tests/mochitest/dnt.html";
 
 Components.utils.import("resource://gre/modules/Services.jsm");
-
-function whenDelayedStartupFinished(aWindow, aCallback) {
-  Services.obs.addObserver(function observer(aSubject, aTopic) {
-    if (aWindow == aSubject) {
-      Services.obs.removeObserver(observer, aTopic);
-      setTimeout(aCallback, 0);
-    }
-  }, "browser-delayed-startup-finished");
-}
+Components.utils.import("resource://testing-common/TestUtils.jsm");
 
 function executeTest(test) {
   SpecialPowers.pushPrefEnv({"set": [
    [DNT_PREF, test.setting.dntPref],
    [TP_PREF, test.setting.tpPref],
    [TP_PB_PREF, test.setting.tppbPref]
   ]});
 
   var win = mainWindow.OpenBrowserWindow({private: test.setting.pbMode});
 
   return new Promise(function(resolve, reject) {
     win.addEventListener("load", function() {
-      whenDelayedStartupFinished(win, function() {
+      TestUtils.topicObserved("browser-delayed-startup-finished",
+                              subject => subject == win).then(() => {
         win.addEventListener("DOMContentLoaded", function onInnerLoad() {
           if (win.content.location.href != contentPage) {
             win.gBrowser.loadURI(contentPage);
             return;
           }
 
           win.removeEventListener("DOMContentLoaded", onInnerLoad, true);
 

--- a/toolkit/components/url-classifier/tests/mochitest/test_gethash.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_gethash.html
@@ -12,16 +12,17 @@
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 <iframe id="testFrame1" onload=""></iframe>
 <iframe id="testFrame2" onload=""></iframe>
 
 <script src="head.js"></script>
 <script class="testbody" type="text/javascript">
+/* import-globals-from classifierHelper.js */
 
 const MALWARE_LIST = "test-malware-simple";
 const MALWARE_HOST = "malware.example.com/";
 
 const UNWANTED_LIST = "test-unwanted-simple";
 const UNWANTED_HOST = "unwanted.example.com/";
 
 const GETHASH_URL = "http://mochi.test:8888/tests/toolkit/components/url-classifier/tests/mochitest/gethash.sjs";

--- a/toolkit/components/url-classifier/tests/mochitest/test_privatebrowsing_trackingprotection.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_privatebrowsing_trackingprotection.html
@@ -24,30 +24,23 @@ var mainWindow = window.QueryInterface(C
                     .QueryInterface(Ci.nsIDocShellTreeItem)
                     .rootTreeItem
                     .QueryInterface(Ci.nsIInterfaceRequestor)
                     .getInterface(Ci.nsIDOMWindow);
 var contentPage = "http://www.itisatrap.org/tests/toolkit/components/url-classifier/tests/mochitest/classifiedAnnotatedPBFrame.html";
 
 Components.utils.import("resource://gre/modules/Services.jsm");
 Components.utils.import("resource://testing-common/UrlClassifierTestUtils.jsm");
-
-function whenDelayedStartupFinished(aWindow, aCallback) {
-  Services.obs.addObserver(function observer(aSubject, aTopic) {
-    if (aWindow == aSubject) {
-      Services.obs.removeObserver(observer, aTopic);
-      setTimeout(aCallback, 0);
-    }
-  }, "browser-delayed-startup-finished");
-}
+Components.utils.import("resource://testing-common/TestUtils.jsm");
 
 function testOnWindow(aPrivate, aCallback) {
   var win = mainWindow.OpenBrowserWindow({private: aPrivate});
   win.addEventListener("load", function() {
-    whenDelayedStartupFinished(win, function() {
+    TestUtils.topicObserved("browser-delayed-startup-finished",
+                                  subject => subject == win).then(() => {
       win.addEventListener("DOMContentLoaded", function onInnerLoad() {
         if (win.content.location.href != contentPage) {
           win.gBrowser.loadURI(contentPage);
           return;
         }
         win.removeEventListener("DOMContentLoaded", onInnerLoad, true);
 
         win.content.addEventListener("load", function innerLoad2() {
@@ -79,34 +72,34 @@ function checkLoads(aWindow, aBlocked) {
   is(win.document.blockedTrackingNodeCount, aBlocked ? badids.length : 0, "Should identify all tracking elements");
 
   var blockedTrackingNodes = win.document.blockedTrackingNodes;
 
   // Make sure that every node in blockedTrackingNodes exists in the tree
   // (that may not always be the case but do not expect any nodes to disappear
   // from the tree here)
   var allNodeMatch = true;
-  for (var i = 0; i < blockedTrackingNodes.length; i++) {
-    var nodeMatch = false;
-    for (var j = 0; j < badids.length && !nodeMatch; j++) {
+  for (let i = 0; i < blockedTrackingNodes.length; i++) {
+    let nodeMatch = false;
+    for (let j = 0; j < badids.length && !nodeMatch; j++) {
       nodeMatch = nodeMatch ||
         (blockedTrackingNodes[i] == win.document.getElementById(badids[j]));
     }
 
     allNodeMatch = allNodeMatch && nodeMatch;
   }
   is(allNodeMatch, true, "All annotated nodes are expected in the tree");
 
   // Make sure that every node with a badid (see badids) is found in the
   // blockedTrackingNodes. This tells us if we are neglecting to annotate
   // some nodes
   allNodeMatch = true;
-  for (var j = 0; j < badids.length; j++) {
-    var nodeMatch = false;
-    for (var i = 0; i < blockedTrackingNodes.length && !nodeMatch; i++) {
+  for (let j = 0; j < badids.length; j++) {
+    let nodeMatch = false;
+    for (let i = 0; i < blockedTrackingNodes.length && !nodeMatch; i++) {
       nodeMatch = nodeMatch ||
         (blockedTrackingNodes[i] == win.document.getElementById(badids[j]));
     }
 
     allNodeMatch = allNodeMatch && nodeMatch;
   }
   is(allNodeMatch, aBlocked, "All tracking nodes are expected to be annotated as such");
 }
@@ -122,25 +115,25 @@ function test() {
   SimpleTest.registerCleanupFunction(UrlClassifierTestUtils.cleanupTestTrackers);
   UrlClassifierTestUtils.addTestTrackers().then(() => {
     // Normal mode, with the pref (trackers should be loaded)
     testOnWindow(false, function(aWindow) {
       checkLoads(aWindow, false);
       aWindow.close();
 
       // Private Browsing, with the pref (trackers should be blocked)
-      testOnWindow(true, function(aWindow) {
-        checkLoads(aWindow, true);
-        aWindow.close();
+      testOnWindow(true, function(aWindow1) {
+        checkLoads(aWindow1, true);
+        aWindow1.close();
 
         // Private Browsing, without the pref (trackers should be loaded)
         SpecialPowers.setBoolPref("privacy.trackingprotection.pbmode.enabled", false);
-        testOnWindow(true, function(aWindow) {
-          checkLoads(aWindow, false);
-          aWindow.close();
+        testOnWindow(true, function(aWindow2) {
+          checkLoads(aWindow2, false);
+          aWindow2.close();
           SimpleTest.finish();
         });
       });
     });
   });
 }
 
 SimpleTest.waitForExplicitFinish();

--- a/toolkit/components/url-classifier/tests/mochitest/test_reporturl.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_reporturl.html
@@ -11,22 +11,24 @@
 
 <body>
 <p id="display"></p>
 <div id="content" style="display: none">
 </div>
 <pre id="test">
 
 <script class="testbody" type="text/javascript">
+/* import-globals-from classifierHelper.js */
 
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://testing-common/BrowserTestUtils.jsm");
 Cu.import("resource://testing-common/ContentTask.jsm");
+Cu.import("resource://testing-common/TestUtils.jsm");
 
 var mainWindow = window.QueryInterface(Ci.nsIInterfaceRequestor)
                     .getInterface(Ci.nsIWebNavigation)
                     .QueryInterface(Ci.nsIDocShellTreeItem)
                     .rootTreeItem
                     .QueryInterface(Ci.nsIInterfaceRequestor)
                     .getInterface(Ci.nsIDOMWindow);
 const SJS = "mochi.test:8888/chrome/toolkit/components/url-classifier/tests/mochitest/report.sjs";
@@ -60,31 +62,23 @@ function setupTestData(data) {
   let activeTable = SpecialPowers.getCharPref(activeTablePref);
       activeTable += "," + data.list;
   promises.push(pushPrefs([activeTablePref, activeTable]));
 
   promises.push(addUrlToDB(data.list, data.testUrl));
   return Promise.all(promises);
 }
 
-function whenDelayedStartupFinished(aWindow, aCallback) {
-  Services.obs.addObserver(function observer(aSubject, aTopic) {
-    if (aWindow == aSubject) {
-      Services.obs.removeObserver(observer, aTopic);
-      setTimeout(aCallback, 0);
-    }
-  }, "browser-delayed-startup-finished");
-}
-
 function testOnWindow(aTestData, aCallback, aTestCreater) {
   return new Promise(resolve => {
     let win = mainWindow.OpenBrowserWindow();
 
     (async function() {
-      await new Promise(resolve => whenDelayedStartupFinished(win, resolve));
+      await TestUtils.topicObserved("browser-delayed-startup-finished",
+                                    subject => subject == win);
 
       let browser = win.gBrowser.selectedBrowser;
       aTestCreater(win, browser, aTestData.topUrl, aTestData.testUrl);
 
       let notification = await BrowserTestUtils.waitForNotificationBar(win.gBrowser, browser, "blocked-badware-page");
       ok(notification, "Notification box should be displayed");
 
       let buttons = notification.getElementsByTagName("button");
@@ -108,25 +102,25 @@ function testOnWindow(aTestData, aCallba
   });
 }
 
 var createBlockedIframe = function(aWindow, aBrowser, aTopUrl, aUrl) {
   (async function() {
     await BrowserTestUtils.loadURI(aBrowser, aTopUrl);
     await BrowserTestUtils.browserLoaded(aBrowser);
 
-    await ContentTask.spawn(aBrowser, aUrl, async function(aUrl) {
+    await ContentTask.spawn(aBrowser, aUrl, async function(url) {
       return new Promise(resolve => {
         let listener = e => {
           removeEventListener("AboutBlockedLoaded", listener, false, true);
           resolve();
         };
         addEventListener("AboutBlockedLoaded", listener, false, true);
         let frame = content.document.getElementById("phishingFrame");
-        frame.setAttribute("src", "http://" + aUrl);
+        frame.setAttribute("src", "http://" + url);
       });
     });
 
     let doc = aWindow.gBrowser.contentDocument.getElementsByTagName("iframe")[0].contentDocument;
     let ignoreButton = doc.getElementById("ignoreWarningButton");
     ok(ignoreButton, "ignoreWarningButton should exist");
     ignoreButton.click();
   })();

--- a/toolkit/components/url-classifier/tests/mochitest/test_safebrowsing_bug1272239.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_safebrowsing_bug1272239.html
@@ -41,47 +41,47 @@ for (var child of children) {
   var prefComponents =  child.split(".");
   var providerName = prefComponents[0];
   providers[providerName] = {};
 }
 
 // Get lists from |browser.safebrowsing.provider.PROVIDER_NAME.lists| preference.
 var listsWithProvider = [];
 var listsToProvider = [];
-for (var provider in providers) {
-  var pref = "browser.safebrowsing.provider." + provider + ".lists";
-  var list = SpecialPowers.getCharPref(pref).split(",");
+for (let provider in providers) {
+  let pref = "browser.safebrowsing.provider." + provider + ".lists";
+  let list = SpecialPowers.getCharPref(pref).split(",");
 
   listsToProvider = listsToProvider.concat(list.map( () => { return provider; }));
   listsWithProvider = listsWithProvider.concat(list);
 }
 
 // Get all the lists
 var lists = [];
-for (var pref of prefs) {
+for (let pref of prefs) {
   lists = lists.concat(SpecialPowers.getCharPref(pref).split(","));
 }
 
 var listmanager = Cc["@mozilla.org/url-classifier/listmanager;1"].
                   getService(Ci.nsIUrlListManager);
 
 let googleKey = SpecialPowers.Services.urlFormatter.formatURL("%GOOGLE_API_KEY%").trim();
 
-for (var list of lists) {
+for (let list of lists) {
   if (!list)
     continue;
 
   // For lists having a provider, it should have a correct gethash url
   // For lists without a provider, for example, test-malware-simple, it should not
   // have a gethash url.
   var url = listmanager.getGethashUrl(list);
   var index = listsWithProvider.indexOf(list);
   if (index >= 0) {
-    var provider = listsToProvider[index];
-    var pref = "browser.safebrowsing.provider." + provider + ".gethashURL";
+    let provider = listsToProvider[index];
+    let pref = "browser.safebrowsing.provider." + provider + ".gethashURL";
     if ((provider == "google" || provider == "google4") &&
         (!googleKey || googleKey == "no-google-api-key")) {
       is(url, "", "getHash url of " + list + " should be empty");
     } else {
       is(url, SpecialPowers.getCharPref(pref), list + " matches its gethash url");
     }
   } else {
     is(url, "", list + " should not have a gethash url");

--- a/toolkit/components/url-classifier/tests/mochitest/test_trackingprotection_bug1157081.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_trackingprotection_bug1157081.html
@@ -24,30 +24,23 @@ var mainWindow = window.QueryInterface(C
                     .QueryInterface(Ci.nsIDocShellTreeItem)
                     .rootTreeItem
                     .QueryInterface(Ci.nsIInterfaceRequestor)
                     .getInterface(Ci.nsIDOMWindow);
 var contentPage = "chrome://mochitests/content/chrome/toolkit/components/url-classifier/tests/mochitest/classifiedAnnotatedPBFrame.html"
 
 Components.utils.import("resource://gre/modules/Services.jsm");
 Components.utils.import("resource://testing-common/UrlClassifierTestUtils.jsm");
-
-function whenDelayedStartupFinished(aWindow, aCallback) {
-  Services.obs.addObserver(function observer(aSubject, aTopic) {
-    if (aWindow == aSubject) {
-      Services.obs.removeObserver(observer, aTopic);
-      setTimeout(aCallback, 0);
-    }
-  }, "browser-delayed-startup-finished");
-}
+Components.utils.import("resource://testing-common/TestUtils.jsm");
 
 function testOnWindow(aCallback) {
   var win = mainWindow.OpenBrowserWindow();
   win.addEventListener("load", function() {
-    whenDelayedStartupFinished(win, function() {
+    TestUtils.topicObserved("browser-delayed-startup-finished",
+                            subject => subject == win).then(() => {
       win.addEventListener("DOMContentLoaded", function onInnerLoad() {
         if (win.content.location.href != contentPage) {
           win.gBrowser.loadURI(contentPage);
           return;
         }
         win.removeEventListener("DOMContentLoaded", onInnerLoad, true);
 
         win.content.addEventListener("load", function innerLoad2() {
@@ -82,19 +75,19 @@ function test() {
   UrlClassifierTestUtils.addTestTrackers().then(() => {
     // Safe Browsing turned OFF, tracking protection should work nevertheless
     testOnWindow(function(aWindow) {
       checkLoads(aWindow, true);
       aWindow.close();
 
       // Safe Browsing turned ON, tracking protection should still work
       SpecialPowers.setBoolPref("browser.safebrowsing.phishing.enabled", true);
-      testOnWindow(function(aWindow) {
-        checkLoads(aWindow, true);
-        aWindow.close();
+      testOnWindow(function(aWindow1) {
+        checkLoads(aWindow1, true);
+        aWindow1.close();
         SimpleTest.finish();
       });
     });
   });
 }
 
 SimpleTest.waitForExplicitFinish();
 

--- a/toolkit/components/url-classifier/tests/mochitest/test_trackingprotection_bug1312515.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_trackingprotection_bug1312515.html
@@ -24,30 +24,23 @@ var mainWindow = window.QueryInterface(C
                        .QueryInterface(Ci.nsIDocShellTreeItem)
                        .rootTreeItem
                        .QueryInterface(Ci.nsIInterfaceRequestor)
                        .getInterface(Ci.nsIDOMWindow);
 var contentPage = "http://www.itisatrap.org/tests/toolkit/components/url-classifier/tests/mochitest/trackingRequest.html";
 
 Components.utils.import("resource://gre/modules/Services.jsm");
 Components.utils.import("resource://testing-common/UrlClassifierTestUtils.jsm");
-
-function whenDelayedStartupFinished(aWindow, aCallback) {
-  Services.obs.addObserver(function observer(aSubject, aTopic) {
-    if (aWindow == aSubject) {
-      Services.obs.removeObserver(observer, aTopic);
-      setTimeout(aCallback, 0);
-    }
-  }, "browser-delayed-startup-finished");
-}
+Components.utils.import("resource://testing-common/TestUtils.jsm");
 
 function testOnWindow(aPrivate, aCallback) {
   var win = mainWindow.OpenBrowserWindow({private: aPrivate});
   win.addEventListener("load", function() {
-    whenDelayedStartupFinished(win, function() {
+    TestUtils.topicObserved("browser-delayed-startup-finished",
+                            subject => subject == win).then(() => {
       win.addEventListener("DOMContentLoaded", function onInnerLoad() {
         if (win.content.location.href != contentPage) {
           win.gBrowser.loadURI(contentPage);
           return;
         }
         win.removeEventListener("DOMContentLoaded", onInnerLoad, true);
 
         win.content.addEventListener("load", function innerLoad2() {

--- a/toolkit/components/url-classifier/tests/mochitest/test_trackingprotection_whitelist.html
+++ b/toolkit/components/url-classifier/tests/mochitest/test_trackingprotection_whitelist.html
@@ -25,30 +25,23 @@ var mainWindow = window.QueryInterface(C
                     .rootTreeItem
                     .QueryInterface(Ci.nsIInterfaceRequestor)
                     .getInterface(Ci.nsIDOMWindow);
 var contentPage1 = "http://www.itisatrap.org/tests/toolkit/components/url-classifier/tests/mochitest/whitelistFrame.html";
 var contentPage2 = "http://example.com/tests/toolkit/components/url-classifier/tests/mochitest/whitelistFrame.html";
 
 Components.utils.import("resource://gre/modules/Services.jsm");
 Components.utils.import("resource://testing-common/UrlClassifierTestUtils.jsm");
-
-function whenDelayedStartupFinished(aWindow, aCallback) {
-  Services.obs.addObserver(function observer(aSubject, aTopic) {
-    if (aWindow == aSubject) {
-      Services.obs.removeObserver(observer, aTopic);
-      setTimeout(aCallback, 0);
-    }
-  }, "browser-delayed-startup-finished");
-}
+Components.utils.import("resource://testing-common/TestUtils.jsm");
 
 function testOnWindow(contentPage, aCallback) {
   var win = mainWindow.OpenBrowserWindow();
   win.addEventListener("load", function() {
-    whenDelayedStartupFinished(win, function() {
+    TestUtils.topicObserved("browser-delayed-startup-finished",
+                            subject => subject == win).then(() => {
       win.addEventListener("DOMContentLoaded", function onInnerLoad() {
         if (win.content.location.href != contentPage) {
           win.gBrowser.loadURI(contentPage);
           return;
         }
         win.removeEventListener("DOMContentLoaded", onInnerLoad, true);
 
         win.content.addEventListener("load", function innerLoad2() {
@@ -77,34 +70,34 @@ function checkLoads(aWindow, aWhiteliste
   is(win.document.blockedTrackingNodeCount, badids.length, "Should identify all tracking elements");
 
   var blockedTrackingNodes = win.document.blockedTrackingNodes;
 
   // Make sure that every node in blockedTrackingNodes exists in the tree
   // (that may not always be the case but do not expect any nodes to disappear
   // from the tree here)
   var allNodeMatch = true;
-  for (var i = 0; i < blockedTrackingNodes.length; i++) {
-    var nodeMatch = false;
-    for (var j = 0; j < badids.length && !nodeMatch; j++) {
+  for (let i = 0; i < blockedTrackingNodes.length; i++) {
+    let nodeMatch = false;
+    for (let j = 0; j < badids.length && !nodeMatch; j++) {
       nodeMatch = nodeMatch ||
         (blockedTrackingNodes[i] == win.document.getElementById(badids[j]));
     }
 
     allNodeMatch = allNodeMatch && nodeMatch;
   }
   is(allNodeMatch, true, "All annotated nodes are expected in the tree");
 
   // Make sure that every node with a badid (see badids) is found in the
   // blockedTrackingNodes. This tells us if we are neglecting to annotate
   // some nodes
   allNodeMatch = true;
-  for (var j = 0; j < badids.length; j++) {
-    var nodeMatch = false;
-    for (var i = 0; i < blockedTrackingNodes.length && !nodeMatch; i++) {
+  for (let j = 0; j < badids.length; j++) {
+    let nodeMatch = false;
+    for (let i = 0; i < blockedTrackingNodes.length && !nodeMatch; i++) {
       nodeMatch = nodeMatch ||
         (blockedTrackingNodes[i] == win.document.getElementById(badids[j]));
     }
 
     allNodeMatch = allNodeMatch && nodeMatch;
   }
   is(allNodeMatch, true, "All tracking nodes are expected to be annotated as such");
 }
@@ -118,26 +111,26 @@ function test() {
   SimpleTest.registerCleanupFunction(UrlClassifierTestUtils.cleanupTestTrackers);
   UrlClassifierTestUtils.addTestTrackers().then(() => {
     // Load the test from a URL on the whitelist
     testOnWindow(contentPage1, function(aWindow) {
       checkLoads(aWindow, true);
       aWindow.close();
 
       // Load the test from a URL that's NOT on the whitelist
-      testOnWindow(contentPage2, function(aWindow) {
-        checkLoads(aWindow, false);
-        aWindow.close();
+      testOnWindow(contentPage2, function(aWindow1) {
+        checkLoads(aWindow1, false);
+        aWindow1.close();
 
         // Load the test from a URL on the whitelist but without the whitelist
         SpecialPowers.pushPrefEnv({"set": [["urlclassifier.trackingWhitelistTable", ""]]},
           function() {
-            testOnWindow(contentPage1, function(aWindow) {
-              checkLoads(aWindow, false);
-              aWindow.close();
+            testOnWindow(contentPage1, function(aWindow2) {
+              checkLoads(aWindow2, false);
+              aWindow2.close();
               SimpleTest.finish();
             });
           });
 
       });
     });
   });
 }

--- a/toolkit/components/url-classifier/tests/mochitest/unwantedWorker.js
+++ b/toolkit/components/url-classifier/tests/mochitest/unwantedWorker.js
@@ -1,3 +1,5 @@
+/* eslint-env worker */
+
 onmessage = function() {
   postMessage("loaded bad file");
 }

--- a/toolkit/components/url-classifier/tests/unit/test_addsub.js
+++ b/toolkit/components/url-classifier/tests/unit/test_addsub.js
@@ -192,17 +192,16 @@ function testDuplicateAdds() {
     "subsDontExist": [ "foo.com/a"]
   }
 
   doTest([addUpdate1, addUpdate2, subUpdate], assertions);
 }
 
 // Tests a sub which matches some existing adds but leaves others.
 function testSubPartiallyMatches() {
-  var subUrls = ["foo.com/a"];
   var addUrls = ["1:foo.com/a", "2:foo.com/b"];
 
   var addUpdate = buildPhishingUpdate(
     [{ "chunkNum": 1,
        "urls": addUrls }]);
 
   var subUpdate = buildPhishingUpdate(
     [{ "chunkNum": 1,

--- a/toolkit/components/url-classifier/tests/unit/test_dbservice.js
+++ b/toolkit/components/url-classifier/tests/unit/test_dbservice.js
@@ -58,42 +58,42 @@ var chunk7 = chunk7Urls.join("\n");
 // and chunk 7 to block-simple.
 // Then we'll remove the urls in chunk3 from phish-simple, then
 // expire chunk 1 and chunks 4-7 from phish-simple.
 var phishExpected = {};
 var phishUnexpected = {};
 var malwareExpected = {};
 var unwantedExpected = {};
 var blockedExpected = {};
-for (var i = 0; i < chunk2Urls.length; i++) {
+for (let i = 0; i < chunk2Urls.length; i++) {
   phishExpected[chunk2Urls[i]] = true;
   malwareExpected[chunk2Urls[i]] = true;
 }
-for (var i = 0; i < chunk3Urls.length; i++) {
+for (let i = 0; i < chunk3Urls.length; i++) {
   unwantedExpected[chunk3Urls[i]] = true;
   delete phishExpected[chunk3Urls[i]];
   phishUnexpected[chunk3Urls[i]] = true;
 }
-for (var i = 0; i < chunk1Urls.length; i++) {
+for (let i = 0; i < chunk1Urls.length; i++) {
   // chunk1 urls are expired
   phishUnexpected[chunk1Urls[i]] = true;
 }
-for (var i = 0; i < chunk4Urls.length; i++) {
+for (let i = 0; i < chunk4Urls.length; i++) {
   // chunk4 urls are expired
   phishUnexpected[chunk4Urls[i]] = true;
 }
-for (var i = 0; i < chunk5Urls.length; i++) {
+for (let i = 0; i < chunk5Urls.length; i++) {
   // chunk5 urls are expired
   phishUnexpected[chunk5Urls[i]] = true;
 }
-for (var i = 0; i < chunk6Urls.length; i++) {
+for (let i = 0; i < chunk6Urls.length; i++) {
   // chunk6 urls are expired
   phishUnexpected[chunk6Urls[i]] = true;
 }
-for (var i = 0; i < chunk7Urls.length; i++) {
+for (let i = 0; i < chunk7Urls.length; i++) {
   blockedExpected[chunk7Urls[i]] = true;
   // chunk7 urls are expired
   phishUnexpected[chunk7Urls[i]] = true;
 }
 
 // Check that the entries hit based on sub-parts
 phishExpected["baz.com/foo/bar"] = true;
 phishExpected["foo.bar.baz.com/foo"] = true;
@@ -104,17 +104,17 @@ var numExpecting;
 function testFailure(arg) {
   do_throw(arg);
 }
 
 function checkNoHost() {
   // Looking up a no-host uri such as a data: uri should throw an exception.
   var exception;
   try {
-    var principal = secMan.createCodebasePrincipal(iosvc.newURI("data:text/html,<b>test</b>"), {});
+    let principal = secMan.createCodebasePrincipal(iosvc.newURI("data:text/html,<b>test</b>"), {});
     dbservice.lookup(principal, allTables);
 
     exception = false;
   } catch (e) {
     exception = true;
   }
   do_check_true(exception);
 
@@ -212,42 +212,42 @@ function blockedExists(result) {
     checkDone();
   }
 }
 
 function checkState() {
   numExpecting = 0;
 
 
-  for (var key in phishExpected) {
-    var principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
+  for (let key in phishExpected) {
+    let principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
     dbservice.lookup(principal, allTables, phishExists, true);
     numExpecting++;
   }
 
-  for (var key in phishUnexpected) {
-    var principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
+  for (let key in phishUnexpected) {
+    let principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
     dbservice.lookup(principal, allTables, phishDoesntExist, true);
     numExpecting++;
   }
 
-  for (var key in malwareExpected) {
-    var principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
+  for (let key in malwareExpected) {
+    let principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
     dbservice.lookup(principal, allTables, malwareExists, true);
     numExpecting++;
   }
 
-  for (var key in unwantedExpected) {
-    var principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
+  for (let key in unwantedExpected) {
+    let principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
     dbservice.lookup(principal, allTables, unwantedExists, true);
     numExpecting++;
   }
 
-  for (var key in blockedExpected) {
-    var principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
+  for (let key in blockedExpected) {
+    let principal = secMan.createCodebasePrincipal(iosvc.newURI("http://" + key), {});
     dbservice.lookup(principal, allTables, blockedExists, true);
     numExpecting++;
   }
 }
 
 function testSubSuccess(result) {
   do_check_eq(result, "1000");
   checkState();

--- a/toolkit/components/url-classifier/tests/unit/test_digest256.js
+++ b/toolkit/components/url-classifier/tests/unit/test_digest256.js
@@ -68,18 +68,16 @@ function processUpdateRequest() {
 }
 
 // Set up our test server to handle update requests.
 function run_test() {
   gHttpServ = new HttpServer();
   gHttpServ.registerDirectory("/", do_get_cwd());
 
   gHttpServ.registerPathHandler("/downloads", function(request, response) {
-    let buf = NetUtil.readInputStreamToString(request.bodyInputStream,
-      request.bodyInputStream.available());
     let blob = processUpdateRequest();
     response.setHeader("Content-Type",
                        "application/vnd.google.safebrowsing-update", false);
     response.setStatusLine(request.httpVersion, 200, "OK");
     response.bodyOutputStream.write(blob, blob.length);
   });
 
   gHttpServ.start(4444);

--- a/toolkit/components/url-classifier/tests/unit/test_hashcompleter.js
+++ b/toolkit/components/url-classifier/tests/unit/test_hashcompleter.js
@@ -135,17 +135,16 @@ function parseCompletionRequest(aRequest
 
   let tokens = /(\d):(\d+)/.exec(aRequest);
   if (tokens.length < 3) {
     dump("Request format error.");
     return null;
   }
 
   let partialLength = parseInt(tokens[1]);
-  let payloadLength = parseInt(tokens[2]);
 
   let payloadStart = tokens[1].length + // partial length
                      1 +                // ':'
                      tokens[2].length + // payload length
                      1;                 // '\n'
 
   let prefixSet = [];
   for (let i = payloadStart; i < aRequest.length; i += partialLength) {
@@ -187,17 +186,17 @@ function getRandomCompletionSet(forceSer
 
     // Generate a random 256 bit hash. First we get a random number and then
     // convert it to a string.
     let hash;
     let prefix;
     do {
       hash = "";
       let length = 1 + rand.nextNum(5);
-      for (let i = 0; i < length; i++)
+      for (let j = 0; j < length; j++)
         hash += String.fromCharCode(rand.nextNum(8));
       prefix = hash.substring(0, 4);
     } while (hashPrefixes.indexOf(prefix) != -1);
 
     hashPrefixes.push(prefix);
     completion.hash = hash;
 
     if (!forceServerError) {
@@ -218,17 +217,16 @@ function getRandomCompletionSet(forceSer
   return completionSet;
 }
 
 var completionSets = [basicCompletionSet, falseCompletionSet,
                       dupedCompletionSet, multipleResponsesCompletionSet];
 var currentCompletionSet = -1;
 var finishedCompletions = 0;
 
-const SERVER_PORT = 8080;
 const SERVER_PATH = "/hash-completer";
 var server;
 
 // Completion hashes are automatically right-padded with null chars to have a
 // length of COMPLETE_LENGTH.
 // Taken from nsUrlClassifierDBService.h
 const COMPLETE_LENGTH = 32;
 
@@ -349,17 +347,17 @@ function hashCompleterServer(aRequest, a
 }
 
 
 function callback(completion) {
   this._completion = completion;
 }
 
 callback.prototype = {
-  completionV2: function completion(hash, table, chunkId, trusted) {
+  completionV2: function completionV2(hash, table, chunkId, trusted) {
     do_check_true(this._completion.expectCompletion);
     if (this._completion.multipleCompletions) {
       for (let completion of this._completion.completions) {
         if (completion.hash == hash) {
           do_check_eq(JSON.stringify(hash), JSON.stringify(completion.hash));
           do_check_eq(table, completion.table);
           do_check_eq(chunkId, completion.chunkId);
 

--- a/toolkit/components/url-classifier/tests/unit/test_partial.js
+++ b/toolkit/components/url-classifier/tests/unit/test_partial.js
@@ -23,27 +23,26 @@ complete(partialHash, gethashUrl, tableN
   this.queries.push(partialHash);
   var fragments = this.fragments;
   var self = this;
   var doCallback = function() {
       if (self.alwaysFail) {
         cb.completionFinished(Cr.NS_ERROR_FAILURE);
         return;
       }
-      var results;
       if (fragments[partialHash]) {
         for (var i = 0; i < fragments[partialHash].length; i++) {
           var chunkId = fragments[partialHash][i][0];
           var hash = fragments[partialHash][i][1];
           cb.completionV2(hash, self.tableName, chunkId);
         }
       }
     cb.completionFinished(0);
   }
-  var timer = new Timer(0, doCallback);
+  do_execute_soon(doCallback);
 },
 
 getHash(fragment) {
   var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
   createInstance(Ci.nsIScriptableUnicodeConverter);
   converter.charset = "UTF-8";
   var data = converter.convertToByteArray(fragment);
   var ch = Cc["@mozilla.org/security/hash;1"].createInstance(Ci.nsICryptoHash);
@@ -71,42 +70,42 @@ addHash(chunkId, hash) {
     this.fragments[partial].push([chunkId, hash]);
   } else {
     this.fragments[partial] = [[chunkId, hash]];
   }
 },
 
 compareQueries(fragments) {
   var expectedQueries = [];
-  for (var i = 0; i < fragments.length; i++) {
+  for (let i = 0; i < fragments.length; i++) {
     expectedQueries.push(this.getHash(fragments[i]).slice(0, 4));
   }
   do_check_eq(this.queries.length, expectedQueries.length);
   expectedQueries.sort();
   this.queries.sort();
-  for (var i = 0; i < this.queries.length; i++) {
+  for (let i = 0; i < this.queries.length; i++) {
     do_check_eq(this.queries[i], expectedQueries[i]);
   }
 }
 };
 
 function setupCompleter(table, hits, conflicts) {
   var completer = new DummyCompleter();
   completer.tableName = table;
-  for (var i = 0; i < hits.length; i++) {
-    var chunkId = hits[i][0];
-    var fragments = hits[i][1];
-    for (var j = 0; j < fragments.length; j++) {
+  for (let i = 0; i < hits.length; i++) {
+    let chunkId = hits[i][0];
+    let fragments = hits[i][1];
+    for (let j = 0; j < fragments.length; j++) {
       completer.addFragment(chunkId, fragments[j]);
     }
   }
-  for (var i = 0; i < conflicts.length; i++) {
-    var chunkId = conflicts[i][0];
-    var fragments = conflicts[i][1];
-    for (var j = 0; j < fragments.length; j++) {
+  for (let i = 0; i < conflicts.length; i++) {
+    let chunkId = conflicts[i][0];
+    let fragments = conflicts[i][1];
+    for (let j = 0; j < fragments.length; j++) {
       completer.addConflict(chunkId, fragments[j]);
     }
   }
 
   dbservice.setHashCompleter(table, completer);
 
   return completer;
 }
@@ -404,17 +403,17 @@ function testInvalidHashSize() {
   var addUrls2 = [ "zaz.com/a", "xyz.com/b" ];
   var update2 = buildPhishingUpdate(
         [
           { "chunkNum": 2,
             "urls": addUrls2
           }],
         4);
 
-  var completer = installCompleter("test-phish-simple", [[1, addUrls]], []);
+  installCompleter("test-phish-simple", [[1, addUrls]], []);
 
   var assertions = {
     "tableData": "test-phish-simple;a:2",
     "urlsDontExist": addUrls
   };
 
   // A successful update will trigger an error
   doUpdateTest([update2, update], assertions, updateError, runNextTest);
@@ -444,27 +443,27 @@ function testWrongTable() {
     "urlsDontExist": addUrls,
     // Make sure the completer was actually queried.
     "completerQueried": [completer, addUrls]
   };
 
   doUpdateTest([update], assertions,
                function() {
                  // Give the dbservice a chance to (not) cache the result.
-                 var timer = new Timer(3000, function() {
+                 do_timeout(3000, function() {
                      // The miss earlier will have caused a miss to be cached.
                      // Resetting the completer does not count as an update,
                      // so we will not be probed again.
                      var newCompleter = installCompleter("test-malware-simple", [[1, addUrls]], []); dbservice.setHashCompleter("test-phish-simple",
                                                 newCompleter);
 
-                     var assertions = {
+                     var assertions1 = {
                        "urlsDontExist": addUrls
                      };
-                     checkAssertions(assertions, runNextTest);
+                     checkAssertions(assertions1, runNextTest);
                    });
                }, updateError);
 }
 
 function setupCachedResults(addUrls, part2) {
   var update = buildPhishingUpdate(
         [
           { "chunkNum": 1,
@@ -480,17 +479,17 @@ function setupCachedResults(addUrls, par
     "urlsExist": addUrls,
     // Make sure the completer was actually queried.
     "completerQueried": [completer, addUrls]
   };
 
   doUpdateTest([update], assertions,
                function() {
                  // Give the dbservice a chance to cache the result.
-                 var timer = new Timer(3000, part2);
+                 do_timeout(3000, part2);
                }, updateError);
 }
 
 function testCachedResults() {
   setupCachedResults(["foo.com/a"], function(add) {
       // This is called after setupCachedResults().  Verify that
       // checking the url again does not cause a completer request.
 
@@ -552,25 +551,16 @@ function testCachedResultsFailure() {
     // install a new completer, this one should never be queried.
     var newCompleter = installCompleter("test-phish-simple", [[1, []]], []);
 
     var assertions = {
       "urlsExist": existUrls,
       "completerQueried": [newCompleter, []]
     };
 
-    var addUrls = ["foobar.org/a"];
-
-    var update2 = buildPhishingUpdate(
-        [
-          { "chunkNum": 2,
-            "urls": addUrls
-          }],
-        4);
-
     checkAssertions(assertions, function() {
       // Apply the update. The cached completes should be gone.
       doErrorUpdate("test-phish-simple,test-malware-simple", function() {
         // Now the completer gets queried again.
         var newCompleter2 = installCompleter("test-phish-simple", [[1, existUrls]], []);
         var assertions2 = {
           "tableData": "test-phish-simple;a:1",
           "urlsExist": existUrls,