Bug 1325989 - Resolve ESLint issues in devtools/server/tests/unit. r=jryans
authorMichael Brennan <brennan.brisad@gmail.com>
Sat, 18 Mar 2017 12:26:05 +0100
changeset 349276 060667a1f5aeecba0d87d16519478a49f5f4588c
parent 349275 969b5b7a564671710a230fa2885024847d45e2f4
child 349277 2f432eb76b015922c91b3d5240f8ca1cf33bb435
push id31548
push userkwierso@gmail.com
push dateThu, 23 Mar 2017 23:15:46 +0000
treeherdermozilla-central@01d1dedf400d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjryans
bugs1325989
milestone55.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1325989 - Resolve ESLint issues in devtools/server/tests/unit. r=jryans
.eslintignore
devtools/server/tests/unit/.eslintrc.js
devtools/server/tests/unit/head_dbg.js
devtools/server/tests/unit/hello-actor.js
devtools/server/tests/unit/post_init_global_actors.js
devtools/server/tests/unit/post_init_tab_actors.js
devtools/server/tests/unit/pre_init_global_actors.js
devtools/server/tests/unit/pre_init_tab_actors.js
devtools/server/tests/unit/registertestactors-01.js
devtools/server/tests/unit/registertestactors-02.js
devtools/server/tests/unit/registertestactors-03.js
devtools/server/tests/unit/test_actor-registry-actor.js
devtools/server/tests/unit/test_add_actors.js
devtools/server/tests/unit/test_addon_reload.js
devtools/server/tests/unit/test_addons_actor.js
devtools/server/tests/unit/test_animation_name.js
devtools/server/tests/unit/test_animation_type.js
devtools/server/tests/unit/test_attach.js
devtools/server/tests/unit/test_blackboxing-01.js
devtools/server/tests/unit/test_blackboxing-02.js
devtools/server/tests/unit/test_blackboxing-03.js
devtools/server/tests/unit/test_blackboxing-04.js
devtools/server/tests/unit/test_blackboxing-05.js
devtools/server/tests/unit/test_blackboxing-06.js
devtools/server/tests/unit/test_blackboxing-07.js
devtools/server/tests/unit/test_breakpoint-01.js
devtools/server/tests/unit/test_breakpoint-02.js
devtools/server/tests/unit/test_breakpoint-03.js
devtools/server/tests/unit/test_breakpoint-04.js
devtools/server/tests/unit/test_breakpoint-05.js
devtools/server/tests/unit/test_breakpoint-06.js
devtools/server/tests/unit/test_breakpoint-07.js
devtools/server/tests/unit/test_breakpoint-08.js
devtools/server/tests/unit/test_breakpoint-09.js
devtools/server/tests/unit/test_breakpoint-10.js
devtools/server/tests/unit/test_breakpoint-11.js
devtools/server/tests/unit/test_breakpoint-12.js
devtools/server/tests/unit/test_breakpoint-13.js
devtools/server/tests/unit/test_breakpoint-14.js
devtools/server/tests/unit/test_breakpoint-15.js
devtools/server/tests/unit/test_breakpoint-16.js
devtools/server/tests/unit/test_breakpoint-17.js
devtools/server/tests/unit/test_breakpoint-18.js
devtools/server/tests/unit/test_breakpoint-19.js
devtools/server/tests/unit/test_breakpoint-20.js
devtools/server/tests/unit/test_breakpoint-21.js
devtools/server/tests/unit/test_breakpoint-22.js
devtools/server/tests/unit/test_breakpoint-actor-map.js
devtools/server/tests/unit/test_client_close.js
devtools/server/tests/unit/test_client_request.js
devtools/server/tests/unit/test_conditional_breakpoint-01.js
devtools/server/tests/unit/test_conditional_breakpoint-02.js
devtools/server/tests/unit/test_conditional_breakpoint-03.js
devtools/server/tests/unit/test_dbgactor.js
devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
devtools/server/tests/unit/test_dbgglobal.js
devtools/server/tests/unit/test_eval-01.js
devtools/server/tests/unit/test_eval-02.js
devtools/server/tests/unit/test_eval-03.js
devtools/server/tests/unit/test_eval-04.js
devtools/server/tests/unit/test_eval-05.js
devtools/server/tests/unit/test_eventlooplag_actor.js
devtools/server/tests/unit/test_forwardingprefix.js
devtools/server/tests/unit/test_frameactor-01.js
devtools/server/tests/unit/test_frameactor-02.js
devtools/server/tests/unit/test_frameactor-03.js
devtools/server/tests/unit/test_frameactor-04.js
devtools/server/tests/unit/test_frameactor-05.js
devtools/server/tests/unit/test_frameactor_wasm-01.js
devtools/server/tests/unit/test_framearguments-01.js
devtools/server/tests/unit/test_framebindings-01.js
devtools/server/tests/unit/test_framebindings-02.js
devtools/server/tests/unit/test_framebindings-03.js
devtools/server/tests/unit/test_framebindings-04.js
devtools/server/tests/unit/test_framebindings-05.js
devtools/server/tests/unit/test_framebindings-06.js
devtools/server/tests/unit/test_framebindings-07.js
devtools/server/tests/unit/test_frameclient-01.js
devtools/server/tests/unit/test_frameclient-02.js
devtools/server/tests/unit/test_functiongrips-01.js
devtools/server/tests/unit/test_get-executable-lines-source-map.js
devtools/server/tests/unit/test_get-executable-lines.js
devtools/server/tests/unit/test_getRuleText.js
devtools/server/tests/unit/test_getyoungestframe.js
devtools/server/tests/unit/test_ignore_caught_exceptions.js
devtools/server/tests/unit/test_ignore_no_interface_exceptions.js
devtools/server/tests/unit/test_interrupt.js
devtools/server/tests/unit/test_layout-reflows-observer.js
devtools/server/tests/unit/test_listsources-01.js
devtools/server/tests/unit/test_listsources-02.js
devtools/server/tests/unit/test_listsources-03.js
devtools/server/tests/unit/test_listsources-04.js
devtools/server/tests/unit/test_longstringactor.js
devtools/server/tests/unit/test_longstringgrips-01.js
devtools/server/tests/unit/test_longstringgrips-02.js
devtools/server/tests/unit/test_monitor_actor.js
devtools/server/tests/unit/test_nativewrappers.js
devtools/server/tests/unit/test_nesting-01.js
devtools/server/tests/unit/test_nesting-02.js
devtools/server/tests/unit/test_nesting-03.js
devtools/server/tests/unit/test_new_source-01.js
devtools/server/tests/unit/test_nsjsinspector.js
devtools/server/tests/unit/test_objectgrips-01.js
devtools/server/tests/unit/test_objectgrips-02.js
devtools/server/tests/unit/test_objectgrips-03.js
devtools/server/tests/unit/test_objectgrips-04.js
devtools/server/tests/unit/test_objectgrips-05.js
devtools/server/tests/unit/test_objectgrips-06.js
devtools/server/tests/unit/test_objectgrips-07.js
devtools/server/tests/unit/test_objectgrips-08.js
devtools/server/tests/unit/test_objectgrips-09.js
devtools/server/tests/unit/test_objectgrips-10.js
devtools/server/tests/unit/test_objectgrips-11.js
devtools/server/tests/unit/test_objectgrips-12.js
devtools/server/tests/unit/test_objectgrips-13.js
devtools/server/tests/unit/test_pause_exceptions-01.js
devtools/server/tests/unit/test_pause_exceptions-02.js
devtools/server/tests/unit/test_pauselifetime-01.js
devtools/server/tests/unit/test_pauselifetime-02.js
devtools/server/tests/unit/test_pauselifetime-03.js
devtools/server/tests/unit/test_pauselifetime-04.js
devtools/server/tests/unit/test_profiler_activation-01.js
devtools/server/tests/unit/test_profiler_activation-02.js
devtools/server/tests/unit/test_profiler_bufferstatus.js
devtools/server/tests/unit/test_profiler_close.js
devtools/server/tests/unit/test_profiler_data.js
devtools/server/tests/unit/test_profiler_events-01.js
devtools/server/tests/unit/test_profiler_events-02.js
devtools/server/tests/unit/test_profiler_getbufferinfo.js
devtools/server/tests/unit/test_profiler_getfeatures.js
devtools/server/tests/unit/test_profiler_sharedlibraries.js
devtools/server/tests/unit/test_promise_state-01.js
devtools/server/tests/unit/test_promise_state-02.js
devtools/server/tests/unit/test_promise_state-03.js
devtools/server/tests/unit/test_promises_actor_attach.js
devtools/server/tests/unit/test_promises_actor_exist.js
devtools/server/tests/unit/test_protocolSpec.js
devtools/server/tests/unit/test_protocol_abort.js
devtools/server/tests/unit/test_protocol_async.js
devtools/server/tests/unit/test_protocol_children.js
devtools/server/tests/unit/test_protocol_formtype.js
devtools/server/tests/unit/test_protocol_longstring.js
devtools/server/tests/unit/test_protocol_simple.js
devtools/server/tests/unit/test_protocol_stack.js
devtools/server/tests/unit/test_protocol_unregister.js
devtools/server/tests/unit/test_reattach-thread.js
devtools/server/tests/unit/test_registerClient.js
devtools/server/tests/unit/test_register_actor.js
devtools/server/tests/unit/test_requestTypes.js
devtools/server/tests/unit/test_safe-getter.js
devtools/server/tests/unit/test_setBreakpoint-on-column-with-no-offsets-at-end-of-line.js
devtools/server/tests/unit/test_source-01.js
devtools/server/tests/unit/test_sourcemaps-01.js
devtools/server/tests/unit/test_sourcemaps-02.js
devtools/server/tests/unit/test_sourcemaps-03.js
devtools/server/tests/unit/test_sourcemaps-04.js
devtools/server/tests/unit/test_sourcemaps-05.js
devtools/server/tests/unit/test_sourcemaps-06.js
devtools/server/tests/unit/test_sourcemaps-07.js
devtools/server/tests/unit/test_sourcemaps-08.js
devtools/server/tests/unit/test_sourcemaps-09.js
devtools/server/tests/unit/test_sourcemaps-10.js
devtools/server/tests/unit/test_sourcemaps-11.js
devtools/server/tests/unit/test_sourcemaps-12.js
devtools/server/tests/unit/test_sourcemaps-13.js
devtools/server/tests/unit/test_sourcemaps-16.js
devtools/server/tests/unit/test_sourcemaps-17.js
devtools/server/tests/unit/test_stepping-01.js
devtools/server/tests/unit/test_stepping-02.js
devtools/server/tests/unit/test_stepping-03.js
devtools/server/tests/unit/test_stepping-04.js
devtools/server/tests/unit/test_stepping-05.js
devtools/server/tests/unit/test_stepping-06.js
devtools/server/tests/unit/test_stepping-07.js
devtools/server/tests/unit/test_symbols-01.js
devtools/server/tests/unit/test_symbols-02.js
devtools/server/tests/unit/test_threadlifetime-01.js
devtools/server/tests/unit/test_threadlifetime-02.js
devtools/server/tests/unit/test_threadlifetime-03.js
devtools/server/tests/unit/test_threadlifetime-04.js
devtools/server/tests/unit/test_threadlifetime-05.js
devtools/server/tests/unit/test_threadlifetime-06.js
devtools/server/tests/unit/test_unsafeDereference.js
devtools/server/tests/unit/test_xpcshell_debugging.js
devtools/server/tests/unit/testactors.js
devtools/server/tests/unit/tracerlocations.js
--- a/.eslintignore
+++ b/.eslintignore
@@ -130,17 +130,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
@@ -173,16 +173,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/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 */
 }
--- a/devtools/server/tests/unit/test_breakpoint-14.js
+++ b/devtools/server/tests/unit/test_breakpoint-14.js
@@ -1,93 +1,94 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Check that a breakpoint or a debugger statement cause execution to pause even
  * in a stepped-over function.
  */
 
 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) {
           // Reached the breakpoint.
-          do_check_eq(aPacket.frame.where.line, location.line);
-          do_check_eq(aPacket.why.type, "breakpoint");
-          do_check_neq(aPacket.why.type, "resumeLimit");
+          do_check_eq(packet.frame.where.line, location.line);
+          do_check_eq(packet.why.type, "breakpoint");
+          do_check_neq(packet.why.type, "resumeLimit");
         },
-        function (aPacket) {
+        function (packet) {
           // Stepped to the closing brace of the function.
-          do_check_eq(aPacket.frame.where.line, gDebuggee.line0 + 3);
-          do_check_eq(aPacket.why.type, "resumeLimit");
+          do_check_eq(packet.frame.where.line, gDebuggee.line0 + 3);
+          do_check_eq(packet.why.type, "resumeLimit");
         },
-        function (aPacket) {
+        function (packet) {
           // 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.stepOver();
         let packet = yield waiter;
         callback(packet);
@@ -96,18 +97,20 @@ function test_simple_breakpoint()
       // Remove the breakpoint and finish.
       let waiter = waitForPause(gThreadClient);
       gThreadClient.stepOver();
       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 */
 }
--- a/devtools/server/tests/unit/test_breakpoint-15.js
+++ b/devtools/server/tests/unit/test_breakpoint-15.js
@@ -1,69 +1,75 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check that adding a breakpoint in the same place returns the same actor.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      testSameBreakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             testSameBreakpoint();
+                           });
   });
   do_test_pending();
 }
 
 const SOURCE_URL = "http://example.com/source.js";
 
 const testSameBreakpoint = Task.async(function* () {
   let packet = yield executeOnNextTickAndWaitForPause(evalCode, gClient);
   let source = gThreadClient.source(packet.frame.where.source);
 
   // Whole line
   let wholeLineLocation = {
     line: 2
   };
 
-  let [firstResponse, firstBpClient] = yield setBreakpoint(source, wholeLineLocation);
-  let [secondResponse, secondBpClient] = yield setBreakpoint(source, wholeLineLocation);
+  let [, firstBpClient] = yield setBreakpoint(source, wholeLineLocation);
+  let [, secondBpClient] = yield setBreakpoint(source, wholeLineLocation);
 
-  do_check_eq(firstBpClient.actor, secondBpClient.actor, "Should get the same actor w/ whole line breakpoints");
+  do_check_eq(firstBpClient.actor, secondBpClient.actor,
+              "Should get the same actor w/ whole line breakpoints");
 
   // Specific column
 
   let columnLocation = {
     line: 2,
     column: 6
   };
 
-  [firstResponse, firstBpClient] = yield setBreakpoint(source, columnLocation);
-  [secondResponse, secondBpClient] = yield setBreakpoint(source, columnLocation);
+  [, firstBpClient] = yield setBreakpoint(source, columnLocation);
+  [, secondBpClient] = yield setBreakpoint(source, columnLocation);
 
-  do_check_eq(secondBpClient.actor, secondBpClient.actor, "Should get the same actor column breakpoints");
+  do_check_eq(secondBpClient.actor, secondBpClient.actor,
+              "Should get the same actor column breakpoints");
 
   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
     } + "\n"                   // line 4
     + "debugger;",             // line 5
     gDebuggee,
     "1.8",
     SOURCE_URL,
     1
   );
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_breakpoint-16.js
+++ b/devtools/server/tests/unit/test_breakpoint-16.js
@@ -1,83 +1,83 @@
 /* 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 we can set breakpoints in columns, not just lines.
  */
 
 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-breakpoints", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-breakpoints", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function (aResponse, aTabClient, aThreadClient) {
-                             gThreadClient = aThreadClient;
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
                              test_column_breakpoint();
                            });
   });
 }
 
-function test_column_breakpoint()
-{
+function test_column_breakpoint() {
   // Debugger statement
-  gClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let source = gThreadClient.source(aPacket.frame.where.source);
+  gClient.addOneTimeListener("paused", function (event, packet) {
+    let source = gThreadClient.source(packet.frame.where.source);
     let location = {
       line: gDebuggee.line0 + 1,
       column: 55
     };
     let timesBreakpointHit = 0;
 
-    source.setBreakpoint(location, function (aResponse, bpClient) {
-      gThreadClient.addListener("paused", function onPaused(aEvent, aPacket) {
-        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(aPacket.frame.where.source.actor, source.actor);
-        do_check_eq(aPacket.frame.where.line, location.line);
-        do_check_eq(aPacket.frame.where.column, location.column);
+    source.setBreakpoint(location, function (response, bpClient) {
+      gThreadClient.addListener("paused", function onPaused(event, packet) {
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.why.actors[0], bpClient.actor);
+        do_check_eq(packet.frame.where.source.actor, source.actor);
+        do_check_eq(packet.frame.where.line, location.line);
+        do_check_eq(packet.frame.where.column, location.column);
 
         do_check_eq(gDebuggee.acc, timesBreakpointHit);
-        do_check_eq(aPacket.frame.environment.bindings.variables.i.value,
+        do_check_eq(packet.frame.environment.bindings.variables.i.value,
                     timesBreakpointHit);
 
         if (++timesBreakpointHit === 3) {
           gThreadClient.removeListener("paused", onPaused);
-          bpClient.remove(function (aResponse) {
+          bpClient.remove(function (response) {
             gThreadClient.resume(() => gClient.close().then(gCallback));
           });
         } else {
           gThreadClient.resume();
         }
       });
 
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
-
   });
 
-
+  /* eslint-disable */
   Components.utils.evalInSandbox(
     "var line0 = Error().lineNumber;\n" +
     "(function () { debugger; this.acc = 0; for (var i = 0; i < 3; i++) this.acc++; }());",
     gDebuggee
   );
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_breakpoint-17.js
+++ b/devtools/server/tests/unit/test_breakpoint-17.js
@@ -1,38 +1,40 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Test that when we add 2 breakpoints to the same line at different columns and
  * then remove one of them, we don't remove them both.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 var gCallback;
 
-function run_test()
-{
+function run_test() {
   run_test_with_server(DebuggerServer, do_test_finished);
   do_test_pending();
 }
 
-function run_test_with_server(aServer, aCallback)
-{
-  gCallback = aCallback;
-  initTestDebuggerServer(aServer);
-  gDebuggee = addTestGlobal("test-breakpoints", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-breakpoints", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-breakpoints", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_breakpoints_columns();
-    });
+    attachTestTabAndResume(gClient, "test-breakpoints",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_breakpoints_columns();
+                           });
   });
 }
 
 const code =
 "(" + function (global) {
   global.foo = function () {
     Math.abs(-1); Math.log(0.5);
     debugger;
@@ -51,54 +53,54 @@ const secondLocation = {
 };
 
 function test_breakpoints_columns() {
   gClient.addOneTimeListener("paused", set_breakpoints);
 
   Components.utils.evalInSandbox(code, gDebuggee, "1.8", "http://example.com/", 1);
 }
 
-function set_breakpoints(aEvent, aPacket) {
+function set_breakpoints(event, packet) {
   let first, second;
-  let source = gThreadClient.source(aPacket.frame.where.source);
+  let source = gThreadClient.source(packet.frame.where.source);
 
   source.setBreakpoint(firstLocation, function ({ error, actualLocation },
-                                        aBreakpointClient) {
+                                        breakpointClient) {
     do_check_true(!error, "Should not get an error setting the breakpoint");
     do_check_true(!actualLocation, "Should not get an actualLocation");
-    first = aBreakpointClient;
+    first = breakpointClient;
 
     source.setBreakpoint(secondLocation, function ({ error, actualLocation },
-                                                          aBreakpointClient) {
+                                                          breakpointClient) {
       do_check_true(!error, "Should not get an error setting the breakpoint");
       do_check_true(!actualLocation, "Should not get an actualLocation");
-      second = aBreakpointClient;
+      second = breakpointClient;
 
       test_different_actors(first, second);
     });
   });
 }
 
-function test_different_actors(aFirst, aSecond) {
-  do_check_neq(aFirst.actor, aSecond.actor,
+function test_different_actors(first, second) {
+  do_check_neq(first.actor, second.actor,
                "Each breakpoint should have a different actor");
-  test_remove_one(aFirst, aSecond);
+  test_remove_one(first, second);
 }
 
-function test_remove_one(aFirst, aSecond) {
-  aFirst.remove(function ({error}) {
+function test_remove_one(first, second) {
+  first.remove(function ({error}) {
     do_check_true(!error, "Should not get an error removing a breakpoint");
 
     let hitSecond;
-    gClient.addListener("paused", function _onPaused(aEvent, {why, frame}) {
+    gClient.addListener("paused", function _onPaused(event, {why, frame}) {
       if (why.type == "breakpoint") {
         hitSecond = true;
         do_check_eq(why.actors.length, 1,
                     "Should only be paused because of one breakpoint actor");
-        do_check_eq(why.actors[0], aSecond.actor,
+        do_check_eq(why.actors[0], second.actor,
                     "Should be paused because of the correct breakpoint actor");
         do_check_eq(frame.where.line, secondLocation.line,
                     "Should be at the right line");
         do_check_eq(frame.where.column, secondLocation.column,
                     "Should be at the right column");
         gThreadClient.resume();
         return;
       }
--- a/devtools/server/tests/unit/test_breakpoint-18.js
+++ b/devtools/server/tests/unit/test_breakpoint-18.js
@@ -1,41 +1,41 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check that we only break on offsets that are entry points for the line we are
  * breaking on. Bug 907278.
  */
 
 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-breakpoints", aServer);
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-breakpoints", server);
   gDebuggee.console = { log: x => void x };
-  gClient = new DebuggerClient(aServer.connectPipe());
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function (aResponse, aTabClient, aThreadClient) {
-                             gThreadClient = aThreadClient;
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
                              setUpCode();
                            });
   });
 }
 
 function setUpCode() {
   gClient.addOneTimeListener("paused", setBreakpoint);
   Cu.evalInSandbox(
@@ -46,18 +46,18 @@ function setUpCode() {
     },
     gDebuggee,
     "1.8",
     "http://example.com/",
     1
   );
 }
 
-function setBreakpoint(aEvent, aPacket) {
-  let source = gThreadClient.source(aPacket.frame.where.source);
+function setBreakpoint(event, packet) {
+  let source = gThreadClient.source(packet.frame.where.source);
   gClient.addOneTimeListener("resumed", runCode);
 
   source.setBreakpoint({ line: 2 }, ({ error }) => {
     do_check_true(!error);
     gThreadClient.resume();
   });
 }
 
--- a/devtools/server/tests/unit/test_breakpoint-19.js
+++ b/devtools/server/tests/unit/test_breakpoint-19.js
@@ -1,64 +1,64 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Make sure that setting a breakpoint in a not-yet-existing script doesn't throw
  * an error (see bug 897567). Also make sure that this 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-breakpoints", aServer);
+function run_test_with_server(server, callback) {
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-breakpoints", server);
   gDebuggee.console = { log: x => void x };
-  gClient = new DebuggerClient(aServer.connectPipe());
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function (aResponse, aTabClient, aThreadClient) {
-                             gThreadClient = aThreadClient;
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
                              testBreakpoint();
                            });
   });
 }
 
 const URL = "test.js";
 
 function setUpCode() {
+  /* eslint-disable */
   Cu.evalInSandbox(
     "" + function test() { // 1
       var a = 1;           // 2
       debugger;            // 3
     } +                    // 4
     "\ndebugger;",         // 5
     gDebuggee,
     "1.8",
     URL
   );
+  /* eslint-enable */
 }
 
 const testBreakpoint = Task.async(function* () {
   let source = yield getSource(gThreadClient, URL);
-  let [response, bpClient] = yield setBreakpoint(source, {line: 2});
+  let [response, ] = yield setBreakpoint(source, {line: 2});
   ok(!response.error);
 
   let actor = response.actor;
   ok(actor);
 
   yield executeOnNextTickAndWaitForPause(setUpCode, gClient);
   yield resume(gThreadClient);
 
--- a/devtools/server/tests/unit/test_breakpoint-20.js
+++ b/devtools/server/tests/unit/test_breakpoint-20.js
@@ -1,45 +1,45 @@
 /* Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Verify that when two of the "same" source are loaded concurrently (like e10s
  * frame scripts), breakpoints get hit in scripts defined by all sources.
  */
 
 var gDebuggee;
 var gClient;
-var gTraceClient;
-var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-breakpoints");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
     attachTestThread(gClient, "test-breakpoints", testBreakpoint);
   });
   do_test_pending();
 }
 
-const testBreakpoint = Task.async(function* (threadResponse, tabClient, threadClient, tabResponse) {
+const testBreakpoint = Task.async(function* (threadResponse, tabClient,
+                                             threadClient, tabResponse) {
   evalSetupCode();
 
   // Load the test source once.
 
   evalTestCode();
   equal(gDebuggee.functions.length, 1,
         "The test code should have added a function.");
 
   // Set a breakpoint in the test source.
 
   const source = yield getSource(threadClient, "test.js");
-  const [response, bpClient] = yield setBreakpoint(source, {
+  const [response, ] = yield setBreakpoint(source, {
     line: 3
   });
   ok(!response.error, "Shouldn't get an error setting the BP.");
   ok(!response.actualLocation,
      "Shouldn't get an actualLocation, the location we provided was good.");
   const bpActor = response.actor;
 
   yield resume(threadClient);
--- a/devtools/server/tests/unit/test_breakpoint-21.js
+++ b/devtools/server/tests/unit/test_breakpoint-21.js
@@ -1,41 +1,39 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Bug 1122064 - make sure that scripts introduced via onNewScripts
  * properly populate the `ScriptStore` with all there nested child
  * scripts, so you can set breakpoints on deeply nested 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-breakpoints", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-breakpoints", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function (aResponse, aTabClient, aThreadClient) {
-                             gThreadClient = aThreadClient;
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
                              test();
                            });
   });
 }
 
 const test = Task.async(function* () {
   // Populate the `ScriptStore` so that we only test that the script
   // is added through `onNewScript`
@@ -57,16 +55,17 @@ const test = Task.async(function* () {
   do_check_eq(packet.why.actors[0], bpClient.actor);
   do_check_eq(packet.frame.where.source.actor, source.actor);
   do_check_eq(packet.frame.where.line, location.line);
 
   yield resume(gThreadClient);
   finishClient(gClient);
 });
 
+/* eslint-disable */
 function evalCode() {
   // Start a new script
   Components.utils.evalInSandbox(
     "var line0 = Error().lineNumber;\n(" + function () {
       debugger;
       var a = (function () {
         return (function () {
           return (function () {
--- a/devtools/server/tests/unit/test_breakpoint-22.js
+++ b/devtools/server/tests/unit/test_breakpoint-22.js
@@ -1,57 +1,55 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Bug 1333219 - make that setBreakpoint fails when script is not found
  * at the specified line.
  */
 
 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-breakpoints", aServer);
-  gClient = new DebuggerClient(aServer.connectPipe());
+function run_test_with_server(server, callback) {
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-breakpoints", server);
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function (aResponse, aTabClient, aThreadClient) {
-                             gThreadClient = aThreadClient;
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
                              test();
                            });
   });
 }
 
 const test = Task.async(function* () {
   // Populate the `ScriptStore` so that we only test that the script
   // is added through `onNewScript`
   yield getSources(gThreadClient);
 
   let packet = yield executeOnNextTickAndWaitForPause(evalCode, gClient);
   let source = gThreadClient.source(packet.frame.where.source);
   let location = {
     line: gDebuggee.line0 + 2
   };
 
-  let [res, bpClient] = yield setBreakpoint(source, location);
+  let [res, ] = yield setBreakpoint(source, location);
   ok(!res.error);
 
   let location2 = {
     line: gDebuggee.line0 + 5
   };
 
   yield source.setBreakpoint(location2).then(_ => {
     do_throw("no code shall not be found the specified line or below it");
--- a/devtools/server/tests/unit/test_breakpoint-actor-map.js
+++ b/devtools/server/tests/unit/test_breakpoint-actor-map.js
@@ -123,28 +123,33 @@ function test_find_actors() {
   for (let bp of bpStore.findActors()) {
     bpSet.delete(bp);
   }
   do_check_eq(bpSet.size, 0,
               "Should be able to iterate over all breakpoints");
 
   // Breakpoints by URL
 
-  bpSet = new Set(bps.filter(bp => { return bp.originalSourceActor.actorID === "actor1"; }));
+  bpSet = new Set(bps.filter(bp => {
+    return bp.originalSourceActor.actorID === "actor1";
+  }));
   for (let bp of bpStore.findActors({ originalSourceActor: { actorID: "actor1" } })) {
     bpSet.delete(bp);
   }
   do_check_eq(bpSet.size, 0,
               "Should be able to filter the iteration by url");
 
   // Breakpoints by URL and line
 
-  bpSet = new Set(bps.filter(bp => { return bp.originalSourceActor.actorID === "actor1" && bp.originalLine === 10; }));
+  bpSet = new Set(bps.filter(bp => {
+    return bp.originalSourceActor.actorID === "actor1" && bp.originalLine === 10;
+  }));
   let first = true;
-  for (let bp of bpStore.findActors({ originalSourceActor: { actorID: "actor1" }, originalLine: 10 })) {
+  for (let bp of bpStore.findActors({ originalSourceActor: { actorID: "actor1" },
+                                      originalLine: 10 })) {
     if (first) {
       do_check_eq(bp.originalColumn, undefined,
                   "Should always get the whole line breakpoint first");
       first = false;
     } else {
       do_check_neq(bp.originalColumn, undefined,
                    "Should not get the whole line breakpoint any time other than first.");
     }
--- a/devtools/server/tests/unit/test_client_close.js
+++ b/devtools/server/tests/unit/test_client_close.js
@@ -1,39 +1,39 @@
 /* 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) {
+  gClient.connect().then(function (type, traits) {
+    attachTestTab(gClient, "test-1", function (reply, tabClient) {
       test_close(transport);
     });
   });
   do_test_pending();
 }
 
-function test_close(aTransport)
-{
+function test_close(transport) {
   // Check that, if we fake a transport shutdown
   // (like if a device is unplugged)
   // the client is automatically closed,
   // and we can still call client.close.
   let onClosed = function () {
     gClient.removeListener("closed", onClosed);
     ok(true, "Client emitted 'closed' event");
     gClient.close().then(function () {
       ok(true, "client.close() successfully called its callback");
       do_test_finished();
     });
   };
   gClient.addListener("closed", onClosed);
-  aTransport.close();
+  transport.close();
 }
--- a/devtools/server/tests/unit/test_client_request.js
+++ b/devtools/server/tests/unit/test_client_request.js
@@ -1,11 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 // Test the DebuggerClient.request API.
 
 var gClient, gActorId;
 
 function TestActor(conn) {
   this.conn = conn;
 }
 TestActor.prototype = {
@@ -19,41 +21,39 @@ TestActor.prototype = {
     return {error: "code", message: "human message"};
   }
 };
 TestActor.prototype.requestTypes = {
   "hello": TestActor.prototype.hello,
   "error": TestActor.prototype.error
 };
 
-function run_test()
-{
+function run_test() {
   DebuggerServer.addGlobalActor(TestActor);
 
   DebuggerServer.init();
   DebuggerServer.addBrowserActors();
 
   add_test(init);
   add_test(test_client_request_callback);
   add_test(test_client_request_promise);
   add_test(test_client_request_promise_error);
   add_test(test_client_request_event_emitter);
   add_test(test_close_client_while_sending_requests);
   add_test(test_client_request_after_close);
   add_test(test_client_request_after_close_callback);
   run_next_test();
 }
 
-function init()
-{
+function init() {
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect()
     .then(() => gClient.listTabs())
-    .then(aResponse => {
-      gActorId = aResponse.test;
+    .then(response => {
+      gActorId = response.test;
       run_next_test();
     });
 }
 
 function checkStack(expectedName) {
   if (!Services.prefs.getBoolPref("javascript.options.asyncstack")) {
     do_print("Async stacks are disabled.");
     return;
@@ -67,48 +67,45 @@ function checkStack(expectedName) {
       ok(true, "Complete stack");
       return;
     }
     stack = stack.asyncCaller || stack.caller;
   }
   ok(false, "Incomplete stack");
 }
 
-function test_client_request_callback()
-{
+function test_client_request_callback() {
   // Test that DebuggerClient.request accepts a `onResponse` callback as 2nd argument
   gClient.request({
     to: gActorId,
     type: "hello"
   }, response => {
     do_check_eq(response.from, gActorId);
     do_check_eq(response.hello, "world");
     checkStack("test_client_request_callback");
     run_next_test();
   });
 }
 
-function test_client_request_promise()
-{
+function test_client_request_promise() {
   // Test that DebuggerClient.request returns a promise that resolves on response
   let request = gClient.request({
     to: gActorId,
     type: "hello"
   });
 
   request.then(response => {
     do_check_eq(response.from, gActorId);
     do_check_eq(response.hello, "world");
     checkStack("test_client_request_promise");
     run_next_test();
   });
 }
 
-function test_client_request_promise_error()
-{
+function test_client_request_promise_error() {
   // Test that DebuggerClient.request returns a promise that reject when server
   // returns an explicit error message
   let request = gClient.request({
     to: gActorId,
     type: "error"
   });
 
   request.then(() => {
@@ -117,18 +114,17 @@ function test_client_request_promise_err
     do_check_eq(response.from, gActorId);
     do_check_eq(response.error, "code");
     do_check_eq(response.message, "human message");
     checkStack("test_client_request_promise_error");
     run_next_test();
   });
 }
 
-function test_client_request_event_emitter()
-{
+function test_client_request_event_emitter() {
   // Test that DebuggerClient.request returns also an EventEmitter object
   let request = gClient.request({
     to: gActorId,
     type: "hello"
   });
   request.on("json-reply", reply => {
     do_check_eq(reply.from, gActorId);
     do_check_eq(reply.hello, "world");
@@ -151,64 +147,67 @@ function test_close_client_while_sending
   let pendingRequest = gClient.request({
     to: gActorId,
     type: "hello"
   });
 
   let expectReply = promise.defer();
   gClient.expectReply("root", function (response) {
     do_check_eq(response.error, "connectionClosed");
-    do_check_eq(response.message, "server side packet can't be received as the connection just closed.");
+    do_check_eq(response.message,
+                "server side packet can't be received as the connection just closed.");
     expectReply.resolve();
   });
 
   gClient.close().then(() => {
     activeRequest.then(() => {
       ok(false, "First request unexpectedly succeed while closing the connection");
     }, response => {
       do_check_eq(response.error, "connectionClosed");
-      do_check_eq(response.message, "'hello' active request packet to '" + gActorId + "' can't be sent as the connection just closed.");
+      do_check_eq(response.message, "'hello' active request packet to '" +
+                  gActorId + "' can't be sent as the connection just closed.");
     })
     .then(() => pendingRequest)
     .then(() => {
       ok(false, "Second request unexpectedly succeed while closing the connection");
     }, response => {
       do_check_eq(response.error, "connectionClosed");
-      do_check_eq(response.message, "'hello' pending request packet to '" + gActorId + "' can't be sent as the connection just closed.");
+      do_check_eq(response.message, "'hello' pending request packet to '" +
+                  gActorId + "' can't be sent as the connection just closed.");
     })
     .then(() => expectReply.promise)
     .then(run_next_test);
   });
 }
 
-function test_client_request_after_close()
-{
+function test_client_request_after_close() {
   // Test that DebuggerClient.request fails after we called client.close()
   // (with promise API)
   let request = gClient.request({
     to: gActorId,
     type: "hello"
   });
 
   request.then(response => {
     ok(false, "Request succeed even after client.close");
   }, response => {
     ok(true, "Request failed after client.close");
     do_check_eq(response.error, "connectionClosed");
-    ok(response.message.match(/'hello' request packet to '.*' can't be sent as the connection is closed./));
+    ok(response.message.match(
+        /'hello' request packet to '.*' can't be sent as the connection is closed./));
     run_next_test();
   });
 }
 
-function test_client_request_after_close_callback()
-{
+function test_client_request_after_close_callback() {
   // Test that DebuggerClient.request fails after we called client.close()
   // (with callback API)
-  let request = gClient.request({
+  gClient.request({
     to: gActorId,
     type: "hello"
   }, response => {
     ok(true, "Request failed after client.close");
     do_check_eq(response.error, "connectionClosed");
-    ok(response.message.match(/'hello' request packet to '.*' can't be sent as the connection is closed./));
+    ok(response.message.match(
+        /'hello' request packet to '.*' can't be sent as the connection is closed./));
     run_next_test();
   });
 }
--- a/devtools/server/tests/unit/test_conditional_breakpoint-01.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-01.js
@@ -1,61 +1,62 @@
 /* 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 conditional breakpoint when condition evaluates to true.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-conditional-breakpoint");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-conditional-breakpoint", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-conditional-breakpoint",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_breakpoint();
+                           });
   });
   do_test_pending();
 }
 
-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);
     source.setBreakpoint({
       line: 3,
       condition: "a === 1"
-    }, function (aResponse, bpClient) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+    }, function (response, bpClient) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.why.type, "breakpoint");
-        do_check_eq(aPacket.frame.where.line, 3);
+        do_check_eq(packet.why.type, "breakpoint");
+        do_check_eq(packet.frame.where.line, 3);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
-
       });
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
-
     });
-
   });
 
+  /* eslint-disable */
   Components.utils.evalInSandbox("debugger;\n" +   // 1
                                  "var a = 1;\n" +  // 2
                                  "var b = 2;\n",  // 3
                                  gDebuggee,
                                  "1.8",
                                  "test.js",
                                  1);
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_conditional_breakpoint-02.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-02.js
@@ -1,60 +1,63 @@
 /* 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 conditional breakpoint when condition evaluates to false.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-conditional-breakpoint");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-conditional-breakpoint", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-conditional-breakpoint",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_breakpoint();
+                           });
   });
   do_test_pending();
 }
 
-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);
     source.setBreakpoint({
       line: 3,
       condition: "a === 2"
-    }, function (aResponse, bpClient) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+    }, function (response, bpClient) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.why.type, "debuggerStatement");
-        do_check_eq(aPacket.frame.where.line, 4);
+        do_check_eq(packet.why.type, "debuggerStatement");
+        do_check_eq(packet.frame.where.line, 4);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
-
       });
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
     });
   });
 
+  /* eslint-disable */
   Components.utils.evalInSandbox("debugger;\n" +   // 1
                                  "var a = 1;\n" +  // 2
                                  "var b = 2;\n" +  // 3
                                  "debugger;",      // 4
                                  gDebuggee,
                                  "1.8",
                                  "test.js",
                                  1);
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_conditional_breakpoint-03.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-03.js
@@ -1,61 +1,62 @@
 /* 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 conditional breakpoint when condition throws and make sure it pauses
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-conditional-breakpoint");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-conditional-breakpoint", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_breakpoint();
-    });
+    attachTestTabAndResume(gClient, "test-conditional-breakpoint",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_breakpoint();
+                           });
   });
   do_test_pending();
 }
 
-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);
     source.setBreakpoint({
       line: 3,
       condition: "throw new Error()"
-    }, function (aResponse, bpClient) {
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+    }, function (response, bpClient) {
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
         // Check the return value.
-        do_check_eq(aPacket.why.type, "breakpointConditionThrown");
-        do_check_eq(aPacket.frame.where.line, 3);
+        do_check_eq(packet.why.type, "breakpointConditionThrown");
+        do_check_eq(packet.frame.where.line, 3);
 
         // Remove the breakpoint.
-        bpClient.remove(function (aResponse) {
+        bpClient.remove(function (response) {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
-
       });
       // Continue until the breakpoint is hit.
       gThreadClient.resume();
-
     });
-
   });
 
+  /* eslint-disable */
   Components.utils.evalInSandbox("debugger;\n" +   // 1
                                  "var a = 1;\n" +  // 2
                                  "var b = 2;\n",  // 3
                                  gDebuggee,
                                  "1.8",
                                  "test.js",
                                  1);
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_dbgactor.js
+++ b/devtools/server/tests/unit/test_dbgactor.js
@@ -1,116 +1,114 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gClient;
 var gDebuggee;
 
 const xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = testGlobal("test-1");
   DebuggerServer.addTestGlobal(gDebuggee);
 
   let transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
-  gClient.addListener("connected", function (aEvent, aType, aTraits) {
-    gClient.listTabs((aResponse) => {
-      do_check_true("tabs" in aResponse);
-      for (let tab of aResponse.tabs) {
+  gClient.addListener("connected", function (event, type, traits) {
+    gClient.listTabs((response) => {
+      do_check_true("tabs" in response);
+      for (let tab of response.tabs) {
         if (tab.title == "test-1") {
           test_attach_tab(tab.actor);
           return false;
         }
       }
-      do_check_true(false); // We should have found our tab in the list.
+      // We should have found our tab in the list.
+      do_check_true(false);
       return undefined;
     });
   });
 
   gClient.connect();
 
   do_test_pending();
 }
 
-// Attach to |aTabActor|, and check the response.
-function test_attach_tab(aTabActor)
-{
-  gClient.request({ to: aTabActor, type: "attach" }, function (aResponse) {
-    do_check_false("error" in aResponse);
-    do_check_eq(aResponse.from, aTabActor);
-    do_check_eq(aResponse.type, "tabAttached");
-    do_check_true(typeof aResponse.threadActor === "string");
+// Attach to |tabActor|, and check the response.
+function test_attach_tab(tabActor) {
+  gClient.request({ to: tabActor, type: "attach" }, function (response) {
+    do_check_false("error" in response);
+    do_check_eq(response.from, tabActor);
+    do_check_eq(response.type, "tabAttached");
+    do_check_true(typeof response.threadActor === "string");
 
-    test_attach_thread(aResponse.threadActor);
+    test_attach_thread(response.threadActor);
   });
 }
 
-// Attach to |aThreadActor|, check the response, and resume it.
-function test_attach_thread(aThreadActor)
-{
-  gClient.request({ to: aThreadActor, type: "attach" }, function (aResponse) {
-    do_check_false("error" in aResponse);
-    do_check_eq(aResponse.from, aThreadActor);
-    do_check_eq(aResponse.type, "paused");
-    do_check_true("why" in aResponse);
-    do_check_eq(aResponse.why.type, "attached");
+// Attach to |threadActor|, check the response, and resume it.
+function test_attach_thread(threadActor) {
+  gClient.request({ to: threadActor, type: "attach" }, function (response) {
+    do_check_false("error" in response);
+    do_check_eq(response.from, threadActor);
+    do_check_eq(response.type, "paused");
+    do_check_true("why" in response);
+    do_check_eq(response.why.type, "attached");
 
-    test_resume_thread(aThreadActor);
+    test_resume_thread(threadActor);
   });
 }
 
-// Resume |aThreadActor|, and see that it stops at the 'debugger'
+// Resume |threadActor|, and see that it stops at the 'debugger'
 // statement.
-function test_resume_thread(aThreadActor)
-{
+function test_resume_thread(threadActor) {
   // Allow the client to resume execution.
-  gClient.request({ to: aThreadActor, type: "resume" }, function (aResponse) {
-    do_check_false("error" in aResponse);
-    do_check_eq(aResponse.from, aThreadActor);
-    do_check_eq(aResponse.type, "resumed");
+  gClient.request({ to: threadActor, type: "resume" }, function (response) {
+    do_check_false("error" in response);
+    do_check_eq(response.from, threadActor);
+    do_check_eq(response.type, "resumed");
 
     do_check_eq(xpcInspector.eventLoopNestLevel, 0);
 
     // Now that we know we're resumed, we can make the debuggee do something.
     Cu.evalInSandbox("var a = true; var b = false; debugger; var b = true;", gDebuggee);
     // Now make sure that we've run the code after the debugger statement...
     do_check_true(gDebuggee.b);
   });
 
-  gClient.addListener("paused", function (aName, aPacket) {
-    do_check_eq(aName, "paused");
-    do_check_false("error" in aPacket);
-    do_check_eq(aPacket.from, aThreadActor);
-    do_check_eq(aPacket.type, "paused");
-    do_check_true("actor" in aPacket);
-    do_check_true("why" in aPacket);
-    do_check_eq(aPacket.why.type, "debuggerStatement");
+  gClient.addListener("paused", function (name, packet) {
+    do_check_eq(name, "paused");
+    do_check_false("error" in packet);
+    do_check_eq(packet.from, threadActor);
+    do_check_eq(packet.type, "paused");
+    do_check_true("actor" in packet);
+    do_check_true("why" in packet);
+    do_check_eq(packet.why.type, "debuggerStatement");
 
     // Reach around the protocol to check that the debuggee is in the state
     // we expect.
     do_check_true(gDebuggee.a);
     do_check_false(gDebuggee.b);
 
     do_check_eq(xpcInspector.eventLoopNestLevel, 1);
 
     // Let the debuggee continue execution.
-    gClient.request({ to: aThreadActor, type: "resume" }, cleanup);
+    gClient.request({ to: threadActor, type: "resume" }, cleanup);
   });
 }
 
-function cleanup()
-{
-  gClient.addListener("closed", function (aEvent, aResult) {
+function cleanup() {
+  gClient.addListener("closed", function (event, result) {
     do_test_finished();
   });
 
   try {
-    let xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
-    do_check_eq(xpcInspector.eventLoopNestLevel, 0);
+    let inspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
+    do_check_eq(inspector.eventLoopNestLevel, 0);
   } catch (e) {
     dump(e);
   }
 
   gClient.close();
 }
--- a/devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
+++ b/devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
@@ -1,69 +1,67 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gClient;
 var gTabClient;
 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) {
-      gTabClient = aTabClient;
-      test_threadAttach(aReply.threadActor);
+  gClient.connect().then(function ([type, traits]) {
+    attachTestTab(gClient, "test-1", function (reply, tabClient) {
+      gTabClient = tabClient;
+      test_threadAttach(reply.threadActor);
     });
   });
   do_test_pending();
 }
 
-function test_threadAttach(aThreadActorID)
-{
-  do_print("Trying to attach to thread " + aThreadActorID);
-  gTabClient.attachThread({}, function (aResponse, aThreadClient) {
-    do_check_eq(aThreadClient.state, "paused");
-    do_check_eq(aThreadClient.actor, aThreadActorID);
-    aThreadClient.resume(function () {
-      do_check_eq(aThreadClient.state, "attached");
-      test_debugger_statement(aThreadClient);
+function test_threadAttach(threadActorID) {
+  do_print("Trying to attach to thread " + threadActorID);
+  gTabClient.attachThread({}, function (response, threadClient) {
+    do_check_eq(threadClient.state, "paused");
+    do_check_eq(threadClient.actor, threadActorID);
+    threadClient.resume(function () {
+      do_check_eq(threadClient.state, "attached");
+      test_debugger_statement(threadClient);
     });
   });
 }
 
-function test_debugger_statement(aThreadClient)
-{
-  aThreadClient.addListener("paused", function (aEvent, aPacket) {
-    do_check_eq(aThreadClient.state, "paused");
+function test_debugger_statement(threadClient) {
+  threadClient.addListener("paused", function (event, packet) {
+    do_check_eq(threadClient.state, "paused");
     // Reach around the protocol to check that the debuggee is in the state
     // we expect.
     do_check_true(gDebuggee.a);
     do_check_false(gDebuggee.b);
 
     let xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
     do_check_eq(xpcInspector.eventLoopNestLevel, 1);
 
-    aThreadClient.resume(cleanup);
+    threadClient.resume(cleanup);
   });
 
   Cu.evalInSandbox("var a = true; var b = false; debugger; var b = true;", gDebuggee);
 
   // Now make sure that we've run the code after the debugger statement...
   do_check_true(gDebuggee.b);
 }
 
-function cleanup()
-{
-  gClient.addListener("closed", function (aEvent) {
+function cleanup() {
+  gClient.addListener("closed", function (event) {
     do_test_finished();
   });
 
   try {
     let xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
     do_check_eq(xpcInspector.eventLoopNestLevel, 0);
   } catch (e) {
     dump(e);
--- a/devtools/server/tests/unit/test_dbgglobal.js
+++ b/devtools/server/tests/unit/test_dbgglobal.js
@@ -1,13 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
-function run_test()
-{
+"use strict";
+
+function run_test() {
   // Should get an exception if we try to interact with DebuggerServer
   // before we initialize it...
   check_except(function () {
     DebuggerServer.createListener();
   });
   check_except(DebuggerServer.closeAllListeners);
   check_except(DebuggerServer.connectPipe);
 
@@ -23,37 +24,37 @@ function run_test()
 
   // Now they should work.
   DebuggerServer.createListener();
   DebuggerServer.closeAllListeners();
 
   // Make sure we got the test's root actor all set up.
   let client1 = DebuggerServer.connectPipe();
   client1.hooks = {
-    onPacket: function (aPacket1) {
-      do_check_eq(aPacket1.from, "root");
-      do_check_eq(aPacket1.applicationType, "xpcshell-tests");
+    onPacket: function (packet1) {
+      do_check_eq(packet1.from, "root");
+      do_check_eq(packet1.applicationType, "xpcshell-tests");
 
       // Spin up a second connection, make sure it has its own root
       // actor.
       let client2 = DebuggerServer.connectPipe();
       client2.hooks = {
-        onPacket: function (aPacket2) {
-          do_check_eq(aPacket2.from, "root");
-          do_check_neq(aPacket1.testConnectionPrefix,
-                       aPacket2.testConnectionPrefix);
+        onPacket: function (packet2) {
+          do_check_eq(packet2.from, "root");
+          do_check_neq(packet1.testConnectionPrefix,
+                       packet2.testConnectionPrefix);
           client2.close();
         },
-        onClosed: function (aResult) {
+        onClosed: function (result) {
           client1.close();
         },
       };
       client2.ready();
     },
 
-    onClosed: function (aResult) {
+    onClosed: function (result) {
       do_test_finished();
     },
   };
 
   client1.ready();
   do_test_pending();
 }
--- a/devtools/server/tests/unit/test_eval-01.js
+++ b/devtools/server/tests/unit/test_eval-01.js
@@ -1,58 +1,59 @@
 /* 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 eval resume/re-pause
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_eval();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_eval();
+                           });
   });
   do_test_pending();
 }
 
-function test_simple_eval()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let arg1Actor = aPacket.frame.arguments[0].actor;
-    gThreadClient.eval(null, "({ obj: true })", function (aResponse) {
-      do_check_eq(aResponse.type, "resumed");
+function test_simple_eval() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let arg1Actor = packet.frame.arguments[0].actor;
+    gThreadClient.eval(null, "({ obj: true })", function (response) {
+      do_check_eq(response.type, "resumed");
       // Expect a pause notification immediately.
-      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, "clientEvaluated");
-        do_check_eq(aPacket.why.frameFinished.return.type, "object");
-        do_check_eq(aPacket.why.frameFinished.return.class, "Object");
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.why.type, "clientEvaluated");
+        do_check_eq(packet.why.frameFinished.return.type, "object");
+        do_check_eq(packet.why.frameFinished.return.class, "Object");
 
         // Make sure the previous pause lifetime was correctly dropped.
-        gClient.request({ to: arg1Actor, type: "bogusRequest" }, function (aResponse) {
-          do_check_eq(aResponse.error, "noSuchActor");
+        gClient.request({ to: arg1Actor, type: "bogusRequest" }, function (response) {
+          do_check_eq(response.error, "noSuchActor");
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         });
-
       });
-
     });
-
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
     function stopMe(arg1) { debugger; }
     stopMe({obj: true});
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_eval-02.js
+++ b/devtools/server/tests/unit/test_eval-02.js
@@ -1,48 +1,52 @@
 /* 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 eval resume/re-pause with a throw.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_throw_eval();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_throw_eval();
+                           });
   });
   do_test_pending();
 }
 
-function test_throw_eval()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.eval(null, "throw 'failure'", function (aResponse) {
-      do_check_eq(aResponse.type, "resumed");
+function test_throw_eval() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.eval(null, "throw 'failure'", function (response) {
+      do_check_eq(response.type, "resumed");
       // Expect a pause notification immediately.
-      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, "clientEvaluated");
-        do_check_eq(aPacket.why.frameFinished.throw, "failure");
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.why.type, "clientEvaluated");
+        do_check_eq(packet.why.frameFinished.throw, "failure");
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
     function stopMe(arg1) { debugger; }
     stopMe({obj: true});
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_eval-03.js
+++ b/devtools/server/tests/unit/test_eval-03.js
@@ -1,50 +1,54 @@
 /* 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 syntax errors in an eval.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_syntax_error_eval();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_syntax_error_eval();
+                           });
   });
   do_test_pending();
 }
 
-function test_syntax_error_eval()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.eval(null, "%$@!@#", function (aResponse) {
-      do_check_eq(aResponse.type, "resumed");
+function test_syntax_error_eval() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.eval(null, "%$@!@#", function (response) {
+      do_check_eq(response.type, "resumed");
       // Expect a pause notification immediately.
-      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, "clientEvaluated");
-        do_check_eq(aPacket.why.frameFinished.throw.type, "object");
-        do_check_eq(aPacket.why.frameFinished.throw.class, "Error");
+        do_check_eq(packet.type, "paused");
+        do_check_eq(packet.why.type, "clientEvaluated");
+        do_check_eq(packet.why.frameFinished.throw.type, "object");
+        do_check_eq(packet.why.frameFinished.throw.class, "Error");
 
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
     function stopMe(arg1) { debugger; }
     stopMe({obj: true});
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_eval-04.js
+++ b/devtools/server/tests/unit/test_eval-04.js
@@ -1,56 +1,57 @@
 /* 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 evals against different frames.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_syntax_error_eval();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_different_frames_eval();
+                           });
   });
   do_test_pending();
 }
 
-function test_syntax_error_eval()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-
-    gThreadClient.getFrames(0, 2, function (aResponse) {
-      let frame0 = aResponse.frames[0];
-      let frame1 = aResponse.frames[1];
+function test_different_frames_eval() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.getFrames(0, 2, function (response) {
+      let frame0 = response.frames[0];
+      let frame1 = response.frames[1];
 
       // Eval against the top frame...
-      gThreadClient.eval(frame0.actor, "arg", function (aResponse) {
-        do_check_eq(aResponse.type, "resumed");
-        gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+      gThreadClient.eval(frame0.actor, "arg", function (response) {
+        do_check_eq(response.type, "resumed");
+        gThreadClient.addOneTimeListener("paused", function (event, packet) {
           // 'arg' should have been evaluated in frame0
-          do_check_eq(aPacket.type, "paused");
-          do_check_eq(aPacket.why.type, "clientEvaluated");
-          do_check_eq(aPacket.why.frameFinished.return, "arg0");
+          do_check_eq(packet.type, "paused");
+          do_check_eq(packet.why.type, "clientEvaluated");
+          do_check_eq(packet.why.frameFinished.return, "arg0");
 
           // Now eval against the second frame.
-          gThreadClient.eval(frame1.actor, "arg", function (aResponse) {
-            gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+          gThreadClient.eval(frame1.actor, "arg", function (response) {
+            gThreadClient.addOneTimeListener("paused", function (event, packet) {
               // 'arg' should have been evaluated in frame1
-              do_check_eq(aPacket.type, "paused");
-              do_check_eq(aPacket.why.frameFinished.return, "arg1");
+              do_check_eq(packet.type, "paused");
+              do_check_eq(packet.why.frameFinished.return, "arg1");
 
               gThreadClient.resume(function () {
                 finishClient(gClient);
               });
             });
           });
         });
       });
--- a/devtools/server/tests/unit/test_eval-05.js
+++ b/devtools/server/tests/unit/test_eval-05.js
@@ -1,47 +1,49 @@
 /* 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 pauses within evals.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_syntax_error_eval();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pauses_eval();
+                           });
   });
   do_test_pending();
 }
 
-function test_syntax_error_eval()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.eval(null, "debugger", function (aResponse) {
+function test_pauses_eval() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.eval(null, "debugger", function (response) {
       // Expect a resume then a debuggerStatement pause.
-      do_check_eq(aResponse.type, "resumed");
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-        do_check_eq(aPacket.why.type, "debuggerStatement");
+      do_check_eq(response.type, "resumed");
+      gThreadClient.addOneTimeListener("paused", function (event, packet) {
+        do_check_eq(packet.why.type, "debuggerStatement");
         // Resume from the debugger statement should immediately re-pause
         // with a clientEvaluated reason.
-        gThreadClient.resume(function (aPacket) {
-          do_check_eq(aPacket.type, "resumed");
-          gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-            do_check_eq(aPacket.why.type, "clientEvaluated");
+        gThreadClient.resume(function (packet) {
+          do_check_eq(packet.type, "resumed");
+          gThreadClient.addOneTimeListener("paused", function (event, packet) {
+            do_check_eq(packet.why.type, "clientEvaluated");
             gThreadClient.resume(function () {
               finishClient(gClient);
             });
           });
         });
       });
     });
   });
--- a/devtools/server/tests/unit/test_eventlooplag_actor.js
+++ b/devtools/server/tests/unit/test_eventlooplag_actor.js
@@ -2,28 +2,26 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 /**
  * Test the eventLoopLag actor.
  */
 
 "use strict";
 
-function run_test()
-{
+function run_test() {
   let {EventLoopLagFront} = require("devtools/shared/fronts/eventlooplag");
 
   DebuggerServer.init();
   DebuggerServer.addBrowserActors();
 
   // As seen in EventTracer.cpp
   let threshold = 20;
   let interval = 10;
 
-
   let front;
   let client = new DebuggerClient(DebuggerServer.connectPipe());
 
   // Start tracking event loop lags.
   client.connect().then(function () {
     client.listTabs(function (resp) {
       front = new EventLoopLagFront(client, resp);
       front.start().then(success => {
--- a/devtools/server/tests/unit/test_forwardingprefix.js
+++ b/devtools/server/tests/unit/test_forwardingprefix.js
@@ -1,21 +1,22 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /* Exercise prefix-based forwarding of packets to other transports. */
 
 const { RootActor } = require("devtools/server/actors/root");
 
 var gMainConnection, gMainTransport;
 var gSubconnection1, gSubconnection2;
 var gClient;
 
-function run_test()
-{
+function run_test() {
   DebuggerServer.init();
 
   add_test(createMainConnection);
   add_test(TestNoForwardingYet);
   add_test(createSubconnection1);
   add_test(TestForwardPrefix1OnlyRoot);
   add_test(createSubconnection2);
   add_test(TestForwardPrefix12OnlyRoot);
@@ -26,171 +27,172 @@ function run_test()
 
 /*
  * Create a pipe connection, and return an object |{ conn, transport }|,
  * where |conn| is the new DebuggerServerConnection instance, and
  * |transport| is the client side of the transport on which it communicates
  * (that is, packets sent on |transport| go to the new connection, and
  * |transport|'s hooks receive replies).
  *
- * |aPrefix| is optional; if present, it's the prefix (minus the '/') for
+ * |prefix| is optional; if present, it's the prefix (minus the '/') for
  * actors in the new connection.
  */
-function newConnection(aPrefix)
-{
-  var conn;
-  DebuggerServer.createRootActor = function (aConn) {
-    conn = aConn;
-    return new RootActor(aConn, {});
+function newConnection(prefix) {
+  let conn;
+  DebuggerServer.createRootActor = function (connection) {
+    conn = connection;
+    return new RootActor(connection, {});
   };
 
-  var transport = DebuggerServer.connectPipe(aPrefix);
+  let transport = DebuggerServer.connectPipe(prefix);
 
   return { conn: conn, transport: transport };
 }
 
 /* Create the main connection for these tests. */
-function createMainConnection()
-{
+function createMainConnection() {
   ({ conn: gMainConnection, transport: gMainTransport } = newConnection());
   gClient = new DebuggerClient(gMainTransport);
-  gClient.connect().then(([aType, aTraits]) => run_next_test());
+  gClient.connect().then(([type, traits]) => run_next_test());
 }
 
 /*
  * Exchange 'echo' messages with five actors:
  * - root
  * - prefix1/root
  * - prefix1/actor
  * - prefix2/root
  * - prefix2/actor
  *
- * Expect proper echos from those named in |aReachables|, and 'noSuchActor'
+ * Expect proper echos from those named in |reachables|, and 'noSuchActor'
  * errors from the others. When we've gotten all our replies (errors or
- * otherwise), call |aCompleted|.
+ * otherwise), call |completed|.
  *
- * To avoid deep stacks, we call aCompleted from the next tick.
+ * To avoid deep stacks, we call completed from the next tick.
  */
-function tryActors(aReachables, aCompleted) {
+function tryActors(reachables, completed) {
   let count = 0;
 
   let outerActor;
   for (outerActor of [ "root",
                        "prefix1/root", "prefix1/actor",
                        "prefix2/root", "prefix2/actor" ]) {
     /*
      * Let each callback capture its own iteration's value; outerActor is
      * local to the whole loop, not to a single iteration.
      */
     let actor = outerActor;
 
     count++;
 
-    gClient.request({ to: actor, type: "echo", value: "tango"}, // phone home
-                    (aResponse) => {
-                      if (aReachables.has(actor))
-                        do_check_matches({ from: actor, to: actor, type: "echo", value: "tango" }, aResponse);
-                      else
-                        do_check_matches({ from: actor, error: "noSuchActor", message: "No such actor for ID: " + actor }, aResponse);
+    // phone home
+    gClient.request(
+      { to: actor, type: "echo", value: "tango"},
+      (response) => {
+        if (reachables.has(actor)) {
+          do_check_matches({ from: actor, to: actor,
+                             type: "echo", value: "tango" }, response);
+        } else {
+          do_check_matches({ from: actor, error: "noSuchActor",
+                             message: "No such actor for ID: " + actor }, response);
+        }
 
-                      if (--count == 0)
-                        do_execute_soon(aCompleted, "tryActors callback " + aCompleted.name);
-                    });
+        if (--count == 0) {
+          do_execute_soon(completed, "tryActors callback " + completed.name);
+        }
+      });
   }
 }
 
 /*
  * With no forwarding established, sending messages to root should work,
  * but sending messages to prefixed actor names, or anyone else, should get
  * an error.
  */
-function TestNoForwardingYet()
-{
+function TestNoForwardingYet() {
   tryActors(new Set(["root"]), run_next_test);
 }
 
 /*
  * Create a new pipe connection which forwards its reply packets to
  * gMainConnection's client, and to which gMainConnection forwards packets
- * directed to actors whose names begin with |aPrefix + '/'|, and.
+ * directed to actors whose names begin with |prefix + '/'|, and.
  *
  * Return an object { conn, transport }, as for newConnection.
  */
-function newSubconnection(aPrefix)
-{
-  let { conn, transport } = newConnection(aPrefix);
+function newSubconnection(prefix) {
+  let { conn, transport } = newConnection(prefix);
   transport.hooks = {
-    onPacket: (aPacket) => gMainConnection.send(aPacket),
+    onPacket: (packet) => gMainConnection.send(packet),
     onClosed: () => {}
   };
-  gMainConnection.setForwarding(aPrefix, transport);
+  gMainConnection.setForwarding(prefix, transport);
 
   return { conn: conn, transport: transport };
 }
 
 /* Create a second root actor, to which we can forward things. */
-function createSubconnection1()
-{
+function createSubconnection1() {
   let { conn, transport } = newSubconnection("prefix1");
   gSubconnection1 = conn;
   transport.ready();
-  gClient.expectReply("prefix1/root", (aReply) => run_next_test());
+  gClient.expectReply("prefix1/root", (reply) => run_next_test());
 }
 
 // Establish forwarding, but don't put any actors in that server.
-function TestForwardPrefix1OnlyRoot()
-{
+function TestForwardPrefix1OnlyRoot() {
   tryActors(new Set(["root", "prefix1/root"]), run_next_test);
 }
 
 /* Create a third root actor, to which we can forward things. */
-function createSubconnection2()
-{
+function createSubconnection2() {
   let { conn, transport } = newSubconnection("prefix2");
   gSubconnection2 = conn;
   transport.ready();
-  gClient.expectReply("prefix2/root", (aReply) => run_next_test());
+  gClient.expectReply("prefix2/root", (reply) => run_next_test());
 }
 
-function TestForwardPrefix12OnlyRoot()
-{
+function TestForwardPrefix12OnlyRoot() {
   tryActors(new Set(["root", "prefix1/root", "prefix2/root"]), run_next_test);
 }
 
 // A dumb actor that implements 'echo'.
 //
 // It's okay that both subconnections' actors behave identically, because
 // the reply-sending code attaches the replying actor's name to the packet,
 // so simply matching the 'from' field in the reply ensures that we heard
 // from the right actor.
-function EchoActor(aConnection)
-{
-  this.conn = aConnection;
+function EchoActor(connection) {
+  this.conn = connection;
 }
 EchoActor.prototype.actorPrefix = "EchoActor";
-EchoActor.prototype.onEcho = function (aRequest) {
+EchoActor.prototype.onEcho = function (request) {
   /*
-   * Request packets are frozen. Copy aRequest, so that
+   * Request packets are frozen. Copy request, so that
    * DebuggerServerConnection.onPacket can attach a 'from' property.
    */
-  return JSON.parse(JSON.stringify(aRequest));
+  return JSON.parse(JSON.stringify(request));
 };
 EchoActor.prototype.requestTypes = {
   "echo": EchoActor.prototype.onEcho
 };
 
-function TestForwardPrefix12WithActor1()
-{
+function TestForwardPrefix12WithActor1() {
   let actor = new EchoActor(gSubconnection1);
   actor.actorID = "prefix1/actor";
   gSubconnection1.addActor(actor);
 
-  tryActors(new Set(["root", "prefix1/root", "prefix1/actor", "prefix2/root"]), run_next_test);
+  tryActors(
+    new Set(["root", "prefix1/root", "prefix1/actor", "prefix2/root"]),
+    run_next_test
+  );
 }
 
-function TestForwardPrefix12WithActor12()
-{
+function TestForwardPrefix12WithActor12() {
   let actor = new EchoActor(gSubconnection2);
   actor.actorID = "prefix2/actor";
   gSubconnection2.addActor(actor);
 
-  tryActors(new Set(["root", "prefix1/root", "prefix1/actor", "prefix2/root", "prefix2/actor"]), run_next_test);
+  tryActors(
+    new Set(["root", "prefix1/root", "prefix1/actor", "prefix2/root", "prefix2/actor"]),
+    run_next_test
+  );
 }
--- a/devtools/server/tests/unit/test_frameactor-01.js
+++ b/devtools/server/tests/unit/test_frameactor-01.js
@@ -1,39 +1,40 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Verify that we get a frame actor along with a debugger statement.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    do_check_true(!!aPacket.frame);
-    do_check_true(!!aPacket.frame.actor);
-    do_check_eq(aPacket.frame.callee.name, "stopMe");
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    do_check_true(!!packet.frame);
+    do_check_true(!!packet.frame.actor);
+    do_check_eq(packet.frame.callee.name, "stopMe");
     gThreadClient.resume(function () {
       finishClient(gClient);
     });
   });
 
   gDebuggee.eval("(" + function () {
     function stopMe() {
       debugger;
--- a/devtools/server/tests/unit/test_frameactor-02.js
+++ b/devtools/server/tests/unit/test_frameactor-02.js
@@ -1,38 +1,40 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Verify that two pauses in a row will keep the same frame actor.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket1) {
-    gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket2) {
-      do_check_eq(aPacket1.frame.actor, aPacket2.frame.actor);
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet1) {
+    gThreadClient.addOneTimeListener("paused", function (event, packet2) {
+      do_check_eq(packet1.frame.actor, packet2.frame.actor);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
     gThreadClient.resume();
   });
 
   gDebuggee.eval("(" + function () {
--- a/devtools/server/tests/unit/test_frameactor-03.js
+++ b/devtools/server/tests/unit/test_frameactor-03.js
@@ -1,40 +1,42 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Verify that a frame actor is properly expired when the frame goes away.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket1) {
-    gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket2) {
-      let poppedFrames = aPacket2.poppedFrames;
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet1) {
+    gThreadClient.addOneTimeListener("paused", function (event, packet2) {
+      let poppedFrames = packet2.poppedFrames;
       do_check_eq(typeof (poppedFrames), typeof ([]));
-      do_check_true(poppedFrames.indexOf(aPacket1.frame.actor) >= 0);
+      do_check_true(poppedFrames.indexOf(packet1.frame.actor) >= 0);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
     gThreadClient.resume();
   });
 
   gDebuggee.eval("(" + function () {
--- a/devtools/server/tests/unit/test_frameactor-04.js
+++ b/devtools/server/tests/unit/test_frameactor-04.js
@@ -1,29 +1,31 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Verify the "frames" request on the thread.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
 var gFrames = [
   // Function calls...
   { type: "call", callee: { name: "depth3" } },
   { type: "call", callee: { name: "depth2" } },
@@ -41,43 +43,43 @@ var gSliceTests = [
   { start: 0, count: 1 },
   { start: 2, count: 2 },
   { start: 1, count: 15 },
   { start: 15, count: undefined },
 ];
 
 function test_frame_slice() {
   if (gSliceTests.length == 0) {
-    gThreadClient.resume(function () { finishClient(gClient); });
+    gThreadClient.resume(() => finishClient(gClient));
     return;
   }
 
   let test = gSliceTests.shift();
-  gThreadClient.getFrames(test.start, test.count, function (aResponse) {
-    var testFrames = gFrames.slice(test.start, test.count ? test.start + test.count : undefined);
-    do_check_eq(testFrames.length, aResponse.frames.length);
-    for (var i = 0; i < testFrames.length; i++) {
+  gThreadClient.getFrames(test.start, test.count, function (response) {
+    let testFrames = gFrames.slice(test.start,
+                                   test.count ? test.start + test.count : undefined);
+    do_check_eq(testFrames.length, response.frames.length);
+    for (let i = 0; i < testFrames.length; i++) {
       let expected = testFrames[i];
-      let actual = aResponse.frames[i];
+      let actual = response.frames[i];
 
       if (test.resetActors) {
         expected.actor = actual.actor;
       }
 
       for (let key of ["type", "callee-name"]) {
         do_check_eq(expected[key] || undefined, actual[key]);
       }
     }
     test_frame_slice();
   });
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket1) {
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
     test_frame_slice();
   });
 
   gDebuggee.eval("(" + function () {
     function depth3() {
       debugger;
     }
     function depth2() {
--- a/devtools/server/tests/unit/test_frameactor-05.js
+++ b/devtools/server/tests/unit/test_frameactor-05.js
@@ -1,78 +1,54 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 /**
  * Verify that frame actors retrieved with the frames request
  * are included in the pause packet's popped-frames property.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_frame_slice() {
-  if (gSliceTests.length == 0) {
-    gThreadClient.resume(function () { finishClient(gClient); });
-    return;
-  }
-
-  let test = gSliceTests.shift();
-  gThreadClient.getFrames(test.start, test.count, function (aResponse) {
-    var testFrames = gFrames.slice(test.start, test.count ? test.start + test.count : undefined);
-    do_check_eq(testFrames.length, aResponse.frames.length);
-    for (var i = 0; i < testFrames.length; i++) {
-      let expected = testFrames[i];
-      let actual = aResponse.frames[i];
-
-      if (test.resetActors) {
-        expected.actor = actual.actor;
-      }
-
-      for (var key in expected) {
-        do_check_eq(expected[key], actual[key]);
-      }
-    }
-    test_frame_slice();
-  });
-}
-
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket1) {
-    gThreadClient.getFrames(0, null, function (aFrameResponse) {
-      do_check_eq(aFrameResponse.frames.length, 5);
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.getFrames(0, null, function (frameResponse) {
+      do_check_eq(frameResponse.frames.length, 5);
       // Now wait for the next pause, after which the three
       // youngest actors should be popped..
-      let expectPopped = aFrameResponse.frames.slice(0, 3).map(frame => frame.actor);
+      let expectPopped = frameResponse.frames.slice(0, 3).map(frame => frame.actor);
       expectPopped.sort();
 
-      gThreadClient.addOneTimeListener("paused", function (aEvent, aPausePacket) {
-        let popped = aPausePacket.poppedFrames.sort();
+      gThreadClient.addOneTimeListener("paused", function (event, pausePacket) {
+        let popped = pausePacket.poppedFrames.sort();
         do_check_eq(popped.length, 3);
         for (let i = 0; i < 3; i++) {
           do_check_eq(expectPopped[i], popped[i]);
         }
 
-        gThreadClient.resume(function () { finishClient(gClient); });
+        gThreadClient.resume(() => finishClient(gClient));
       });
       gThreadClient.resume();
     });
   });
 
   gDebuggee.eval("(" + function () {
     function depth3() {
       debugger;
--- a/devtools/server/tests/unit/test_frameactor_wasm-01.js
+++ b/devtools/server/tests/unit/test_frameactor_wasm-01.js
@@ -1,65 +1,70 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Verify that wasm frame(s) can be requested from the client.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   if (typeof WebAssembly == "undefined") {
-    return; // wasm is not enabled for this platform
+    // wasm is not enabled for this platform
+    return;
   }
 
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      gThreadClient.reconfigure({ observeAsmJS: true }, function (aResponse) {
-        do_check_eq(!!aResponse.error, false);
-        test_pause_frame();
+    attachTestTabAndResume(
+      gClient, "test-stack",
+      function (response, tabClient, threadClient) {
+        gThreadClient = threadClient;
+        gThreadClient.reconfigure({ observeAsmJS: true }, function (response) {
+          do_check_eq(!!response.error, false);
+          test_pause_frame();
+        });
       });
-    });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket1) {
-    gThreadClient.getFrames(0, null, function (aFrameResponse) {
-      do_check_eq(aFrameResponse.frames.length, 4);
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.getFrames(0, null, function (frameResponse) {
+      do_check_eq(frameResponse.frames.length, 4);
 
-      let wasmFrame = aFrameResponse.frames[1];
+      let wasmFrame = frameResponse.frames[1];
       do_check_eq(wasmFrame.type, "wasmcall");
       do_check_eq(wasmFrame.this, undefined);
 
       let location = wasmFrame.where;
       do_check_eq(location.line > 0, true);
       do_check_eq(location.column > 0, true);
       do_check_eq(location.source.url.endsWith(" > wasm"), true);
 
       finishClient(gClient);
     });
   });
 
+  /* eslint-disable comma-spacing, max-len */
   gDebuggee.eval("(" + function () {
     // WebAssembly bytecode was generated by running:
     // js -e 'print(wasmTextToBinary("(module(import \"a\" \"b\")(func(export \"c\")call 0))"))'
-    var m = new WebAssembly.Module(new Uint8Array([
+    let m = new WebAssembly.Module(new Uint8Array([
       0,97,115,109,1,0,0,0,1,132,128,128,128,0,1,96,0,0,2,135,128,128,128,0,1,1,97,1,
       98,0,0,3,130,128,128,128,0,1,0,6,129,128,128,128,0,0,7,133,128,128,128,0,1,1,99,
       0,1,10,138,128,128,128,0,1,132,128,128,128,0,0,16,0,11
     ]));
-    var i = new WebAssembly.Instance(m, {a: {b: () => {
+    let i = new WebAssembly.Instance(m, {a: {b: () => {
       debugger;
     }}});
     i.exports.c();
   } + ")()");
 }
--- a/devtools/server/tests/unit/test_framearguments-01.js
+++ b/devtools/server/tests/unit/test_framearguments-01.js
@@ -1,51 +1,52 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check a frame actor's arguments property.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame["arguments"];
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
     do_check_eq(args.length, 6);
     do_check_eq(args[0], 42);
     do_check_eq(args[1], true);
     do_check_eq(args[2], "nasu");
     do_check_eq(args[3].type, "null");
     do_check_eq(args[4].type, "undefined");
     do_check_eq(args[5].type, "object");
     do_check_eq(args[5].class, "Object");
     do_check_true(!!args[5].actor);
 
     gThreadClient.resume(function () {
       finishClient(gClient);
     });
   });
 
   gDebuggee.eval("(" + function () {
-    function stopMe(aNumber, aBool, aString, aNull, aUndefined, aObject) {
+    function stopMe(number, bool, string, null_, undef, object) {
       debugger;
     }
     stopMe(42, true, "nasu", null, undefined, { foo: "bar" });
   } + ")()");
 }
--- a/devtools/server/tests/unit/test_framebindings-01.js
+++ b/devtools/server/tests/unit/test_framebindings-01.js
@@ -1,77 +1,80 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check a frame actor's bindings property.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let bindings = aPacket.frame.environment.bindings;
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let bindings = packet.frame.environment.bindings;
     let args = bindings.arguments;
     let vars = bindings.variables;
 
     do_check_eq(args.length, 6);
-    do_check_eq(args[0].aNumber.value, 42);
-    do_check_eq(args[1].aBool.value, true);
-    do_check_eq(args[2].aString.value, "nasu");
-    do_check_eq(args[3].aNull.value.type, "null");
-    do_check_eq(args[4].aUndefined.value.type, "undefined");
-    do_check_eq(args[5].aObject.value.type, "object");
-    do_check_eq(args[5].aObject.value.class, "Object");
-    do_check_true(!!args[5].aObject.value.actor);
+    do_check_eq(args[0].number.value, 42);
+    do_check_eq(args[1].bool.value, true);
+    do_check_eq(args[2].string.value, "nasu");
+    do_check_eq(args[3].null_.value.type, "null");
+    do_check_eq(args[4].undef.value.type, "undefined");
+    do_check_eq(args[5].object.value.type, "object");
+    do_check_eq(args[5].object.value.class, "Object");
+    do_check_true(!!args[5].object.value.actor);
 
     do_check_eq(vars.a.value, 1);
     do_check_eq(vars.b.value, true);
     do_check_eq(vars.c.value.type, "object");
     do_check_eq(vars.c.value.class, "Object");
     do_check_true(!!vars.c.value.actor);
 
     let objClient = gThreadClient.pauseGrip(vars.c.value);
-    objClient.getPrototypeAndProperties(function (aResponse) {
-      do_check_eq(aResponse.ownProperties.a.configurable, true);
-      do_check_eq(aResponse.ownProperties.a.enumerable, true);
-      do_check_eq(aResponse.ownProperties.a.writable, true);
-      do_check_eq(aResponse.ownProperties.a.value, "a");
+    objClient.getPrototypeAndProperties(function (response) {
+      do_check_eq(response.ownProperties.a.configurable, true);
+      do_check_eq(response.ownProperties.a.enumerable, true);
+      do_check_eq(response.ownProperties.a.writable, true);
+      do_check_eq(response.ownProperties.a.value, "a");
 
-      do_check_eq(aResponse.ownProperties.b.configurable, true);
-      do_check_eq(aResponse.ownProperties.b.enumerable, true);
-      do_check_eq(aResponse.ownProperties.b.writable, true);
-      do_check_eq(aResponse.ownProperties.b.value.type, "undefined");
-      do_check_false("class" in aResponse.ownProperties.b.value);
+      do_check_eq(response.ownProperties.b.configurable, true);
+      do_check_eq(response.ownProperties.b.enumerable, true);
+      do_check_eq(response.ownProperties.b.writable, true);
+      do_check_eq(response.ownProperties.b.value.type, "undefined");
+      do_check_false("class" in response.ownProperties.b.value);
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
-    function stopMe(aNumber, aBool, aString, aNull, aUndefined, aObject) {
+    function stopMe(number, bool, string, null_, undef, object) {
       var a = 1;
       var b = true;
       var c = { a: "a", b: undefined };
       debugger;
     }
     stopMe(42, true, "nasu", null, undefined, { foo: "bar" });
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_framebindings-02.js
+++ b/devtools/server/tests/unit/test_framebindings-02.js
@@ -1,63 +1,65 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check a frame actor's parent bindings.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let parentEnv = aPacket.frame.environment.parent;
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let parentEnv = packet.frame.environment.parent;
     let bindings = parentEnv.bindings;
     let args = bindings.arguments;
     let vars = bindings.variables;
     do_check_neq(parentEnv, undefined);
     do_check_eq(args.length, 0);
     do_check_eq(vars.stopMe.value.type, "object");
     do_check_eq(vars.stopMe.value.class, "Function");
     do_check_true(!!vars.stopMe.value.actor);
 
     // Skip the global lexical scope.
     parentEnv = parentEnv.parent.parent;
     do_check_neq(parentEnv, undefined);
     let objClient = gThreadClient.pauseGrip(parentEnv.object);
-    objClient.getPrototypeAndProperties(function (aResponse) {
-      do_check_eq(aResponse.ownProperties.Object.value.type, "object");
-      do_check_eq(aResponse.ownProperties.Object.value.class, "Function");
-      do_check_true(!!aResponse.ownProperties.Object.value.actor);
+    objClient.getPrototypeAndProperties(function (response) {
+      do_check_eq(response.ownProperties.Object.value.type, "object");
+      do_check_eq(response.ownProperties.Object.value.class, "Function");
+      do_check_true(!!response.ownProperties.Object.value.actor);
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
-    function stopMe(aNumber, aBool, aString, aNull, aUndefined, aObject) {
+    function stopMe(number, bool, string, null_, undef, object) {
       var a = 1;
       var b = true;
       var c = { a: "a" };
       debugger;
     }
     stopMe(42, true, "nasu", null, undefined, { foo: "bar" });
   } + ")()");
 }
--- a/devtools/server/tests/unit/test_framebindings-03.js
+++ b/devtools/server/tests/unit/test_framebindings-03.js
@@ -1,69 +1,73 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+/* strict mode code may not contain 'with' statements */
+/* eslint-disable strict */
+
 /**
  * Check a |with| frame actor's bindings.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let env = aPacket.frame.environment;
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let env = packet.frame.environment;
     do_check_neq(env, undefined);
 
     let parentEnv = env.parent;
     do_check_neq(parentEnv, undefined);
 
     let bindings = parentEnv.bindings;
     let args = bindings.arguments;
     let vars = bindings.variables;
     do_check_eq(args.length, 1);
-    do_check_eq(args[0].aNumber.value, 10);
+    do_check_eq(args[0].number.value, 10);
     do_check_eq(vars.r.value, 10);
     do_check_eq(vars.a.value, Math.PI * 100);
     do_check_eq(vars.arguments.value.class, "Arguments");
     do_check_true(!!vars.arguments.value.actor);
 
     let objClient = gThreadClient.pauseGrip(env.object);
-    objClient.getPrototypeAndProperties(function (aResponse) {
-      do_check_eq(aResponse.ownProperties.PI.value, Math.PI);
-      do_check_eq(aResponse.ownProperties.cos.value.type, "object");
-      do_check_eq(aResponse.ownProperties.cos.value.class, "Function");
-      do_check_true(!!aResponse.ownProperties.cos.value.actor);
+    objClient.getPrototypeAndProperties(function (response) {
+      do_check_eq(response.ownProperties.PI.value, Math.PI);
+      do_check_eq(response.ownProperties.cos.value.type, "object");
+      do_check_eq(response.ownProperties.cos.value.class, "Function");
+      do_check_true(!!response.ownProperties.cos.value.actor);
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
-    function stopMe(aNumber) {
+    function stopMe(number) {
       var a;
-      var r = aNumber;
+      var r = number;
       with (Math) {
         a = PI * r * r;
         debugger;
       }
     }
     stopMe(10);
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_framebindings-04.js
+++ b/devtools/server/tests/unit/test_framebindings-04.js
@@ -1,84 +1,88 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+/* strict mode code may not contain 'with' statements */
+/* eslint-disable strict */
 
 /**
- * Check the environment bindongs of a  |with| within a |with|.
+ * Check the environment bindings of a  |with| within a |with|.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let env = aPacket.frame.environment;
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let env = packet.frame.environment;
     do_check_neq(env, undefined);
 
     let objClient = gThreadClient.pauseGrip(env.object);
-    objClient.getPrototypeAndProperties(function (aResponse) {
-      do_check_eq(aResponse.ownProperties.one.value, 1);
-      do_check_eq(aResponse.ownProperties.two.value, 2);
-      do_check_eq(aResponse.ownProperties.foo, undefined);
+    objClient.getPrototypeAndProperties(function (response) {
+      do_check_eq(response.ownProperties.one.value, 1);
+      do_check_eq(response.ownProperties.two.value, 2);
+      do_check_eq(response.ownProperties.foo, undefined);
 
       let parentEnv = env.parent;
       do_check_neq(parentEnv, undefined);
 
       let parentClient = gThreadClient.pauseGrip(parentEnv.object);
-      parentClient.getPrototypeAndProperties(function (aResponse) {
-        do_check_eq(aResponse.ownProperties.PI.value, Math.PI);
-        do_check_eq(aResponse.ownProperties.cos.value.type, "object");
-        do_check_eq(aResponse.ownProperties.cos.value.class, "Function");
-        do_check_true(!!aResponse.ownProperties.cos.value.actor);
+      parentClient.getPrototypeAndProperties(function (response) {
+        do_check_eq(response.ownProperties.PI.value, Math.PI);
+        do_check_eq(response.ownProperties.cos.value.type, "object");
+        do_check_eq(response.ownProperties.cos.value.class, "Function");
+        do_check_true(!!response.ownProperties.cos.value.actor);
 
         parentEnv = parentEnv.parent;
         do_check_neq(parentEnv, undefined);
 
         let bindings = parentEnv.bindings;
         let args = bindings.arguments;
         let vars = bindings.variables;
         do_check_eq(args.length, 1);
-        do_check_eq(args[0].aNumber.value, 10);
+        do_check_eq(args[0].number.value, 10);
         do_check_eq(vars.r.value, 10);
         do_check_eq(vars.a.value, Math.PI * 100);
         do_check_eq(vars.arguments.value.class, "Arguments");
         do_check_true(!!vars.arguments.value.actor);
         do_check_eq(vars.foo.value, 2 * Math.PI);
 
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
-
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
-    function stopMe(aNumber) {
+    function stopMe(number) {
       var a, obj = { one: 1, two: 2 };
-      var r = aNumber;
+      var r = number;
       with (Math) {
         a = PI * r * r;
         with (obj) {
           var foo = two * PI;
           debugger;
         }
       }
     }
     stopMe(10);
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_framebindings-05.js
+++ b/devtools/server/tests/unit/test_framebindings-05.js
@@ -1,57 +1,59 @@
 /* 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 the environment bindings of a |with| in global scope.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let env = aPacket.frame.environment;
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let env = packet.frame.environment;
     do_check_neq(env, undefined);
 
     let objClient = gThreadClient.pauseGrip(env.object);
-    objClient.getPrototypeAndProperties(function (aResponse) {
-      do_check_eq(aResponse.ownProperties.PI.value, Math.PI);
-      do_check_eq(aResponse.ownProperties.cos.value.type, "object");
-      do_check_eq(aResponse.ownProperties.cos.value.class, "Function");
-      do_check_true(!!aResponse.ownProperties.cos.value.actor);
+    objClient.getPrototypeAndProperties(function (response) {
+      do_check_eq(response.ownProperties.PI.value, Math.PI);
+      do_check_eq(response.ownProperties.cos.value.type, "object");
+      do_check_eq(response.ownProperties.cos.value.class, "Function");
+      do_check_true(!!response.ownProperties.cos.value.actor);
 
       // Skip the global lexical scope.
       let parentEnv = env.parent.parent;
       do_check_neq(parentEnv, undefined);
 
       let parentClient = gThreadClient.pauseGrip(parentEnv.object);
-      parentClient.getPrototypeAndProperties(function (aResponse) {
-        do_check_eq(aResponse.ownProperties.a.value, Math.PI * 100);
-        do_check_eq(aResponse.ownProperties.r.value, 10);
-        do_check_eq(aResponse.ownProperties.Object.value.type, "object");
-        do_check_eq(aResponse.ownProperties.Object.value.class, "Function");
-        do_check_true(!!aResponse.ownProperties.Object.value.actor);
+      parentClient.getPrototypeAndProperties(function (response) {
+        do_check_eq(response.ownProperties.a.value, Math.PI * 100);
+        do_check_eq(response.ownProperties.r.value, 10);
+        do_check_eq(response.ownProperties.Object.value.type, "object");
+        do_check_eq(response.ownProperties.Object.value.class, "Function");
+        do_check_true(!!response.ownProperties.Object.value.actor);
 
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
   });
 
--- a/devtools/server/tests/unit/test_framebindings-06.js
+++ b/devtools/server/tests/unit/test_framebindings-06.js
@@ -1,37 +1,37 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_banana_environment();
-    });
+    attachTestTabAndResume(gClient, "test-grips",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_banana_environment();
+                           });
   });
   do_test_pending();
 }
 
-function test_banana_environment()
-{
-
+function test_banana_environment() {
   gThreadClient.addOneTimeListener("paused",
-    function (aEvent, aPacket) {
-      equal(aPacket.type, "paused");
-      let env = aPacket.frame.environment;
+    function (event, packet) {
+      equal(packet.type, "paused");
+      let env = packet.frame.environment;
       equal(env.type, "function");
       equal(env.function.name, "banana3");
       let parent = env.parent;
       equal(parent.type, "block");
       ok("banana3" in parent.bindings.variables);
       parent = parent.parent;
       equal(parent.type, "function");
       equal(parent.function.name, "banana2");
@@ -42,19 +42,17 @@ function test_banana_environment()
       equal(parent.type, "function");
       equal(parent.function.name, "banana");
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
 
-  gDebuggee.eval("\
-        function banana(x) {                                            \n\
-          return function banana2(y) {                                  \n\
-            return function banana3(z) {                                \n\
-              debugger;                                                 \n\
-            };                                                          \n\
-          };                                                            \n\
-        }                                                               \n\
-        banana('x')('y')('z');                                          \n\
-        ");
+  gDebuggee.eval("function banana(x) {\n" +
+                 "  return function banana2(y) {\n" +
+                 "    return function banana3(z) {\n" +
+                 "      debugger;\n" +
+                 "    };\n" +
+                 "  };\n" +
+                 "}\n" +
+                 "banana('x')('y')('z');\n");
 }
--- a/devtools/server/tests/unit/test_framebindings-07.js
+++ b/devtools/server/tests/unit/test_framebindings-07.js
@@ -1,64 +1,63 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
 // Test that the EnvironmentClient's getBindings() method works as expected.
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-bindings");
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-bindings", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_banana_environment();
-    });
+    attachTestTabAndResume(gClient, "test-bindings",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_banana_environment();
+                           });
   });
   do_test_pending();
 }
 
-function test_banana_environment()
-{
-
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let environment = aPacket.frame.environment;
+function test_banana_environment() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let environment = packet.frame.environment;
     do_check_eq(environment.type, "function");
 
     let parent = environment.parent;
     do_check_eq(parent.type, "block");
 
     let grandpa = parent.parent;
     do_check_eq(grandpa.type, "function");
 
     let envClient = gThreadClient.environment(environment);
-    envClient.getBindings(aResponse => {
-      do_check_eq(aResponse.bindings.arguments[0].z.value, "z");
+    envClient.getBindings(response => {
+      do_check_eq(response.bindings.arguments[0].z.value, "z");
 
       let parentClient = gThreadClient.environment(parent);
-      parentClient.getBindings(aResponse => {
-        do_check_eq(aResponse.bindings.variables.banana3.value.class, "Function");
+      parentClient.getBindings(response => {
+        do_check_eq(response.bindings.variables.banana3.value.class, "Function");
 
         let grandpaClient = gThreadClient.environment(grandpa);
-        grandpaClient.getBindings(aResponse => {
-          do_check_eq(aResponse.bindings.arguments[0].y.value, "y");
+        grandpaClient.getBindings(response => {
+          do_check_eq(response.bindings.arguments[0].y.value, "y");
           gThreadClient.resume(() => finishClient(gClient));
         });
       });
     });
   });
 
-  gDebuggee.eval("\
-        function banana(x) {                                            \n\
-          return function banana2(y) {                                  \n\
-            return function banana3(z) {                                \n\
-              debugger;                                                 \n\
-            };                                                          \n\
-          };                                                            \n\
-        }                                                               \n\
-        banana('x')('y')('z');                                          \n\
-        ");
+  gDebuggee.eval("function banana(x) {\n" +
+                 "  return function banana2(y) {\n" +
+                 "    return function banana3(z) {\n" +
+                 "      debugger;\n" +
+                 "    };\n" +
+                 "  };\n" +
+                 "}\n" +
+                 "banana('x')('y')('z');\n");
 }
--- a/devtools/server/tests/unit/test_frameclient-01.js
+++ b/devtools/server/tests/unit/test_frameclient-01.js
@@ -1,32 +1,34 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable max-nested-callbacks */
+
+"use strict";
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
     gThreadClient.addOneTimeListener("framesadded", function () {
       do_check_eq(gThreadClient.cachedFrames.length, 3);
       do_check_true(gThreadClient.moreFrames);
       do_check_false(gThreadClient.fillFrames(3));
 
       do_check_true(gThreadClient.fillFrames(30));
       gThreadClient.addOneTimeListener("framesadded", function () {
         do_check_false(gThreadClient.moreFrames);
@@ -34,20 +36,22 @@ function test_pause_frame()
         gThreadClient.resume(function () {
           finishClient(gClient);
         });
       });
     });
     do_check_true(gThreadClient.fillFrames(3));
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
     var recurseLeft = 5;
     function recurse() {
       if (--recurseLeft == 0) {
         debugger;
         return;
       }
       recurse();
     }
     recurse();
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_frameclient-02.js
+++ b/devtools/server/tests/unit/test_frameclient-02.js
@@ -1,46 +1,49 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
     // Ask for exactly the number of frames we expect.
     gThreadClient.addOneTimeListener("framesadded", function () {
       do_check_false(gThreadClient.moreFrames);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
     do_check_true(gThreadClient.fillFrames(3));
   });
 
+  /* eslint-disable */
   gDebuggee.eval("(" + function () {
     var recurseLeft = 1;
     function recurse() {
       if (--recurseLeft == 0) {
         debugger;
         return;
       }
       recurse();
     }
     recurse();
   } + ")()");
+  /* eslint-enable */
 }
--- a/devtools/server/tests/unit/test_functiongrips-01.js
+++ b/devtools/server/tests/unit/test_functiongrips-01.js
@@ -1,93 +1,93 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_named_function();
-    });
+    attachTestTabAndResume(gClient, "test-grips",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_named_function();
+                           });
   });
   do_test_pending();
 }
 
-function test_named_function()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+function test_named_function() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
 
     do_check_eq(args[0].class, "Function");
     do_check_eq(args[0].name, "stopMe");
     do_check_eq(args[0].displayName, "stopMe");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
-    objClient.getParameterNames(function (aResponse) {
-      do_check_eq(aResponse.parameterNames.length, 1);
-      do_check_eq(aResponse.parameterNames[0], "arg1");
+    objClient.getParameterNames(function (response) {
+      do_check_eq(response.parameterNames.length, 1);
+      do_check_eq(response.parameterNames[0], "arg1");
 
       gThreadClient.resume(test_inferred_name_function);
     });
-
   });
 
   gDebuggee.eval("stopMe(stopMe)");
 }
 
 function test_inferred_name_function() {
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
 
     do_check_eq(args[0].class, "Function");
     // No name for an anonymous function, but it should have an inferred name.
     do_check_eq(args[0].name, undefined);
     do_check_eq(args[0].displayName, "m");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
-    objClient.getParameterNames(function (aResponse) {
-      do_check_eq(aResponse.parameterNames.length, 3);
-      do_check_eq(aResponse.parameterNames[0], "foo");
-      do_check_eq(aResponse.parameterNames[1], "bar");
-      do_check_eq(aResponse.parameterNames[2], "baz");
+    objClient.getParameterNames(function (response) {
+      do_check_eq(response.parameterNames.length, 3);
+      do_check_eq(response.parameterNames[0], "foo");
+      do_check_eq(response.parameterNames[1], "bar");
+      do_check_eq(response.parameterNames[2], "baz");
 
       gThreadClient.resume(test_anonymous_function);
     });
   });
 
   gDebuggee.eval("var o = { m: function(foo, bar, baz) { } }; stopMe(o.m)");
 }
 
 function test_anonymous_function() {
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
 
     do_check_eq(args[0].class, "Function");
     // No name for an anonymous function, and no inferred name, either.
     do_check_eq(args[0].name, undefined);
     do_check_eq(args[0].displayName, undefined);
 
     let objClient = gThreadClient.pauseGrip(args[0]);
-    objClient.getParameterNames(function (aResponse) {
-      do_check_eq(aResponse.parameterNames.length, 3);
-      do_check_eq(aResponse.parameterNames[0], "foo");
-      do_check_eq(aResponse.parameterNames[1], "bar");
-      do_check_eq(aResponse.parameterNames[2], "baz");
+    objClient.getParameterNames(function (response) {
+      do_check_eq(response.parameterNames.length, 3);
+      do_check_eq(response.parameterNames[0], "foo");
+      do_check_eq(response.parameterNames[1], "bar");
+      do_check_eq(response.parameterNames[2], "baz");
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
   gDebuggee.eval("stopMe(function(foo, bar, baz) { })");
--- a/devtools/server/tests/unit/test_get-executable-lines-source-map.js
+++ b/devtools/server/tests/unit/test_get-executable-lines-source-map.js
@@ -1,12 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+"use strict";
+
 /**
  * Test if getExecutableLines return correct information
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
@@ -15,18 +17,18 @@ const SOURCE_MAPPED_FILE = getFileUrl("s
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-get-executable-lines");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function _onConnect() {
     attachTestTabAndResume(
       gClient,
       "test-get-executable-lines",
-      function (aResponse, aTabClient, aThreadClient) {
-        gThreadClient = aThreadClient;
+      function (response, tabClient, threadClient) {
+        gThreadClient = threadClient;
         test_executable_lines();
       }
     );
   });
 
   do_test_pending();
 }
 
--- a/devtools/server/tests/unit/test_get-executable-lines.js
+++ b/devtools/server/tests/unit/test_get-executable-lines.js
@@ -1,12 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+"use strict";
+
 /**
  * Test if getExecutableLines return correct information
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
@@ -15,18 +17,18 @@ const SOURCE_MAPPED_FILE = getFileUrl("s
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-get-executable-lines");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function _onConnect() {
     attachTestTabAndResume(
       gClient,
       "test-get-executable-lines",
-      function (aResponse, aTabClient, aThreadClient) {
-        gThreadClient = aThreadClient;
+      function (response, tabClient, threadClient) {
+        gThreadClient = threadClient;
         test_executable_lines();
       }
     );
   });
 
   do_test_pending();
 }
 
--- a/devtools/server/tests/unit/test_getRuleText.js
+++ b/devtools/server/tests/unit/test_getRuleText.js
@@ -19,17 +19,18 @@ const TEST_DATA = [
     desc: "Simplest test case",
     input: "#id{color:red;background:yellow;}",
     line: 1,
     column: 1,
     expected: {offset: 4, text: "color:red;background:yellow;"}
   },
   {
     desc: "Multiple rules test case",
-    input: "#id{color:red;background:yellow;}.class-one .class-two { position:absolute; line-height: 45px}",
+    input: "#id{color:red;background:yellow;}.class-one .class-two " +
+      "{ position:absolute; line-height: 45px}",
     line: 1,
     column: 34,
     expected: {offset: 56, text: " position:absolute; line-height: 45px"}
   },
   {
     desc: "Unclosed rule",
     input: "#id{color:red;background:yellow;",
     line: 1,
--- a/devtools/server/tests/unit/test_getyoungestframe.js
+++ b/devtools/server/tests/unit/test_getyoungestframe.js
@@ -1,27 +1,27 @@
-function run_test()
-{
+/* eslint-disable strict */
+function run_test() {
   Components.utils.import("resource://gre/modules/jsdebugger.jsm");
   addDebuggerToGlobal(this);
-  var xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
-  var g = testGlobal("test1");
+  let xpcInspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
+  let g = testGlobal("test1");
 
-  var dbg = new Debugger();
+  let dbg = new Debugger();
   dbg.uncaughtExceptionHook = testExceptionHook;
 
   dbg.addDebuggee(g);
-  dbg.onDebuggerStatement = function (aFrame) {
-    do_check_true(aFrame === dbg.getNewestFrame());
+  dbg.onDebuggerStatement = function (frame) {
+    do_check_true(frame === dbg.getNewestFrame());
     // Execute from the nested event loop, dbg.getNewestFrame() won't
     // be working anymore.
 
     do_execute_soon(function () {
       try {
-        do_check_true(aFrame === dbg.getNewestFrame());
+        do_check_true(frame === dbg.getNewestFrame());
       } finally {
         xpcInspector.exitNestedEventLoop("test");
       }
     });
     xpcInspector.enterNestedEventLoop("test");
   };
 
   g.eval("function debuggerStatement() { debugger; }; debuggerStatement();");
--- a/devtools/server/tests/unit/test_ignore_caught_exceptions.js
+++ b/devtools/server/tests/unit/test_ignore_caught_exceptions.js
@@ -1,50 +1,56 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Test that setting ignoreCaughtExceptions will cause the debugger to ignore
  * caught exceptions, but not uncaught ones.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-      do_check_eq(aPacket.why.type, "exception");
-      do_check_eq(aPacket.why.exception, "bar");
+function test_pause_frame() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.addOneTimeListener("paused", function (event, packet) {
+      do_check_eq(packet.why.type, "exception");
+      do_check_eq(packet.why.exception, "bar");
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
     gThreadClient.pauseOnExceptions(true, true);
     gThreadClient.resume();
   });
 
   try {
+    /* eslint-disable */
     gDebuggee.eval("(" + function () {
       debugger;
       try {
         throw "foo";
       } catch (e) {}
       throw "bar";
     } + ")()");
-  } catch (e) {}
+    /* eslint-enable */
+  } catch (e) {
+    /* Empty */
+  }
 }
--- a/devtools/server/tests/unit/test_ignore_no_interface_exceptions.js
+++ b/devtools/server/tests/unit/test_ignore_no_interface_exceptions.js
@@ -1,54 +1,56 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Test that the debugger automatically ignores NS_ERROR_NO_INTERFACE
  * exceptions, but not normal ones.
  */
 
-
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-no-interface");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-no-interface", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_pause_frame();
-    });
+    attachTestTabAndResume(gClient, "test-no-interface",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_pause_frame();
+                           });
   });
   do_test_pending();
 }
 
-function test_pause_frame()
-{
+function test_pause_frame() {
   gThreadClient.pauseOnExceptions(true, false, function () {
-    gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-      do_check_eq(aPacket.why.type, "exception");
-      do_check_eq(aPacket.why.exception, 42);
+    gThreadClient.addOneTimeListener("paused", function (event, packet) {
+      do_check_eq(packet.why.type, "exception");
+      do_check_eq(packet.why.exception, 42);
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
 
+    /* eslint-disable */
     gDebuggee.eval("(" + function () {
       function QueryInterface() {
         throw Components.results.NS_ERROR_NO_INTERFACE;
       }
       function stopMe() {
         throw 42;
       }
       try {
         QueryInterface();
       } catch (e) {}
       try {
         stopMe();
       } catch (e) {}
     } + ")()");
+    /* eslint-enable */
   });
 }
--- a/devtools/server/tests/unit/test_interrupt.js
+++ b/devtools/server/tests/unit/test_interrupt.js
@@ -1,50 +1,49 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"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) {
+  gClient.connect().then(function (type, traits) {
     attachTestTab(gClient, "test-1", test_attach);
   });
   do_test_pending();
 }
 
-function test_attach(aResponse, aTabClient)
-{
-  aTabClient.attachThread({}, function (aResponse, aThreadClient) {
-    do_check_eq(aThreadClient.paused, true);
-    aThreadClient.resume(function () {
-      test_interrupt(aThreadClient);
+function test_attach(response, tabClient) {
+  tabClient.attachThread({}, function (response, threadClient) {
+    do_check_eq(threadClient.paused, true);
+    threadClient.resume(function () {
+      test_interrupt(threadClient);
     });
   });
 }
 
-function test_interrupt(aThreadClient)
-{
-  do_check_eq(aThreadClient.paused, false);
-  aThreadClient.interrupt(function (aResponse) {
-    do_check_eq(aThreadClient.paused, true);
-    aThreadClient.resume(function () {
-      do_check_eq(aThreadClient.paused, false);
+function test_interrupt(threadClient) {
+  do_check_eq(threadClient.paused, false);
+  threadClient.interrupt(function (response) {
+    do_check_eq(threadClient.paused, true);
+    threadClient.resume(function () {
+      do_check_eq(threadClient.paused, false);
       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_layout-reflows-observer.js
+++ b/devtools/server/tests/unit/test_layout-reflows-observer.js
@@ -1,11 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 // Test the LayoutChangesObserver
 
 var {
   getLayoutChangesObserver,
   releaseLayoutChangesObserver,
   LayoutChangesObserver
 } = require("devtools/server/actors/reflow");
 
--- a/devtools/server/tests/unit/test_listsources-01.js
+++ b/devtools/server/tests/unit/test_listsources-01.js
@@ -1,59 +1,62 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check basic getSources functionality.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
 var gNumTimesSourcesSent = 0;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
-  gClient.request = (function (request) {
-    return function (aRequest, aOnResponse) {
-      if (aRequest.type === "sources") {
+  gClient.request = (function (origRequest) {
+    return function (request, onResponse) {
+      if (request.type === "sources") {
         ++gNumTimesSourcesSent;
       }
-      return request.call(this, aRequest, aOnResponse);
+      return origRequest.call(this, request, onResponse);
     };
   }(gClient.request));
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_listsources();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_listsources();
+                           });
   });
   do_test_pending();
 }
 
-function test_simple_listsources()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.getSources(function (aResponse) {
-      do_check_true(aResponse.sources.some(function (s) {
+function test_simple_listsources() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.getSources(function (response) {
+      do_check_true(response.sources.some(function (s) {
         return s.url && s.url.match(/test_listsources-01.js/);
       }));
 
       do_check_true(gNumTimesSourcesSent <= 1,
                     "Should only send one sources request at most, even though we"
                     + " might have had to send one to determine feature support.");
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
 
+  /* eslint-disable */
   Components.utils.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_listsources-02.js
+++ b/devtools/server/tests/unit/test_listsources-02.js
@@ -1,49 +1,49 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check getting sources before there are any.
  */
 
-var gDebuggee;
 var gClient;
 var gThreadClient;
 
 var gNumTimesSourcesSent = 0;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
-  gDebuggee = addTestGlobal("test-stack");
+  addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
-  gClient.request = (function (request) {
-    return function (aRequest, aOnResponse) {
-      if (aRequest.type === "sources") {
+  gClient.request = (function (origRequest) {
+    return function (request, onResponse) {
+      if (request.type === "sources") {
         ++gNumTimesSourcesSent;
       }
-      return request.call(this, aRequest, aOnResponse);
+      return origRequest.call(this, request, onResponse);
     };
   }(gClient.request));
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_listing_zero_sources();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_listing_zero_sources();
+                           });
   });
   do_test_pending();
 }
 
-function test_listing_zero_sources()
-{
-  gThreadClient.getSources(function (aPacket) {
-    do_check_true(!aPacket.error);
-    do_check_true(!!aPacket.sources);
-    do_check_eq(aPacket.sources.length, 0);
+function test_listing_zero_sources() {
+  gThreadClient.getSources(function (packet) {
+    do_check_true(!packet.error);
+    do_check_true(!!packet.sources);
+    do_check_eq(packet.sources.length, 0);
 
     do_check_true(gNumTimesSourcesSent <= 1,
                   "Should only send one sources request at most, even though we"
                   + " might have had to send one to determine feature support.");
 
     finishClient(gClient);
   });
 }
--- a/devtools/server/tests/unit/test_listsources-03.js
+++ b/devtools/server/tests/unit/test_listsources-03.js
@@ -1,42 +1,43 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check getSources functionality when there are lots of sources.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-sources");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-sources", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_listsources();
-    });
+    attachTestTabAndResume(gClient, "test-sources",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_listsources();
+                           });
   });
   do_test_pending();
 }
 
-function test_simple_listsources()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    gThreadClient.getSources(function (aResponse) {
+function test_simple_listsources() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    gThreadClient.getSources(function (response) {
       do_check_true(
-        !aResponse.error,
+        !response.error,
         "There shouldn't be an error fetching large amounts of sources.");
 
-      do_check_true(aResponse.sources.some(function (s) {
+      do_check_true(response.sources.some(function (s) {
         return s.url.match(/foo-999.js$/);
       }));
 
       gThreadClient.resume(function () {
         finishClient(gClient);
       });
     });
   });
--- a/devtools/server/tests/unit/test_listsources-04.js
+++ b/devtools/server/tests/unit/test_listsources-04.js
@@ -1,10 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow */
+
+"use strict";
 
 /**
  * Check getSources functionality with sourcemaps.
  */
 
 const {SourceNode} = require("source-map");
 
 function run_test() {
@@ -13,32 +16,32 @@ function run_test() {
     // `rpc` method which talks to the main thread does not work.
     // run_test_with_server(WorkerDebuggerServer, do_test_finished);
     do_test_finished();
   });
   do_test_pending();
 }
 
 function run_test_with_server(server, cb) {
-  Task.spawn(function*() {
+  Task.spawn(function* () {
     initTestDebuggerServer(server);
     const debuggee = addTestGlobal("test-sources", server);
     const client = new DebuggerClient(server.connectPipe());
     yield client.connect();
-    const [,,threadClient] = yield attachTestTabAndResume(client, "test-sources");
+    const [,, threadClient] = yield attachTestTabAndResume(client, "test-sources");
 
     yield threadClient.reconfigure({ useSourceMaps: true });
     addSources(debuggee);
 
     threadClient.getSources(Task.async(function* (res) {
       do_check_eq(res.sources.length, 3, "3 sources exist");
 
       yield threadClient.reconfigure({ useSourceMaps: false });
 
-      threadClient.getSources(function(res) {
+      threadClient.getSources(function (res) {
         do_check_eq(res.sources.length, 1, "1 source exist");
         client.close().then(cb);
       });
     }));
   });
 }
 
 function addSources(debuggee) {
--- a/devtools/server/tests/unit/test_longstringactor.js
+++ b/devtools/server/tests/unit/test_longstringactor.js
@@ -9,59 +9,48 @@ const { LongStringActor } = require("dev
 function run_test() {
   test_LSA_destroy();
   test_LSA_grip();
   test_LSA_onSubstring();
 }
 
 const TEST_STRING = "This is a very long string!";
 
-function makeMockLongStringActor()
-{
+function makeMockLongStringActor() {
   let string = TEST_STRING;
   let actor = new LongStringActor(string);
   actor.actorID = "longString1";
   actor.registeredPool = {
     longStringActors: {
       [string]: actor
     }
   };
   return actor;
 }
 
-function test_LSA_destroy()
-{
+function test_LSA_destroy() {
   let actor = makeMockLongStringActor();
   do_check_eq(actor.registeredPool.longStringActors[TEST_STRING], actor);
 
   actor.destroy();
   do_check_eq(actor.registeredPool.longStringActors[TEST_STRING], void 0);
 }
 
-function test_LSA_substring()
-{
-  let actor = makeMockLongStringActor();
-  do_check_eq(actor._substring(0, 4), TEST_STRING.substring(0, 4));
-  do_check_eq(actor._substring(6, 9), TEST_STRING.substring(6, 9));
-  do_check_eq(actor._substring(0, TEST_STRING.length), TEST_STRING);
-}
-
-function test_LSA_grip()
-{
+function test_LSA_grip() {
   let actor = makeMockLongStringActor();
 
   let grip = actor.grip();
   do_check_eq(grip.type, "longString");
-  do_check_eq(grip.initial, TEST_STRING.substring(0, DebuggerServer.LONG_STRING_INITIAL_LENGTH));
+  do_check_eq(grip.initial,
+              TEST_STRING.substring(0, DebuggerServer.LONG_STRING_INITIAL_LENGTH));
   do_check_eq(grip.length, TEST_STRING.length);
   do_check_eq(grip.actor, actor.actorID);
 }
 
-function test_LSA_onSubstring()
-{
+function test_LSA_onSubstring() {
   let actor = makeMockLongStringActor();
   let response;
 
   // From the start
   response = actor.onSubstring({
     start: 0,
     end: 4
   });
--- a/devtools/server/tests/unit/test_longstringgrips-01.js
+++ b/devtools/server/tests/unit/test_longstringgrips-01.js
@@ -1,62 +1,64 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_longstring_grip();
-    });
+    attachTestTabAndResume(gClient, "test-grips",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_longstring_grip();
+                           });
   });
   do_test_pending();
 }
 
-function test_longstring_grip()
-{
+function test_longstring_grip() {
   let longString = "All I want is to be a monkey of moderate intelligence who"
     + " wears a suit... that's why I'm transferring to business school! Maybe I"
     + " love you so much, I love you no matter who you are pretending to be."
     + " Enough about your promiscuous mother, Hermes! We have bigger problems."
     + " For example, if you killed your grandfather, you'd cease to exist! What"
     + " kind of a father would I be if I said no? Yep, I remember. They came in"
     + " last at the Olympics, then retired to promote alcoholic beverages! And"
     + " remember, don't do anything that affects anything, unless it turns out"
     + " you were supposed to, in which case, for the love of God, don't not do"
     + " it!";
 
   DebuggerServer.LONG_STRING_LENGTH = 200;
 
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
     do_check_eq(args.length, 1);
     let grip = args[0];
 
     try {
       do_check_eq(grip.type, "longString");
       do_check_eq(grip.length, longString.length);
-      do_check_eq(grip.initial, longString.substr(0, DebuggerServer.LONG_STRING_INITIAL_LENGTH));
+      do_check_eq(grip.initial,
+                  longString.substr(0, DebuggerServer.LONG_STRING_INITIAL_LENGTH));
 
       let longStringClient = gThreadClient.pauseLongString(grip);
-      longStringClient.substring(22, 28, function (aResponse) {
+      longStringClient.substring(22, 28, function (response) {
         try {
-          do_check_eq(aResponse.substring, "monkey");
+          do_check_eq(response.substring, "monkey");
         } finally {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         }
       });
     } catch (error) {
       gThreadClient.resume(function () {
--- a/devtools/server/tests/unit/test_longstringgrips-02.js
+++ b/devtools/server/tests/unit/test_longstringgrips-02.js
@@ -1,50 +1,50 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
     attachTestTabAndResume(
-      gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-        gThreadClient = aThreadClient;
+      gClient, "test-grips", function (response, tabClient, threadClient) {
+        gThreadClient = threadClient;
         test_longstring_grip();
       });
   });
   do_test_pending();
 }
 
-function test_longstring_grip()
-{
+function test_longstring_grip() {
   DebuggerServer.LONG_STRING_LENGTH = 200;
 
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
     try {
       let fakeLongStringGrip = {
         type: "longString",
         length: 1000000,
         actor: "123fakeActor123",
         initial: ""
       };
       let longStringClient = gThreadClient.pauseLongString(fakeLongStringGrip);
-      longStringClient.substring(22, 28, function (aResponse) {
+      longStringClient.substring(22, 28, function (response) {
         try {
-          do_check_true(!!aResponse.error,
+          do_check_true(!!response.error,
                         "We should not get a response, but an error.");
         } finally {
           gThreadClient.resume(function () {
             finishClient(gClient);
           });
         }
       });
     } catch (error) {
--- a/devtools/server/tests/unit/test_monitor_actor.js
+++ b/devtools/server/tests/unit/test_monitor_actor.js
@@ -2,18 +2,17 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 /**
  * Test the monitor actor.
  */
 
 "use strict";
 
-function run_test()
-{
+function run_test() {
   let EventEmitter = require("devtools/shared/event-emitter");
 
   function MonitorClient(client, form) {
     this.client = client;
     this.actor = form.monitorActor;
     this.events = ["update"];
 
     EventEmitter.decorate(this);
@@ -59,17 +58,17 @@ function run_test()
 
   function gotUpdate(type, packet) {
     packet.data.forEach(function (event) {
       // Ignore updates that were not sent by this test.
       if (event.graph === "Test") {
         do_check_eq(event.curve, "test");
         do_check_eq(event.value, 42);
         do_check_eq(event.time, time);
-        monitor.stop(function (aResponse) {
+        monitor.stop(function (response) {
           monitor.destroy();
           finishClient(client);
         });
       }
     });
   }
 
   do_test_pending();
--- a/devtools/server/tests/unit/test_nativewrappers.js
+++ b/devtools/server/tests/unit/test_nativewrappers.js
@@ -1,30 +1,31 @@
-function run_test()
-{
+/* eslint-disable strict */
+function run_test() {
   Components.utils.import("resource://gre/modules/jsdebugger.jsm");
   addDebuggerToGlobal(this);
-  var g = testGlobal("test1");
+  let g = testGlobal("test1");
 
-  var dbg = new Debugger();
+  let dbg = new Debugger();
   dbg.addDebuggee(g);
-  dbg.onDebuggerStatement = function (aFrame) {
-    let args = aFrame.arguments;
+  dbg.onDebuggerStatement = function (frame) {
+    let args = frame.arguments;
     try {
       args[0];
       do_check_true(true);
     } catch (ex) {
       do_check_true(false);
     }
   };
 
   g.eval("function stopMe(arg) {debugger;}");
 
   g2 = testGlobal("test2");
   g2.g = g;
   g2.eval("(" + function createBadEvent() {
-    let parser = Components.classes["@mozilla.org/xmlextras/domparser;1"].createInstance(Components.interfaces.nsIDOMParser);
+    let parser = Components.classes["@mozilla.org/xmlextras/domparser;1"]
+        .createInstance(Components.interfaces.nsIDOMParser);
     let doc = parser.parseFromString("<foo></foo>", "text/xml");
     g.stopMe(doc.createEvent("MouseEvent"));
   } + ")()");
 
   dbg.enabled = false;
 }
--- a/devtools/server/tests/unit/test_nesting-01.js
+++ b/devtools/server/tests/unit/test_nesting-01.js
@@ -1,36 +1,41 @@
 /* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 // Test that we can nest event loops when needed in
 // ThreadActor.prototype.unsafeSynchronize.
 
 var gClient;
 var gThreadActor;
 
 function run_test() {
   initTestDebuggerServer();
-  let gDebuggee = addTestGlobal("test-nesting");
+  addTestGlobal("test-nesting");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-nesting", function (aResponse, aTabClient, aThreadClient) {
-      // Reach over the protocol connection and get a reference to the thread actor.
-      gThreadActor = aThreadClient._transport._serverConnection.getActor(aThreadClient._actor);
+    attachTestTabAndResume(
+      gClient, "test-nesting",
+      function (response, tabClient, threadClient) {
+        // Reach over the protocol connection and get a reference to the thread actor.
+        gThreadActor =
+          threadClient._transport._serverConnection.getActor(threadClient._actor);
 
-      test_nesting();
-    });
+        test_nesting();
+      });
   });
   do_test_pending();
 }
 
 function test_nesting() {
   const thread = gThreadActor;
-  const { resolve, reject, promise: p } = promise.defer();
+  const { resolve, promise: p } = promise.defer();
 
   let currentStep = 0;
 
   executeSoon(function () {
     // Should be on the first step
     do_check_eq(++currentStep, 1);
     // We should have one nested event loop from unsfeSynchronize
     do_check_eq(thread._nestedEventLoops.size, 1);
--- a/devtools/server/tests/unit/test_nesting-02.js
+++ b/devtools/server/tests/unit/test_nesting-02.js
@@ -1,37 +1,42 @@
 /* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 // Test that we can nest event loops and then automatically exit nested event
 // loops when requested.
 
 var gClient;
 var gThreadActor;
 
 function run_test() {
   initTestDebuggerServer();
-  let gDebuggee = addTestGlobal("test-nesting");
+  addTestGlobal("test-nesting");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-nesting", function (aResponse, aTabClient, aThreadClient) {
-      // Reach over the protocol connection and get a reference to the thread
-      // actor.
-      gThreadActor = aThreadClient._transport._serverConnection.getActor(aThreadClient._actor);
+    attachTestTabAndResume(
+      gClient, "test-nesting",
+      function (response, tabClient, threadClient) {
+        // Reach over the protocol connection and get a reference to the thread
+        // actor.
+        gThreadActor =
+          threadClient._transport._serverConnection.getActor(threadClient._actor);
 
-      test_nesting();
-    });
+        test_nesting();
+      });
   });
   do_test_pending();
 }
 
 function test_nesting() {
   const thread = gThreadActor;
-  const { resolve, reject, promise: p } = promise.defer();
+  const { resolve, promise: p } = promise.defer();
 
   // The following things should happen (in order):
   // 1. In the new event loop (created by unsafeSynchronize)
   // 2. Resolve the promise (shouldn't exit any event loops)
   // 3. Exit the event loop (should also then exit unsafeSynchronize's event loop)
   // 4. Be after the unsafeSynchronize call
   let currentStep = 0;
 
--- a/devtools/server/tests/unit/test_nesting-03.js
+++ b/devtools/server/tests/unit/test_nesting-03.js
@@ -1,51 +1,54 @@
 /* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
 /* 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 can detect nested event loops in tabs with the same URL.
 
 var gClient1, gClient2, gThreadClient1, gThreadClient2;
 
 function run_test() {
   initTestDebuggerServer();
   addTestGlobal("test-nesting1");
   addTestGlobal("test-nesting1");
   // Conect the first client to the first debuggee.
   gClient1 = new DebuggerClient(DebuggerServer.connectPipe());
   gClient1.connect(function () {
-    attachTestThread(gClient1, "test-nesting1", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient1 = aThreadClient;
-      start_second_connection();
-    });
+    attachTestThread(gClient1, "test-nesting1",
+                     function (response, tabClient, threadClient) {
+                       gThreadClient1 = threadClient;
+                       start_second_connection();
+                     });
   });
   do_test_pending();
 }
 
 function start_second_connection() {
   gClient2 = new DebuggerClient(DebuggerServer.connectPipe());
   gClient2.connect(function () {
-    attachTestThread(gClient2, "test-nesting1", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient2 = aThreadClient;
-      test_nesting();
-    });
+    attachTestThread(gClient2, "test-nesting1",
+                     function (response, tabClient, threadClient) {
+                       gThreadClient2 = threadClient;
+                       test_nesting();
+                     });
   });
 }
 
 function test_nesting() {
-  const { resolve, reject, promise: p } = promise.defer();
+  gThreadClient1.resume(response => {
+    do_check_eq(response.error, "wrongOrder");
+    gThreadClient2.resume(response => {
+      do_check_true(!response.error);
+      do_check_eq(response.from, gThreadClient2.actor);
 
-  gThreadClient1.resume(aResponse => {
-    do_check_eq(aResponse.error, "wrongOrder");
-    gThreadClient2.resume(aResponse => {
-      do_check_true(!aResponse.error);
-      do_check_eq(aResponse.from, gThreadClient2.actor);
-
-      gThreadClient1.resume(aResponse => {
-        do_check_true(!aResponse.error);
-        do_check_eq(aResponse.from, gThreadClient1.actor);
+      gThreadClient1.resume(response => {
+        do_check_true(!response.error);
+        do_check_eq(response.from, gThreadClient1.actor);
 
         gClient1.close(() => finishClient(gClient2));
       });
     });
   });
 }
--- a/devtools/server/tests/unit/test_new_source-01.js
+++ b/devtools/server/tests/unit/test_new_source-01.js
@@ -1,40 +1,41 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * Check basic newSource packet sent from server.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
 
-function run_test()
-{
+function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-stack", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_simple_new_source();
-    });
+    attachTestTabAndResume(gClient, "test-stack",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_simple_new_source();
+                           });
   });
   do_test_pending();
 }
 
-function test_simple_new_source()
-{
-  gThreadClient.addOneTimeListener("newSource", function (aEvent, aPacket) {
-    do_check_eq(aEvent, "newSource");
-    do_check_eq(aPacket.type, "newSource");
-    do_check_true(!!aPacket.source);
-    do_check_true(!!aPacket.source.url.match(/test_new_source-01.js$/));
+function test_simple_new_source() {
+  gThreadClient.addOneTimeListener("newSource", function (event, packet) {
+    do_check_eq(event, "newSource");
+    do_check_eq(packet.type, "newSource");
+    do_check_true(!!packet.source);
+    do_check_true(!!packet.source.url.match(/test_new_source-01.js$/));
 
     finishClient(gClient);
   });
 
   Components.utils.evalInSandbox(function inc(n) {
     return n + 1;
   }.toString(), gDebuggee);
 }
--- a/devtools/server/tests/unit/test_nsjsinspector.js
+++ b/devtools/server/tests/unit/test_nsjsinspector.js
@@ -1,44 +1,44 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 // Test the basic functionality of the nsIJSInspector component.
 var gCount = 0;
 const MAX = 10;
 var inspector = Cc["@mozilla.org/jsinspector;1"].getService(Ci.nsIJSInspector);
 var tm = Cc["@mozilla.org/thread-manager;1"].getService(Ci.nsIThreadManager);
 
 // Emulate 10 simultaneously-debugged windows from 3 separate client connections.
 var requestor = (count) => ({
-  url:"http://foo/bar/" + count,
+  url: "http://foo/bar/" + count,
   connection: "conn" + (count % 3)
 });
 
-function run_test()
-{
+function run_test() {
   test_nesting();
 }
 
-function test_nesting()
-{
+function test_nesting() {
   do_check_eq(inspector.eventLoopNestLevel, 0);
 
   tm.currentThread.dispatch({ run: enterEventLoop}, 0);
 
   do_check_eq(inspector.enterNestedEventLoop(requestor(gCount)), 0);
   do_check_eq(inspector.eventLoopNestLevel, 0);
   do_check_eq(inspector.lastNestRequestor, null);
 }
 
 function enterEventLoop() {
   if (gCount++ < MAX) {
     tm.currentThread.dispatch({ run: enterEventLoop}, 0);
 
-    let r = Object.create(requestor(gCount));
+    Object.create(requestor(gCount));
 
     do_check_eq(inspector.eventLoopNestLevel, gCount);
     do_check_eq(inspector.lastNestRequestor.url, requestor(gCount - 1).url);
     do_check_eq(inspector.lastNestRequestor.connection, requestor(gCount - 1).connection);
     do_check_eq(inspector.enterNestedEventLoop(requestor(gCount)), gCount);
   } else {
     do_check_eq(gCount, MAX + 1);
     tm.currentThread.dispatch({ run: exitEventLoop}, 0);
--- a/devtools/server/tests/unit/test_objectgrips-01.js
+++ b/devtools/server/tests/unit/test_objectgrips-01.js
@@ -1,58 +1,57 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 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-grips", aServer);
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
-  gClient = new DebuggerClient(aServer.connectPipe());
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_object_grip();
-    });
+    attachTestTabAndResume(gClient, "test-grips",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_object_grip();
+                           });
   });
 }
 
-function test_object_grip()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+function test_object_grip() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
 
     do_check_eq(args[0].class, "Object");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
-    objClient.getOwnPropertyNames(function (aResponse) {
-      do_check_eq(aResponse.ownPropertyNames.length, 3);
-      do_check_eq(aResponse.ownPropertyNames[0], "a");
-      do_check_eq(aResponse.ownPropertyNames[1], "b");
-      do_check_eq(aResponse.ownPropertyNames[2], "c");
+    objClient.getOwnPropertyNames(function (response) {
+      do_check_eq(response.ownPropertyNames.length, 3);
+      do_check_eq(response.ownPropertyNames[0], "a");
+      do_check_eq(response.ownPropertyNames[1], "b");
+      do_check_eq(response.ownPropertyNames[2], "c");
 
       gThreadClient.resume(function () {
         gClient.close().then(gCallback);
       });
     });
-
   });
 
   gDebuggee.eval("stopMe({ a: 1, b: true, c: 'foo' })");
 }
 
--- a/devtools/server/tests/unit/test_objectgrips-02.js
+++ b/devtools/server/tests/unit/test_objectgrips-02.js
@@ -1,65 +1,66 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 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-grips", aServer);
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
-  gClient = new DebuggerClient(aServer.connectPipe());
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_object_grip();
-    });
+    attachTestTabAndResume(gClient, "test-grips",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_object_grip();
+                           });
   });
 }
 
-function test_object_grip()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+function test_object_grip() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
 
     do_check_eq(args[0].class, "Object");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
-    objClient.getPrototype(function (aResponse) {
-      do_check_true(aResponse.prototype != undefined);
+    objClient.getPrototype(function (response) {
+      do_check_true(response.prototype != undefined);
 
-      let protoClient = gThreadClient.pauseGrip(aResponse.prototype);
-      protoClient.getOwnPropertyNames(function (aResponse) {
-        do_check_eq(aResponse.ownPropertyNames.length, 2);
-        do_check_eq(aResponse.ownPropertyNames[0], "b");
-        do_check_eq(aResponse.ownPropertyNames[1], "c");
+      let protoClient = gThreadClient.pauseGrip(response.prototype);
+      protoClient.getOwnPropertyNames(function (response) {
+        do_check_eq(response.ownPropertyNames.length, 2);
+        do_check_eq(response.ownPropertyNames[0], "b");
+        do_check_eq(response.ownPropertyNames[1], "c");
 
         gThreadClient.resume(function () {
           gClient.close().then(gCallback);
         });
       });
     });
-
   });
 
   gDebuggee.eval(function Constr() {
     this.a = 1;
   }.toString());
-  gDebuggee.eval("Constr.prototype = { b: true, c: 'foo' }; var o = new Constr(); stopMe(o)");
+  gDebuggee.eval(
+    "Constr.prototype = { b: true, c: 'foo' }; var o = new Constr(); stopMe(o)");
 }
 
--- a/devtools/server/tests/unit/test_objectgrips-03.js
+++ b/devtools/server/tests/unit/test_objectgrips-03.js
@@ -1,73 +1,73 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 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-grips", aServer);
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
-  gClient = new DebuggerClient(aServer.connectPipe());
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_object_grip();
-    });
+    attachTestTabAndResume(gClient, "test-grips",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_object_grip();
+                           });
   });
 }
 
-function test_object_grip()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+function test_object_grip() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
 
     do_check_eq(args[0].class, "Object");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
-    objClient.getProperty("x", function (aResponse) {
-      do_check_eq(aResponse.descriptor.configurable, true);
-      do_check_eq(aResponse.descriptor.enumerable, true);
-      do_check_eq(aResponse.descriptor.writable, true);
-      do_check_eq(aResponse.descriptor.value, 10);
+    objClient.getProperty("x", function (response) {
+      do_check_eq(response.descriptor.configurable, true);
+      do_check_eq(response.descriptor.enumerable, true);
+      do_check_eq(response.descriptor.writable, true);
+      do_check_eq(response.descriptor.value, 10);
 
-      objClient.getProperty("y", function (aResponse) {
-        do_check_eq(aResponse.descriptor.configurable, true);
-        do_check_eq(aResponse.descriptor.enumerable, true);
-        do_check_eq(aResponse.descriptor.writable, true);
-        do_check_eq(aResponse.descriptor.value, "kaiju");
+      objClient.getProperty("y", function (response) {
+        do_check_eq(response.descriptor.configurable, true);
+        do_check_eq(response.descriptor.enumerable, true);
+        do_check_eq(response.descriptor.writable, true);
+        do_check_eq(response.descriptor.value, "kaiju");
 
-        objClient.getProperty("a", function (aResponse) {
-          do_check_eq(aResponse.descriptor.configurable, true);
-          do_check_eq(aResponse.descriptor.enumerable, true);
-          do_check_eq(aResponse.descriptor.get.type, "object");
-          do_check_eq(aResponse.descriptor.get.class, "Function");
-          do_check_eq(aResponse.descriptor.set.type, "undefined");
+        objClient.getProperty("a", function (response) {
+          do_check_eq(response.descriptor.configurable, true);
+          do_check_eq(response.descriptor.enumerable, true);
+          do_check_eq(response.descriptor.get.type, "object");
+          do_check_eq(response.descriptor.get.class, "Function");
+          do_check_eq(response.descriptor.set.type, "undefined");
 
           gThreadClient.resume(function () {
             gClient.close().then(gCallback);
           });
         });
       });
     });
-
   });
 
   gDebuggee.eval("stopMe({ x: 10, y: 'kaiju', get a() { return 42; } })");
 }
 
--- a/devtools/server/tests/unit/test_objectgrips-04.js
+++ b/devtools/server/tests/unit/test_objectgrips-04.js
@@ -1,76 +1,76 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable no-shadow, max-nested-callbacks */
+
+"use strict";
 
 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-grips", aServer);
+function run_test_with_server(server, callback) {
+  gCallback = callback;
+  initTestDebuggerServer(server);
+  gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
-  gClient = new DebuggerClient(aServer.connectPipe());
+  gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function () {
-    attachTestTabAndResume(gClient, "test-grips", function (aResponse, aTabClient, aThreadClient) {
-      gThreadClient = aThreadClient;
-      test_object_grip();
-    });
+    attachTestTabAndResume(gClient, "test-grips",
+                           function (response, tabClient, threadClient) {
+                             gThreadClient = threadClient;
+                             test_object_grip();
+                           });
   });
 }
 
-function test_object_grip()
-{
-  gThreadClient.addOneTimeListener("paused", function (aEvent, aPacket) {
-    let args = aPacket.frame.arguments;
+function test_object_grip() {
+  gThreadClient.addOneTimeListener("paused", function (event, packet) {
+    let args = packet.frame.arguments;
 
     do_check_eq(args[0].class, "Object");
 
     let objClient = gThreadClient.pauseGrip(args[0]);
-    objClient.getPrototypeAndProperties(function (aResponse) {
-      do_check_eq(aResponse.ownProperties.x.configurable, true);
-      do_check_eq(aResponse.ownProperties.x.enumerable, true);
-      do_check_eq(aResponse.ownProperties.x.writable, true);
-      do_check_eq(aResponse.ownProperties.x.value, 10);
+    objClient.getPrototypeAndProperties(function (response) {
+      do_check_eq(response.ownProperties.x.configurable, true);
+      do_check_eq(response.ownProperties.x.enumerable, true);
+      do_check_eq(response.ownProperties.x.writable, true);
+      do_check_eq(response.ownProperties.x.value, 10);
 
-      do_check_eq(aResponse.ownProperties.y.configurable, true);
-      do_check_eq(aResponse.ownProperties.y.enumerable, true);
-      do_check_eq(aResponse.ownProperties.y.writable, true);
-      do_check_eq(aResponse.ownProperties.y.value, "kaiju");
+      do_check_eq(response.ownProperties.y.configurable, true);
+      do_check_eq(response.ownProperties.y.enumerable, true);
+      do_check_eq(response.ownProperties.y.writable, true);
+      do_check_eq(response.ownProperties.y.value, "kaiju");
 
-      do_check_eq(aResponse.ownProperties.a.configurable, true);
-      do_check_eq(aResponse.ownProperties.a.enumerable, true);
-      do_check_eq(aResponse.ownProperties.a.get.type, "object");
-      do_check_eq(aResponse.ownProperties.a.get.class, "Function");
-      do_check_eq(aResponse.ownProperties.a.set.type, "undefined");
+      do_check_eq(response.ownProperties.a.configurable, true);
+      do_check_eq(response.ownProperties.a.enumerable, true);
+      do_check_eq(response.ownProperties.a.get.type, "object");
+      do_check_eq(response.ownProperties.a.get.class, "Function");
+      do_check_eq(response.ownProperties.a.set.type, "undefined");
 
-      do_check_true(aResponse.prototype != undefined);
+      do_check_true(response.prototype != undefined);
 
-      let protoClient = gThreadClient.pauseGrip(aResponse.prototype);
-      protoClient.getOwnPropertyNames(function (aResponse) {
-        do_check_true(aResponse.ownPropertyNames.toString != undefined);
+      let protoClient = gThreadClient.pauseGrip(response.prototype);
+      protoClient.getOwnPropertyNames(function (response) {
+        do_check_true(response.ownPropertyNames.toString != undefined);
 
         gThreadClient.resume(function () {
           gClient.close().then(gCallback);
         });
       });
     });
-
   });
 
   gDebuggee.eval("stopMe({ x: 10, y: 'kaiju', get a() { return 42; } })");
 }
 
--- a/devtools/server/tests/unit/test_objectgrips-05.js
+++ b/devtools/server/tests/unit/test_objectgrips-05.js
@@ -1,57 +1,57 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+"use strict";
+
 /**
  * This test checks that frozen objects report themselves as frozen in their
  * grip.
  */
 
 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)
-{