--- a/devtools/client/debugger/test/mochitest/browser_dbg_globalactor.js
+++ b/devtools/client/debugger/test/mochitest/browser_dbg_globalactor.js
@@ -10,50 +10,54 @@
 const ACTORS_URL = CHROME_URL + "testactors.js";
 
 function test() {
   let gClient;
 
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
 
-  DebuggerServer.addActors(ACTORS_URL);
+  DebuggerServer.registerModule(ACTORS_URL, {
+    prefix: "testOne",
+    constructor: "TestActor1",
+    type: { global: true },
+  });
 
   let transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(([aType, aTraits]) => {
     is(aType, "browser",
       "Root actor should identify itself as a browser.");
 
     gClient.listTabs().then(aResponse => {
-      let globalActor = aResponse.testGlobalActor1;
+      let globalActor = aResponse.testOneActor;
       ok(globalActor, "Found the test global actor.");
-      ok(globalActor.includes("test_one"),
+      ok(globalActor.includes("testOne"),
         "testGlobalActor1's actorPrefix should be used.");
 
       gClient.request({ to: globalActor, type: "ping" }, aResponse => {
         is(aResponse.pong, "pong", "Actor should respond to requests.");
 
         // Send another ping to see if the same actor is used.
         gClient.request({ to: globalActor, type: "ping" }, aResponse => {
           is(aResponse.pong, "pong", "Actor should respond to requests.");
 
           // Make sure that lazily-created actors are created only once.
           let count = 0;
           for (let connID of Object.getOwnPropertyNames(DebuggerServer._connections)) {
             let conn = DebuggerServer._connections[connID];
-            let actorPrefix = conn._prefix + "test_one";
+            let actorPrefix = conn._prefix + "testOne";
             for (let pool of conn._extraPools) {
               count += Object.keys(pool._actors).filter(e => {
                 return e.startsWith(actorPrefix);
               }).length;
             }
           }
 
-          is(count, 2,
-            "Only two actor exists in all pools. One target-scoped actor and one global.");
+          is(count, 1,
+            "Only one actor exists in all pools. One global actor.");
 
           gClient.close().then(finish);
         });
       });
     });
   });
 }

--- a/devtools/client/debugger/test/mochitest/browser_dbg_target-scoped-actor-01.js
+++ b/devtools/client/debugger/test/mochitest/browser_dbg_target-scoped-actor-01.js
@@ -11,17 +11,21 @@ const ACTORS_URL = CHROME_URL + "testact
 const TAB_URL = EXAMPLE_URL + "doc_empty-tab-01.html";
 
 var gClient;
 
 function test() {
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
 
-  DebuggerServer.addActors(ACTORS_URL);
+  DebuggerServer.registerModule(ACTORS_URL, {
+    prefix: "testOne",
+    constructor: "TestActor1",
+    type: { target: true },
+  });
 
   let transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(([aType, aTraits]) => {
     is(aType, "browser",
       "Root actor should identify itself as a browser.");
 
     addTab(TAB_URL)
@@ -34,22 +38,22 @@ function test() {
         ok(false, "Got an error: " + aError.message + "\n" + aError.stack);
       });
   });
 }
 
 function testTargetScopedActor([aGrip, aResponse]) {
   let deferred = promise.defer();
 
-  ok(aGrip.testTargetScopedActor1,
+  ok(aGrip.testOneActor,
     "Found the test target-scoped actor.");
-  ok(aGrip.testTargetScopedActor1.includes("test_one"),
-    "testTargetScopedActor1's actorPrefix should be used.");
+  ok(aGrip.testOneActor.includes("testOne"),
+    "testOneActor's actorPrefix should be used.");
 
-  gClient.request({ to: aGrip.testTargetScopedActor1, type: "ping" }, aResponse => {
+  gClient.request({ to: aGrip.testOneActor, type: "ping" }, aResponse => {
     is(aResponse.pong, "pong",
       "Actor should respond to requests.");
 
     deferred.resolve();
   });
 
   return deferred.promise;
 }

--- a/devtools/client/debugger/test/mochitest/browser_dbg_target-scoped-actor-02.js
+++ b/devtools/client/debugger/test/mochitest/browser_dbg_target-scoped-actor-02.js
@@ -11,17 +11,21 @@ const ACTORS_URL = CHROME_URL + "testact
 const TAB_URL = EXAMPLE_URL + "doc_empty-tab-01.html";
 
 var gClient;
 
 function test() {
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
 
-  DebuggerServer.addActors(ACTORS_URL);
+  DebuggerServer.registerModule(ACTORS_URL, {
+    prefix: "testOne",
+    constructor: "TestActor1",
+    type: { target: true },
+  });
 
   let transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(([aType, aTraits]) => {
     is(aType, "browser",
       "Root actor should identify itself as a browser.");
 
     addTab(TAB_URL)
@@ -34,22 +38,22 @@ function test() {
         ok(false, "Got an error: " + aError.message + "\n" + aError.stack);
       });
   });
 }
 
 function testTargetScopedActor([aGrip, aResponse]) {
   let deferred = promise.defer();
 
-  ok(aGrip.testTargetScopedActor1,
+  ok(aGrip.testOneActor,
     "Found the test target-scoped actor.");
-  ok(aGrip.testTargetScopedActor1.includes("test_one"),
-    "testTargetScopedActor1's actorPrefix should be used.");
+  ok(aGrip.testOneActor.includes("testOne"),
+    "testOneActor's actorPrefix should be used.");
 
-  gClient.request({ to: aGrip.testTargetScopedActor1, type: "ping" }, aResponse => {
+  gClient.request({ to: aGrip.testOneActor, type: "ping" }, aResponse => {
     is(aResponse.pong, "pong",
       "Actor should respond to requests.");
 
     deferred.resolve(aResponse.actor);
   });
 
   return deferred.promise;
 }
@@ -59,17 +63,17 @@ function closeTab(aTestActor) {
     let deferred = promise.defer();
 
     try {
       gClient.request({ to: aTestActor, type: "ping" }, aResponse => {
         ok(false, "testTargetScopedActor1 didn't go away with the tab.");
         deferred.reject(aResponse);
       });
     } catch (e) {
-      is(e.message, "'ping' request packet has no destination.", "testTargetScopedActor1 went away.");
+      is(e.message, "'ping' request packet has no destination.", "testOnActor went away.");
       deferred.resolve();
     }
 
     return deferred.promise;
   });
 }
 
 registerCleanupFunction(function () {

--- a/devtools/client/debugger/test/mochitest/testactors.js
+++ b/devtools/client/debugger/test/mochitest/testactors.js
@@ -4,35 +4,24 @@
 "use strict";
 
 function TestActor1(aConnection, aTab) {
   this.conn = aConnection;
   this.tab = aTab;
 }
 
 TestActor1.prototype = {
-  actorPrefix: "test_one",
+  actorPrefix: "testOne",
 
   grip: function TA1_grip() {
     return { actor: this.actorID,
              test: "TestActor1" };
   },
 
   onPing: function TA1_onPing() {
     return { pong: "pong" };
   }
 };
 
 TestActor1.prototype.requestTypes = {
   "ping": TestActor1.prototype.onPing
 };
-
-DebuggerServer.removeTargetScopedActor("testTargetScopedActor1");
-DebuggerServer.removeGlobalActor("testGlobalActor1");
-
-DebuggerServer.addTargetScopedActor({
-  constructorName: "TestActor1",
-  constructorFun: TestActor1,
-}, "testTargetScopedActor1");
-DebuggerServer.addGlobalActor({
-  constructorName: "TestActor1",
-  constructorFun: TestActor1,
-}, "testGlobalActor1");
+exports.TestActor1 = TestActor1;

--- a/devtools/server/main.js
+++ b/devtools/server/main.js
@@ -24,41 +24,19 @@ loader.lazyRequireGetter(this, "MainThre
 
 loader.lazyGetter(this, "generateUUID", () => {
   // eslint-disable-next-line no-shadow
   const { generateUUID } = Cc["@mozilla.org/uuid-generator;1"]
                            .getService(Ci.nsIUUIDGenerator);
   return generateUUID;
 });
 
-// Overload `Components` to prevent DevTools loader exception on Components
-// object usage
-// eslint-disable-next-line no-unused-vars
-Object.defineProperty(this, "Components", {
-  get() {
-    return require("chrome").components;
-  }
-});
-
 const CONTENT_PROCESS_SERVER_STARTUP_SCRIPT =
   "resource://devtools/server/startup/content-process.js";
 
-function loadSubScript(url) {
-  try {
-    Services.scriptloader.loadSubScript(url, this);
-  } catch (e) {
-    const errorStr = "Error loading: " + url + ":\n" +
-                   (e.fileName ? "at " + e.fileName + " : " + e.lineNumber + "\n" : "") +
-                   e + " - " + e.stack + "\n";
-    dump(errorStr);
-    reportError(errorStr);
-    throw e;
-  }
-}
-
 loader.lazyRequireGetter(this, "EventEmitter", "devtools/shared/event-emitter");
 
 var gRegisteredModules = Object.create(null);
 
 /**
  * Public API
  */
 var DebuggerServer = {
@@ -151,17 +129,17 @@ var DebuggerServer = {
    * Raises an exception if the server has not been properly initialized.
    */
   _checkInit() {
     if (!this._initialized) {
       throw new Error("DebuggerServer has not been initialized.");
     }
 
     if (!this.rootlessServer && !this.createRootActor) {
-      throw new Error("Use DebuggerServer.addActors() to add a root actor " +
+      throw new Error("Use DebuggerServer.setRootActor() to add a root actor " +
                       "implementation.");
     }
   },
 
   /**
    * Register different type of actors. Only register the one that are not already
    * registered.
    *
@@ -193,28 +171,16 @@ var DebuggerServer = {
   /**
    * Register all possible actors for this DebuggerServer.
    */
   registerAllActors() {
     this.registerActors({ root: true, browser: true, target: true });
   },
 
   /**
-   * Load a subscript into the debugging global.
-   *
-   * @param url string A url that will be loaded as a subscript into the
-   *        debugging global.  The user must load at least one script
-   *        that implements a createRootActor() function to create the
-   *        server's root actor.
-   */
-  addActors(url) {
-    loadSubScript.call(this, url);
-  },
-
-  /**
    * Register a CommonJS module with the debugger server.
    * @param id string
    *        The ID of a CommonJS module.
    *        The actor is going to be registered immediately, but loaded only
    *        when a client starts sending packets to an actor with the same id.
    *
    * @param options object
    *        An object with 3 mandatory attributes:
@@ -1339,25 +1305,16 @@ if (this.exports) {
   exports.OriginalLocation = OriginalLocation;
 }
 
 // Needed on B2G (See header note)
 this.DebuggerServer = DebuggerServer;
 this.ActorPool = ActorPool;
 this.OriginalLocation = OriginalLocation;
 
-// When using DebuggerServer.addActors, some symbols are expected to be in
-// the scope of the added actor even before the corresponding modules are
-// loaded, so let's explicitly bind the expected symbols here.
-var includes = ["Components", "Ci", "Cu", "require", "Services", "DebuggerServer",
-                "ActorPool", "DevToolsUtils"];
-includes.forEach(name => {
-  DebuggerServer[name] = this[name];
-});
-
 /**
  * Creates a DebuggerServerConnection.
  *
  * Represents a connection to this debugging global from a client.
  * Manages a set of actors and actor pools, allocates actor ids, and
  * handles incoming requests.
  *
  * @param prefix string

--- a/devtools/server/startup/frame.js
+++ b/devtools/server/startup/frame.js
@@ -16,17 +16,18 @@ try {
   var chromeGlobal = this;
 
   // Encapsulate in its own scope to allows loading this frame script more than once.
   (function() {
     const { require } = ChromeUtils.import("resource://devtools/shared/Loader.jsm", {});
 
     const DevToolsUtils = require("devtools/shared/DevToolsUtils");
     const { dumpn } = DevToolsUtils;
-    const { DebuggerServer, ActorPool } = require("devtools/server/main");
+    const { DebuggerServer } = require("devtools/server/main");
+    const { ActorPool } = require("devtools/server/actors/common");
 
     DebuggerServer.init();
     // We want a special server without any root actor and only target-scoped actors.
     // We are going to spawn a FrameTargetActor instance in the next few lines,
     // it is going to act like a root actor without being one.
     DebuggerServer.registerActors({ target: true });
 
     const connections = new Map();

--- a/devtools/server/tests/browser/browser_actor_error.js
+++ b/devtools/server/tests/browser/browser_actor_error.js
@@ -11,17 +11,21 @@
 
 const ACTORS_URL =
   "chrome://mochitests/content/browser/devtools/server/tests/browser/error-actor.js";
 
 async function test() {
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
 
-  DebuggerServer.addActors(ACTORS_URL);
+  DebuggerServer.registerModule(ACTORS_URL, {
+    prefix: "error",
+    constructor: "ErrorActor",
+    type: { global: true },
+  });
 
   const transport = DebuggerServer.connectPipe();
   const gClient = new DebuggerClient(transport);
   await gClient.connect();
 
   const { errorActor } = await gClient.listTabs();
   ok(errorActor, "Found the error actor.");
 

--- a/devtools/server/tests/browser/error-actor.js
+++ b/devtools/server/tests/browser/error-actor.js
@@ -22,14 +22,9 @@ ErrorActor.prototype = {
   onError: function() {
     throw new Error("error");
   }
 };
 
 ErrorActor.prototype.requestTypes = {
   "error": ErrorActor.prototype.onError
 };
-
-DebuggerServer.removeGlobalActor("errorActor");
-DebuggerServer.addGlobalActor({
-  constructorName: "ErrorActor",
-  constructorFun: ErrorActor,
-}, "errorActor");
+exports.ErrorActor = ErrorActor;

--- a/devtools/server/tests/unit/post_init_global_actors.js
+++ b/devtools/server/tests/unit/post_init_global_actors.js
@@ -13,13 +13,9 @@ PostInitGlobalActor.prototype = {
   onPing(request) {
     return { message: "pong" };
   },
 };
 
 PostInitGlobalActor.prototype.requestTypes = {
   "ping": PostInitGlobalActor.prototype.onPing,
 };
-
-DebuggerServer.addGlobalActor({
-  constructorName: "PostInitGlobalActor",
-  constructorFun: PostInitGlobalActor,
-}, "postInitGlobalActor");
+exports.PostInitGlobalActor = PostInitGlobalActor;

--- a/devtools/server/tests/unit/post_init_target_scoped_actors.js
+++ b/devtools/server/tests/unit/post_init_target_scoped_actors.js
@@ -4,22 +4,18 @@
 "use strict";
 
 // Uses the same scope as test_add_actors.js
 /* import-globals-from head_dbg.js */
 
 function PostInitTargetScopedActor(connection) {}
 
 PostInitTargetScopedActor.prototype = {
-  actorPostfix: "postInitTab",
+  actorPostfix: "postInitTargetScoped",
   onPing(request) {
     return { message: "pong" };
   },
 };
 
 PostInitTargetScopedActor.prototype.requestTypes = {
   "ping": PostInitTargetScopedActor.prototype.onPing,
 };
-
-DebuggerServer.addTargetScopedActor({
-  constructorName: "PostInitTargetScopedActor",
-  constructorFun: PostInitTargetScopedActor,
-}, "postInitTargetScopedActor");
+exports.PostInitTargetScopedActor = PostInitTargetScopedActor;

--- a/devtools/server/tests/unit/pre_init_global_actors.js
+++ b/devtools/server/tests/unit/pre_init_global_actors.js
@@ -13,13 +13,9 @@ PreInitGlobalActor.prototype = {
   onPing(request) {
     return { message: "pong" };
   },
 };
 
 PreInitGlobalActor.prototype.requestTypes = {
   "ping": PreInitGlobalActor.prototype.onPing,
 };
-
-DebuggerServer.addGlobalActor({
-  constructorName: "PreInitGlobalActor",
-  constructorFun: PreInitGlobalActor,
-}, "preInitGlobalActor");
+exports.PreInitGlobalActor = PreInitGlobalActor;

--- a/devtools/server/tests/unit/pre_init_target_scoped_actors.js
+++ b/devtools/server/tests/unit/pre_init_target_scoped_actors.js
@@ -4,22 +4,18 @@
 "use strict";
 
 // Uses the same scope as test_add_actors.js
 /* import-globals-from head_dbg.js */
 
 function PreInitTargetScopedActor(connection) {}
 
 PreInitTargetScopedActor.prototype = {
-  actorPrefix: "preInitTab",
+  actorPrefix: "preInitTargetScoped",
   onPing(request) {
     return { message: "pong" };
   },
 };
 
 PreInitTargetScopedActor.prototype.requestTypes = {
   "ping": PreInitTargetScopedActor.prototype.onPing,
 };
-
-DebuggerServer.addTargetScopedActor({
-  constructorName: "PreInitTargetScopedActor",
-  constructorFun: PreInitTargetScopedActor,
-}, "preInitTargetScopedActor");
+exports.PreInitTargetScopedActor = PreInitTargetScopedActor;

--- a/devtools/server/tests/unit/test_add_actors.js
+++ b/devtools/server/tests/unit/test_add_actors.js
@@ -11,23 +11,39 @@ function getActorInstance(connID, actorI
 /**
  * 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.
  */
 add_task(async function() {
-  DebuggerServer.addActors("resource://test/pre_init_global_actors.js");
-  DebuggerServer.addActors("resource://test/pre_init_target_scoped_actors.js");
+  DebuggerServer.registerModule("resource://test/pre_init_global_actors.js", {
+    prefix: "preInitGlobal",
+    constructor: "PreInitGlobalActor",
+    type: { global: true },
+  });
+  DebuggerServer.registerModule("resource://test/pre_init_target_scoped_actors.js", {
+    prefix: "preInitTargetScoped",
+    constructor: "PreInitTargetScopedActor",
+    type: { target: true },
+  });
 
   const client = await startTestDebuggerServer("example tab");
 
-  DebuggerServer.addActors("resource://test/post_init_global_actors.js");
-  DebuggerServer.addActors("resource://test/post_init_target_scoped_actors.js");
+  DebuggerServer.registerModule("resource://test/post_init_global_actors.js", {
+    prefix: "postInitGlobal",
+    constructor: "PostInitGlobalActor",
+    type: { global: true },
+  });
+  DebuggerServer.registerModule("resource://test/post_init_target_scoped_actors.js", {
+    prefix: "postInitTargetScoped",
+    constructor: "PostInitTargetScopedActor",
+    type: { target: true },
+  });
 
   let actors = await client.listTabs();
   Assert.equal(actors.tabs.length, 1);
 
   let reply = await client.request({
     to: actors.preInitGlobalActor,
     type: "ping",
   });

--- a/testing/xpcshell/dbg-actors.js
+++ b/testing/xpcshell/dbg-actors.js
@@ -1,24 +1,20 @@
 /* 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/. */
 
+/* globals require, exports */
+
 "use strict";
 
-/* import-globals-from ../../devtools/server/main.js */
-/* eslint "mozilla/use-chromeutils-import": ["error", {allowCu: true}] */
-
-// eslint-disable-next-line mozilla/no-define-cc-etc
-const Cu = Components.utils; // eslint-disable-line mozilla/use-cc-etc
-const { Promise } = Cu.import("resource://gre/modules/Promise.jsm", {});
-var { Services } = Cu.import("resource://gre/modules/Services.jsm", {});
-const { devtools } = Cu.import("resource://devtools/shared/Loader.jsm", {});
-const { RootActor } = devtools.require("devtools/server/actors/root");
-const { BrowserTabList } = devtools.require("devtools/server/actors/webbrowser");
+const DebuggerServer = require("devtools/server/main");
+const { RootActor } = require("devtools/server/actors/root");
+const { BrowserTabList } = require("devtools/server/actors/webbrowser");
+const Services = require("Services");
 
 /**
  * xpcshell-test (XPCST) specific actors.
  *
  */
 
 /**
  * Construct a root actor appropriate for use in a server running xpcshell
@@ -31,16 +27,17 @@ function createRootActor(connection) {
     onShutdown() {
       // If the user never switches to the "debugger" tab we might get a
       // shutdown before we've attached.
       Services.obs.notifyObservers(null, "xpcshell-test-devtools-shutdown");
     }
   };
   return new RootActor(connection, parameters);
 }
+exports.createRootActor = createRootActor;
 
 /**
  * A "stub" TabList implementation that provides no tabs.
  */
 
 function XPCSTTabList(connection) {
   BrowserTabList.call(this, connection);
 }

--- a/testing/xpcshell/head.js
+++ b/testing/xpcshell/head.js
@@ -390,17 +390,18 @@ function _setupDebuggerServer(breakpoint
                     "triggering additional browser code to run, so check " +
                     "test behavior after making this change.\n" +
                     "See also https://bugzil.la/1215378.");
   }
   let { DebuggerServer } = require("devtools/server/main");
   let { OriginalLocation } = require("devtools/server/actors/common");
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
-  DebuggerServer.addActors("resource://testing-common/dbg-actors.js");
+  let { createRootActor } = require("resource://testing-common/dbg-actors.js");
+  DebuggerServer.setRootActor(createRootActor);
   DebuggerServer.allowChromeProcess = true;
 
   // An observer notification that tells us when we can "resume" script
   // execution.
   const TOPICS = ["devtools-thread-resumed", "xpcshell-test-devtools-shutdown"];
   let observe = function(subject, topic, data) {
     switch (topic) {
       case "devtools-thread-resumed":