axmol/cocos/scripting/js-bindings/script/debugger/main.js

/****************************************************************************
 Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
 
 http://www.cocos2d-x.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ****************************************************************************/

/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
/* 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";

/**
 * Toolkit glue for the remote debugging protocol, loaded into the
 * debugging global.
 */
// var { Ci, Cc, CC, Cu, Cr } = require("chrome");
// var Services = require("Services");
// var { ActorPool, OriginalLocation, RegisteredActorFactory,
//       ObservedActorFactory } = require("devtools/server/actors/common");
// var { LocalDebuggerTransport, ChildDebuggerTransport, WorkerDebuggerTransport } =
//   require("devtools/toolkit/transport/transport");
// var DevToolsUtils = require("devtools/toolkit/DevToolsUtils");
// var { dumpn, dumpv, dbg_assert } = DevToolsUtils;
// var EventEmitter = require("devtools/toolkit/event-emitter");
// var Debugger = require("Debugger");
// var Promise = require("promise");

// DevToolsUtils.defineLazyGetter(this, "DebuggerSocket", () => {
//   let { DebuggerSocket } = require("devtools/toolkit/security/socket");
//   return DebuggerSocket;
// });
// DevToolsUtils.defineLazyGetter(this, "Authentication", () => {
//   return require("devtools/toolkit/security/auth");
// });

// // On B2G, `this` != Global scope, so `Ci` won't be binded on `this`
// // (i.e. this.Ci is undefined) Then later, when using loadSubScript,
// // Ci,... won't be defined for sub scripts.
// this.Ci = Ci;
// this.Cc = Cc;
// this.CC = CC;
// this.Cu = Cu;
// this.Cr = Cr;
// this.Services = Services;
// this.ActorPool = ActorPool;
// this.DevToolsUtils = DevToolsUtils;
// this.dumpn = dumpn;
// this.dumpv = dumpv;
// this.dbg_assert = dbg_assert;

// Overload `Components` to prevent SDK loader exception on Components
// object usage
// Object.defineProperty(this, "Components", {
//   get: function() {
//     return require("chrome").components;
//   }
// });

// if (isWorker) {
//   dumpn.wantLogging = true;
//   dumpv.wantVerbose = true;
// } else {
//   const LOG_PREF = "devtools.debugger.log";
//   const VERBOSE_PREF = "devtools.debugger.log.verbose";

//   dumpn.wantLogging = Services.prefs.getBoolPref(LOG_PREF);
//   dumpv.wantVerbose =
//     Services.prefs.getPrefType(VERBOSE_PREF) !== Services.prefs.PREF_INVALID &&
//     Services.prefs.getBoolPref(VERBOSE_PREF);
// }

// function loadSubScript(aURL)
// {
//   try {
//     let loader = Cc["@mozilla.org/moz/jssubscript-loader;1"]
//       .getService(Ci.mozIJSSubScriptLoader);
//     loader.loadSubScript(aURL, this);
//   } catch(e) {
//     let errorStr = "Error loading: " + aURL + ":\n" +
//                    (e.fileName ? "at " + e.fileName + " : " + e.lineNumber + "\n" : "") +
//                    e + " - " + e.stack + "\n";
//     dump(errorStr);
//     reportError(errorStr);
//     throw e;
//   }
// }

// loader.lazyRequireGetter(this, "events", "sdk/event/core");

// var {defer, resolve, reject, all} = require("devtools/toolkit/deprecated-sync-thenables");
// this.defer = defer;
// this.resolve = resolve;
// this.reject = reject;
// this.all = all;

// var gRegisteredModules = Object.create(null);

/**
 * The ModuleAPI object is passed to modules loaded using the
 * DebuggerServer.registerModule() API.  Modules can use this
 * object to register actor factories.
 * Factories registered through the module API will be removed
 * when the module is unregistered or when the server is
 * destroyed.
 */
// function ModuleAPI() {
//   let activeTabActors = new Set();
//   let activeGlobalActors = new Set();

//   return {
//     // See DebuggerServer.setRootActor for a description.
//     setRootActor: function(factory) {
//       DebuggerServer.setRootActor(factory);
//     },

//     // See DebuggerServer.addGlobalActor for a description.
//     addGlobalActor: function(factory, name) {
//       DebuggerServer.addGlobalActor(factory, name);
//       activeGlobalActors.add(factory);
//     },
//     // See DebuggerServer.removeGlobalActor for a description.
//     removeGlobalActor: function(factory) {
//       DebuggerServer.removeGlobalActor(factory);
//       activeGlobalActors.delete(factory);
//     },

//     // See DebuggerServer.addTabActor for a description.
//     addTabActor: function(factory, name) {
//       DebuggerServer.addTabActor(factory, name);
//       activeTabActors.add(factory);
//     },
//     // See DebuggerServer.removeTabActor for a description.
//     removeTabActor: function(factory) {
//       DebuggerServer.removeTabActor(factory);
//       activeTabActors.delete(factory);
//     },

//     // Destroy the module API object, unregistering any
//     // factories registered by the module.
//     destroy: function() {
//       for (let factory of activeTabActors) {
//         DebuggerServer.removeTabActor(factory);
//       }
//       activeTabActors = null;
//       for (let factory of activeGlobalActors) {
//         DebuggerServer.removeGlobalActor(factory);
//       }
//       activeGlobalActors = null;
//     }
//   };
// };

/***
 * Public API
 */
var DebuggerServer = {
  _listeners: [],
  _initialized: false,
  // Map of global actor names to actor constructors provided by extensions.
  globalActorFactories: {},
  // Map of tab actor names to actor constructors provided by extensions.
  tabActorFactories: {},

  LONG_STRING_LENGTH: 10000,
  LONG_STRING_INITIAL_LENGTH: 1000,
  LONG_STRING_READ_LENGTH: 65 * 1024,

  /**
   * The windowtype of the chrome window to use for actors that use the global
   * window (i.e the global style editor). Set this to your main window type,
   * for example "navigator:browser".
   */
  chromeWindowType: null,

  /**
   * Allow debugging chrome of (parent or child) processes.
   */
  allowChromeProcess: false,

  /**
   * Initialize the debugger server.
   */
  init: function DS_init() {
    if (this.initialized) {
      return;
    }

    this._connections = {};
    this._nextConnID = 0;

    this._initialized = true;
  },

  // get protocol() {
  //   return require("devtools/server/protocol");
  // },

  get initialized() {
    return this._initialized;
  },

  /**
   * Performs cleanup tasks before shutting down the debugger server. Such tasks
   * include clearing any actor constructors added at runtime. This method
   * should be called whenever a debugger server is no longer useful, to avoid
   * memory leaks. After this method returns, the debugger server must be
   * initialized again before use.
   */
  destroy: function DS_destroy() {
    if (!this._initialized) {
      return;
    }

    for (let connID of Object.getOwnPropertyNames(this._connections)) {
      this._connections[connID].close();
    }

    for (let id of Object.getOwnPropertyNames(gRegisteredModules)) {
      this.unregisterModule(id);
    }
    gRegisteredModules = Object.create(null);

    this.closeAllListeners();
    this.globalActorFactories = {};
    this.tabActorFactories = {};
    this._initialized = false;

    dumpn("Debugger server is shut down.");
  },

  /**
   * Raises an exception if the server has not been properly initialized.
   */
  _checkInit: function DS_checkInit() {
    if (!this._initialized) {
      throw "DebuggerServer has not been initialized.";
    }

    if (!this.createRootActor) {
      throw "Use DebuggerServer.addActors() to add a root actor implementation.";
    }
  },

  /**
   * Load a subscript into the debugging global.
   *
   * @param aURL 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: function DS_addActors(aURL) {
  //   loadSubScript.call(this, aURL);
  // },

  /**
   * Register a CommonJS module with the debugger server.
   * @param id string
   *        The ID of a CommonJS module.  This module must export 'register'
   *        and 'unregister' functions if no `options` argument is given.
   *        If `options` is set, 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 (optional)
   *        This parameter is still optional, but not providing it is
   *        deprecated and will result in eagerly loading the actor module
   *        with the memory overhead that entails.
   *        An object with 3 mandatory attributes:
   *        - prefix (string):
   *          The prefix of an actor is used to compute:
   *          - the `actorID` of each new actor instance (ex: prefix1).
   *            (See ActorPool.addActor)
   *          - the actor name in the listTabs request. Sending a listTabs
   *            request to the root actor returns actor IDs. IDs are in
   *            dictionaries, with actor names as keys and actor IDs as values.
   *            The actor name is the prefix to which the "Actor" string is
   *            appended. So for an actor with the `console` prefix, the actor
   *            name will be `consoleActor`.
   *        - constructor (string):
   *          the name of the exported symbol to be used as the actor
   *          constructor.
   *        - type (a dictionary of booleans with following attribute names):
   *          - "global"
   *            registers a global actor instance, if true.
   *            A global actor has the root actor as its parent.
   *          - "tab"
   *            registers a tab actor instance, if true.
   *            A new actor will be created for each tab and each app.
   */
  // registerModule: function(id, options) {
  //   if (id in gRegisteredModules) {
  //     throw new Error("Tried to register a module twice: " + id + "\n");
  //   }

  //   if (options) {
  //     // Lazy loaded actors
  //     let {prefix, constructor, type} = options;
  //     if (typeof(prefix) !== "string") {
  //       throw new Error("Lazy actor definition for '" + id + "' requires a string 'prefix' option.");
  //     }
  //     if (typeof(constructor) !== "string") {
  //       throw new Error("Lazy actor definition for '" + id + "' requires a string 'constructor' option.");
  //     }
  //     if (!("global" in type) && !("tab" in type)) {
  //       throw new Error("Lazy actor definition for '" + id + "' requires a dictionary 'type' option whose attributes can be 'global' or 'tab'.");
  //     }
  //     let name = prefix + "Actor";
  //     let mod = {
  //       id: id,
  //       prefix: prefix,
  //       constructorName: constructor,
  //       type: type,
  //       globalActor: type.global,
  //       tabActor: type.tab
  //     };
  //     gRegisteredModules[id] = mod;
  //     if (mod.tabActor) {
  //       this.addTabActor(mod, name);
  //     }
  //     if (mod.globalActor) {
  //       this.addGlobalActor(mod, name);
  //     }
  //   } else {
  //     // Deprecated actors being loaded at startup
  //     let moduleAPI = ModuleAPI();
  //     let mod = require(id);
  //     mod.register(moduleAPI);
  //     gRegisteredModules[id] = {
  //       module: mod,
  //       api: moduleAPI
  //     };
  //   }
  // },

  /**
   * Returns true if a module id has been registered.
   */
  // isModuleRegistered: function(id) {
  //   return (id in gRegisteredModules);
  // },

  /**
   * Unregister a previously-loaded CommonJS module from the debugger server.
   */
  // unregisterModule: function(id) {
  //   let mod = gRegisteredModules[id];
  //   if (!mod) {
  //     throw new Error("Tried to unregister a module that was not previously registered.");
  //   }

  //   // Lazy actors
  //   if (mod.tabActor) {
  //     this.removeTabActor(mod);
  //   }
  //   if (mod.globalActor) {
  //     this.removeGlobalActor(mod);
  //   }

  //   if (mod.module) {
  //     // Deprecated non-lazy module API
  //     mod.module.unregister(mod.api);
  //     mod.api.destroy();
  //   }

  //   delete gRegisteredModules[id];
  // },

  /**
   * Install Firefox-specific actors.
   *
   * /!\ Be careful when adding a new actor, especially global actors.
   * Any new global actor will be exposed and returned by the root actor.
   *
   * That's the reason why tab actors aren't loaded on demand via
   * restrictPrivileges=true, to prevent exposing them on b2g parent process's
   * root actor.
   */
  // addBrowserActors: function(aWindowType = "navigator:browser", restrictPrivileges = false) {
  //   this.chromeWindowType = aWindowType;
  //   this.registerModule("devtools/server/actors/webbrowser");

  //   if (!restrictPrivileges) {
  //     this.addTabActors();
  //     this.registerModule("devtools/server/actors/preference", {
  //       prefix: "preference",
  //       constructor: "PreferenceActor",
  //       type: { global: true }
  //     });
  //     this.registerModule("devtools/server/actors/actor-registry", {
  //       prefix: "actorRegistry",
  //       constructor: "ActorRegistryActor",
  //       type: { global: true }
  //     });
  //   }
  //   let win = Services.wm.getMostRecentWindow(DebuggerServer.chromeWindowType);
  //   if (win && win.navigator.mozSettings) {
  //     this.registerModule("devtools/server/actors/settings", {
  //       prefix: "settings",
  //       constructor: "SettingsActor",
  //       type: { global: true }
  //     });
  //   }
  //   this.registerModule("devtools/server/actors/webapps", {
  //     prefix: "webapps",
  //     constructor: "WebappsActor",
  //     type: { global: true }
  //   });
  //   this.registerModule("devtools/server/actors/device", {
  //     prefix: "device",
  //     constructor: "DeviceActor",
  //     type: { global: true }
  //   });
  //   this.registerModule("devtools/server/actors/director-registry", {
  //     prefix: "directorRegistry",
  //     constructor: "DirectorRegistryActor",
  //     type: { global: true }
  //   });
  // },

  /**
   * Install tab actors in documents loaded in content childs
   */
  // addChildActors: function () {
  //   // In case of apps being loaded in parent process, DebuggerServer is already
  //   // initialized and browser actors are already loaded,
  //   // but childtab.js hasn't been loaded yet.
  //   if (!DebuggerServer.tabActorFactories.hasOwnProperty("consoleActor")) {
  //     this.addTabActors();
  //   }
  //   // But webbrowser.js and childtab.js aren't loaded from shell.js.
  //   if (!this.isModuleRegistered("devtools/server/actors/webbrowser")) {
  //     this.registerModule("devtools/server/actors/webbrowser");
  //   }
  //   if (!("ContentActor" in this)) {
  //     this.addActors("resource://gre/modules/devtools/server/actors/childtab.js");
  //   }
  // },

  /**
   * Install tab actors.
   */
  // addTabActors: function() {
  //   this.registerModule("devtools/server/actors/webconsole", {
  //     prefix: "console",
  //     constructor: "WebConsoleActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/inspector", {
  //     prefix: "inspector",
  //     constructor: "InspectorActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/call-watcher", {
  //     prefix: "callWatcher",
  //     constructor: "CallWatcherActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/canvas", {
  //     prefix: "canvas",
  //     constructor: "CanvasActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/webgl", {
  //     prefix: "webgl",
  //     constructor: "WebGLActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/webaudio", {
  //     prefix: "webaudio",
  //     constructor: "WebAudioActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/stylesheets", {
  //     prefix: "styleSheets",
  //     constructor: "StyleSheetsActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/styleeditor", {
  //     prefix: "styleEditor",
  //     constructor: "StyleEditorActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/storage", {
  //     prefix: "storage",
  //     constructor: "StorageActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/gcli", {
  //     prefix: "gcli",
  //     constructor: "GcliActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/memory", {
  //     prefix: "memory",
  //     constructor: "MemoryActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/memprof", {
  //     prefix: "memprof",
  //     constructor: "MemprofActor",
  //     type: { global: true, tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/framerate", {
  //     prefix: "framerate",
  //     constructor: "FramerateActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/eventlooplag", {
  //     prefix: "eventLoopLag",
  //     constructor: "EventLoopLagActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/layout", {
  //     prefix: "reflow",
  //     constructor: "ReflowActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/csscoverage", {
  //     prefix: "cssUsage",
  //     constructor: "CSSUsageActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/monitor", {
  //     prefix: "monitor",
  //     constructor: "MonitorActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/timeline", {
  //     prefix: "timeline",
  //     constructor: "TimelineActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/director-manager", {
  //     prefix: "directorManager",
  //     constructor: "DirectorManagerActor",
  //     type: { global: false, tab: true }
  //   });
  //   if ("nsIProfiler" in Ci) {
  //     this.registerModule("devtools/server/actors/profiler", {
  //       prefix: "profiler",
  //       constructor: "ProfilerActor",
  //       type: { tab: true }
  //     });
  //     this.registerModule("devtools/server/actors/performance", {
  //       prefix: "performance",
  //       constructor: "PerformanceActor",
  //       type: { tab: true }
  //     });
  //   }
  //   this.registerModule("devtools/server/actors/animation", {
  //     prefix: "animations",
  //     constructor: "AnimationsActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/promises", {
  //     prefix: "promises",
  //     constructor: "PromisesActor",
  //     type: { tab: true }
  //   });
  //   this.registerModule("devtools/server/actors/performance-entries", {
  //     prefix: "performanceEntries",
  //     constructor: "PerformanceEntriesActor",
  //     type: { tab: true }
  //   });
  // },

  /**
   * Passes a set of options to the BrowserAddonActors for the given ID.
   *
   * @param aId string
   *        The ID of the add-on to pass the options to
   * @param aOptions object
   *        The options.
   * @return a promise that will be resolved when complete.
   */
  // setAddonOptions: function DS_setAddonOptions(aId, aOptions) {
  //   if (!this._initialized) {
  //     return;
  //   }

  //   let promises = [];

  //   // Pass to all connections
  //   for (let connID of Object.getOwnPropertyNames(this._connections)) {
  //     promises.push(this._connections[connID].setAddonOptions(aId, aOptions));
  //   }

  //   return all(promises);
  // },

  // get listeningSockets() {
  //   return this._listeners.length;
  // },

  /**
   * Creates a socket listener for remote debugger connections.
   *
   * After calling this, set some socket options, such as the port / path to
   * listen on, and then call |open| on the listener.
   *
   * See SocketListener in toolkit/devtools/security/socket.js for available
   * options.
   *
   * @return SocketListener
   *         A SocketListener instance that is waiting to be configured and
   *         opened is returned.  This single listener can be closed at any
   *         later time by calling |close| on the SocketListener.  If remote
   *         connections are disabled, an error is thrown.
   */
  // createListener: function() {
  //   if (!Services.prefs.getBoolPref("devtools.debugger.remote-enabled")) {
  //     throw new Error("Can't create listener, remote debugging disabled");
  //   }
  //   this._checkInit();
  //   return DebuggerSocket.createListener();
  // },

  /**
   * Add a SocketListener instance to the server's set of active
   * SocketListeners.  This is called by a SocketListener after it is opened.
   */
  // _addListener: function(listener) {
  //   this._listeners.push(listener);
  // },

  /**
   * Remove a SocketListener instance from the server's set of active
   * SocketListeners.  This is called by a SocketListener after it is closed.
   */
  // _removeListener: function(listener) {
  //   this._listeners = this._listeners.filter(l => l !== listener);
  // },

  /**
   * Closes and forgets all previously opened listeners.
   *
   * @return boolean
   *         Whether any listeners were actually closed.
   */
  // closeAllListeners: function() {
  //   if (!this.listeningSockets) {
  //     return false;
  //   }

  //   for (let listener of this._listeners) {
  //     listener.close();
  //   }

  //   return true;
  // },

  /**
   * Creates a new connection to the local debugger speaking over a fake
   * transport. This connection results in straightforward calls to the onPacket
   * handlers of each side.
   *
   * @param aPrefix string [optional]
   *    If given, all actors in this connection will have names starting
   *    with |aPrefix + '/'|.
   * @returns a client-side DebuggerTransport for communicating with
   *    the newly-created connection.
   */
  // connectPipe: function DS_connectPipe(aPrefix) {
  //   this._checkInit();

  //   let serverTransport = new LocalDebuggerTransport;
  //   let clientTransport = new LocalDebuggerTransport(serverTransport);
  //   serverTransport.other = clientTransport;
  //   let connection = this._onConnection(serverTransport, aPrefix);

  //   // I'm putting this here because I trust you.
  //   //
  //   // There are times, when using a local connection, when you're going
  //   // to be tempted to just get direct access to the server.  Resist that
  //   // temptation!  If you succumb to that temptation, you will make the
  //   // fine developers that work on Fennec and Firefox OS sad.  They're
  //   // professionals, they'll try to act like they understand, but deep
  //   // down you'll know that you hurt them.
  //   //
  //   // This reference allows you to give in to that temptation.  There are
  //   // times this makes sense: tests, for example, and while porting a
  //   // previously local-only codebase to the remote protocol.
  //   //
  //   // But every time you use this, you will feel the shame of having
  //   // used a property that starts with a '_'.
  //   clientTransport._serverConnection = connection;

  //   return clientTransport;
  // },

  /**
   * In a content child process, create a new connection that exchanges
   * nsIMessageSender messages with our parent process.
   *
   * @param aPrefix
   *    The prefix we should use in our nsIMessageSender message names and
   *    actor names. This connection will use messages named
   *    "debug:<prefix>:packet", and all its actors will have names
   *    beginning with "<prefix>/".
   */
  // connectToParent: function(aPrefix, aScopeOrManager) {
  //   this._checkInit();

  //   let transport = isWorker ?
  //                   new WorkerDebuggerTransport(aScopeOrManager, aPrefix) :
  //                   new ChildDebuggerTransport(aScopeOrManager, aPrefix);

  //   return this._onConnection(transport, aPrefix, true);
  // },

  // connectToContent: function (aConnection, aMm) {
  //   let deferred = defer();

  //   let prefix = aConnection.allocID("content-process");
  //   let actor, childTransport;

  //   aMm.addMessageListener("debug:content-process-actor", function listener(msg) {
  //     // Arbitrarily choose the first content process to reply
  //     // XXX: This code needs to be updated if we use more than one content process
  //     aMm.removeMessageListener("debug:content-process-actor", listener);

  //     // Pipe Debugger message from/to parent/child via the message manager
  //     childTransport = new ChildDebuggerTransport(aMm, prefix);
  //     childTransport.hooks = {
  //       onPacket: aConnection.send.bind(aConnection),
  //       onClosed: function () {}
  //     };
  //     childTransport.ready();

  //     aConnection.setForwarding(prefix, childTransport);

  //     dumpn("establishing forwarding for process with prefix " + prefix);

  //     actor = msg.json.actor;

  //     deferred.resolve(actor);
  //   });

  //   aMm.sendAsyncMessage("DevTools:InitDebuggerServer", {
  //     prefix: prefix
  //   });

  //   function onClose() {
  //     Services.obs.removeObserver(onMessageManagerClose, "message-manager-close");
  //     events.off(aConnection, "closed", onClose);
  //     if (childTransport) {
  //       // If we have a child transport, the actor has already
  //       // been created. We need to stop using this message manager.
  //       childTransport.close();
  //       childTransport = null;
  //       aConnection.cancelForwarding(prefix);

  //       // ... and notify the child process to clean the tab actors.
  //       try {
  //         aMm.sendAsyncMessage("debug:content-process-destroy");
  //       } catch(e) {}
  //     }
  //   }

  //   let onMessageManagerClose = DevToolsUtils.makeInfallible(function (subject, topic, data) {
  //     if (subject == aMm) {
  //       onClose();
  //       aConnection.send({ from: actor.actor, type: "tabDetached" });
  //     }
  //   }).bind(this);
  //   Services.obs.addObserver(onMessageManagerClose,
  //                            "message-manager-close", false);

  //   events.on(aConnection, "closed", onClose);

  //   return deferred.promise;
  // },

  // connectToWorker: function (aConnection, aDbg, aId, aOptions) {
  //   return new Promise((resolve, reject) => {
  //     // Step 1: Ensure the worker debugger is initialized.
  //     if (!aDbg.isInitialized) {
  //       aDbg.initialize("resource://gre/modules/devtools/server/worker.js");

  //       // Create a listener for rpc requests from the worker debugger. Only do
  //       // this once, when the worker debugger is first initialized, rather than
  //       // for each connection.
  //       let listener = {
  //         onClose: () => {
  //           aDbg.removeListener(listener);
  //         },

  //         onMessage: (message) => {
  //           let packet = JSON.parse(message);
  //           if (packet.type !== "rpc") {
  //             return;
  //           }

  //           Promise.resolve().then(() => {
  //             let method = {
  //               "fetch": DevToolsUtils.fetch,
  //             }[packet.method];
  //             if (!method) {
  //               throw Error("Unknown method: " + packet.method);
  //             }

  //             return method.apply(undefined, packet.params);
  //           }).then((value) => {
  //             aDbg.postMessage(JSON.stringify({
  //               type: "rpc",
  //               result: value,
  //               error: null,
  //               id: packet.id
  //             }));
  //           }, (reason) => {
  //             aDbg.postMessage(JSON.stringify({
  //               type: "rpc",
  //               result: null,
  //               error: reason,
  //               id: packet.id
  //             }));
  //           });
  //         }
  //       };

  //       aDbg.addListener(listener);
  //     }

  //     // Step 2: Send a connect request to the worker debugger.
  //     aDbg.postMessage(JSON.stringify({
  //       type: "connect",
  //       id: aId,
  //       options: aOptions
  //     }));

  //     // Steps 3-5 are performed on the worker thread (see worker.js).

  //     // Step 6: Wait for a response from the worker debugger.
  //     let listener = {
  //       onClose: () => {
  //         aDbg.removeListener(listener);

  //         reject("closed");
  //       },

  //       onMessage: (message) => {
  //         let packet = JSON.parse(message);
  //         if (packet.type !== "message" || packet.id !== aId) {
  //           return;
  //         }

  //         message = packet.message;
  //         if (message.error) {
  //           reject(error);
  //         }

  //         if (message.type !== "paused") {
  //           return;
  //         }

  //         aDbg.removeListener(listener);

  //         // Step 7: Create a transport for the connection to the worker.
  //         let transport = new WorkerDebuggerTransport(aDbg, aId);
  //         transport.ready();
  //         transport.hooks = {
  //           onClosed: () => {
  //             if (!aDbg.isClosed) {
  //               aDbg.postMessage(JSON.stringify({
  //                 type: "disconnect",
  //                 id: aId
  //               }));
  //             }

  //             aConnection.cancelForwarding(aId);
  //           },

  //           onPacket: (packet) => {
  //             // Ensure that any packets received from the server on the worker
  //             // thread are forwarded to the client on the main thread, as if
  //             // they had been sent by the server on the main thread.
  //             aConnection.send(packet);
  //           }
  //         };

  //         // Ensure that any packets received from the client on the main thread
  //         // to actors on the worker thread are forwarded to the server on the
  //         // worker thread.
  //         aConnection.setForwarding(aId, transport);

  //         resolve({
  //           threadActor: message.from,
  //           transport: transport
  //         });
  //       }
  //     };
  //     aDbg.addListener(listener);
  //   });
  // },

  /**
   * Check if the caller is running in a content child process.
   * (Eventually set by child.js)
   *
   * @return boolean
   *         true if the caller is running in a content
   */
  isInChildProcess: false,

  /**
   * In a chrome parent process, ask all content child processes
   * to execute a given module setup helper.
   *
   * @param module
   *        The module to be required
   * @param setupChild
   *        The name of the setup helper exported by the above module
   *        (setup helper signature: function ({mm}) { ... })
   */
  // setupInChild: function({ module, setupChild, args }) {
  //   if (this.isInChildProcess) {
  //     return;
  //   }

  //   this._childMessageManagers.forEach(mm => {
  //     mm.sendAsyncMessage("debug:setup-in-child", {
  //       module: module,
  //       setupChild: setupChild,
  //       args: args,
  //     });
  //   });
  // },

  /**
   * Live list of all currenctly attached child's message managers.
   */
  // _childMessageManagers: new Set(),

  /**
   * Connect to a child process.
   *
   * @param object aConnection
   *        The debugger server connection to use.
   * @param nsIDOMElement aFrame
   *        The browser element that holds the child process.
   * @param function [aOnDestroy]
   *        Optional function to invoke when the child process closes
   *        or the connection shuts down. (Need to forget about the
   *        related TabActor)
   * @return object
   *         A promise object that is resolved once the connection is
   *         established.
   */
  // connectToChild: function(aConnection, aFrame, aOnDestroy) {
  //   let deferred = defer();

  //   let mm = aFrame.QueryInterface(Ci.nsIFrameLoaderOwner).frameLoader
  //            .messageManager;
  //   mm.loadFrameScript("resource://gre/modules/devtools/server/child.js", false);
  //   this._childMessageManagers.add(mm);

  //   let actor, childTransport;
  //   let prefix = aConnection.allocID("child");
  //   let netMonitor = null;

  //   // provides hook to actor modules that need to exchange messages
  //   // between e10s parent and child processes
  //   let onSetupInParent = function (msg) {
  //     let { module, setupParent } = msg.json;
  //     let m, fn;

  //     try {
  //       m = require(module);

  //       if (!setupParent in m) {
  //         dumpn("ERROR: module '" + module + "' does not export '" + setupParent + "'");
  //         return false;
  //       }

  //       m[setupParent]({ mm: mm, prefix: prefix });

  //       return true;
  //     } catch(e) {
  //       let error_msg = "exception during actor module setup running in the parent process: ";
  //       DevToolsUtils.reportException(error_msg + e);
  //       dumpn("ERROR: " + error_msg + " \n\t module: '" + module + "' \n\t setupParent: '" + setupParent + "'\n" +
  //             DevToolsUtils.safeErrorString(e));
  //       return false;
  //     }
  //   };
  //   mm.addMessageListener("debug:setup-in-parent", onSetupInParent);

  //   let onActorCreated = DevToolsUtils.makeInfallible(function (msg) {
  //     if (msg.json.prefix != prefix) {
  //       return;
  //     }
  //     mm.removeMessageListener("debug:actor", onActorCreated);

  //     // Pipe Debugger message from/to parent/child via the message manager
  //     childTransport = new ChildDebuggerTransport(mm, prefix);
  //     childTransport.hooks = {
  //       onPacket: aConnection.send.bind(aConnection),
  //       onClosed: function () {}
  //     };
  //     childTransport.ready();

  //     aConnection.setForwarding(prefix, childTransport);

  //     dumpn("establishing forwarding for app with prefix " + prefix);

  //     actor = msg.json.actor;

  //     let { NetworkMonitorManager } = require("devtools/toolkit/webconsole/network-monitor");
  //     netMonitor = new NetworkMonitorManager(aFrame, actor.actor);

  //     events.emit(DebuggerServer, "new-child-process", { mm: mm });

  //     deferred.resolve(actor);
  //   }).bind(this);
  //   mm.addMessageListener("debug:actor", onActorCreated);

  //   let destroy = DevToolsUtils.makeInfallible(function () {
  //     // provides hook to actor modules that need to exchange messages
  //     // between e10s parent and child processes
  //     DebuggerServer.emit("disconnected-from-child:" + prefix, { mm: mm, prefix: prefix });

  //     if (childTransport) {
  //       // If we have a child transport, the actor has already
  //       // been created. We need to stop using this message manager.
  //       childTransport.close();
  //       childTransport = null;
  //       aConnection.cancelForwarding(prefix);

  //       // ... and notify the child process to clean the tab actors.
  //       mm.sendAsyncMessage("debug:disconnect", { prefix: prefix });
  //     } else {
  //       // Otherwise, the app has been closed before the actor
  //       // had a chance to be created, so we are not able to create
  //       // the actor.
  //       deferred.resolve(null);
  //     }
  //     if (actor) {
  //       // The ContentActor within the child process doesn't necessary
  //       // have time to uninitialize itself when the app is closed/killed.
  //       // So ensure telling the client that the related actor is detached.
  //       aConnection.send({ from: actor.actor, type: "tabDetached" });
  //       actor = null;
  //     }

  //     if (netMonitor) {
  //       netMonitor.destroy();
  //       netMonitor = null;
  //     }

  //     if (aOnDestroy) {
  //       aOnDestroy(mm);
  //     }

  //     // Cleanup all listeners
  //     Services.obs.removeObserver(onMessageManagerClose, "message-manager-close");
  //     mm.removeMessageListener("debug:setup-in-parent", onSetupInParent);
  //     if (!actor) {
  //       mm.removeMessageListener("debug:actor", onActorCreated);
  //     }
  //     events.off(aConnection, "closed", destroy);

  //     DebuggerServer._childMessageManagers.delete(mm);
  //   });

  //   // Listen for app process exit
  //   let onMessageManagerClose = function (subject, topic, data) {
  //     if (subject == mm) {
  //       destroy();
  //     }
  //   };
  //   Services.obs.addObserver(onMessageManagerClose,
  //                            "message-manager-close", false);

  //   // Listen for connection close to cleanup things
  //   // when user unplug the device or we lose the connection somehow.
  //   events.on(aConnection, "closed", destroy);

  //   mm.sendAsyncMessage("debug:connect", { prefix: prefix });

  //   return deferred.promise;
  // },

  /**
   * Create a new debugger connection for the given transport. Called after
   * connectPipe(), from connectToParent, or from an incoming socket
   * connection handler.
   *
   * If present, |aForwardingPrefix| is a forwarding prefix that a parent
   * server is using to recognizes messages intended for this server. Ensure
   * that all our actors have names beginning with |aForwardingPrefix + '/'|.
   * In particular, the root actor's name will be |aForwardingPrefix + '/root'|.
   */
  _onConnection: function DS_onConnection(aTransport, aForwardingPrefix, aNoRootActor) {
    let connID;
    if (aForwardingPrefix) {
      connID = aForwardingPrefix + "/";
    } else {
      // Multiple servers can be started at the same time, and when that's the
      // case, they are loaded in separate devtools loaders.
      // So, use the current loader ID to prefix the connection ID and make it
      // unique.
      // connID = "server" + loader.id + ".conn" + this._nextConnID++ + '.';
      connID = "server" + ".conn" + this._nextConnID++ + '.';
    }

    let conn = new DebuggerServerConnection(connID, aTransport);
    this._connections[connID] = conn;

    // Create a root actor for the connection and send the hello packet.
    if (!aNoRootActor) {
      conn.rootActor = this.createRootActor(conn);
      if (aForwardingPrefix)
        conn.rootActor.actorID = aForwardingPrefix + "/root";
      else
        conn.rootActor.actorID = "root";
      conn.addActor(conn.rootActor);
      aTransport.send(conn.rootActor.sayHello());
    }
    aTransport.ready();

    // this.emit("connectionchange", "opened", conn);
    return conn;
  },

  /**
   * Remove the connection from the debugging server.
   */
  _connectionClosed: function DS_connectionClosed(aConnection) {
    delete this._connections[aConnection.prefix];
    this.emit("connectionchange", "closed", aConnection);
  },

  // DebuggerServer extension API.

  setRootActor: function DS_setRootActor(aFunction) {
    this.createRootActor = aFunction;
  },

  /**
   * Registers handlers for new tab-scoped request types defined dynamically.
   * This is used for example by add-ons to augment the functionality of the tab
   * actor. Note that the name or actorPrefix of the request type is not allowed
   * to clash with existing protocol packet properties, like 'title', 'url' or
   * 'actor', since that would break the protocol.
   *
   * @param aActor function, object
   *      In case of function:
   *        The constructor function for this request type. This expects to be
   *        called as a constructor (i.e. with 'new'), and passed two
   *        arguments: the DebuggerServerConnection, and the BrowserTabActor
   *        with which it will be associated.
   *        Only used for deprecated eagerly loaded actors.
   *      In case of object:
   *        First argument of RegisteredActorFactory constructor.
   *        See the it's definition for more info.
   *
   * @param aName string [optional]
   *        The name of the new request type. If this is not present, the
   *        actorPrefix property of the constructor prototype is used.
   */
  // addTabActor: function DS_addTabActor(aActor, aName) {
  //   let name = aName ? aName : aActor.prototype.actorPrefix;
  //   if (["title", "url", "actor"].indexOf(name) != -1) {
  //     throw Error(name + " is not allowed");
  //   }
  //   if (DebuggerServer.tabActorFactories.hasOwnProperty(name)) {
  //     throw Error(name + " already exists");
  //   }
  //   DebuggerServer.tabActorFactories[name] = new RegisteredActorFactory(aActor, name);
  // },

  /**
   * Unregisters the handler for the specified tab-scoped request type.
   * This may be used for example by add-ons when shutting down or upgrading.
   * When unregistering an existing tab actor remove related tab factory
   * as well as all existing instances of the actor.
   *
   * @param aActor function, object
   *      In case of function:
   *        The constructor function for this request type.
   *      In case of object:
   *        Same object being given to related addTabActor call.
   */
  // removeTabActor: function DS_removeTabActor(aActor) {
  //   for (let name in DebuggerServer.tabActorFactories) {
  //     let handler = DebuggerServer.tabActorFactories[name];
  //     if ((handler.name && handler.name == aActor.name) ||
  //         (handler.id && handler.id == aActor.id)) {
  //       delete DebuggerServer.tabActorFactories[name];
  //       for (let connID of Object.getOwnPropertyNames(this._connections)) {
  //         this._connections[connID].rootActor.removeActorByName(name);
  //       }
  //     }
  //   }
  // },

  /**
   * Registers handlers for new browser-scoped request types defined
   * dynamically. This is used for example by add-ons to augment the
   * functionality of the root actor. Note that the name or actorPrefix of the
   * request type is not allowed to clash with existing protocol packet
   * properties, like 'from', 'tabs' or 'selected', since that would break the
   * protocol.
   *
   * @param aActor function, object
   *      In case of function:
   *        The constructor function for this request type. This expects to be
   *        called as a constructor (i.e. with 'new'), and passed two
   *        arguments: the DebuggerServerConnection, and the BrowserRootActor
   *        with which it will be associated.
   *        Only used for deprecated eagerly loaded actors.
   *      In case of object:
   *        First argument of RegisteredActorFactory constructor.
   *        See the it's definition for more info.
   *
   * @param aName string [optional]
   *        The name of the new request type. If this is not present, the
   *        actorPrefix property of the constructor prototype is used.
   */
  // addGlobalActor: function DS_addGlobalActor(aActor, aName) {
  //   let name = aName ? aName : aActor.prototype.actorPrefix;
  //   if (["from", "tabs", "selected"].indexOf(name) != -1) {
  //     throw Error(name + " is not allowed");
  //   }
  //   if (DebuggerServer.globalActorFactories.hasOwnProperty(name)) {
  //     throw Error(name + " already exists");
  //   }
  //   DebuggerServer.globalActorFactories[name] = new RegisteredActorFactory(aActor, name);
  // },

  /**
   * Unregisters the handler for the specified browser-scoped request type.
   * This may be used for example by add-ons when shutting down or upgrading.
   * When unregistering an existing global actor remove related global factory
   * as well as all existing instances of the actor.
   *
   * @param aActor function, object
   *      In case of function:
   *        The constructor function for this request type.
   *      In case of object:
   *        Same object being given to related addGlobalActor call.
   */
  // removeGlobalActor: function DS_removeGlobalActor(aActor) {
  //   for (let name in DebuggerServer.globalActorFactories) {
  //     let handler = DebuggerServer.globalActorFactories[name];
  //     if ((handler.name && handler.name == aActor.name) ||
  //         (handler.id && handler.id == aActor.id)) {
  //       delete DebuggerServer.globalActorFactories[name];
  //       for (let connID of Object.getOwnPropertyNames(this._connections)) {
  //         this._connections[connID].rootActor.removeActorByName(name);
  //       }
  //     }
  //   }
  // }
};

// Expose these to save callers the trouble of importing DebuggerSocket
// DevToolsUtils.defineLazyGetter(DebuggerServer, "Authenticators", () => {
//   return Authentication.Authenticators;
// });
// DevToolsUtils.defineLazyGetter(DebuggerServer, "AuthenticationResult", () => {
//   return Authentication.AuthenticationResult;
// });

// EventEmitter.decorate(DebuggerServer);

// if (this.exports) {
//   exports.DebuggerServer = DebuggerServer;
//   exports.ActorPool = ActorPool;
//   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 aPrefix string
 *        All actor IDs created by this connection should be prefixed
 *        with aPrefix.
 * @param aTransport transport
 *        Packet transport for the debugging protocol.
 */
function DebuggerServerConnection(aPrefix, aTransport)
{
  this._prefix = aPrefix;
  this._transport = aTransport;
  this._transport.hooks = this;
  this._nextID = 1;

  this._actorPool = new ActorPool(this);
  this._extraPools = [this._actorPool];

  // Responses to a given actor must be returned the client
  // in the same order as the requests that they're replying to, but
  // Implementations might finish serving requests in a different
  // order.  To keep things in order we generate a promise for each
  // request, chained to the promise for the request before it.
  // This map stores the latest request promise in the chain, keyed
  // by an actor ID string.
  this._actorResponses = new Map;

  /*
   * We can forward packets to other servers, if the actors on that server
   * all use a distinct prefix on their names. This is a map from prefixes
   * to transports: it maps a prefix P to a transport T if T conveys
   * packets to the server whose actors' names all begin with P + "/".
   */
  this._forwardingPrefixes = new Map;
}

DebuggerServerConnection.prototype = {
  _prefix: null,
  get prefix() { return this._prefix },

  _transport: null,
  get transport() { return this._transport },

  /**
   * Message manager used to communicate with the parent process,
   * set by child.js. Is only defined for connections instantiated
   * within a child process.
   */
  parentMessageManager: null,

  close: function() {
    this._transport.close();
  },

  send: function DSC_send(aPacket) {
    this.transport.send(aPacket);
  },

  /**
   * Used when sending a bulk reply from an actor.
   * @see DebuggerTransport.prototype.startBulkSend
   */
  startBulkSend: function(header) {
    return this.transport.startBulkSend(header);
  },

  allocID: function DSC_allocID(aPrefix) {
    return this.prefix + (aPrefix || '') + this._nextID++;
  },

  /**
   * Add a map of actor IDs to the connection.
   */
  addActorPool: function DSC_addActorPool(aActorPool) {
    this._extraPools.push(aActorPool);
  },

  /**
   * Remove a previously-added pool of actors to the connection.
   *
   * @param ActorPool aActorPool
   *        The ActorPool instance you want to remove.
   * @param boolean aNoCleanup [optional]
   *        True if you don't want to disconnect each actor from the pool, false
   *        otherwise.
   */
  removeActorPool: function DSC_removeActorPool(aActorPool, aNoCleanup) {
    let index = this._extraPools.lastIndexOf(aActorPool);
    if (index > -1) {
      let pool = this._extraPools.splice(index, 1);
      if (!aNoCleanup) {
        pool.map(function(p) { p.cleanup(); });
      }
    }
  },

  /**
   * Add an actor to the default actor pool for this connection.
   */
  addActor: function DSC_addActor(aActor) {
    this._actorPool.addActor(aActor);
  },

  /**
   * Remove an actor to the default actor pool for this connection.
   */
  removeActor: function DSC_removeActor(aActor) {
    this._actorPool.removeActor(aActor);
  },

  /**
   * Match the api expected by the protocol library.
   */
  unmanage: function(aActor) {
    return this.removeActor(aActor);
  },

  /**
   * Look up an actor implementation for an actorID.  Will search
   * all the actor pools registered with the connection.
   *
   * @param aActorID string
   *        Actor ID to look up.
   */
  getActor: function DSC_getActor(aActorID) {
    let pool = this.poolFor(aActorID);
    if (pool) {
      return pool.get(aActorID);
    }

    if (aActorID === "root") {
      return this.rootActor;
    }

    return null;
  },

  _getOrCreateActor: function(actorID) {
    let actor = this.getActor(actorID);
    if (!actor) {
      this.transport.send({ from: actorID ? actorID : "root",
                            error: "noSuchActor",
                            message: "No such actor for ID: " + actorID });
      return;
    }

    // Dynamically-loaded actors have to be created lazily.
    // if (actor instanceof ObservedActorFactory) {
    //   try {
    //     actor= actor.createActor();
    //   } catch (e) {
    //     this.transport.send(this._unknownError(
    //       "Error occurred while creating actor '" + actor.name,
    //       e));
    //   }
    // } else if (typeof(actor) !== "object") {
    //   // ActorPools should now contain only actor instances (i.e. objects)
    //   // or ObservedActorFactory instances.
    //   throw new Error("Unexpected actor constructor/function in ActorPool " +
    //                   "for actorID=" + actorID + ".");
    // }

    return actor;
  },

  poolFor: function DSC_actorPool(aActorID) {
    for (let pool of this._extraPools) {
      if (pool.has(aActorID)) {
        return pool;
      }
    }
    return null;
  },

  _unknownError: function DSC__unknownError(aPrefix, aError) {
    // let errorString = aPrefix + ": " + DevToolsUtils.safeErrorString(aError);
    // reportError(errorString);
    // dumpn(errorString);
    return {
      error: "unknownError",
      // message: errorString
      message: aPrefix + ": " + aError
    };
  },

  _queueResponse: function(from, type, response) {
    let pendingResponse = this._actorResponses.get(from) || resolve(null);
    let responsePromise = pendingResponse.then(() => {
      return response;
    }).then(aResponse => {
      if (!aResponse.from) {
        aResponse.from = from;
      }
      this.transport.send(aResponse);
    }).then(null, (e) => {
      let errorPacket = this._unknownError(
        "error occurred while processing '" + type,
        e);
      errorPacket.from = from;
      this.transport.send(errorPacket);
    });

    this._actorResponses.set(from, responsePromise);
  },

  /**
   * Passes a set of options to the BrowserAddonActors for the given ID.
   *
   * @param aId string
   *        The ID of the add-on to pass the options to
   * @param aOptions object
   *        The options.
   * @return a promise that will be resolved when complete.
   */
  // setAddonOptions: function DSC_setAddonOptions(aId, aOptions) {
  //   let addonList = this.rootActor._parameters.addonList;
  //   if (!addonList) {
  //     return resolve();
  //   }
  //   return addonList.getList().then((addonActors) => {
  //     for (let actor of addonActors) {
  //       if (actor.id != aId) {
  //         continue;
  //       }
  //       actor.setOptions(aOptions);
  //       return;
  //     }
  //   });
  // },

  /* Forwarding packets to other transports based on actor name prefixes. */

  /*
   * Arrange to forward packets to another server. This is how we
   * forward debugging connections to child processes.
   *
   * If we receive a packet for an actor whose name begins with |aPrefix|
   * followed by '/', then we will forward that packet to |aTransport|.
   *
   * This overrides any prior forwarding for |aPrefix|.
   *
   * @param aPrefix string
   *    The actor name prefix, not including the '/'.
   * @param aTransport object
   *    A packet transport to which we should forward packets to actors
   *    whose names begin with |(aPrefix + '/').|
   */
  setForwarding: function(aPrefix, aTransport) {
    this._forwardingPrefixes.set(aPrefix, aTransport);
  },

  /*
   * Stop forwarding messages to actors whose names begin with
   * |aPrefix+'/'|. Such messages will now elicit 'noSuchActor' errors.
   */
  cancelForwarding: function(aPrefix) {
    this._forwardingPrefixes.delete(aPrefix);
  },

  sendActorEvent: function (actorID, eventName, event = {}) {
    event.from = actorID;
    event.type = eventName;
    this.send(event);
  },

  // Transport hooks.

  /**
   * Called by DebuggerTransport to dispatch incoming packets as appropriate.
   *
   * @param aPacket object
   *        The incoming packet.
   */
  onPacket: function DSC_onPacket(aPacket) {
    // If the actor's name begins with a prefix we've been asked to
    // forward, do so.
    //
    // Note that the presence of a prefix alone doesn't indicate that
    // forwarding is needed: in DebuggerServerConnection instances in child
    // processes, every actor has a prefixed name.
    if (this._forwardingPrefixes.size > 0) {
      let to = aPacket.to;
      let separator = to.lastIndexOf('/');
      while (separator >= 0) {
        to = to.substring(0, separator);
        let forwardTo = this._forwardingPrefixes.get(aPacket.to.substring(0, separator));
        if (forwardTo) {
          forwardTo.send(aPacket);
          return;
        }
        separator = to.lastIndexOf('/');
      }
    }

    let actor = this._getOrCreateActor(aPacket.to);
    if (!actor) {
      return;
    }

    var ret = null;

    // handle "requestTypes" RDP request.
    if (aPacket.type == "requestTypes") {
      ret = { from: actor.actorID, requestTypes: Object.keys(actor.requestTypes) };
    } else if (actor.requestTypes && actor.requestTypes[aPacket.type]) {
      // Dispatch the request to the actor.
      try {
        this.currentPacket = aPacket;
        ret = actor.requestTypes[aPacket.type].bind(actor)(aPacket, this);
      } catch(e) {
        this.transport.send(this._unknownError(
          "error occurred while processing '" + aPacket.type,
          e));
        // log(e.stack);
      } finally {
        this.currentPacket = undefined;
      }
    } else {
      ret = { error: "unrecognizedPacketType",
              message: ("Actor " + actor.actorID +
                        " does not recognize the packet type " +
                        aPacket.type) };
    }

    // There will not be a return value if a bulk reply is sent.
    if (ret) {
      this._queueResponse(aPacket.to, aPacket.type, ret);
    }
  },

  /**
   * Called by the DebuggerTransport to dispatch incoming bulk packets as
   * appropriate.
   *
   * @param packet object
   *        The incoming packet, which contains:
   *        * actor:  Name of actor that will receive the packet
   *        * type:   Name of actor's method that should be called on receipt
   *        * length: Size of the data to be read
   *        * stream: This input stream should only be used directly if you can
   *                  ensure that you will read exactly |length| bytes and will
   *                  not close the stream when reading is complete
   *        * done:   If you use the stream directly (instead of |copyTo|
   *                  below), you must signal completion by resolving /
   *                  rejecting this deferred.  If it's rejected, the transport
   *                  will be closed.  If an Error is supplied as a rejection
   *                  value, it will be logged via |dumpn|.  If you do use
   *                  |copyTo|, resolving is taken care of for you when copying
   *                  completes.
   *        * copyTo: A helper function for getting your data out of the stream
   *                  that meets the stream handling requirements above, and has
   *                  the following signature:
   *          @param  output nsIAsyncOutputStream
   *                  The stream to copy to.
   *          @return Promise
   *                  The promise is resolved when copying completes or rejected
   *                  if any (unexpected) errors occur.
   *                  This object also emits "progress" events for each chunk
   *                  that is copied.  See stream-utils.js.
   */
  onBulkPacket: function(packet) {
    let { actor: actorKey, type, length } = packet;

    let actor = this._getOrCreateActor(actorKey);
    if (!actor) {
      return;
    }

    // Dispatch the request to the actor.
    let ret;
    if (actor.requestTypes && actor.requestTypes[type]) {
      try {
        ret = actor.requestTypes[type].call(actor, packet);
      } catch(e) {
        this.transport.send(this._unknownError(
          "error occurred while processing bulk packet '" + type, e));
        packet.done.reject(e);
      }
    } else {
      let message = "Actor " + actorKey +
                    " does not recognize the bulk packet type " + type;
      ret = { error: "unrecognizedPacketType",
              message: message };
      packet.done.reject(new Error(message));
    }

    // If there is a JSON response, queue it for sending back to the client.
    if (ret) {
      this._queueResponse(actorKey, type, ret);
    }
  },

  /**
   * Called by DebuggerTransport when the underlying stream is closed.
   *
   * @param aStatus nsresult
   *        The status code that corresponds to the reason for closing
   *        the stream.
   */
  onClosed: function DSC_onClosed(aStatus) {
    dumpn("Cleaning up connection.");
    if (!this._actorPool) {
      // Ignore this call if the connection is already closed.
      return;
    }
    events.emit(this, "closed", aStatus);

    this._actorPool = null;
    this._extraPools.map(function(p) { p.cleanup(); });
    this._extraPools = null;

    this.rootActor = null;
    this._transport = null;
    DebuggerServer._connectionClosed(this);
  },

  /*
   * Debugging helper for inspecting the state of the actor pools.
   */
  _dumpPools: function DSC_dumpPools() {
    // dumpn("/-------------------- dumping pools:");
    // if (this._actorPool) {
    //   dumpn("--------------------- actorPool actors: " +
    //         uneval(Object.keys(this._actorPool._actors)));
    // }
    // for (let pool of this._extraPools) {
    //   if (pool !== this._actorPool) {
    //     dumpn("--------------------- extraPool actors: " +
    //           uneval(Object.keys(pool._actors)));
    //   }
    // }
  },

  /*
   * Debugging helper for inspecting the state of an actor pool.
   */
  _dumpPool: function DSC_dumpPools(aPool) {
    // dumpn("/-------------------- dumping pool:");
    // dumpn("--------------------- actorPool actors: " +
    //       uneval(Object.keys(aPool._actors)));
  },

  /**
   * In a content child process, ask the DebuggerServer in the parent process
   * to execute a given module setup helper.
   *
   * @param module
   *        The module to be required
   * @param setupParent
   *        The name of the setup helper exported by the above module
   *        (setup helper signature: function ({mm}) { ... })
   * @return boolean
   *         true if the setup helper returned successfully
   */
  // setupInParent: function({ conn, module, setupParent }) {
  //   if (!this.parentMessageManager) {
  //     return false;
  //   }

  //   let { sendSyncMessage } = this.parentMessageManager;

  //   return sendSyncMessage("debug:setup-in-parent", {
  //     module: module,
  //     setupParent: setupParent
  //   });
  // },
};