--- a/.cron.yml
+++ b/.cron.yml
@@ -54,19 +54,8 @@ jobs:
       job:
           type: decision-task
           treeherder-symbol: Nc
           target-tasks-method: nightly_code_coverage
       run-on-projects:
           - mozilla-central
       when:
           - {hour: 18, minute: 0}
-
-    - name: nightly-stylo-talos
-      job:
-          type: decision-task
-          treeherder-symbol: T 
-          target-tasks-method: stylo_talos
-      run-on-projects:
-          - mozilla-central
-      when:
-          - {hour: 4, minute: 0}
-

--- a/.eslintignore
+++ b/.eslintignore
@@ -126,17 +126,17 @@ devtools/client/webide/**
 devtools/server/actors/webconsole.js
 devtools/server/actors/object.js
 devtools/server/actors/script.js
 devtools/server/actors/styleeditor.js
 devtools/server/actors/stylesheets.js
 devtools/server/tests/browser/storage-*.html
 !devtools/server/tests/browser/storage-unsecured-iframe.html
 devtools/server/tests/browser/stylesheets-nested-iframes.html
-devtools/server/tests/unit/**
+devtools/server/tests/unit/xpcshell_debugging_script.js
 devtools/shared/platform/content/test/test_clipboard.html
 devtools/shared/qrcode/tests/mochitest/test_decode.html
 devtools/shared/tests/mochitest/*.html
 devtools/shared/webconsole/test/test_*.html
 
 # Ignore devtools pre-processed files
 devtools/client/framework/toolbox-process-window.js
 devtools/client/performance/system.js
@@ -169,16 +169,17 @@ devtools/server/actors/utils/automation-
 devtools/client/debugger/test/mochitest/code_binary_search.js
 devtools/client/debugger/test/mochitest/code_math.min.js
 devtools/client/debugger/test/mochitest/code_math_bogus_map.js
 devtools/client/debugger/test/mochitest/code_ugly*
 devtools/client/debugger/test/mochitest/code_worker-source-map.js
 devtools/client/framework/test/code_ugly*
 devtools/server/tests/unit/babel_and_browserify_script_with_source_map.js
 devtools/server/tests/unit/setBreakpoint*
+devtools/server/tests/unit/sourcemapped.js
 
 # dom/ exclusions
 dom/animation/**
 dom/archivereader/**
 dom/asmjscache/**
 dom/audiochannel/**
 dom/base/**
 dom/battery/**

--- a/accessible/base/NotificationController.cpp
+++ b/accessible/base/NotificationController.cpp
@@ -750,18 +750,21 @@ NotificationController::WillRefresh(mozi
 
         outerDocAcc->RemoveChild(childDoc);
       }
 
       // Failed to bind the child document, destroy it.
       childDoc->Shutdown();
     }
   }
-
   mHangingChildDocuments.Clear();
+  MOZ_ASSERT(mDocument, "Illicit document shutdown");
+  if (!mDocument) {
+    return;
+  }
 
   // If the document is ready and all its subdocuments are completely loaded
   // then process the document load.
   if (mDocument->HasLoadState(DocAccessible::eReady) &&
       !mDocument->HasLoadState(DocAccessible::eCompletelyLoaded) &&
       hangingDocCnt == 0) {
     uint32_t childDocCnt = mDocument->ChildDocumentCount(), childDocIdx = 0;
     for (; childDocIdx < childDocCnt; childDocIdx++) {

--- a/browser/base/content/browser-ctrlTab.js
+++ b/browser/base/content/browser-ctrlTab.js
@@ -199,26 +199,27 @@ var ctrlTab = {
       tabPreviews.init();
 
       this._initRecentlyUsedTabs();
       this._init(true);
     }
   },
 
   uninit: function ctrlTab_uninit() {
-    this._recentlyUsedTabs = null;
-    this._init(false);
+    if (this._recentlyUsedTabs) {
+      this._recentlyUsedTabs = null;
+      this._init(false);
+    }
   },
 
   prefName: "browser.ctrlTab.previews",
   readPref: function ctrlTab_readPref() {
     var enable =
       gPrefService.getBoolPref(this.prefName) &&
-      (!gPrefService.prefHasUserValue("browser.ctrlTab.disallowForScreenReaders") ||
-       !gPrefService.getBoolPref("browser.ctrlTab.disallowForScreenReaders"));
+      !gPrefService.getBoolPref("browser.ctrlTab.disallowForScreenReaders", false);
 
     if (enable)
       this.init();
     else
       this.uninit();
   },
   observe(aSubject, aTopic, aPrefName) {
     this.readPref();
@@ -530,25 +531,25 @@ var ctrlTab = {
     this._recentlyUsedTabs =
       Array.filter(gBrowser.tabs, tab => !tab.closing)
            .sort((tab1, tab2) => tab2.lastAccessed - tab1.lastAccessed);
   },
 
   _init: function ctrlTab__init(enable) {
     var toggleEventListener = enable ? "addEventListener" : "removeEventListener";
 
-    window[toggleEventListener]("SSWindowRestored", this, false);
+    window[toggleEventListener]("SSWindowRestored", this);
 
     var tabContainer = gBrowser.tabContainer;
-    tabContainer[toggleEventListener]("TabOpen", this, false);
-    tabContainer[toggleEventListener]("TabAttrModified", this, false);
-    tabContainer[toggleEventListener]("TabSelect", this, false);
-    tabContainer[toggleEventListener]("TabClose", this, false);
+    tabContainer[toggleEventListener]("TabOpen", this);
+    tabContainer[toggleEventListener]("TabAttrModified", this);
+    tabContainer[toggleEventListener]("TabSelect", this);
+    tabContainer[toggleEventListener]("TabClose", this);
 
-    document[toggleEventListener]("keypress", this, false);
+    document[toggleEventListener]("keypress", this);
     gBrowser.mTabBox.handleCtrlTab = !enable;
 
     if (enable)
       PageThumbs.addExpirationFilter(this);
     else
       PageThumbs.removeExpirationFilter(this);
 
     // If we're not running, hide the "Show All Tabs" menu item,

--- a/browser/base/content/browser-sets.inc
+++ b/browser/base/content/browser-sets.inc
@@ -333,17 +333,17 @@
     <key id="key_fullZoomReduce"  key="&fullZoomReduceCmd.commandkey;"   command="cmd_fullZoomReduce"  modifiers="accel"/>
     <key                          key="&fullZoomReduceCmd.commandkey2;"  command="cmd_fullZoomReduce"  modifiers="accel"/>
     <key id="key_fullZoomEnlarge" key="&fullZoomEnlargeCmd.commandkey;"  command="cmd_fullZoomEnlarge" modifiers="accel"/>
     <key                          key="&fullZoomEnlargeCmd.commandkey2;" command="cmd_fullZoomEnlarge" modifiers="accel"/>
     <key                          key="&fullZoomEnlargeCmd.commandkey3;" command="cmd_fullZoomEnlarge" modifiers="accel"/>
     <key id="key_fullZoomReset"   key="&fullZoomResetCmd.commandkey;"    command="cmd_fullZoomReset"   modifiers="accel"/>
     <key                          key="&fullZoomResetCmd.commandkey2;"   command="cmd_fullZoomReset"   modifiers="accel"/>
 
-    <key id="key_showAllTabs" command="Browser:ShowAllTabs" keycode="VK_TAB" modifiers="control,shift"/>
+    <key id="key_showAllTabs" command="Browser:ShowAllTabs" keycode="VK_TAB" modifiers="control,shift" disabled="true"/>
 
     <key id="key_switchTextDirection" key="&bidiSwitchTextDirectionItem.commandkey;" command="cmd_switchTextDirection" modifiers="accel,shift" />
 
     <key id="key_privatebrowsing" command="Tools:PrivateBrowsing" key="&privateBrowsingCmd.commandkey;"
          modifiers="accel,shift" reserved="true"/>
     <key id="key_sanitize" command="Tools:Sanitize" keycode="VK_DELETE" modifiers="accel,shift"/>
 #ifdef XP_MACOSX
     <key id="key_sanitize_mac" command="Tools:Sanitize" keycode="VK_BACK" modifiers="accel,shift"/>

--- a/devtools/server/tests/unit/.eslintrc.js
+++ b/devtools/server/tests/unit/.eslintrc.js
@@ -1,6 +1,9 @@
 "use strict";
 
 module.exports = {
   // Extend from the common devtools xpcshell eslintrc config.
-  "extends": "../../../.eslintrc.xpcshell.js"
+  "extends": "../../../.eslintrc.xpcshell.js",
+  "rules": {
+    "no-debugger": 0,
+  }
 };

--- a/devtools/server/tests/unit/head_dbg.js
+++ b/devtools/server/tests/unit/head_dbg.js
@@ -1,10 +1,12 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint no-unused-vars: ["error", {"vars": "local"}] */
+/* eslint-disable no-shadow */
 
 "use strict";
 var Cc = Components.classes;
 var Ci = Components.interfaces;
 var Cu = Components.utils;
 var Cr = Components.results;
 var CC = Components.Constructor;
 
@@ -37,21 +39,21 @@ Services.prefs.setBoolPref("devtools.deb
 const DevToolsUtils = require("devtools/shared/DevToolsUtils");
 const { DebuggerServer } = require("devtools/server/main");
 const { DebuggerServer: WorkerDebuggerServer } = worker.require("devtools/server/main");
 const { DebuggerClient, ObjectClient } = require("devtools/shared/client/main");
 const { MemoryFront } = require("devtools/shared/fronts/memory");
 
 const { addDebuggerToGlobal } = Cu.import("resource://gre/modules/jsdebugger.jsm", {});
 
-const systemPrincipal = Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal);
+const systemPrincipal = Cc["@mozilla.org/systemprincipal;1"]
+                        .createInstance(Ci.nsIPrincipal);
 
-var loadSubScript = Cc[
-  "@mozilla.org/moz/jssubscript-loader;1"
-].getService(Ci.mozIJSSubScriptLoader).loadSubScript;
+var { loadSubScript } = Cc["@mozilla.org/moz/jssubscript-loader;1"]
+                        .getService(Ci.mozIJSSubScriptLoader);
 
 /**
  * Initializes any test that needs to work with add-ons.
  */
 function startupAddonsManager() {
   // Create a directory for extensions.
   const profileDir = do_get_profile().clone();
   profileDir.append("extensions");
@@ -145,19 +147,18 @@ function makeFullRuntimeMemoryActorTest(
           finishClient(client);
         });
       });
     });
   };
 }
 
 function createTestGlobal(name) {
-  let sandbox = Cu.Sandbox(
-    Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal)
-  );
+  let sandbox = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"]
+                           .createInstance(Ci.nsIPrincipal));
   sandbox.__name = name;
   return sandbox;
 }
 
 function connect(client) {
   dump("Connecting client.\n");
   return client.connect();
 }
@@ -231,60 +232,64 @@ function setBreakpoint(sourceClient, loc
 
 function dumpn(msg) {
   dump("DBG-TEST: " + msg + "\n");
 }
 
 function testExceptionHook(ex) {
   try {
     do_report_unexpected_exception(ex);
-  } catch (ex) {
-    return {throw: ex};
+  } catch (e) {
+    return {throw: e};
   }
   return undefined;
 }
 
-// Convert an nsIScriptError 'aFlags' value into an appropriate string.
-function scriptErrorFlagsToKind(aFlags) {
-  var kind;
-  if (aFlags & Ci.nsIScriptError.warningFlag)
+// Convert an nsIScriptError 'flags' value into an appropriate string.
+function scriptErrorFlagsToKind(flags) {
+  let kind;
+  if (flags & Ci.nsIScriptError.warningFlag) {
     kind = "warning";
-  if (aFlags & Ci.nsIScriptError.exceptionFlag)
+  }
+  if (flags & Ci.nsIScriptError.exceptionFlag) {
     kind = "exception";
-  else
+  } else {
     kind = "error";
+  }
 
-  if (aFlags & Ci.nsIScriptError.strictFlag)
+  if (flags & Ci.nsIScriptError.strictFlag) {
     kind = "strict " + kind;
+  }
 
   return kind;
 }
 
 // Register a console listener, so console messages don't just disappear
 // into the ether.
 var errorCount = 0;
 var listener = {
-  observe: function (aMessage) {
+  observe: function (message) {
     try {
+      let string;
       errorCount++;
       try {
         // If we've been given an nsIScriptError, then we can print out
         // something nicely formatted, for tools like Emacs to pick up.
-        var scriptError = aMessage.QueryInterface(Ci.nsIScriptError);
-        dumpn(aMessage.sourceName + ":" + aMessage.lineNumber + ": " +
-              scriptErrorFlagsToKind(aMessage.flags) + ": " +
-              aMessage.errorMessage);
-        var string = aMessage.errorMessage;
-      } catch (x) {
+        message.QueryInterface(Ci.nsIScriptError);
+        dumpn(message.sourceName + ":" + message.lineNumber + ": " +
+              scriptErrorFlagsToKind(message.flags) + ": " +
+              message.errorMessage);
+        string = message.errorMessage;
+      } catch (e1) {
         // Be a little paranoid with message, as the whole goal here is to lose
         // no information.
         try {
-          var string = "" + aMessage.message;
-        } catch (x) {
-          var string = "<error converting error message to string>";
+          string = "" + message.message;
+        } catch (e2) {
+          string = "<error converting error message to string>";
         }
       }
 
       // Make sure we exit all nested event loops so that the test can finish.
       while (DebuggerServer
              && DebuggerServer.xpcInspector
              && DebuggerServer.xpcInspector.eventLoopNestLevel > 0) {
         DebuggerServer.xpcInspector.exitNestedEventLoop();
@@ -305,133 +310,128 @@ var listener = {
       // to log above, but apparently that didn't cut it.
     }
   }
 };
 
 var consoleService = Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService);
 consoleService.registerListener(listener);
 
-function check_except(func)
-{
+function check_except(func) {
   try {
     func();
   } catch (e) {
     do_check_true(true);
     return;
   }
   dumpn("Should have thrown an exception: " + func.toString());
   do_check_true(false);
 }
 
-function testGlobal(aName) {
-  let systemPrincipal = Cc["@mozilla.org/systemprincipal;1"]
-    .createInstance(Ci.nsIPrincipal);
-
-  let sandbox = Cu.Sandbox(systemPrincipal);
-  sandbox.__name = aName;
+function testGlobal(name) {
+  let sandbox = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"]
+                           .createInstance(Ci.nsIPrincipal));
+  sandbox.__name = name;
   return sandbox;
 }
 
-function addTestGlobal(aName, aServer = DebuggerServer)
-{
-  let global = testGlobal(aName);
-  aServer.addTestGlobal(global);
+function addTestGlobal(name, server = DebuggerServer) {
+  let global = testGlobal(name);
+  server.addTestGlobal(global);
   return global;
 }
 
-// List the DebuggerClient |aClient|'s tabs, look for one whose title is
-// |aTitle|, and apply |aCallback| to the packet's entry for that tab.
-function getTestTab(aClient, aTitle, aCallback) {
-  aClient.listTabs(function (aResponse) {
-    for (let tab of aResponse.tabs) {
-      if (tab.title === aTitle) {
-        aCallback(tab, aResponse);
+// List the DebuggerClient |client|'s tabs, look for one whose title is
+// |title|, and apply |callback| to the packet's entry for that tab.
+function getTestTab(client, title, callback) {
+  client.listTabs(function (response) {
+    for (let tab of response.tabs) {
+      if (tab.title === title) {
+        callback(tab, response);
         return;
       }
     }
-    aCallback(null);
+    callback(null);
   });
 }
 
-// Attach to |aClient|'s tab whose title is |aTitle|; pass |aCallback| the
+// Attach to |client|'s tab whose title is |title|; pass |callback| the
 // response packet and a TabClient instance referring to that tab.
-function attachTestTab(aClient, aTitle, aCallback) {
-  getTestTab(aClient, aTitle, function (aTab) {
-    aClient.attachTab(aTab.actor, aCallback);
+function attachTestTab(client, title, callback) {
+  getTestTab(client, title, function (tab) {
+    client.attachTab(tab.actor, callback);
   });
 }
 
-// Attach to |aClient|'s tab whose title is |aTitle|, and then attach to
-// that tab's thread. Pass |aCallback| the thread attach response packet, a
+// Attach to |client|'s tab whose title is |title|, and then attach to
+// that tab's thread. Pass |callback| the thread attach response packet, a
 // TabClient referring to the tab, and a ThreadClient referring to the
 // thread.
-function attachTestThread(aClient, aTitle, aCallback) {
-  attachTestTab(aClient, aTitle, function (aTabResponse, aTabClient) {
-    function onAttach(aResponse, aThreadClient) {
-      aCallback(aResponse, aTabClient, aThreadClient, aTabResponse);
+function attachTestThread(client, title, callback) {
+  attachTestTab(client, title, function (tabResponse, tabClient) {
+    function onAttach(response, threadClient) {
+      callback(response, tabClient, threadClient, tabResponse);
     }
-    aTabClient.attachThread({
+    tabClient.attachThread({
       useSourceMaps: true,
       autoBlackBox: true
     }, onAttach);
   });
 }
 
-// Attach to |aClient|'s tab whose title is |aTitle|, attach to the tab's
-// thread, and then resume it. Pass |aCallback| the thread's response to
+// Attach to |client|'s tab whose title is |title|, attach to the tab's
+// thread, and then resume it. Pass |callback| the thread's response to
 // the 'resume' packet, a TabClient for the tab, and a ThreadClient for the
 // thread.
-function attachTestTabAndResume(aClient, aTitle, aCallback = () => {}) {
-  return new Promise((resolve, reject) => {
-    attachTestThread(aClient, aTitle, function (aResponse, aTabClient, aThreadClient) {
-      aThreadClient.resume(function (aResponse) {
-        aCallback(aResponse, aTabClient, aThreadClient);
-        resolve([aResponse, aTabClient, aThreadClient]);
+function attachTestTabAndResume(client, title, callback = () => {}) {
+  return new Promise((resolve) => {
+    attachTestThread(client, title, function (response, tabClient, threadClient) {
+      threadClient.resume(function (response) {
+        callback(response, tabClient, threadClient);
+        resolve([response, tabClient, threadClient]);
       });
     });
   });
 }
 
 /**
  * Initialize the testing debugger server.
  */
-function initTestDebuggerServer(aServer = DebuggerServer)
-{
-  aServer.registerModule("xpcshell-test/testactors");
+function initTestDebuggerServer(server = DebuggerServer) {
+  server.registerModule("xpcshell-test/testactors");
   // Allow incoming connections.
-  aServer.init(function () { return true; });
+  server.init(function () {
+    return true;
+  });
 }
 
 /**
  * Initialize the testing debugger server with a tab whose title is |title|.
  */
 function startTestDebuggerServer(title, server = DebuggerServer) {
   initTestDebuggerServer(server);
   addTestGlobal(title);
   DebuggerServer.addTabActors();
 
   let transport = DebuggerServer.connectPipe();
   let client = new DebuggerClient(transport);
 
   return connect(client).then(() => client);
 }
 
-function finishClient(aClient)
-{
-  aClient.close(function () {
+function finishClient(client) {
+  client.close(function () {
     DebuggerServer.destroy();
     do_test_finished();
   });
 }
 
 // Create a server, connect to it and fetch tab actors for the parent process;
-// pass |aCallback| the debugger client and tab actor form with all actor IDs.
-function get_chrome_actors(callback)
-{
+// pass |callback| the debugger client and tab actor form with all actor IDs.
+function get_chrome_actors(callback) {
   if (!DebuggerServer.initialized) {
     DebuggerServer.init();
     DebuggerServer.addBrowserActors();
   }
   DebuggerServer.allowChromeProcess = true;
 
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   client.connect()
@@ -444,69 +444,68 @@ function get_chrome_actors(callback)
 function getChromeActors(client, server = DebuggerServer) {
   server.allowChromeProcess = true;
   return client.getProcess().then(response => response.form);
 }
 
 /**
  * Takes a relative file path and returns the absolute file url for it.
  */
-function getFileUrl(aName, aAllowMissing = false) {
-  let file = do_get_file(aName, aAllowMissing);
+function getFileUrl(name, allowMissing = false) {
+  let file = do_get_file(name, allowMissing);
   return Services.io.newFileURI(file).spec;
 }
 
 /**
  * Returns the full path of the file with the specified name in a
  * platform-independent and URL-like form.
  */
-function getFilePath(aName, aAllowMissing = false, aUsePlatformPathSeparator = false)
-{
-  let file = do_get_file(aName, aAllowMissing);
+function getFilePath(name, allowMissing = false, usePlatformPathSeparator = false) {
+  let file = do_get_file(name, allowMissing);
   let path = Services.io.newFileURI(file).spec;
   let filePrePath = "file://";
   if ("nsILocalFileWin" in Ci &&
       file instanceof Ci.nsILocalFileWin) {
     filePrePath += "/";
   }
 
   path = path.slice(filePrePath.length);
 
-  if (aUsePlatformPathSeparator && path.match(/^\w:/)) {
+  if (usePlatformPathSeparator && path.match(/^\w:/)) {
     path = path.replace(/\//g, "\\");
   }
 
   return path;
 }
 
 /**
  * Returns the full text contents of the given file.
  */
-function readFile(aFileName) {
-  let f = do_get_file(aFileName);
+function readFile(fileName) {
+  let f = do_get_file(fileName);
   let s = Cc["@mozilla.org/network/file-input-stream;1"]
     .createInstance(Ci.nsIFileInputStream);
   s.init(f, -1, -1, false);
   try {
     return NetUtil.readInputStreamToString(s, s.available());
   } finally {
     s.close();
   }
 }
 
-function writeFile(aFileName, aContent) {
-  let file = do_get_file(aFileName, true);
+function writeFile(fileName, content) {
+  let file = do_get_file(fileName, true);
   let stream = Cc["@mozilla.org/network/file-output-stream;1"]
     .createInstance(Ci.nsIFileOutputStream);
   stream.init(file, -1, -1, 0);
   try {
     do {
-      let numWritten = stream.write(aContent, aContent.length);
-      aContent = aContent.slice(numWritten);
-    } while (aContent.length > 0);
+      let numWritten = stream.write(content, content.length);
+      content = content.slice(numWritten);
+    } while (content.length > 0);
   } finally {
     stream.close();
   }
 }
 
 function connectPipeTracing() {
   return new TracingTransport(DebuggerServer.connectPipe());
 }
@@ -580,19 +579,19 @@ TracingTransport.prototype = {
   }
 };
 
 function StubTransport() { }
 StubTransport.prototype.ready = function () {};
 StubTransport.prototype.send = function () {};
 StubTransport.prototype.close = function () {};
 
-function executeSoon(aFunc) {
+function executeSoon(func) {
   Services.tm.mainThread.dispatch({
-    run: DevToolsUtils.makeInfallible(aFunc)
+    run: DevToolsUtils.makeInfallible(func)
   }, Ci.nsIThread.DISPATCH_NORMAL);
 }
 
 // The do_check_* family of functions expect their last argument to be an
 // optional stack object. Unfortunately, most tests actually pass a in a string
 // containing an error message instead, which causes error reporting to break if
 // strict warnings as errors is turned on. To avoid this, we wrap these
 // functions here below to ensure the correct number of arguments is passed.
@@ -805,18 +804,17 @@ function getSourceContent(sourceClient) 
 function getSource(threadClient, url) {
   let deferred = promise.defer();
   threadClient.getSources((res) => {
     let source = res.sources.filter(function (s) {
       return s.url === url;
     });
     if (source.length) {
       deferred.resolve(threadClient.source(source[0]));
-    }
-    else {
+    } else {
       deferred.reject(new Error("source not found"));
     }
   });
   return deferred.promise;
 }
 
 /**
  * Do a fake reload which clears the thread debugger

--- a/devtools/server/tests/unit/hello-actor.js
+++ b/devtools/server/tests/unit/hello-actor.js
@@ -1,18 +1,19 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint no-unused-vars: ["error", {"vars": "local"}] */
+
+"use strict";
 
 const protocol = require("devtools/shared/protocol");
 
 const helloSpec = protocol.generateActorSpec({
   typeName: "helloActor",
 
   methods: {
     hello: {}
   }
 });
 
 var HelloActor = protocol.ActorClassWithSpec(helloSpec, {
-  hello: function () {
-    return;
-  }
+  hello: function () {}
 });

--- a/devtools/server/tests/unit/post_init_global_actors.js
+++ b/devtools/server/tests/unit/post_init_global_actors.js
@@ -1,16 +1,18 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
-function PostInitGlobalActor(aConnection) {}
+"use strict";
+
+function PostInitGlobalActor(connection) {}
 
 PostInitGlobalActor.prototype = {
   actorPrefix: "postInitGlobal",
-  onPing: function onPing(aRequest) {
+  onPing(request) {
     return { message: "pong" };
   },
 };
 
 PostInitGlobalActor.prototype.requestTypes = {
   "ping": PostInitGlobalActor.prototype.onPing,
 };
 

--- a/devtools/server/tests/unit/post_init_tab_actors.js
+++ b/devtools/server/tests/unit/post_init_tab_actors.js
@@ -1,16 +1,18 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
-function PostInitTabActor(aConnection) {}
+"use strict";
+
+function PostInitTabActor(connection) {}
 
 PostInitTabActor.prototype = {
   actorPostfix: "postInitTab",
-  onPing: function onPing(aRequest) {
+  onPing(request) {
     return { message: "pong" };
   },
 };
 
 PostInitTabActor.prototype.requestTypes = {
   "ping": PostInitTabActor.prototype.onPing,
 };
 

--- a/devtools/server/tests/unit/pre_init_global_actors.js
+++ b/devtools/server/tests/unit/pre_init_global_actors.js
@@ -1,16 +1,18 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
-function PreInitGlobalActor(aConnection) {}
+"use strict";
+
+function PreInitGlobalActor(connection) {}
 
 PreInitGlobalActor.prototype = {
   actorPrefix: "preInitGlobal",
-  onPing: function onPing(aRequest) {
+  onPing(request) {
     return { message: "pong" };
   },
 };
 
 PreInitGlobalActor.prototype.requestTypes = {
   "ping": PreInitGlobalActor.prototype.onPing,
 };
 

--- a/devtools/server/tests/unit/pre_init_tab_actors.js
+++ b/devtools/server/tests/unit/pre_init_tab_actors.js
@@ -1,16 +1,18 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
-function PreInitTabActor(aConnection) {}
+"use strict";
+
+function PreInitTabActor(connection) {}
 
 PreInitTabActor.prototype = {
   actorPrefix: "preInitTab",
-  onPing: function onPing(aRequest) {
+  onPing(request) {
     return { message: "pong" };
   },
 };
 
 PreInitTabActor.prototype.requestTypes = {
   "ping": PreInitTabActor.prototype.onPing,
 };
 

--- a/devtools/server/tests/unit/registertestactors-01.js
+++ b/devtools/server/tests/unit/registertestactors-01.js
@@ -1,11 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 function Actor() {}
 
 exports.register = function (handle) {
   handle.addTabActor(Actor, "registeredActor1");
   handle.addGlobalActor(Actor, "registeredActor1");
 };
 
 exports.unregister = function (handle) {

--- a/devtools/server/tests/unit/registertestactors-02.js
+++ b/devtools/server/tests/unit/registertestactors-02.js
@@ -1,11 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 function Actor() {}
 
 exports.register = function (handle) {
   handle.addGlobalActor(Actor, "registeredActor2");
   handle.addTabActor(Actor, "registeredActor2");
 };
 
 exports.unregister = function (handle) {

--- a/devtools/server/tests/unit/registertestactors-03.js
+++ b/devtools/server/tests/unit/registertestactors-03.js
@@ -1,12 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
-var {method, RetVal, Actor, ActorClassWithSpec, Front, FrontClassWithSpec,
+"use strict";
+
+var {RetVal, Actor, ActorClassWithSpec, Front, FrontClassWithSpec,
      generateActorSpec} = require("devtools/shared/protocol");
 var Services = require("Services");
 
 const lazySpec = generateActorSpec({
   typeName: "lazy",
 
   methods: {
     hello: {

--- a/devtools/server/tests/unit/test_actor-registry-actor.js
+++ b/devtools/server/tests/unit/test_actor-registry-actor.js
@@ -1,24 +1,25 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check that you can register new actors via the ActorRegistrationActor.
  */
 
 var gClient;
 var gRegistryFront;
 var gActorFront;
 var gOldPref;
 
 const { ActorRegistryFront } = require("devtools/shared/fronts/actor-registry");
 
-function run_test()
-{
+function run_test() {
   gOldPref = Services.prefs.getBoolPref("devtools.debugger.forbid-certified-apps");
   Services.prefs.setBoolPref("devtools.debugger.forbid-certified-apps", false);
   initTestDebuggerServer();
   DebuggerServer.addBrowserActors();
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(getRegistry);
   do_test_pending();
 }
@@ -34,17 +35,17 @@ function registerNewActor() {
   let options = {
     prefix: "helloActor",
     constructor: "HelloActor",
     type: { global: true }
   };
 
   gRegistryFront
     .registerActor("resource://test/hello-actor.js", options)
-    .then(actorFront => gActorFront = actorFront)
+    .then(actorFront => (gActorFront = actorFront))
     .then(talkToNewActor)
     .then(null, e => {
       DevToolsUtils.reportException("registerNewActor", e);
       do_check_true(false);
     });
 }
 
 function talkToNewActor() {

--- a/devtools/server/tests/unit/test_add_actors.js
+++ b/devtools/server/tests/unit/test_add_actors.js
@@ -1,23 +1,24 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gClient;
 var gActors;
 
 /**
  * The purpose of these tests is to verify that it's possible to add actors
  * both before and after the DebuggerServer has been initialized, so addons
  * that add actors don't have to poll the object for its initialization state
  * in order to add actors after initialization but rather can add actors anytime
  * regardless of the object's state.
  */
-function run_test()
-{
+function run_test() {
   DebuggerServer.addActors("resource://test/pre_init_global_actors.js");
   DebuggerServer.addActors("resource://test/pre_init_tab_actors.js");
 
   DebuggerServer.init();
   DebuggerServer.addBrowserActors();
 
   DebuggerServer.addActors("resource://test/post_init_global_actors.js");
   DebuggerServer.addActors("resource://test/post_init_tab_actors.js");
@@ -27,81 +28,77 @@ function run_test()
   add_test(test_pre_init_tab_actor);
   add_test(test_post_init_global_actor);
   add_test(test_post_init_tab_actor);
   add_test(test_stable_global_actor_instances);
   add_test(close_client);
   run_next_test();
 }
 
-function init()
-{
+function init() {
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect()
     .then(() => gClient.listTabs())
-    .then(aResponse => {
-      gActors = aResponse;
+    .then(response => {
+      gActors = response;
       run_next_test();
     });
 }
 
-function test_pre_init_global_actor()
-{
+function test_pre_init_global_actor() {
   gClient.request({ to: gActors.preInitGlobalActor, type: "ping" },
-    function onResponse(aResponse) {
-      do_check_eq(aResponse.message, "pong");
+    function onResponse(response) {
+      do_check_eq(response.message, "pong");
       run_next_test();
     }
   );
 }
 
-function test_pre_init_tab_actor()
-{
+function test_pre_init_tab_actor() {
   gClient.request({ to: gActors.preInitTabActor, type: "ping" },
-    function onResponse(aResponse) {
-      do_check_eq(aResponse.message, "pong");
+    function onResponse(response) {
+      do_check_eq(response.message, "pong");
       run_next_test();
     }
   );
 }
 
-function test_post_init_global_actor()
-{
+function test_post_init_global_actor() {
   gClient.request({ to: gActors.postInitGlobalActor, type: "ping" },
-    function onResponse(aResponse) {
-      do_check_eq(aResponse.message, "pong");
+    function onResponse(response) {
+      do_check_eq(response.message, "pong");
       run_next_test();
     }
   );
 }
 
-function test_post_init_tab_actor()
-{
+function test_post_init_tab_actor() {
   gClient.request({ to: gActors.postInitTabActor, type: "ping" },
-    function onResponse(aResponse) {
-      do_check_eq(aResponse.message, "pong");
+    function onResponse(response) {
+      do_check_eq(response.message, "pong");
       run_next_test();
     }
   );
 }
 
 // Get the object object, from the server side, for a given actor ID
 function getActorInstance(connID, actorID) {
   return DebuggerServer._connections[connID].getActor(actorID);
 }
 
-function test_stable_global_actor_instances()
-{
+function test_stable_global_actor_instances() {
   // Consider that there is only one connection,
   // and the first one is ours
   let connID = Object.keys(DebuggerServer._connections)[0];
   let postInitGlobalActor = getActorInstance(connID, gActors.postInitGlobalActor);
   let preInitGlobalActor = getActorInstance(connID, gActors.preInitGlobalActor);
-  gClient.listTabs(function onListTabs(aResponse) {
-    do_check_eq(postInitGlobalActor, getActorInstance(connID, aResponse.postInitGlobalActor));
-    do_check_eq(preInitGlobalActor, getActorInstance(connID, aResponse.preInitGlobalActor));
+  gClient.listTabs(function onListTabs(response) {
+    do_check_eq(postInitGlobalActor,
+                getActorInstance(connID, response.postInitGlobalActor));
+    do_check_eq(preInitGlobalActor,
+                getActorInstance(connID, response.preInitGlobalActor));
     run_next_test();
   });
 }
 
 function close_client() {
   gClient.close().then(() => run_next_test());
 }

--- a/devtools/server/tests/unit/test_addon_reload.js
+++ b/devtools/server/tests/unit/test_addon_reload.js
@@ -1,12 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
 
-const protocol = require("devtools/shared/protocol");
+"use strict";
+
 const {AddonManager} = require("resource://gre/modules/AddonManager.jsm");
 
 startupAddonsManager();
 
 function promiseAddonEvent(event) {
   return new Promise(resolve => {
     let listener = {
       [event]: function (...args) {
@@ -75,17 +77,17 @@ add_task(function* testReloadExitedAddon
   yield Promise.all([
     reloadAddon(client, addonActor),
     promiseWebExtensionStartup(),
   ]);
 
   // Uninstall the decoy add-on, which should cause its actor to exit.
   const onUninstalled = promiseAddonEvent("onUninstalled");
   installedAddon2.uninstall();
-  const [uninstalledAddon] = yield onUninstalled;
+  yield onUninstalled;
 
   // Try to re-list all add-ons after a reload.
   // This was throwing an exception because of the exited actor.
   const newAddonActor = yield findAddonInRootList(client, installedAddon.id);
   equal(newAddonActor.id, addonActor.id);
 
   // The actor id should be the same after the reload
   equal(newAddonActor.actor, addonActor.actor);

--- a/devtools/server/tests/unit/test_addons_actor.js
+++ b/devtools/server/tests/unit/test_addons_actor.js
@@ -1,13 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
 
-const protocol = require("devtools/shared/protocol");
-const {AddonsActor} = require("devtools/server/actors/addons");
+"use strict";
+
 const {AddonsFront} = require("devtools/shared/fronts/addons");
 
 startupAddonsManager();
 
 function* connect() {
   const client = yield new Promise(resolve => {
     get_chrome_actors(client => resolve(client));
   });

--- a/devtools/server/tests/unit/test_animation_name.js
+++ b/devtools/server/tests/unit/test_animation_name.js
@@ -1,87 +1,87 @@
-/* Any copyright is dedicated to the Public Domain.
-   http://creativecommons.org/publicdomain/zero/1.0/ */
-"use strict";
-
-// Test that AnimationPlayerActor.getName returns the right name depending on
-// the type of an animation and the various properties available on it.
-
-const { AnimationPlayerActor } = require("devtools/server/actors/animation");
-
-function run_test() {
-  // Mock a window with just the properties the AnimationPlayerActor uses.
-  let window = {
-    MutationObserver: function () {
-      this.observe = () => {};
-    },
-    Animation: function () {
-      this.effect = {target: getMockNode()};
-    },
-    CSSAnimation: function () {
-      this.effect = {target: getMockNode()};
-    },
-    CSSTransition: function () {
-      this.effect = {target: getMockNode()};
-    }
-  };
-
-  window.CSSAnimation.prototype = Object.create(window.Animation.prototype);
-  window.CSSTransition.prototype = Object.create(window.Animation.prototype);
-
-  // Helper to get a mock DOM node.
-  function getMockNode() {
-    return {
-      ownerDocument: {
-        defaultView: window
-      }
-    };
-  }
-
-  // Objects in this array should contain the following properties:
-  // - desc {String} For logging
-  // - animation {Object} An animation object instantiated from one of the mock
-  //   window animation constructors.
-  // - props {Objet} Properties of this object will be added to the animation
-  //   object.
-  // - expectedName {String} The expected name returned by
-  //   AnimationPlayerActor.getName.
-  const TEST_DATA = [{
-    desc: "Animation with an id",
-    animation: new window.Animation(),
-    props: { id: "animation-id" },
-    expectedName: "animation-id"
-  }, {
-    desc: "Animation without an id",
-    animation: new window.Animation(),
-    props: {},
-    expectedName: ""
-  }, {
-    desc: "CSSTransition with an id",
-    animation: new window.CSSTransition(),
-    props: { id: "transition-with-id", transitionProperty: "width" },
-    expectedName: "transition-with-id"
-  }, {
-    desc: "CSSAnimation with an id",
-    animation: new window.CSSAnimation(),
-    props: { id: "animation-with-id", animationName: "move" },
-    expectedName: "animation-with-id"
-  }, {
-    desc: "CSSTransition without an id",
-    animation: new window.CSSTransition(),
-    props: { transitionProperty: "width" },
-    expectedName: "width"
-  }, {
-    desc: "CSSAnimation without an id",
-    animation: new window.CSSAnimation(),
-    props: { animationName: "move" },
-    expectedName: "move"
-  }];
-
-  for (let { desc, animation, props, expectedName } of TEST_DATA) {
-    do_print(desc);
-    for (let key in props) {
-      animation[key] = props[key];
-    }
-    let actor = AnimationPlayerActor({}, animation);
-    do_check_eq(actor.getName(), expectedName);
-  }
-}
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Test that AnimationPlayerActor.getName returns the right name depending on
+// the type of an animation and the various properties available on it.
+
+const { AnimationPlayerActor } = require("devtools/server/actors/animation");
+
+function run_test() {
+  // Mock a window with just the properties the AnimationPlayerActor uses.
+  let window = {
+    MutationObserver: function () {
+      this.observe = () => {};
+    },
+    Animation: function () {
+      this.effect = {target: getMockNode()};
+    },
+    CSSAnimation: function () {
+      this.effect = {target: getMockNode()};
+    },
+    CSSTransition: function () {
+      this.effect = {target: getMockNode()};
+    }
+  };
+
+  window.CSSAnimation.prototype = Object.create(window.Animation.prototype);
+  window.CSSTransition.prototype = Object.create(window.Animation.prototype);
+
+  // Helper to get a mock DOM node.
+  function getMockNode() {
+    return {
+      ownerDocument: {
+        defaultView: window
+      }
+    };
+  }
+
+  // Objects in this array should contain the following properties:
+  // - desc {String} For logging
+  // - animation {Object} An animation object instantiated from one of the mock
+  //   window animation constructors.
+  // - props {Objet} Properties of this object will be added to the animation
+  //   object.
+  // - expectedName {String} The expected name returned by
+  //   AnimationPlayerActor.getName.
+  const TEST_DATA = [{
+    desc: "Animation with an id",
+    animation: new window.Animation(),
+    props: { id: "animation-id" },
+    expectedName: "animation-id"
+  }, {
+    desc: "Animation without an id",
+    animation: new window.Animation(),
+    props: {},
+    expectedName: ""
+  }, {
+    desc: "CSSTransition with an id",
+    animation: new window.CSSTransition(),
+    props: { id: "transition-with-id", transitionProperty: "width" },
+    expectedName: "transition-with-id"
+  }, {
+    desc: "CSSAnimation with an id",
+    animation: new window.CSSAnimation(),
+    props: { id: "animation-with-id", animationName: "move" },
+    expectedName: "animation-with-id"
+  }, {
+    desc: "CSSTransition without an id",
+    animation: new window.CSSTransition(),
+    props: { transitionProperty: "width" },
+    expectedName: "width"
+  }, {
+    desc: "CSSAnimation without an id",
+    animation: new window.CSSAnimation(),
+    props: { animationName: "move" },
+    expectedName: "move"
+  }];
+
+  for (let { desc, animation, props, expectedName } of TEST_DATA) {
+    do_print(desc);
+    for (let key in props) {
+      animation[key] = props[key];
+    }
+    let actor = AnimationPlayerActor({}, animation);
+    do_check_eq(actor.getName(), expectedName);
+  }
+}

--- a/devtools/server/tests/unit/test_animation_type.js
+++ b/devtools/server/tests/unit/test_animation_type.js
@@ -1,68 +1,68 @@
-/* Any copyright is dedicated to the Public Domain.
-   http://creativecommons.org/publicdomain/zero/1.0/ */
-"use strict";
-
-// Test the output of AnimationPlayerActor.getType().
-
-const { ANIMATION_TYPES, AnimationPlayerActor } =
-  require("devtools/server/actors/animation");
-
-function run_test() {
-  // Mock a window with just the properties the AnimationPlayerActor uses.
-  let window = {
-    MutationObserver: function () {
-      this.observe = () => {};
-    },
-    Animation: function () {
-      this.effect = {target: getMockNode()};
-    },
-    CSSAnimation: function () {
-      this.effect = {target: getMockNode()};
-    },
-    CSSTransition: function () {
-      this.effect = {target: getMockNode()};
-    }
-  };
-
-  window.CSSAnimation.prototype = Object.create(window.Animation.prototype);
-  window.CSSTransition.prototype = Object.create(window.Animation.prototype);
-
-  // Helper to get a mock DOM node.
-  function getMockNode() {
-    return {
-      ownerDocument: {
-        defaultView: window
-      }
-    };
-  }
-
-  // Objects in this array should contain the following properties:
-  // - desc {String} For logging
-  // - animation {Object} An animation object instantiated from one of the mock
-  //   window animation constructors.
-  // - expectedType {String} The expected type returned by
-  //   AnimationPlayerActor.getType.
-  const TEST_DATA = [{
-    desc: "Test CSSAnimation type",
-    animation: new window.CSSAnimation(),
-    expectedType: ANIMATION_TYPES.CSS_ANIMATION
-  }, {
-    desc: "Test CSSTransition type",
-    animation: new window.CSSTransition(),
-    expectedType: ANIMATION_TYPES.CSS_TRANSITION
-  }, {
-    desc: "Test ScriptAnimation type",
-    animation: new window.Animation(),
-    expectedType: ANIMATION_TYPES.SCRIPT_ANIMATION
-  }, {
-    desc: "Test unknown type",
-    animation: {effect: {target: getMockNode()}},
-    expectedType: ANIMATION_TYPES.UNKNOWN
-  }];
-
-  for (let { desc, animation, expectedType } of TEST_DATA) {
-    do_print(desc);
-    let actor = AnimationPlayerActor({}, animation);
-    do_check_eq(actor.getType(), expectedType);
-  }
-}
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Test the output of AnimationPlayerActor.getType().
+
+const { ANIMATION_TYPES, AnimationPlayerActor } =
+  require("devtools/server/actors/animation");
+
+function run_test() {
+  // Mock a window with just the properties the AnimationPlayerActor uses.
+  let window = {
+    MutationObserver: function () {
+      this.observe = () => {};
+    },
+    Animation: function () {
+      this.effect = {target: getMockNode()};
+    },
+    CSSAnimation: function () {
+      this.effect = {target: getMockNode()};
+    },
+    CSSTransition: function () {
+      this.effect = {target: getMockNode()};
+    }
+  };
+
+  window.CSSAnimation.prototype = Object.create(window.Animation.prototype);
+  window.CSSTransition.prototype = Object.create(window.Animation.prototype);
+
+  // Helper to get a mock DOM node.
+  function getMockNode() {
+    return {
+      ownerDocument: {
+        defaultView: window
+      }
+    };
+  }
+
+  // Objects in this array should contain the following properties:
+  // - desc {String} For logging
+  // - animation {Object} An animation object instantiated from one of the mock
+  //   window animation constructors.
+  // - expectedType {String} The expected type returned by
+  //   AnimationPlayerActor.getType.
+  const TEST_DATA = [{
+    desc: "Test CSSAnimation type",
+    animation: new window.CSSAnimation(),
+    expectedType: ANIMATION_TYPES.CSS_ANIMATION
+  }, {
+    desc: "Test CSSTransition type",
+    animation: new window.CSSTransition(),
+    expectedType: ANIMATION_TYPES.CSS_TRANSITION
+  }, {
+    desc: "Test ScriptAnimation type",
+    animation: new window.Animation(),
+    expectedType: ANIMATION_TYPES.SCRIPT_ANIMATION
+  }, {
+    desc: "Test unknown type",
+    animation: {effect: {target: getMockNode()}},
+    expectedType: ANIMATION_TYPES.UNKNOWN
+  }];
+
+  for (let { desc, animation, expectedType } of TEST_DATA) {
+    do_print(desc);
+    let actor = AnimationPlayerActor({}, animation);
+    do_check_eq(actor.getType(), expectedType);
+  }
+}

--- a/devtools/server/tests/unit/test_attach.js
+++ b/devtools/server/tests/unit/test_attach.js
@@ -1,37 +1,36 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gClient;
 var gDebuggee;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = testGlobal("test-1");
   DebuggerServer.addTestGlobal(gDebuggee);
 
   let transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
-  gClient.connect().then(function ([aType, aTraits]) {
-    attachTestTab(gClient, "test-1", function (aReply, aTabClient) {
-      test_attach(aTabClient);
+  gClient.connect().then(function ([type, traits]) {
+    attachTestTab(gClient, "test-1", function (reply, tabClient) {
+      test_attach(tabClient);
     });
   });
   do_test_pending();
 }
 
-function test_attach(aTabClient)
-{
-  aTabClient.attachThread({}, function (aResponse, aThreadClient) {
-    do_check_eq(aThreadClient.state, "paused");
-    aThreadClient.resume(cleanup);
+function test_attach(tabClient) {
+  tabClient.attachThread({}, function (response, threadClient) {
+    do_check_eq(threadClient.state, "paused");
+    threadClient.resume(cleanup);
   });
 }
 
-function cleanup()
-{
-  gClient.addListener("closed", function (aEvent) {
+function cleanup() {
+  gClient.addListener("closed", function (event) {
     do_test_finished();
   });
   gClient.close();
 }

--- a/devtools/server/tests/unit/test_blackboxing-01.js
+++ b/devtools/server/tests/unit/test_blackboxing-01.js
@@ -1,29 +1,31 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Test basic black boxing.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-black-box", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      testBlackBox();
-    });
+    attachTestTabAndResume(gClient, "test-black-box",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             testBlackBox();
+                           });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
 const SOURCE_URL = "http://example.com/source.js";
 
 const testBlackBox = Task.async(function* () {
@@ -38,64 +40,65 @@ const testBlackBox = Task.async(function
   const { sources } = yield getSources(gThreadClient);
   let sourceClient = gThreadClient.source(
     sources.filter(s => s.url == BLACK_BOXED_URL)[0]);
   do_check_true(!sourceClient.isBlackBoxed,
                 "By default the source is not black boxed.");
 
   // Test that we can step into `doStuff` when we are not black boxed.
   yield runTest(
-    function onSteppedLocation(aLocation) {
-      do_check_eq(aLocation.source.url, BLACK_BOXED_URL);
-      do_check_eq(aLocation.line, 2);
+    function onSteppedLocation(location) {
+      do_check_eq(location.source.url, BLACK_BOXED_URL);
+      do_check_eq(location.line, 2);
     },
-    function onDebuggerStatementFrames(aFrames) {
-      do_check_true(!aFrames.some(f => f.where.source.isBlackBoxed));
+    function onDebuggerStatementFrames(frames) {
+      do_check_true(!frames.some(f => f.where.source.isBlackBoxed));
     }
   );
 
-  let blackBoxResponse = yield blackBox(sourceClient);
+  yield blackBox(sourceClient);
   do_check_true(sourceClient.isBlackBoxed);
 
   // Test that we step through `doStuff` when we are black boxed and its frame
   // doesn't show up.
   yield runTest(
-    function onSteppedLocation(aLocation) {
-      do_check_eq(aLocation.source.url, SOURCE_URL);
-      do_check_eq(aLocation.line, 4);
+    function onSteppedLocation(location) {
+      do_check_eq(location.source.url, SOURCE_URL);
+      do_check_eq(location.line, 4);
     },
-    function onDebuggerStatementFrames(aFrames) {
-      for (let f of aFrames) {
+    function onDebuggerStatementFrames(frames) {
+      for (let f of frames) {
         if (f.where.source.url == BLACK_BOXED_URL) {
           do_check_true(f.where.source.isBlackBoxed);
         } else {
           do_check_true(!f.where.source.isBlackBoxed);
         }
       }
     }
   );
 
-  let unBlackBoxResponse = yield unBlackBox(sourceClient);
+  yield unBlackBox(sourceClient);
   do_check_true(!sourceClient.isBlackBoxed);
 
   // Test that we can step into `doStuff` again.
   yield runTest(
-    function onSteppedLocation(aLocation) {
-      do_check_eq(aLocation.source.url, BLACK_BOXED_URL);
-      do_check_eq(aLocation.line, 2);
+    function onSteppedLocation(location) {
+      do_check_eq(location.source.url, BLACK_BOXED_URL);
+      do_check_eq(location.line, 2);
     },
-    function onDebuggerStatementFrames(aFrames) {
-      do_check_true(!aFrames.some(f => f.where.source.isBlackBoxed));
+    function onDebuggerStatementFrames(frames) {
+      do_check_true(!frames.some(f => f.where.source.isBlackBoxed));
     }
   );
 
   finishClient(gClient);
 });
 
 function evalCode() {
+  /* eslint-disable */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
       let arg = 15;            // line 2 - Step in here
       k(arg);                  // line 3
     },                         // line 4
     gDebuggee,
     "1.8",
     BLACK_BOXED_URL,
@@ -111,16 +114,17 @@ function evalCode() {
       );                      // line 6
     } + "\n"                  // line 7
     + "debugger;",            // line 8
     gDebuggee,
     "1.8",
     SOURCE_URL,
     1
   );
+  /* eslint-enable */
 }
 
 const runTest = Task.async(function* (onSteppedLocation, onDebuggerStatementFrames) {
   let packet = yield executeOnNextTickAndWaitForPause(gDebuggee.runTest,
                                                       gClient);
   do_check_eq(packet.why.type, "breakpoint");
 
   yield stepIn(gClient, gThreadClient);

--- a/devtools/server/tests/unit/test_blackboxing-02.js
+++ b/devtools/server/tests/unit/test_blackboxing-02.js
@@ -1,59 +1,62 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Test that we don't hit breakpoints in black boxed sources, and that when we
  * unblack box the source again, the breakpoint hasn't disappeared and we will
  * hit it again.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-black-box", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_black_box();
-    });
+    attachTestTabAndResume(gClient, "test-black-box",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_black_box();
+                           });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
 const SOURCE_URL = "http://example.com/source.js";
 
-function test_black_box()
-{
-  gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.eval(aPacket.frame.actor, "doStuff", function (aResponse) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-        let obj = gThreadClient.pauseGrip(aPacket.why.frameFinished.return);
+function test_black_box() {
+  gClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.eval(packet.frame.actor, "doStuff", function (response) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
+        let obj = gThreadClient.pauseGrip(packet.why.frameFinished.return);
         obj.getDefinitionSite(runWithSource);
       });
     });
 
-    function runWithSource(aPacket) {
-      let source = gThreadClient.source(aPacket.source);
+    function runWithSource(packet) {
+      let source = gThreadClient.source(packet.source);
       source.setBreakpoint({
         line: 2
-      }, function (aResponse) {
-        do_check_true(!aResponse.error, "Should be able to set breakpoint.");
+      }, function (response) {
+        do_check_true(!response.error, "Should be able to set breakpoint.");
         gThreadClient.resume(test_black_box_breakpoint);
       });
     }
   });
 
+  /* eslint-disable */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
       let arg = 15;            // line 2 - Break here
       k(arg);                  // line 3
     },                         // line 4
     gDebuggee,
     "1.8",
     BLACK_BOXED_URL,
@@ -69,43 +72,48 @@ function test_black_box()
       );                      // line 7
     }                         // line 8
     + "\n debugger;",         // line 9
     gDebuggee,
     "1.8",
     SOURCE_URL,
     1
   );
+  /* eslint-enable */
 }
 
 function test_black_box_breakpoint() {
   gThreadClient.getSources(function ({error, sources}) {
     do_check_true(!error, "Should not get an error: " + error);
-    let sourceClient = gThreadClient.source(sources.filter(s => s.url == BLACK_BOXED_URL)[0]);
+    let sourceClient = gThreadClient.source(
+      sources.filter(s => s.url == BLACK_BOXED_URL)[0]
+    );
     sourceClient.blackBox(function ({error}) {
       do_check_true(!error, "Should not get an error: " + error);
 
-      gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-        do_check_eq(aPacket.why.type, "debuggerStatement",
-                    "We should pass over the breakpoint since the source is black boxed.");
+      gClient.addOneTimeListener("paused", function (event, packet) {
+        do_check_eq(
+          packet.why.type, "debuggerStatement",
+          "We should pass over the breakpoint since the source is black boxed.");
         gThreadClient.resume(test_unblack_box_breakpoint.bind(null, sourceClient));
       });
       gDebuggee.runTest();
     });
   });
 }
 
-function test_unblack_box_breakpoint(aSourceClient) {
-  aSourceClient.unblackBox(function ({error}) {
+function test_unblack_box_breakpoint(sourceClient) {
+  sourceClient.unblackBox(function ({error}) {
     do_check_true(!error, "Should not get an error: " + error);
-    gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-      do_check_eq(aPacket.why.type, "breakpoint",
+    gClient.addOneTimeListener("paused", function (event, packet) {
+      do_check_eq(packet.why.type, "breakpoint",
                   "We should hit the breakpoint again");
 
-      // We will hit the debugger statement on resume, so do this nastiness to skip over it.
+      // We will hit the debugger statement on resume, so do this
+      // nastiness to skip over it.
       gClient.addOneTimeListener(
         "paused",
         gThreadClient.resume.bind(
           gThreadClient,
           finishClient.bind(null, gClient)));
       gThreadClient.resume();
     });
     gDebuggee.runTest();

--- a/devtools/server/tests/unit/test_blackboxing-03.js
+++ b/devtools/server/tests/unit/test_blackboxing-03.js
@@ -1,50 +1,53 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Test that we don't stop at debugger statements inside black boxed sources.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gBpClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-black-box", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_black_box();
-    });
+    attachTestTabAndResume(gClient, "test-black-box",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_black_box();
+                           });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
 const SOURCE_URL = "http://example.com/source.js";
 
-function test_black_box()
-{
-  gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_black_box() {
+  gClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     source.setBreakpoint({
       line: 4
     }, function ({error}, bpClient) {
       gBpClient = bpClient;
       do_check_true(!error, "Should not get an error: " + error);
       gThreadClient.resume(test_black_box_dbg_statement);
     });
   });
 
+  /* eslint-disable */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
       debugger;                // line 2 - Break here
       k(100);                  // line 3
     },                         // line 4
     gDebuggee,
     "1.8",
     BLACK_BOXED_URL,
@@ -60,43 +63,46 @@ function test_black_box()
       );                      // line 6
     }                         // line 7
     + "\n debugger;",         // line 8
     gDebuggee,
     "1.8",
     SOURCE_URL,
     1
   );
+  /* eslint-enable */
 }
 
 function test_black_box_dbg_statement() {
   gThreadClient.getSources(function ({error, sources}) {
     do_check_true(!error, "Should not get an error: " + error);
-    let sourceClient = gThreadClient.source(sources.filter(s => s.url == BLACK_BOXED_URL)[0]);
+    let sourceClient = gThreadClient.source(
+      sources.filter(s => s.url == BLACK_BOXED_URL)[0]
+    );
 
     sourceClient.blackBox(function ({error}) {
       do_check_true(!error, "Should not get an error: " + error);
 
-      gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-        do_check_eq(aPacket.why.type, "breakpoint",
+      gClient.addOneTimeListener("paused", function (event, packet) {
+        do_check_eq(packet.why.type, "breakpoint",
                     "We should pass over the debugger statement.");
         gBpClient.remove(function ({error}) {
           do_check_true(!error, "Should not get an error: " + error);
           gThreadClient.resume(test_unblack_box_dbg_statement.bind(null, sourceClient));
         });
       });
       gDebuggee.runTest();
     });
   });
 }
 
-function test_unblack_box_dbg_statement(aSourceClient) {
-  aSourceClient.unblackBox(function ({error}) {
+function test_unblack_box_dbg_statement(sourceClient) {
+  sourceClient.unblackBox(function ({error}) {
     do_check_true(!error, "Should not get an error: " + error);
 
-    gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-      do_check_eq(aPacket.why.type, "debuggerStatement",
+    gClient.addOneTimeListener("paused", function (event, packet) {
+      do_check_eq(packet.why.type, "debuggerStatement",
                   "We should stop at the debugger statement again");
       finishClient(gClient);
     });
     gDebuggee.runTest();
   });
 }

--- a/devtools/server/tests/unit/test_blackboxing-04.js
+++ b/devtools/server/tests/unit/test_blackboxing-04.js
@@ -1,57 +1,60 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Test behavior of blackboxing sources we are currently paused in.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-black-box", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_black_box();
-    });
+    attachTestTabAndResume(gClient, "test-black-box",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_black_box();
+                           });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
 const SOURCE_URL = "http://example.com/source.js";
 
-function test_black_box()
-{
-  gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.eval(aPacket.frame.actor, "doStuff", function (aResponse) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-        let obj = gThreadClient.pauseGrip(aPacket.why.frameFinished.return);
+function test_black_box() {
+  gClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.eval(packet.frame.actor, "doStuff", function (response) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
+        let obj = gThreadClient.pauseGrip(packet.why.frameFinished.return);
         obj.getDefinitionSite(runWithSource);
       });
     });
 
-    function runWithSource(aPacket) {
-      let source = gThreadClient.source(aPacket.source);
+    function runWithSource(packet) {
+      let source = gThreadClient.source(packet.source);
       source.setBreakpoint({
         line: 2
-      }, function (aResponse) {
-        do_check_true(!aResponse.error, "Should be able to set breakpoint.");
+      }, function (response) {
+        do_check_true(!response.error, "Should be able to set breakpoint.");
         test_black_box_paused();
       });
     }
   });
 
+  /* eslint-disable */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) { // line 1
       debugger;                // line 2
       k(100);                  // line 3
     },                         // line 4
     gDebuggee,
     "1.8",
     BLACK_BOXED_URL,
@@ -67,22 +70,26 @@ function test_black_box()
       );                      // line 6
     }                         // line 7
     + "\n runTest();",        // line 8
     gDebuggee,
     "1.8",
     SOURCE_URL,
     1
   );
+  /* eslint-enable */
 }
 
 function test_black_box_paused() {
   gThreadClient.getSources(function ({error, sources}) {
     do_check_true(!error, "Should not get an error: " + error);
-    let sourceClient = gThreadClient.source(sources.filter(s => s.url == BLACK_BOXED_URL)[0]);
+    let sourceClient = gThreadClient.source(
+      sources.filter(s => s.url == BLACK_BOXED_URL)[0]
+    );
 
     sourceClient.blackBox(function ({error, pausedInSource}) {
       do_check_true(!error, "Should not get an error: " + error);
-      do_check_true(pausedInSource, "We should be notified that we are currently paused in this source");
+      do_check_true(pausedInSource,
+                    "We should be notified that we are currently paused in this source");
       finishClient(gClient);
     });
   });
 }

--- a/devtools/server/tests/unit/test_blackboxing-05.js
+++ b/devtools/server/tests/unit/test_blackboxing-05.js
@@ -1,45 +1,49 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Test exceptions inside black boxed sources.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-black-box", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      // XXX: We have to do an executeSoon so that the error isn't caught and
-      // reported by DebuggerClient.requester (because we are using the local
-      // transport and share a stack) which causes the test to fail.
-      Services.tm.mainThread.dispatch({
-        run: test_black_box
-      }, Ci.nsIThread.DISPATCH_NORMAL);
-    });
+    attachTestTabAndResume(
+      gClient, "test-black-box",
+      function (response, tabClient, threadClient) {
+        gThreadClient = threadClient;
+        // XXX: We have to do an executeSoon so that the error isn't caught and
+        // reported by DebuggerClient.requester (because we are using the local
+        // transport and share a stack) which causes the test to fail.
+        Services.tm.mainThread.dispatch({
+          run: test_black_box
+        }, Ci.nsIThread.DISPATCH_NORMAL);
+      });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
 const SOURCE_URL = "http://example.com/source.js";
 
-function test_black_box()
-{
+function test_black_box() {
   gClient.addOneTimeListener("paused", test_black_box_exception);
 
+  /* eslint-disable */
   Components.utils.evalInSandbox(
     "" + function doStuff(k) {                                   // line 1
       throw new Error("wu tang clan ain't nuthin' ta fuck wit"); // line 2
       k(100);                                                    // line 3
     },                                                           // line 4
     gDebuggee,
     "1.8",
     BLACK_BOXED_URL,
@@ -56,29 +60,32 @@ function test_black_box()
     }                                           // line 7
     + "\ndebugger;\n"                           // line 8
     + "try { runTest() } catch (ex) { }",       // line 9
     gDebuggee,
     "1.8",
     SOURCE_URL,
     1
   );
+  /* eslint-enable */
 }
 
 function test_black_box_exception() {
   gThreadClient.getSources(function ({error, sources}) {
     do_check_true(!error, "Should not get an error: " + error);
-    let sourceClient = gThreadClient.source(sources.filter(s => s.url == BLACK_BOXED_URL)[0]);
+    let sourceClient = gThreadClient.source(
+      sources.filter(s => s.url == BLACK_BOXED_URL)[0]
+    );
 
     sourceClient.blackBox(function ({error}) {
       do_check_true(!error, "Should not get an error: " + error);
       gThreadClient.pauseOnExceptions(true);
 
-      gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-        do_check_eq(aPacket.frame.where.source.url, SOURCE_URL,
+      gClient.addOneTimeListener("paused", function (event, packet) {
+        do_check_eq(packet.frame.where.source.url, SOURCE_URL,
                     "We shouldn't pause while in the black boxed source.");
         finishClient(gClient);
       });
 
       gThreadClient.resume();
     });
   });
 }

--- a/devtools/server/tests/unit/test_blackboxing-06.js
+++ b/devtools/server/tests/unit/test_blackboxing-06.js
@@ -1,46 +1,51 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Test that we can black box source mapped sources.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
 const {SourceNode} = require("source-map");
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-black-box", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
+    attachTestTabAndResume(
+      gClient, "test-black-box",
+      function (response, tabClient, threadClient) {
+        gThreadClient = threadClient;
 
-      promise.resolve(setup_code())
-        .then(black_box_code)
-        .then(run_code)
-        .then(test_correct_location)
-        .then(null, function (error) {
-          do_check_true(false, "Should not get an error, got " + error);
-        })
-        .then(function () {
-          finishClient(gClient);
-        });
-    });
+        promise.resolve(setup_code())
+          .then(black_box_code)
+          .then(run_code)
+          .then(test_correct_location)
+          .then(null, function (error) {
+            do_check_true(false, "Should not get an error, got " + error);
+          })
+          .then(function () {
+            finishClient(gClient);
+          });
+      });
   });
   do_test_pending();
 }
 
 function setup_code() {
+  /* eslint-disable */
   let { code, map } = (new SourceNode(null, null, null, [
     new SourceNode(1, 0, "a.js", "" + function a() {
       return b();
     }),
     "\n",
     new SourceNode(1, 0, "b.js", "" + function b() {
       debugger; // Don't want to stop here.
       return c();
@@ -49,16 +54,17 @@ function setup_code() {
     new SourceNode(1, 0, "c.js", "" + function c() {
       debugger; // Want to stop here.
     }),
     "\n"
   ])).toStringWithSourceMap({
     file: "abc.js",
     sourceRoot: "http://example.com/"
   });
+  /* eslint-enable */
 
   code += "//# sourceMappingURL=data:text/json," + map.toString();
 
   Components.utils.evalInSandbox(code,
                                  gDebuggee,
                                  "1.8",
                                  "http://example.com/abc.js");
 }
@@ -80,23 +86,24 @@ function black_box_code() {
   });
 
   return d.promise;
 }
 
 function run_code() {
   const d = promise.defer();
 
-  gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    d.resolve(aPacket);
+  gClient.addOneTimeListener("paused", function (event, packet) {
+    d.resolve(packet);
     gThreadClient.resume();
   });
   gDebuggee.a();
 
   return d.promise;
 }
 
-function test_correct_location(aPacket) {
-  do_check_eq(aPacket.why.type, "debuggerStatement",
+function test_correct_location(packet) {
+  do_check_eq(packet.why.type, "debuggerStatement",
               "Should hit a debugger statement.");
-  do_check_eq(aPacket.frame.where.source.url, "http://example.com/c.js",
-              "Should have skipped over the debugger statement in the black boxed source");
+  do_check_eq(packet.frame.where.source.url, "http://example.com/c.js",
+              "Should have skipped over the debugger statement in the" +
+              " black boxed source");
 }

--- a/devtools/server/tests/unit/test_blackboxing-07.js
+++ b/devtools/server/tests/unit/test_blackboxing-07.js
@@ -1,30 +1,32 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Test that sources whose URL ends with ".min.js" automatically get black
  * boxed.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-black-box", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      testBlackBox();
-    });
+    attachTestTabAndResume(gClient, "test-black-box",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             testBlackBox();
+                           });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/black-boxed.min.js";
 const SOURCE_URL = "http://example.com/source.js";
 
 const testBlackBox = Task.async(function* () {

--- a/devtools/server/tests/unit/test_breakpoint-01.js
+++ b/devtools/server/tests/unit/test_breakpoint-01.js
@@ -1,75 +1,77 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check basic breakpoint functionality.
  */
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_breakpoint();
+                           });
   });
 }
 
-function test_simple_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_simple_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = {
       line: gDebuggee.line0 + 3
     };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+    source.setBreakpoint(location, function (response, bpClient) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.frame.where.source.actor, source.actor);
-        do_check_eq(aPacket.frame.where.line, location.line);
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.frame.where.source.actor, source.actor);
+        do_check_eq(packet.frame.where.line, location.line);
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.a, 1);
         do_check_eq(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
-
       });
 
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "debugger;\n" +   // line0 + 1
     "var a = 1;\n" +  // line0 + 2
     "var b = 2;\n",   // line0 + 3
     gDebuggee
   );
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-02.js
+++ b/devtools/server/tests/unit/test_breakpoint-02.js
@@ -1,67 +1,70 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Check that setting breakpoints when the debuggee is running works.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_breakpoint_running();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_breakpoint_running();
+                           });
   });
 }
 
-function test_breakpoint_running()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+function test_breakpoint_running() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let location = { line: gDebuggee.line0 + 3 };
 
     gThreadClient.resume();
 
     // Setting the breakpoint later should interrupt the debuggee.
-    gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-      do_check_eq(aPacket.type, "paused");
-      do_check_eq(aPacket.why.type, "interrupted");
+    gThreadClient.addOneTimeListener("paused", function (event, packet) {
+      do_check_eq(packet.type, "paused");
+      do_check_eq(packet.why.type, "interrupted");
     });
 
-    let source = gThreadClient.source(aPacket.frame.where.source);
-    source.setBreakpoint(location, function (aResponse) {
+    let source = gThreadClient.source(packet.frame.where.source);
+    source.setBreakpoint(location, function (response) {
       // Eval scripts don't stick around long enough for the breakpoint to be set,
       // so just make sure we got the expected response from the actor.
-      do_check_neq(aResponse.error, "noScript");
+      do_check_neq(response.error, "noScript");
 
       do_execute_soon(function () {
         gClient.close().then(gCallback);
       });
     });
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "debugger;\n" +
     "var a = 1;\n" +  // line0 + 2
     "var b = 2;\n",  // line0 + 3
     gDebuggee
   );
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-03.js
+++ b/devtools/server/tests/unit/test_breakpoint-03.js
@@ -1,96 +1,99 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that setting a breakpoint on a line without code will skip
  * forward when we know the script isn't GCed (the debugger is connected,
  * so it's kept alive).
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(gClient,
                            "test-stack",
-                           function (aResponse, aTabClient, aThreadClient) {
-                             gThreadClient = aThreadClient;
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
                              test_skip_breakpoint();
                            });
   });
 }
 
-var test_no_skip_breakpoint = Task.async(function*(source, location) {
-  let [aResponse, bpClient] = yield source.setBreakpoint(
+var test_no_skip_breakpoint = Task.async(function* (source, location) {
+  let [response, bpClient] = yield source.setBreakpoint(
     Object.assign({}, location, { noSliding: true })
   );
 
-  do_check_true(!aResponse.actualLocation);
+  do_check_true(!response.actualLocation);
   do_check_eq(bpClient.location.line, gDebuggee.line0 + 3);
   yield bpClient.remove();
 });
 
-var test_skip_breakpoint = function() {
-  gThreadClient.addOneTimeListener("paused", Task.async(function *(aEvent, aPacket) {
+var test_skip_breakpoint = function () {
+  gThreadClient.addOneTimeListener("paused", Task.async(function* (event, packet) {
     let location = { line: gDebuggee.line0 + 3 };
-    let source = gThreadClient.source(aPacket.frame.where.source);
+    let source = gThreadClient.source(packet.frame.where.source);
 
     // First, make sure that we can disable sliding with the
     // `noSliding` option.
     yield test_no_skip_breakpoint(source, location);
 
     // Now make sure that the breakpoint properly slides forward one line.
-    const [aResponse, bpClient] = yield source.setBreakpoint(location);
-    do_check_true(!!aResponse.actualLocation);
-    do_check_eq(aResponse.actualLocation.source.actor, source.actor);
-    do_check_eq(aResponse.actualLocation.line, location.line + 1);
+    const [response, bpClient] = yield source.setBreakpoint(location);
+    do_check_true(!!response.actualLocation);
+    do_check_eq(response.actualLocation.source.actor, source.actor);
+    do_check_eq(response.actualLocation.line, location.line + 1);
 
-    gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+    gThreadClient.addOneTimeListener("paused", function (event, packet) {
       // Check the return value.
-      do_check_eq(aPacket.type, "paused");
-      do_check_eq(aPacket.frame.where.source.actor, source.actor);
-      do_check_eq(aPacket.frame.where.line, location.line + 1);
-      do_check_eq(aPacket.why.type, "breakpoint");
-      do_check_eq(aPacket.why.actors[0], bpClient.actor);
+      do_check_eq(packet.type, "paused");
+      do_check_eq(packet.frame.where.source.actor, source.actor);
+      do_check_eq(packet.frame.where.line, location.line + 1);
+      do_check_eq(packet.why.type, "breakpoint");
+      do_check_eq(packet.why.actors[0], bpClient.actor);
       // Check that the breakpoint worked.
       do_check_eq(gDebuggee.a, 1);
       do_check_eq(gDebuggee.b, undefined);
 
       // Remove the breakpoint.
-      bpClient.remove(function (aResponse) {
+      bpClient.remove(function (response) {
         gThreadClient.resume(function () {
           gClient.close().then(gCallback);
         });
       });
     });
 
     gThreadClient.resume();
   }));
 
   // Use `evalInSandbox` to make the debugger treat it as normal
   // globally-scoped code, where breakpoint sliding rules apply.
+  /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "debugger;\n" +      // line0 + 1
     "var a = 1;\n" +     // line0 + 2
     "// A comment.\n" +  // line0 + 3
     "var b = 2;",        // line0 + 4
     gDebuggee
   );
-}
+  /* eslint-enable */
+};

--- a/devtools/server/tests/unit/test_breakpoint-04.js
+++ b/devtools/server/tests/unit/test_breakpoint-04.js
@@ -1,80 +1,82 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that setting a breakpoint in a line in a child script works.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_child_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_child_breakpoint();
+                           });
   });
 }
 
-function test_child_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_child_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3 };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
+    source.setBreakpoint(location, function (response, bpClient) {
       // actualLocation is not returned when breakpoints don't skip forward.
-      do_check_eq(aResponse.actualLocation, undefined);
+      do_check_eq(response.actualLocation, undefined);
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.frame.where.source.actor, source.actor);
-        do_check_eq(aPacket.frame.where.line, location.line);
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.frame.where.source.actor, source.actor);
+        do_check_eq(packet.frame.where.line, location.line);
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.a, 1);
         do_check_eq(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
 
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
-
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "function foo() {\n" + // line0 + 1
     "  this.a = 1;\n" +    // line0 + 2
     "  this.b = 2;\n" +    // line0 + 3
     "}\n" +                // line0 + 4
     "debugger;\n" +        // line0 + 5
     "foo();\n",            // line0 + 6
     gDebuggee
   );
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-05.js
+++ b/devtools/server/tests/unit/test_breakpoint-05.js
@@ -1,82 +1,85 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that setting a breakpoint in a line without code in a child script
  * will skip forward.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_child_skip_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_child_skip_breakpoint();
+                           });
   });
 }
 
-function test_child_skip_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_child_skip_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3 };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
+    source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(aResponse.actualLocation.source.actor, source.actor);
-      do_check_eq(aResponse.actualLocation.line, location.line + 1);
+      do_check_eq(response.actualLocation.source.actor, source.actor);
+      do_check_eq(response.actualLocation.line, location.line + 1);
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.frame.where.source.actor, source.actor);
-        do_check_eq(aPacket.frame.where.line, location.line + 1);
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.frame.where.source.actor, source.actor);
+        do_check_eq(packet.frame.where.line, location.line + 1);
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.a, 1);
         do_check_eq(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
 
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "function foo() {\n" + // line0 + 1
     "  this.a = 1;\n" +    // line0 + 2
     "  // A comment.\n" +  // line0 + 3
     "  this.b = 2;\n" +    // line0 + 4
     "}\n" +                // line0 + 5
     "debugger;\n" +        // line0 + 6
     "foo();\n",            // line0 + 7
     gDebuggee
   );
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-06.js
+++ b/devtools/server/tests/unit/test_breakpoint-06.js
@@ -1,79 +1,80 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that setting a breakpoint in a line without code in a deeply-nested
  * child script will skip forward.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_nested_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_nested_breakpoint();
+                           });
   });
 }
 
-function test_nested_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_nested_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 5 };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
+    source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(aResponse.actualLocation.source.actor, source.actor);
-      do_check_eq(aResponse.actualLocation.line, location.line + 1);
+      do_check_eq(response.actualLocation.source.actor, source.actor);
+      do_check_eq(response.actualLocation.line, location.line + 1);
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.frame.where.source.actor, source.actor);
-        do_check_eq(aPacket.frame.where.line, location.line + 1);
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.frame.where.source.actor, source.actor);
+        do_check_eq(packet.frame.where.line, location.line + 1);
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.a, 1);
         do_check_eq(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
 
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
-
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "function foo() {\n" +     // line0 + 1
     "  function bar() {\n" +   // line0 + 2
     "    function baz() {\n" + // line0 + 3
     "      this.a = 1;\n" +    // line0 + 4
     "      // A comment.\n" +  // line0 + 5
     "      this.b = 2;\n" +    // line0 + 6
@@ -81,9 +82,10 @@ function test_nested_breakpoint()
     "    baz();\n" +           // line0 + 8
     "  }\n" +                  // line0 + 9
     "  bar();\n" +             // line0 + 10
     "}\n" +                    // line0 + 11
     "debugger;\n" +            // line0 + 12
     "foo();\n",               // line0 + 13
     gDebuggee
   );
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-07.js
+++ b/devtools/server/tests/unit/test_breakpoint-07.js
@@ -1,85 +1,88 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that setting a breakpoint in a line without code in the second child
  * script will skip forward.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_second_child_skip_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_second_child_skip_breakpoint();
+                           });
   });
 }
 
-function test_second_child_skip_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_second_child_skip_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 6 };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
+    source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(aResponse.actualLocation.source.actor, source.actor);
-      do_check_eq(aResponse.actualLocation.line, location.line + 1);
+      do_check_eq(response.actualLocation.source.actor, source.actor);
+      do_check_eq(response.actualLocation.line, location.line + 1);
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.frame.where.source.actor, source.actor);
-        do_check_eq(aPacket.frame.where.line, location.line + 1);
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.frame.where.source.actor, source.actor);
+        do_check_eq(packet.frame.where.line, location.line + 1);
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.a, 1);
         do_check_eq(gDebuggee.b, undefined);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
 
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "function foo() {\n" + // line0 + 1
     "  bar();\n" +         // line0 + 2
     "}\n" +                // line0 + 3
     "function bar() {\n" + // line0 + 4
     "  this.a = 1;\n" +    // line0 + 5
     "  // A comment.\n" +  // line0 + 6
     "  this.b = 2;\n" +    // line0 + 7
     "}\n" +                // line0 + 8
     "debugger;\n" +        // line0 + 9
     "foo();\n",           // line0 + 10
     gDebuggee
   );
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-08.js
+++ b/devtools/server/tests/unit/test_breakpoint-08.js
@@ -1,96 +1,99 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that setting a breakpoint in a line without code in a child script
  * will skip forward, in a file with two scripts.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_child_skip_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_child_skip_breakpoint();
+                           });
   });
 }
 
-function test_child_skip_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.eval(aPacket.frame.actor, "foo", function (aResponse) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-        let obj = gThreadClient.pauseGrip(aPacket.why.frameFinished.return);
+function test_child_skip_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.eval(packet.frame.actor, "foo", function (response) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
+        let obj = gThreadClient.pauseGrip(packet.why.frameFinished.return);
         obj.getDefinitionSite(runWithBreakpoint);
       });
     });
 
-    function runWithBreakpoint(aPacket) {
-      let source = gThreadClient.source(aPacket.source);
+    function runWithBreakpoint(packet) {
+      let source = gThreadClient.source(packet.source);
       let location = { line: gDebuggee.line0 + 3 };
 
-      source.setBreakpoint(location, function (aResponse, bpClient) {
+      source.setBreakpoint(location, function (response, bpClient) {
         // Check that the breakpoint has properly skipped forward one line.
-        do_check_eq(aResponse.actualLocation.source.actor, source.actor);
-        do_check_eq(aResponse.actualLocation.line, location.line + 1);
+        do_check_eq(response.actualLocation.source.actor, source.actor);
+        do_check_eq(response.actualLocation.line, location.line + 1);
 
-        gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+        gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // Check the return value.
-          do_check_eq(aPacket.type, "paused");
-          do_check_eq(aPacket.frame.where.source.actor, source.actor);
-          do_check_eq(aPacket.frame.where.line, location.line + 1);
-          do_check_eq(aPacket.why.type, "breakpoint");
-          do_check_eq(aPacket.why.actors[0], bpClient.actor);
+          do_check_eq(packet.type, "paused");
+          do_check_eq(packet.frame.where.source.actor, source.actor);
+          do_check_eq(packet.frame.where.line, location.line + 1);
+          do_check_eq(packet.why.type, "breakpoint");
+          do_check_eq(packet.why.actors[0], bpClient.actor);
           // Check that the breakpoint worked.
           do_check_eq(gDebuggee.a, 1);
           do_check_eq(gDebuggee.b, undefined);
 
           // Remove the breakpoint.
-          bpClient.remove(function (aResponse) {
+          bpClient.remove(function (response) {
             gThreadClient.resume(function () {
               gClient.close().then(gCallback);
             });
           });
         });
 
         // Continue until the breakpoint is hit.
         gThreadClient.resume();
       });
     }
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox("var line0 = Error().lineNumber;\n" +
                    "function foo() {\n" + // line0 + 1
                    "  this.a = 1;\n" +    // line0 + 2
                    "  // A comment.\n" +  // line0 + 3
                    "  this.b = 2;\n" +    // line0 + 4
                    "}\n",                 // line0 + 5
                    gDebuggee,
                    "1.7",
                    "script1.js");
 
   Cu.evalInSandbox("var line1 = Error().lineNumber;\n" +
                    "debugger;\n" +        // line1 + 1
                    "foo();\n",           // line1 + 2
                    gDebuggee,
                    "1.7",
                    "script2.js");
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-09.js
+++ b/devtools/server/tests/unit/test_breakpoint-09.js
@@ -1,88 +1,88 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that removing a breakpoint works.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_remove_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_remove_breakpoint();
+                           });
   });
 }
 
-function test_remove_breakpoint()
-{
+function test_remove_breakpoint() {
   let done = false;
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+    source.setBreakpoint(location, function (response, bpClient) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.frame.where.source.actor, source.actor);
-        do_check_eq(aPacket.frame.where.line, location.line);
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.frame.where.source.actor, source.actor);
+        do_check_eq(packet.frame.where.line, location.line);
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.a, undefined);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           done = true;
           gThreadClient.addOneTimeListener("paused",
-                                           function (aEvent, aPacket) {
+                                           function (event, packet) {
             // The breakpoint should not be hit again.
                                              gThreadClient.resume(function () {
                                                do_check_true(false);
                                              });
                                            });
           gThreadClient.resume();
         });
-
       });
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
-
     });
-
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox("var line0 = Error().lineNumber;\n" +
                    "function foo(stop) {\n" + // line0 + 1
                    "  this.a = 1;\n" +        // line0 + 2
                    "  if (stop) return;\n" +  // line0 + 3
                    "  delete this.a;\n" +     // line0 + 4
                    "  foo(true);\n" +         // line0 + 5
                    "}\n" +                    // line0 + 6
                    "debugger;\n" +            // line1 + 7
                    "foo();\n",                // line1 + 8
                    gDebuggee);
+  /* eslint-enable */
   if (!done) {
     do_check_true(false);
   }
   gClient.close().then(gCallback);
 }

--- a/devtools/server/tests/unit/test_breakpoint-10.js
+++ b/devtools/server/tests/unit/test_breakpoint-10.js
@@ -1,89 +1,88 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Check that setting a breakpoint in a line with multiple entry points
  * triggers no matter which entry point we reach.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_child_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_child_breakpoint();
+                           });
   });
 }
 
-function test_child_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_child_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3 };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
+    source.setBreakpoint(location, function (response, bpClient) {
       // actualLocation is not returned when breakpoints don't skip forward.
-      do_check_eq(aResponse.actualLocation, undefined);
+      do_check_eq(response.actualLocation, undefined);
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.i, 0);
 
-        gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+        gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // Check the return value.
-          do_check_eq(aPacket.type, "paused");
-          do_check_eq(aPacket.why.type, "breakpoint");
-          do_check_eq(aPacket.why.actors[0], bpClient.actor);
+          do_check_eq(packet.type, "paused");
+          do_check_eq(packet.why.type, "breakpoint");
+          do_check_eq(packet.why.actors[0], bpClient.actor);
           // Check that the breakpoint worked.
           do_check_eq(gDebuggee.i, 1);
 
           // Remove the breakpoint.
-          bpClient.remove(function (aResponse) {
+          bpClient.remove(function (response) {
             gThreadClient.resume(function () {
               gClient.close().then(gCallback);
             });
           });
         });
 
         // Continue until the breakpoint is hit again.
         gThreadClient.resume();
-
       });
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
-
     });
-
   });
 
-
+  /* eslint-disable */
   Cu.evalInSandbox("var line0 = Error().lineNumber;\n" +
                    "debugger;\n" +                      // line0 + 1
                    "var a, i = 0;\n" +                  // line0 + 2
                    "for (i = 1; i <= 2; i++) {\n" +     // line0 + 3
                    "  a = i;\n" +                       // line0 + 4
                    "}\n",                               // line0 + 5
                    gDebuggee);
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-11.js
+++ b/devtools/server/tests/unit/test_breakpoint-11.js
@@ -1,88 +1,87 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Make sure that setting a breakpoint in a line with bytecodes in multiple
  * scripts, sets the breakpoint in all of them (bug 793214).
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_child_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_child_breakpoint();
+                           });
   });
 }
 
-function test_child_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_child_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
+    source.setBreakpoint(location, function (response, bpClient) {
       // actualLocation is not returned when breakpoints don't skip forward.
-      do_check_eq(aResponse.actualLocation, undefined);
+      do_check_eq(response.actualLocation, undefined);
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.type, "paused");
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.why.actors[0], bpClient.actor);
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
         // Check that the breakpoint worked.
         do_check_eq(gDebuggee.a, undefined);
 
-        gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+        gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // Check the return value.
-          do_check_eq(aPacket.type, "paused");
-          do_check_eq(aPacket.why.type, "breakpoint");
-          do_check_eq(aPacket.why.actors[0], bpClient.actor);
+          do_check_eq(packet.type, "paused");
+          do_check_eq(packet.why.type, "breakpoint");
+          do_check_eq(packet.why.actors[0], bpClient.actor);
           // Check that the breakpoint worked.
           do_check_eq(gDebuggee.a.b, 1);
           do_check_eq(gDebuggee.res, undefined);
 
           // Remove the breakpoint.
-          bpClient.remove(function (aResponse) {
+          bpClient.remove(function (response) {
             gThreadClient.resume(function () {
               gClient.close().then(gCallback);
             });
           });
         });
 
         // Continue until the breakpoint is hit again.
         gThreadClient.resume();
-
       });
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
-
     });
-
   });
 
-
+  /* eslint-disable */
   Cu.evalInSandbox("var line0 = Error().lineNumber;\n" +
                    "debugger;\n" +                      // line0 + 1
                    "var a = { b: 1, f: function() { return 2; } };\n" + // line0+2
                    "var res = a.f();\n",               // line0 + 3
                    gDebuggee);
+  /* eslint-enable */
 }

--- a/devtools/server/tests/unit/test_breakpoint-12.js
+++ b/devtools/server/tests/unit/test_breakpoint-12.js
@@ -1,113 +1,113 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Make sure that setting a breakpoint twice in a line without bytecodes works
  * as expected.
  */
 
 const NUM_BREAKPOINTS = 10;
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gBpActor;
 var gCount;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
+function run_test_with_server(server, callback) {
+  gCallback = callback;
   gCount = 1;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_child_skip_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_child_skip_breakpoint();
+                           });
   });
 }
 
-function test_child_skip_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_child_skip_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 3};
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
+    source.setBreakpoint(location, function (response, bpClient) {
       // Check that the breakpoint has properly skipped forward one line.
-      do_check_eq(aResponse.actualLocation.source.actor, source.actor);
-      do_check_eq(aResponse.actualLocation.line, location.line + 1);
-      gBpActor = aResponse.actor;
+      do_check_eq(response.actualLocation.source.actor, source.actor);
+      do_check_eq(response.actualLocation.line, location.line + 1);
+      gBpActor = response.actor;
 
       // Set more breakpoints at the same location.
       set_breakpoints(source, location);
     });
-
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox("var line0 = Error().lineNumber;\n" +
                    "function foo() {\n" + // line0 + 1
                    "  this.a = 1;\n" +    // line0 + 2
                    "  // A comment.\n" +  // line0 + 3
                    "  this.b = 2;\n" +    // line0 + 4
                    "}\n" +                // line0 + 5
                    "debugger;\n" +        // line0 + 6
                    "foo();\n",            // line0 + 7
                    gDebuggee);
+  /* eslint-enable */
 }
 
 // Set many breakpoints at the same location.
 function set_breakpoints(source, location) {
   do_check_neq(gCount, NUM_BREAKPOINTS);
-  source.setBreakpoint(location, function (aResponse, bpClient) {
+  source.setBreakpoint(location, function (response, bpClient) {
     // Check that the breakpoint has properly skipped forward one line.
-    do_check_eq(aResponse.actualLocation.source.actor, source.actor);
-    do_check_eq(aResponse.actualLocation.line, location.line + 1);
+    do_check_eq(response.actualLocation.source.actor, source.actor);
+    do_check_eq(response.actualLocation.line, location.line + 1);
     // Check that the same breakpoint actor was returned.
-    do_check_eq(aResponse.actor, gBpActor);
+    do_check_eq(response.actor, gBpActor);
 
     if (++gCount < NUM_BREAKPOINTS) {
       set_breakpoints(source, location);
       return;
     }
 
     // After setting all the breakpoints, check that only one has effectively
     // remained.
-    gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+    gThreadClient.addOneTimeListener("paused", function (event, packet) {
       // Check the return value.
-      do_check_eq(aPacket.type, "paused");
-      do_check_eq(aPacket.frame.where.source.actor, source.actor);
-      do_check_eq(aPacket.frame.where.line, location.line + 1);
-      do_check_eq(aPacket.why.type, "breakpoint");
-      do_check_eq(aPacket.why.actors[0], bpClient.actor);
+      do_check_eq(packet.type, "paused");
+      do_check_eq(packet.frame.where.source.actor, source.actor);
+      do_check_eq(packet.frame.where.line, location.line + 1);
+      do_check_eq(packet.why.type, "breakpoint");
+      do_check_eq(packet.why.actors[0], bpClient.actor);
       // Check that the breakpoint worked.
       do_check_eq(gDebuggee.a, 1);
       do_check_eq(gDebuggee.b, undefined);
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // We don't expect any more pauses after the breakpoint was hit once.
         do_check_true(false);
       });
       gThreadClient.resume(function () {
         // Give any remaining breakpoints a chance to trigger.
         do_timeout(1000, function () {
           gClient.close().then(gCallback);
         });
       });
-
     });
     // Continue until the breakpoint is hit.
     gThreadClient.resume();
   });
-
 }

--- a/devtools/server/tests/unit/test_breakpoint-13.js
+++ b/devtools/server/tests/unit/test_breakpoint-13.js
@@ -1,95 +1,96 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Check that execution doesn't pause twice while stepping, when encountering
  * either a breakpoint or a debugger statement.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, function () {
     run_test_with_server(WorkerDebuggerServer, do_test_finished);
   });
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-stack", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-stack", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_breakpoint();
+                           });
   });
 }
 
-function test_simple_breakpoint()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+function test_simple_breakpoint() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
-    source.setBreakpoint(location, Task.async(function* (aResponse, bpClient) {
+    source.setBreakpoint(location, Task.async(function* (response, bpClient) {
       const testCallbacks = [
-        function (aPacket) {
+        function (packet) {
           // Check that the stepping worked.
-          do_check_eq(aPacket.frame.where.line, gDebuggee.line0 + 5);
-          do_check_eq(aPacket.why.type, "resumeLimit");
+          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 5);
+          do_check_eq(packet.why.type, "resumeLimit");
         },
-        function (aPacket) {
+        function (packet) {
           // Entered the foo function call frame.
-          do_check_eq(aPacket.frame.where.line, location.line);
-          do_check_neq(aPacket.why.type, "breakpoint");
-          do_check_eq(aPacket.why.type, "resumeLimit");
+          do_check_eq(packet.frame.where.line, location.line);
+          do_check_neq(packet.why.type, "breakpoint");
+          do_check_eq(packet.why.type, "resumeLimit");
         },
-        function (aPacket) {
+        function (packet) {
           // At the end of the foo function call frame.
-          do_check_eq(aPacket.frame.where.line, gDebuggee.line0 + 3);
-          do_check_neq(aPacket.why.type, "breakpoint");
-          do_check_eq(aPacket.why.type, "resumeLimit");
+          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 3);
+          do_check_neq(packet.why.type, "breakpoint");
+          do_check_eq(packet.why.type, "resumeLimit");
         },
-        function (aPacket) {
+        function (packet) {
           // Check that the breakpoint wasn't the reason for this pause, but
           // that the frame is about to be popped while stepping.
-          do_check_eq(aPacket.frame.where.line, gDebuggee.line0 + 3);
-          do_check_neq(aPacket.why.type, "breakpoint");
-          do_check_eq(aPacket.why.type, "resumeLimit");
-          do_check_eq(aPacket.why.frameFinished.return.type, "undefined");
+          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 3);
+          do_check_neq(packet.why.type, "breakpoint");
+          do_check_eq(packet.why.type, "resumeLimit");
+          do_check_eq(packet.why.frameFinished.return.type, "undefined");
         },
-        function (aPacket) {
+        function (packet) {
           // The foo function call frame was just popped from the stack.
           do_check_eq(gDebuggee.a, 1);
           do_check_eq(gDebuggee.b, undefined);
-          do_check_eq(aPacket.frame.where.line, gDebuggee.line0 + 5);
-          do_check_eq(aPacket.why.type, "resumeLimit");
-          do_check_eq(aPacket.poppedFrames.length, 1);
+          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 5);
+          do_check_eq(packet.why.type, "resumeLimit");
+          do_check_eq(packet.poppedFrames.length, 1);
         },
-        function (aPacket) {
+        function (packet) {
           // Check that the debugger statement wasn't the reason for this pause.
-          do_check_eq(aPacket.frame.where.line, gDebuggee.line0 + 6);
-          do_check_neq(aPacket.why.type, "debuggerStatement");
-          do_check_eq(aPacket.why.type, "resumeLimit");
+          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 6);
+          do_check_neq(packet.why.type, "debuggerStatement");
+          do_check_eq(packet.why.type, "resumeLimit");
         },
-        function (aPacket) {
+        function (packet) {
           // Check that the debugger statement wasn't the reason for this pause.
-          do_check_eq(aPacket.frame.where.line, gDebuggee.line0 + 7);
-          do_check_neq(aPacket.why.type, "debuggerStatement");
-          do_check_eq(aPacket.why.type, "resumeLimit");
+          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 7);
+          do_check_neq(packet.why.type, "debuggerStatement");
+          do_check_eq(packet.why.type, "resumeLimit");
         },
       ];
 
       for (let callback of testCallbacks) {
         let waiter = waitForPause(gThreadClient);
         gThreadClient.stepIn();
         let packet = yield waiter;
         callback(packet);
@@ -98,18 +99,20 @@ function test_simple_breakpoint()
       // Remove the breakpoint and finish.
       let waiter = waitForPause(gThreadClient);
       gThreadClient.stepIn();
       yield waiter;
       bpClient.remove(() => gThreadClient.resume(() => gClient.close().then(gCallback)));
     }));
   });
 
+  /* eslint-disable */
   Cu.evalInSandbox("var line0 = Error().lineNumber;\n" +
                    "function foo() {\n" + // line0 + 1
                    "  this.a = 1;\n" +    // line0 + 2 <-- Breakpoint is set here.
                    "}\n" +                // line0 + 3
                    "debugger;\n" +        // line0 + 4
                    "foo();\n" +           // line0 + 5
                    "debugger;\n" +        // line0 + 6
                    "var b = 2;\n",        // line0 + 7
                    gDebuggee);
+  /* eslint-enable */
 }