--- a/devtools/client/aboutdebugging/components/addons/Panel.js
+++ b/devtools/client/aboutdebugging/components/addons/Panel.js
@@ -86,17 +86,17 @@ class AddonsPanel extends Component {
     this.setState({ debugDisabled });
   }
 
   updateAddonsList() {
     this.props.client.listAddons()
       .then(({addons}) => {
         const extensions = addons.filter(addon => addon.debuggable).map(addon => {
           return {
-            addonActor: addon.actor,
+            addonTargetActor: addon.actor,
             addonID: addon.id,
             // Forward the whole addon actor form for potential remote debugging.
             form: addon,
             icon: addon.iconURL || ExtensionIcon,
             manifestURL: addon.manifestURL,
             name: addon.name,
             temporarilyInstalled: addon.temporarilyInstalled,
             url: addon.url,

--- a/devtools/client/aboutdebugging/components/addons/Target.js
+++ b/devtools/client/aboutdebugging/components/addons/Target.js
@@ -151,17 +151,17 @@ function warningMessages(target) {
 
 class AddonTarget extends Component {
   static get propTypes() {
     return {
       client: PropTypes.instanceOf(DebuggerClient).isRequired,
       connect: PropTypes.object,
       debugDisabled: PropTypes.bool,
       target: PropTypes.shape({
-        addonActor: PropTypes.string.isRequired,
+        addonTargetActor: PropTypes.string.isRequired,
         addonID: PropTypes.string.isRequired,
         form: PropTypes.object.isRequired,
         icon: PropTypes.string,
         name: PropTypes.string.isRequired,
         temporarilyInstalled: PropTypes.bool,
         url: PropTypes.string,
         warnings: PropTypes.array,
       }).isRequired
@@ -190,17 +190,17 @@ class AddonTarget extends Component {
     uninstallAddon(target.addonID);
   }
 
   async reload() {
     const { client, target } = this.props;
     const { AboutDebugging } = window;
     try {
       await client.request({
-        to: target.addonActor,
+        to: target.addonTargetActor,
         type: "reload"
       });
       AboutDebugging.emit("addon-reload");
     } catch (e) {
       throw new Error("Error reloading addon " + target.addonID + ": " + e.message);
     }
   }
 

--- a/devtools/client/debugger/test/mochitest/head.js
+++ b/devtools/client/debugger/test/mochitest/head.js
@@ -170,19 +170,19 @@ function getTabActorForUrl(aClient, aUrl
   return deferred.promise;
 }
 
 function getAddonActorForId(aClient, aAddonId) {
   info("Get addon actor for ID: " + aAddonId);
   let deferred = promise.defer();
 
   aClient.listAddons(aResponse => {
-    let addonActor = aResponse.addons.filter(aGrip => aGrip.id == aAddonId).pop();
+    let addonTargetActor = aResponse.addons.filter(aGrip => aGrip.id == aAddonId).pop();
     info("got addon actor for ID: " + aAddonId);
-    deferred.resolve(addonActor);
+    deferred.resolve(addonTargetActor);
   });
 
   return deferred.promise;
 }
 
 function attachTabActorForUrl(aClient, aUrl) {
   let deferred = promise.defer();
 
@@ -640,20 +640,20 @@ AddonDebugger.prototype = {
     document.documentElement.appendChild(this.frame);
     window.addEventListener("message", this._onMessage);
 
     let transport = DebuggerServer.connectPipe();
     this.client = new DebuggerClient(transport);
 
     yield this.client.connect();
 
-    let addonActor = yield getAddonActorForId(this.client, aAddonId);
+    let addonTargetActor = yield getAddonActorForId(this.client, aAddonId);
 
     let targetOptions = {
-      form: addonActor,
+      form: addonTargetActor,
       client: this.client,
       chrome: true,
       isBrowsingContext: false
     };
 
     let toolboxOptions = {
       customIframe: this.frame
     };

--- a/devtools/client/framework/ToolboxProcess.jsm
+++ b/devtools/client/framework/ToolboxProcess.jsm
@@ -108,17 +108,17 @@ BrowserToolboxProcess.getBrowserToolboxS
     if (!process._options || !process._options.addonID) {
       return true;
     }
   }
   return false;
 };
 
 /**
- * Passes a set of options to the BrowserAddonActors for the given ID.
+ * Passes a set of options to the AddonTargetActors for the given ID.
  *
  * @param id string
  *        The ID of the add-on to pass the options to
  * @param options object
  *        The options.
  * @return a promise that will be resolved when complete.
  */
 BrowserToolboxProcess.setAddonOptions = function(id, options) {

--- a/devtools/client/framework/connect/connect.js
+++ b/devtools/client/framework/connect/connect.js
@@ -83,17 +83,17 @@ var onConnectionReady = async function([
     const response = await gClient.listAddons();
     if (!response.error && response.addons.length > 0) {
       addons = response.addons;
     }
   } catch (e) {
     // listAddons throws if the runtime doesn't support addons
   }
 
-  let parent = document.getElementById("addonActors");
+  let parent = document.getElementById("addonTargetActors");
   if (addons.length > 0) {
     // Add one entry for each add-on.
     for (const addon of addons) {
       if (!addon.debuggable) {
         continue;
       }
       buildAddonLink(addon, parent);
     }

--- a/devtools/client/framework/connect/connect.xhtml
+++ b/devtools/client/framework/connect/connect.xhtml
@@ -37,17 +37,17 @@
       <p class="error-message error-timeout">&errorTimeout;</p>
       <p class="error-message error-refused">&errorRefused;</p>
       <p class="error-message error-unexpected">&errorUnexpected;</p>
     </section>
     <section id="actors-list">
       <p>&availableTabs;</p>
       <ul class="actors" id="tabActors"></ul>
       <p>&availableAddons;</p>
-      <ul class="actors" id="addonActors"></ul>
+      <ul class="actors" id="addonTargetActors"></ul>
       <p>&availableProcesses;</p>
       <ul class="actors" id="globalActors"></ul>
     </section>
     <section id="connecting">
       <p class="devtools-throbber">&connecting;</p>
     </section>
     <footer>&remoteHelp;<a target='_' href='https://developer.mozilla.org/docs/Tools/Remote_Debugging'>&remoteDocumentation;</a>&remoteHelpSuffix;</footer>
   </body>

--- a/devtools/client/framework/target.js
+++ b/devtools/client/framework/target.js
@@ -345,18 +345,19 @@ TabTarget.prototype = {
     return this._url;
   },
 
   get isRemote() {
     return !this.isLocalTab;
   },
 
   get isAddon() {
-    return !!(this._form && this._form.actor &&
-              this._form.actor.match(/conn\d+\.addon\d+/)) || this.isWebExtension;
+    const isLegacyAddon = !!(this._form && this._form.actor &&
+      this._form.actor.match(/conn\d+\.addon(Target)?\d+/));
+    return isLegacyAddon || this.isWebExtension;
   },
 
   get isWebExtension() {
     return !!(this._form && this._form.actor && (
       this._form.actor.match(/conn\d+\.webExtension\d+/) ||
       this._form.actor.match(/child\d+\/webExtension\d+/)
     ));
   },
@@ -415,17 +416,17 @@ TabTarget.prototype = {
       // Enable being able to get child process actors
       DebuggerServer.allowChromeProcess = true;
 
       this._client = new DebuggerClient(DebuggerServer.connectPipe());
       // A local TabTarget will never perform chrome debugging.
       this._chrome = false;
     } else if (this._form.isWebExtension &&
           this.client.mainRoot.traits.webExtensionAddonConnect) {
-      // The addonActor form is related to a WebExtensionParentActor instance,
+      // The addonTargetActor form is related to a WebExtensionParentActor instance,
       // which isn't a target actor on its own, it is an actor living in the parent
       // process with access to the addon metadata, it can control the addon (e.g.
       // reloading it) and listen to the AddonManager events related to the lifecycle of
       // the addon (e.g. when the addon is disabled or uninstalled).
       // To retrieve the target actor instance, we call its "connect" method, (which
       // fetches the target actor form from a WebExtensionChildActor instance).
       const {form} = await this._client.request({
         to: this._form.actor, type: "connect",

--- a/devtools/client/framework/toolbox-process-window.js
+++ b/devtools/client/framework/toolbox-process-window.js
@@ -77,19 +77,19 @@ var connect = async function() {
   });
   gClient = new DebuggerClient(transport);
   appendStatusMessage("Start protocol client for connection");
   await gClient.connect();
 
   appendStatusMessage("Get root form for toolbox");
   if (addonID) {
     const { addons } = await gClient.listAddons();
-    const addonActor = addons.filter(addon => addon.id === addonID).pop();
-    const isBrowsingContext = addonActor.isWebExtension;
-    await openToolbox({form: addonActor, chrome: true, isBrowsingContext});
+    const addonTargetActor = addons.filter(addon => addon.id === addonID).pop();
+    const isBrowsingContext = addonTargetActor.isWebExtension;
+    await openToolbox({form: addonTargetActor, chrome: true, isBrowsingContext});
   } else {
     const response = await gClient.getProcess();
     await openToolbox({form: response.form, chrome: true});
   }
 };
 
 // Certain options should be toggled since we can assume chrome debugging here
 function setPrefDefaults() {

--- a/devtools/docs/backend/actor-hierarchy.md
+++ b/devtools/docs/backend/actor-hierarchy.md
@@ -90,18 +90,18 @@ RootActor (root.js)
    |   Returned by "getProcess" request without any argument.
    |
    |-- ContentProcessTargetActor (content-process.js)
    |   Targets all resources in a content process of Firefox (chrome sandboxes,
    |   frame scripts, documents, etc.)
    |   Returned by "getProcess" request with a id argument, matching the
    |   targeted process.
    |
-   \-- BrowserAddonActor (addon.js)
-       Targets the javascript of add-ons.
+   \-- AddonTargetActor (addon.js)
+       Targets a legacy (non-WebExtension) add-on.
        Returned by "listAddons" request.
 ```
 
 ## Target Actors
 
 Those are the actors exposed by the root actors which are meant to track the
 lifetime of a given target: tab, process, add-on, or worker. It also allows to
 fetch the tab-scoped actors connected to this target, which are actors like

--- a/devtools/server/actors/addon/addons.js
+++ b/devtools/server/actors/addon/addons.js
@@ -22,17 +22,17 @@ const AddonsActor = protocol.ActorClassW
       addonFile = new FileUtils.File(addonPath);
       addon = await AddonManager.installTemporaryAddon(addonFile);
     } catch (error) {
       throw new Error(`Could not install add-on at '${addonPath}': ${error}`);
     }
 
     // TODO: once the add-on actor has been refactored to use
     // protocol.js, we could return it directly.
-    // return new BrowserAddonActor(this.conn, addon);
+    // return new AddonTargetActor(this.conn, addon);
 
     // Return a pseudo add-on object that a calling client can work
     // with. Provide a flag that the client can use to detect when it
     // gets upgraded to a real actor object.
     return { id: addon.id, actor: false };
   },
 });
 

--- a/devtools/server/actors/addon/console.js
+++ b/devtools/server/actors/addon/console.js
@@ -25,17 +25,17 @@ const addonConsolePrototype = extend({},
  * console feature.
  *
  * @constructor
  * @param object addon
  *        The add-on that this console watches.
  * @param object connection
  *        The connection to the client, DebuggerServerConnection.
  * @param object parentActor
- *        The parent BrowserAddonActor actor.
+ *        The parent AddonTargetActor actor.
  */
 addonConsolePrototype.initialize = function(addon, connection, parentActor) {
   this.addon = addon;
   Actor.prototype.initialize.call(this, connection);
   WebConsoleActor.call(this, connection, parentActor);
 };
 
 update(addonConsolePrototype, {

--- a/devtools/server/actors/moz.build
+++ b/devtools/server/actors/moz.build
@@ -16,17 +16,16 @@ DIRS += [
     'webconsole',
     'worker',
 ]
 
 DevToolsModules(
     'accessibility-parent.js',
     'accessibility.js',
     'actor-registry.js',
-    'addon.js',
     'animation-type-longhand.js',
     'animation.js',
     'array-buffer.js',
     'breakpoint.js',
     'call-watcher.js',
     'canvas.js',
     'common.js',
     'css-properties.js',

--- a/devtools/server/actors/root.js
+++ b/devtools/server/actors/root.js
@@ -390,31 +390,31 @@ RootActor.prototype = {
     if (!addonList) {
       return { from: this.actorID, error: "noAddons",
                message: "This root actor has no browser addons." };
     }
 
     // Reattach the onListChanged listener now that a client requested the list.
     addonList.onListChanged = this._onAddonListChanged;
 
-    return addonList.getList().then((addonActors) => {
-      const addonActorPool = new ActorPool(this.conn);
-      for (const addonActor of addonActors) {
-        addonActorPool.addActor(addonActor);
+    return addonList.getList().then((addonTargetActors) => {
+      const addonTargetActorPool = new ActorPool(this.conn);
+      for (const addonTargetActor of addonTargetActors) {
+        addonTargetActorPool.addActor(addonTargetActor);
       }
 
-      if (this._addonActorPool) {
-        this.conn.removeActorPool(this._addonActorPool);
+      if (this._addonTargetActorPool) {
+        this.conn.removeActorPool(this._addonTargetActorPool);
       }
-      this._addonActorPool = addonActorPool;
-      this.conn.addActorPool(this._addonActorPool);
+      this._addonTargetActorPool = addonTargetActorPool;
+      this.conn.addActorPool(this._addonTargetActorPool);
 
       return {
         "from": this.actorID,
-        "addons": addonActors.map(addonActor => addonActor.form())
+        "addons": addonTargetActors.map(addonTargetActor => addonTargetActor.form())
       };
     });
   },
 
   onAddonListChanged: function() {
     this.conn.send({ from: this.actorID, type: "addonListChanged" });
     this._parameters.addonList.onListChanged = null;
   },

rename from devtools/server/actors/addon.js
rename to devtools/server/actors/targets/addon.js
--- a/devtools/server/actors/addon.js
+++ b/devtools/server/actors/targets/addon.js
@@ -1,49 +1,55 @@
 /* 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";
 
+/*
+ * Target actor for a legacy (non-WebExtension) add-on.
+ *
+ * See devtools/docs/backend/actor-hierarchy.md for more details.
+ */
+
 var { Ci, Cu } = require("chrome");
 var Services = require("Services");
 var { ActorPool } = require("devtools/server/actors/common");
-var { TabSources } = require("./utils/TabSources");
-var makeDebugger = require("./utils/make-debugger");
+var { TabSources } = require("devtools/server/actors/utils/TabSources");
+var makeDebugger = require("devtools/server/actors/utils/make-debugger");
 var DevToolsUtils = require("devtools/shared/DevToolsUtils");
 var { assert } = DevToolsUtils;
 
 loader.lazyRequireGetter(this, "AddonThreadActor", "devtools/server/actors/thread", true);
 loader.lazyRequireGetter(this, "unwrapDebuggerObjectGlobal", "devtools/server/actors/thread", true);
 loader.lazyRequireGetter(this, "AddonConsoleActor", "devtools/server/actors/addon/console", true);
 
 loader.lazyImporter(this, "AddonManager", "resource://gre/modules/AddonManager.jsm");
 
-function BrowserAddonActor(connection, addon) {
+function AddonTargetActor(connection, addon) {
   this.conn = connection;
   this._addon = addon;
   this._contextPool = new ActorPool(this.conn);
   this.conn.addActorPool(this._contextPool);
   this.threadActor = null;
   this._global = null;
 
   this._shouldAddNewGlobalAsDebuggee = this._shouldAddNewGlobalAsDebuggee.bind(this);
 
   this.makeDebugger = makeDebugger.bind(null, {
     findDebuggees: this._findDebuggees.bind(this),
     shouldAddNewGlobalAsDebuggee: this._shouldAddNewGlobalAsDebuggee
   });
 
   AddonManager.addAddonListener(this);
 }
-exports.BrowserAddonActor = BrowserAddonActor;
+exports.AddonTargetActor = AddonTargetActor;
 
-BrowserAddonActor.prototype = {
-  actorPrefix: "addon",
+AddonTargetActor.prototype = {
+  actorPrefix: "addonTarget",
 
   get exited() {
     return !this._addon;
   },
 
   get id() {
     return this._addon.id;
   },
@@ -130,17 +136,17 @@ BrowserAddonActor.prototype = {
   onUninstalled: function BAAOnUninstalled(addon) {
     if (addon != this._addon) {
       return;
     }
 
     if (this.attached) {
       this.onDetach();
 
-      // The BrowserAddonActor is not a BrowsingContextTargetActor and it has to send
+      // The AddonTargetActor is not a BrowsingContextTargetActor and it has to send
       // "tabDetached" directly to close the devtools toolbox window.
       this.conn.send({ from: this.actorID, type: "tabDetached" });
     }
 
     this.destroy();
   },
 
   onAttach: function BAAOnAttach() {
@@ -240,14 +246,14 @@ BrowserAddonActor.prototype = {
    * Yield the current set of globals associated with this addon that should be
    * added as debuggees.
    */
   _findDebuggees: function(dbg) {
     return dbg.findAllGlobals().filter(this._shouldAddNewGlobalAsDebuggee);
   }
 };
 
-BrowserAddonActor.prototype.requestTypes = {
-  "attach": BrowserAddonActor.prototype.onAttach,
-  "detach": BrowserAddonActor.prototype.onDetach,
-  "reload": BrowserAddonActor.prototype.onReload
+AddonTargetActor.prototype.requestTypes = {
+  "attach": AddonTargetActor.prototype.onAttach,
+  "detach": AddonTargetActor.prototype.onDetach,
+  "reload": AddonTargetActor.prototype.onReload
 };
 

--- a/devtools/server/actors/targets/moz.build
+++ b/devtools/server/actors/targets/moz.build
@@ -1,15 +1,16 @@
 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # 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/.
 
 DevToolsModules(
+    'addon.js',
     'browsing-context.js',
     'chrome-window.js',
     'content-process.js',
     'frame-proxy.js',
     'frame.js',
     'parent-process.js',
     'worker.js',
 )

--- a/devtools/server/actors/webbrowser.js
+++ b/devtools/server/actors/webbrowser.js
@@ -8,17 +8,17 @@
 
 var { Ci } = require("chrome");
 var Services = require("Services");
 var { DebuggerServer } = require("devtools/server/main");
 var DevToolsUtils = require("devtools/shared/DevToolsUtils");
 
 loader.lazyRequireGetter(this, "RootActor", "devtools/server/actors/root", true);
 loader.lazyRequireGetter(this, "FrameTargetActorProxy", "devtools/server/actors/targets/frame-proxy", true);
-loader.lazyRequireGetter(this, "BrowserAddonActor", "devtools/server/actors/addon", true);
+loader.lazyRequireGetter(this, "AddonTargetActor", "devtools/server/actors/targets/addon", true);
 loader.lazyRequireGetter(this, "WebExtensionParentActor", "devtools/server/actors/addon/webextension-parent", true);
 loader.lazyRequireGetter(this, "WorkerTargetActorList", "devtools/server/actors/worker/worker-list", true);
 loader.lazyRequireGetter(this, "ServiceWorkerRegistrationActorList", "devtools/server/actors/worker/worker-list", true);
 loader.lazyRequireGetter(this, "ProcessActorList", "devtools/server/actors/process", true);
 loader.lazyImporter(this, "AddonManager", "resource://gre/modules/AddonManager.jsm");
 
 /**
  * Browser-specific actors.
@@ -696,17 +696,17 @@ function BrowserAddonList(connection) {
 BrowserAddonList.prototype.getList = async function() {
   const addons = await AddonManager.getAllAddons();
   for (const addon of addons) {
     let actor = this._actorByAddonId.get(addon.id);
     if (!actor) {
       if (addon.isWebExtension) {
         actor = new WebExtensionParentActor(this._connection, addon);
       } else {
-        actor = new BrowserAddonActor(this._connection, addon);
+        actor = new AddonTargetActor(this._connection, addon);
       }
 
       this._actorByAddonId.set(addon.id, actor);
     }
   }
 
   return Array.from(this._actorByAddonId, ([_, actor]) => actor);
 };

--- a/devtools/server/main.js
+++ b/devtools/server/main.js
@@ -535,17 +535,17 @@ var DebuggerServer = {
     this.registerModule("devtools/server/actors/accessibility", {
       prefix: "accessibility",
       constructor: "AccessibilityActor",
       type: { tab: true }
     });
   },
 
   /**
-   * Passes a set of options to the BrowserAddonActors for the given ID.
+   * Passes a set of options to the AddonTargetActors for the given ID.
    *
    * @param id string
    *        The ID of the add-on to pass the options to
    * @param options object
    *        The options.
    * @return a promise that will be resolved when complete.
    */
   setAddonOptions(id, options) {
@@ -1666,31 +1666,31 @@ DebuggerServerConnection.prototype = {
       const prefix = "error occurred while processing '" + type;
       this.transport.send(this._unknownError(from, prefix, error));
     });
 
     this._actorResponses.set(from, responsePromise);
   },
 
   /**
-   * Passes a set of options to the BrowserAddonActors for the given ID.
+   * Passes a set of options to the AddonTargetActors for the given ID.
    *
    * @param id string
    *        The ID of the add-on to pass the options to
    * @param options object
    *        The options.
    * @return a promise that will be resolved when complete.
    */
   setAddonOptions(id, options) {
     const addonList = this.rootActor._parameters.addonList;
     if (!addonList) {
       return Promise.resolve();
     }
-    return addonList.getList().then((addonActors) => {
-      for (const actor of addonActors) {
+    return addonList.getList().then((addonTargetActors) => {
+      for (const actor of addonTargetActors) {
         if (actor.id != id) {
           continue;
         }
         actor.setOptions(options);
         return;
       }
     });
   },

--- a/devtools/server/tests/mochitest/test_webextension-addon-debugging-connect.html
+++ b/devtools/server/tests/mochitest/test_webextension-addon-debugging-connect.html
@@ -31,23 +31,23 @@ async function test_connect_addon(oopMod
 
   // Connect a DebuggerClient.
   const transport = DebuggerServer.connectPipe();
   const client = new DebuggerClient(transport);
   await client.connect();
 
   // List addons and assertions on the expected addon actor.
   const {addons} = await client.mainRoot.listAddons();
-  const addonActor = addons.filter(actor => actor.id === extension.id).pop();
-  ok(addonActor, "The expected webextension addon actor has been found");
+  const addonTargetActor = addons.filter(actor => actor.id === extension.id).pop();
+  ok(addonTargetActor, "The expected webextension addon actor has been found");
 
   // Connect to the target addon actor and wait for the updated list of frames.
   const waitFramesUpdated = waitForFramesUpdated({client});
   const addonTarget = await TargetFactory.forRemoteTab({
-    form: addonActor,
+    form: addonTargetActor,
     client,
     chrome: true,
     isBrowsingContext: true,
   });
   is(addonTarget.form.isOOP, oopMode,
      "Got the expected oop mode in the webextension actor form");
   const frames = await waitFramesUpdated;
   const backgroundPageFrame = frames.filter((frame) => {

--- a/devtools/server/tests/mochitest/webextension-helpers.js
+++ b/devtools/server/tests/mochitest/webextension-helpers.js
@@ -94,44 +94,44 @@ function collectFrameUpdates({client}, m
 
 async function attachAddon(addonId) {
   const transport = DebuggerServer.connectPipe();
   const client = new DebuggerClient(transport);
 
   await client.connect();
 
   const {addons} = await client.mainRoot.listAddons();
-  const addonActor = addons.filter(actor => actor.id === addonId).pop();
+  const addonTargetActor = addons.filter(actor => actor.id === addonId).pop();
 
-  if (!addonActor) {
+  if (!addonTargetActor) {
     client.close();
     throw new Error(`No WebExtension Actor found for ${addonId}`);
   }
 
   const addonTarget = await TargetFactory.forRemoteTab({
-    form: addonActor,
+    form: addonTargetActor,
     client,
     chrome: true,
     isBrowsingContext: true,
   });
 
   return addonTarget;
 }
 
 async function reloadAddon({client}, addonId) {
   const {addons} = await client.mainRoot.listAddons();
-  const addonActor = addons.filter(actor => actor.id === addonId).pop();
+  const addonTargetActor = addons.filter(actor => actor.id === addonId).pop();
 
-  if (!addonActor) {
+  if (!addonTargetActor) {
     client.close();
     throw new Error(`No WebExtension Actor found for ${addonId}`);
   }
 
   await client.request({
-    to: addonActor.actor,
+    to: addonTargetActor.actor,
     type: "reload",
   });
 }
 
 // Test helpers related to the AddonManager.
 
 function generateWebExtensionXPI(extDetails) {
   const addonFile = Extension.generateXPI(extDetails);

--- a/devtools/server/tests/unit/test_addon_reload.js
+++ b/devtools/server/tests/unit/test_addon_reload.js
@@ -31,25 +31,25 @@ function promiseWebExtensionStartup() {
     };
 
     Management.on("ready", listener);
   });
 }
 
 async function findAddonInRootList(client, addonId) {
   const result = await client.listAddons();
-  const addonActor = result.addons.filter(addon => addon.id === addonId)[0];
-  ok(addonActor, `Found add-on actor for ${addonId}`);
-  return addonActor;
+  const addonTargetActor = result.addons.filter(addon => addon.id === addonId)[0];
+  ok(addonTargetActor, `Found add-on actor for ${addonId}`);
+  return addonTargetActor;
 }
 
-async function reloadAddon(client, addonActor) {
+async function reloadAddon(client, addonTargetActor) {
   // The add-on will be re-installed after a successful reload.
   const onInstalled = promiseAddonEvent("onInstalled");
-  await client.request({to: addonActor.actor, type: "reload"});
+  await client.request({to: addonTargetActor.actor, type: "reload"});
   await onInstalled;
 }
 
 function getSupportFile(path) {
   const allowMissing = false;
   return do_get_file(path, allowMissing);
 }
 
@@ -67,35 +67,35 @@ add_task(async function testReloadExited
 
   // Install a decoy add-on.
   const addonFile2 = getSupportFile("addons/web-extension2");
   const [installedAddon2] = await Promise.all([
     AddonManager.installTemporaryAddon(addonFile2),
     promiseWebExtensionStartup(),
   ]);
 
-  const addonActor = await findAddonInRootList(client, installedAddon.id);
+  const addonTargetActor = await findAddonInRootList(client, installedAddon.id);
 
   await Promise.all([
-    reloadAddon(client, addonActor),
+    reloadAddon(client, addonTargetActor),
     promiseWebExtensionStartup(),
   ]);
 
   // Uninstall the decoy add-on, which should cause its actor to exit.
   const onUninstalled = promiseAddonEvent("onUninstalled");
   installedAddon2.uninstall();
   await onUninstalled;
 
   // Try to re-list all add-ons after a reload.
   // This was throwing an exception because of the exited actor.
   const newAddonActor = await findAddonInRootList(client, installedAddon.id);
-  equal(newAddonActor.id, addonActor.id);
+  equal(newAddonActor.id, addonTargetActor.id);
 
   // The actor id should be the same after the reload
-  equal(newAddonActor.actor, addonActor.actor);
+  equal(newAddonActor.actor, addonTargetActor.actor);
 
   const onAddonListChanged = new Promise((resolve) => {
     client.addListener("addonListChanged", function listener() {
       client.removeListener("addonListChanged", listener);
       resolve();
     });
   });
 
@@ -106,17 +106,17 @@ add_task(async function testReloadExited
     promiseWebExtensionStartup(),
   ]);
 
   // Waiting for addonListChanged unsolicited event
   await onAddonListChanged;
 
   // re-list all add-ons after an upgrade.
   const upgradedAddonActor = await findAddonInRootList(client, upgradedAddon.id);
-  equal(upgradedAddonActor.id, addonActor.id);
+  equal(upgradedAddonActor.id, addonTargetActor.id);
   // The actor id should be the same after the upgrade.
-  equal(upgradedAddonActor.actor, addonActor.actor);
+  equal(upgradedAddonActor.actor, addonTargetActor.actor);
 
   // The addon metadata has been updated.
   equal(upgradedAddonActor.name, "Test Addons Actor Upgrade");
 
   await close(client);
 });

--- a/devtools/shared/client/debugger-client.js
+++ b/devtools/shared/client/debugger-client.js
@@ -383,33 +383,33 @@ DebuggerClient.prototype = {
       workerClient = new WorkerClient(this, response);
       this.registerClient(workerClient);
       onResponse(response, workerClient);
       return [response, workerClient];
     });
   },
 
   /**
-   * Attach to an addon actor.
+   * Attach to an addon target actor.
    *
-   * @param string addonActor
+   * @param string addonTargetActor
    *        The actor ID for the addon to attach.
    * @param function onResponse
    *        Called with the response packet and a AddonClient
    *        (which will be undefined on error).
    */
-  attachAddon: function(addonActor, onResponse = noop) {
+  attachAddon: function(addonTargetActor, onResponse = noop) {
     const packet = {
-      to: addonActor,
+      to: addonTargetActor,
       type: "attach"
     };
     return this.request(packet).then(response => {
       let addonClient;
       if (!response.error) {
-        addonClient = new AddonClient(this, addonActor);
+        addonClient = new AddonClient(this, addonTargetActor);
         this.registerClient(addonClient);
         this.activeAddon = addonClient;
       }
       onResponse(response, addonClient);
       return [response, addonClient];
     });
   },