The Tor Browser: toolkit/devtools/server/actors/webconsole.js@129ffea94266 (annotated)

toolkit/devtools/server/actors/webconsole.js@129ffea94266 (annotated)

toolkit/devtools/server/actors/webconsole.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- js2-basic-offset: 2; indent-tabs-mode: nil; -*- */
 /* vim: set 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";
 let {Cc, Ci, Cu} = require("chrome");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 let { DebuggerServer, ActorPool } = require("devtools/server/main");
 // Symbols from script.js
 let { ThreadActor, EnvironmentActor, ObjectActor, LongStringActor } = DebuggerServer;
 Cu.import("resource://gre/modules/jsdebugger.jsm");
 addDebuggerToGlobal(this);
 XPCOMUtils.defineLazyModuleGetter(this, "Services",
                                   "resource://gre/modules/Services.jsm");
 XPCOMUtils.defineLazyGetter(this, "NetworkMonitor", () => {
   return require("devtools/toolkit/webconsole/network-monitor")
          .NetworkMonitor;
 });
 XPCOMUtils.defineLazyGetter(this, "NetworkMonitorChild", () => {
   return require("devtools/toolkit/webconsole/network-monitor")
          .NetworkMonitorChild;
 });
 XPCOMUtils.defineLazyGetter(this, "ConsoleProgressListener", () => {
   return require("devtools/toolkit/webconsole/network-monitor")
          .ConsoleProgressListener;
 });
 XPCOMUtils.defineLazyGetter(this, "events", () => {
   return require("sdk/event/core");
 });
 for (let name of ["WebConsoleUtils", "ConsoleServiceListener",
                   "ConsoleAPIListener", "JSTermHelpers", "JSPropertyProvider",
                   "ConsoleReflowListener"]) {
   Object.defineProperty(this, name, {
     get: function(prop) {
       if (prop == "WebConsoleUtils") {
         prop = "Utils";
       }
       return require("devtools/toolkit/webconsole/utils")[prop];
     }.bind(null, name),
     configurable: true,
     enumerable: true
   });
 }
 /**
  * The WebConsoleActor implements capabilities needed for the Web Console
  * feature.
  *
  * @constructor
  * @param object aConnection
  *        The connection to the client, DebuggerServerConnection.
  * @param object [aParentActor]
  *        Optional, the parent actor.
  */
 function WebConsoleActor(aConnection, aParentActor)
 {
   this.conn = aConnection;
   this.parentActor = aParentActor;
   this._actorPool = new ActorPool(this.conn);
   this.conn.addActorPool(this._actorPool);
   this._prefs = {};
   this.dbg = new Debugger();
   this._netEvents = new Map();
   this._gripDepth = 0;
   this._onWillNavigate = this._onWillNavigate.bind(this);
   this._onObserverNotification = this._onObserverNotification.bind(this);
   if (this.parentActor.isRootActor) {
     Services.obs.addObserver(this._onObserverNotification,
                              "last-pb-context-exited", false);
   }
   this.traits = {
     customNetworkRequest: !this._parentIsContentActor,
   };
 }
 WebConsoleActor.l10n = new WebConsoleUtils.l10n("chrome://global/locale/console.properties");
 WebConsoleActor.prototype =
 {
   /**
    * Debugger instance.
    *
    * @see jsdebugger.jsm
    */
   dbg: null,
   /**
    * This is used by the ObjectActor to keep track of the depth of grip() calls.
    * @private
    * @type number
    */
   _gripDepth: null,
   /**
    * Actor pool for all of the actors we send to the client.
    * @private
    * @type object
    * @see ActorPool
    */
   _actorPool: null,
   /**
    * Web Console-related preferences.
    * @private
    * @type object
    */
   _prefs: null,
   /**
    * Holds a map between nsIChannel objects and NetworkEventActors for requests
    * created with sendHTTPRequest.
    *
    * @private
    * @type Map
    */
   _netEvents: null,
   /**
    * The debugger server connection instance.
    * @type object
    */
   conn: null,
   /**
    * List of supported features by the console actor.
    * @type object
    */
   traits: null,
   /**
    * Boolean getter that tells if the parent actor is a ContentActor.
    *
    * @private
    * @type boolean
    */
   get _parentIsContentActor() {
     return "ContentActor" in DebuggerServer &&
             this.parentActor instanceof DebuggerServer.ContentActor;
   },
   /**
    * The window we work with.
    * @type nsIDOMWindow
    */
   get window() {
     if (this.parentActor.isRootActor) {
       return this._getWindowForBrowserConsole();
     }
     return this.parentActor.window;
   },
   /**
    * Get a window to use for the browser console.
    *
    * @private
    * @return nsIDOMWindow
    *         The window to use, or null if no window could be found.
    */
   _getWindowForBrowserConsole: function WCA__getWindowForBrowserConsole()
   {
     // Check if our last used chrome window is still live.
     let window = this._lastChromeWindow && this._lastChromeWindow.get();
     // If not, look for a new one.
     if (!window || window.closed) {
       window = this.parentActor.window;
       if (!window) {
         // Try to find the Browser Console window to use instead.
         window = Services.wm.getMostRecentWindow("devtools:webconsole");
         // We prefer the normal chrome window over the console window,
         // so we'll look for those windows in order to replace our reference.
         let onChromeWindowOpened = () => {
           // We'll look for this window when someone next requests window()
           Services.obs.removeObserver(onChromeWindowOpened, "domwindowopened");
           this._lastChromeWindow = null;
         };
         Services.obs.addObserver(onChromeWindowOpened, "domwindowopened", false);
       }
       this._handleNewWindow(window);
     }
     return window;
   },
   /**
    * Store a newly found window on the actor to be used in the future.
    *
    * @private
    * @param nsIDOMWindow window
    *        The window to store on the actor (can be null).
    */
   _handleNewWindow: function WCA__handleNewWindow(window)
   {
     if (window) {
       if (this._hadChromeWindow) {
         let contextChangedMsg = WebConsoleActor.l10n.getStr("evaluationContextChanged");
         Services.console.logStringMessage(contextChangedMsg);
       }
       this._lastChromeWindow = Cu.getWeakReference(window);
       this._hadChromeWindow = true;
     } else {
       this._lastChromeWindow = null;
     }
   },
   /**
    * Whether we've been using a window before.
    *
    * @private
    * @type boolean
    */
   _hadChromeWindow: false,
   /**
    * A weak reference to the last chrome window we used to work with.
    *
    * @private
    * @type nsIWeakReference
    */
   _lastChromeWindow: null,
   // The evalWindow is used at the scope for JS evaluation.
   _evalWindow: null,
   get evalWindow() {
     return this._evalWindow || this.window;
   },
   set evalWindow(aWindow) {
     this._evalWindow = aWindow;
     if (!this._progressListenerActive) {
       events.on(this.parentActor, "will-navigate", this._onWillNavigate);
       this._progressListenerActive = true;
     }
   },
   /**
    * Flag used to track if we are listening for events from the progress
    * listener of the tab actor. We use the progress listener to clear
    * this.evalWindow on page navigation.
    *
    * @private
    * @type boolean
    */
   _progressListenerActive: false,
   /**
    * The ConsoleServiceListener instance.
    * @type object
    */
   consoleServiceListener: null,
   /**
    * The ConsoleAPIListener instance.
    */
   consoleAPIListener: null,
   /**
    * The NetworkMonitor instance.
    */
   networkMonitor: null,
   /**
    * The ConsoleProgressListener instance.
    */
   consoleProgressListener: null,
   /**
    * The ConsoleReflowListener instance.
    */
   consoleReflowListener: null,
   /**
    * The JSTerm Helpers names cache.
    * @private
    * @type array
    */
   _jstermHelpersCache: null,
   actorPrefix: "console",
   grip: function WCA_grip()
   {
     return { actor: this.actorID };
   },
   hasNativeConsoleAPI: function WCA_hasNativeConsoleAPI(aWindow) {
     let isNative = false;
     try {
       // We are very explicitly examining the "console" property of
       // the non-Xrayed object here.
       let console = aWindow.wrappedJSObject.console;
       isNative = console instanceof aWindow.Console;
     }
     catch (ex) { }
     return isNative;
   },
   _createValueGrip: ThreadActor.prototype.createValueGrip,
   _stringIsLong: ThreadActor.prototype._stringIsLong,
   _findProtoChain: ThreadActor.prototype._findProtoChain,
   _removeFromProtoChain: ThreadActor.prototype._removeFromProtoChain,
   /**
    * Destroy the current WebConsoleActor instance.
    */
   disconnect: function WCA_disconnect()
   {
     if (this.consoleServiceListener) {
       this.consoleServiceListener.destroy();
       this.consoleServiceListener = null;
     }
     if (this.consoleAPIListener) {
       this.consoleAPIListener.destroy();
       this.consoleAPIListener = null;
     }
     if (this.networkMonitor) {
       this.networkMonitor.destroy();
       this.networkMonitor = null;
     }
     if (this.consoleProgressListener) {
       this.consoleProgressListener.destroy();
       this.consoleProgressListener = null;
     }
     if (this.consoleReflowListener) {
       this.consoleReflowListener.destroy();
       this.consoleReflowListener = null;
     }
     this.conn.removeActorPool(this._actorPool);
     if (this.parentActor.isRootActor) {
       Services.obs.removeObserver(this._onObserverNotification,
                                   "last-pb-context-exited");
     }
     this._actorPool = null;
     this._jstermHelpersCache = null;
     this._evalWindow = null;
     this._netEvents.clear();
     this.dbg.enabled = false;
     this.dbg = null;
     this.conn = null;
   },
   /**
    * Create and return an environment actor that corresponds to the provided
    * Debugger.Environment. This is a straightforward clone of the ThreadActor's
    * method except that it stores the environment actor in the web console
    * actor's pool.
    *
    * @param Debugger.Environment aEnvironment
    *        The lexical environment we want to extract.
    * @return The EnvironmentActor for aEnvironment or undefined for host
    *         functions or functions scoped to a non-debuggee global.
    */
   createEnvironmentActor: function WCA_createEnvironmentActor(aEnvironment) {
     if (!aEnvironment) {
       return undefined;
     }
     if (aEnvironment.actor) {
       return aEnvironment.actor;
     }
     let actor = new EnvironmentActor(aEnvironment, this);
     this._actorPool.addActor(actor);
     aEnvironment.actor = actor;
     return actor;
   },
   /**
    * Create a grip for the given value.
    *
    * @param mixed aValue
    * @return object
    */
   createValueGrip: function WCA_createValueGrip(aValue)
   {
     return this._createValueGrip(aValue, this._actorPool);
   },
   /**
    * Make a debuggee value for the given value.
    *
    * @param mixed aValue
    *        The value you want to get a debuggee value for.
    * @param boolean aUseObjectGlobal
    *        If |true| the object global is determined and added as a debuggee,
    *        otherwise |this.window| is used when makeDebuggeeValue() is invoked.
    * @return object
    *         Debuggee value for |aValue|.
    */
   makeDebuggeeValue: function WCA_makeDebuggeeValue(aValue, aUseObjectGlobal)
   {
     let global = this.window;
     if (aUseObjectGlobal && typeof aValue == "object") {
       try {
         global = Cu.getGlobalForObject(aValue);
       }
       catch (ex) {
         // The above can throw an exception if aValue is not an actual object.
       }
     }
     let dbgGlobal = this.dbg.makeGlobalObjectReference(global);
     return dbgGlobal.makeDebuggeeValue(aValue);
   },
   /**
    * Create a grip for the given object.
    *
    * @param object aObject
    *        The object you want.
    * @param object aPool
    *        An ActorPool where the new actor instance is added.
    * @param object
    *        The object grip.
    */
   objectGrip: function WCA_objectGrip(aObject, aPool)
   {
     let actor = new ObjectActor(aObject, this);
     aPool.addActor(actor);
     return actor.grip();
   },
   /**
    * Create a grip for the given string.
    *
    * @param string aString
    *        The string you want to create the grip for.
    * @param object aPool
    *        An ActorPool where the new actor instance is added.
    * @return object
    *         A LongStringActor object that wraps the given string.
    */
   longStringGrip: function WCA_longStringGrip(aString, aPool)
   {
     let actor = new LongStringActor(aString, this);
     aPool.addActor(actor);
     return actor.grip();
   },
   /**
    * Create a long string grip if needed for the given string.
    *
    * @private
    * @param string aString
    *        The string you want to create a long string grip for.
    * @return string|object
    *         A string is returned if |aString| is not a long string.
    *         A LongStringActor grip is returned if |aString| is a long string.
    */
   _createStringGrip: function NEA__createStringGrip(aString)
   {
     if (aString && this._stringIsLong(aString)) {
       return this.longStringGrip(aString, this._actorPool);
     }
     return aString;
   },
   /**
    * Get an object actor by its ID.
    *
    * @param string aActorID
    * @return object
    */
   getActorByID: function WCA_getActorByID(aActorID)
   {
     return this._actorPool.get(aActorID);
   },
   /**
    * Release an actor.
    *
    * @param object aActor
    *        The actor instance you want to release.
    */
   releaseActor: function WCA_releaseActor(aActor)
   {
     this._actorPool.removeActor(aActor.actorID);
   },
   //////////////////
   // Request handlers for known packet types.
   //////////////////
   /**
    * Handler for the "startListeners" request.
    *
    * @param object aRequest
    *        The JSON request object received from the Web Console client.
    * @return object
    *         The response object which holds the startedListeners array.
    */
   onStartListeners: function WCA_onStartListeners(aRequest)
   {
     let startedListeners = [];
     let window = !this.parentActor.isRootActor ? this.window : null;
     let appId = null;
     let messageManager = null;
     if (this._parentIsContentActor) {
       appId = this.parentActor.docShell.appId;
       messageManager = this.parentActor.messageManager;
     }
     while (aRequest.listeners.length > 0) {
       let listener = aRequest.listeners.shift();
       switch (listener) {
         case "PageError":
           if (!this.consoleServiceListener) {
             this.consoleServiceListener =
               new ConsoleServiceListener(window, this);
             this.consoleServiceListener.init();
           }
           startedListeners.push(listener);
           break;
         case "ConsoleAPI":
           if (!this.consoleAPIListener) {
             this.consoleAPIListener =
               new ConsoleAPIListener(window, this);
             this.consoleAPIListener.init();
           }
           startedListeners.push(listener);
           break;
         case "NetworkActivity":
           if (!this.networkMonitor) {
             if (appId || messageManager) {
               this.networkMonitor =
                 new NetworkMonitorChild(appId, messageManager,
                                         this.parentActor.actorID, this);
             }
             else {
               this.networkMonitor = new NetworkMonitor({ window: window }, this);
             }
             this.networkMonitor.init();
           }
           startedListeners.push(listener);
           break;
         case "FileActivity":
           if (!this.consoleProgressListener) {
             this.consoleProgressListener =
               new ConsoleProgressListener(this.window, this);
           }
           this.consoleProgressListener.startMonitor(this.consoleProgressListener.
                                                     MONITOR_FILE_ACTIVITY);
           startedListeners.push(listener);
           break;
         case "ReflowActivity":
           if (!this.consoleReflowListener) {
             this.consoleReflowListener =
               new ConsoleReflowListener(this.window, this);
           }
           startedListeners.push(listener);
           break;
       }
     }
     return {
       startedListeners: startedListeners,
       nativeConsoleAPI: this.hasNativeConsoleAPI(this.window),
       traits: this.traits,
     };
   },
   /**
    * Handler for the "stopListeners" request.
    *
    * @param object aRequest
    *        The JSON request object received from the Web Console client.
    * @return object
    *         The response packet to send to the client: holds the
    *         stoppedListeners array.
    */
   onStopListeners: function WCA_onStopListeners(aRequest)
   {
     let stoppedListeners = [];
     // If no specific listeners are requested to be detached, we stop all
     // listeners.
     let toDetach = aRequest.listeners ||
                    ["PageError", "ConsoleAPI", "NetworkActivity",
                     "FileActivity"];
     while (toDetach.length > 0) {
       let listener = toDetach.shift();
       switch (listener) {
         case "PageError":
           if (this.consoleServiceListener) {
             this.consoleServiceListener.destroy();
             this.consoleServiceListener = null;
           }
           stoppedListeners.push(listener);
           break;
         case "ConsoleAPI":
           if (this.consoleAPIListener) {
             this.consoleAPIListener.destroy();
             this.consoleAPIListener = null;
           }
           stoppedListeners.push(listener);
           break;
         case "NetworkActivity":
           if (this.networkMonitor) {
             this.networkMonitor.destroy();
             this.networkMonitor = null;
           }
           stoppedListeners.push(listener);
           break;
         case "FileActivity":
           if (this.consoleProgressListener) {
             this.consoleProgressListener.stopMonitor(this.consoleProgressListener.
                                                      MONITOR_FILE_ACTIVITY);
             this.consoleProgressListener = null;
           }
           stoppedListeners.push(listener);
           break;
         case "ReflowActivity":
           if (this.consoleReflowListener) {
             this.consoleReflowListener.destroy();
             this.consoleReflowListener = null;
           }
           stoppedListeners.push(listener);
           break;
       }
     }
     return { stoppedListeners: stoppedListeners };
   },
   /**
    * Handler for the "getCachedMessages" request. This method sends the cached
    * error messages and the window.console API calls to the client.
    *
    * @param object aRequest
    *        The JSON request object received from the Web Console client.
    * @return object
    *         The response packet to send to the client: it holds the cached
    *         messages array.
    */
   onGetCachedMessages: function WCA_onGetCachedMessages(aRequest)
   {
     let types = aRequest.messageTypes;
     if (!types) {
       return {
         error: "missingParameter",
         message: "The messageTypes parameter is missing.",
       };
     }
     let messages = [];
     while (types.length > 0) {
       let type = types.shift();
       switch (type) {
         case "ConsoleAPI": {
           if (!this.consoleAPIListener) {
             break;
           }
           let cache = this.consoleAPIListener
                       .getCachedMessages(!this.parentActor.isRootActor);
           cache.forEach((aMessage) => {
             let message = this.prepareConsoleMessageForRemote(aMessage);
             message._type = type;
             messages.push(message);
           });
           break;
         }
         case "PageError": {
           if (!this.consoleServiceListener) {
             break;
           }
           let cache = this.consoleServiceListener
                       .getCachedMessages(!this.parentActor.isRootActor);
           cache.forEach((aMessage) => {
             let message = null;
             if (aMessage instanceof Ci.nsIScriptError) {
               message = this.preparePageErrorForRemote(aMessage);
               message._type = type;
             }
             else {
               message = {
                 _type: "LogMessage",
                 message: this._createStringGrip(aMessage.message),
                 timeStamp: aMessage.timeStamp,
               };
             }
             messages.push(message);
           });
           break;
         }
       }
     }
     messages.sort(function(a, b) { return a.timeStamp - b.timeStamp; });
     return {
       from: this.actorID,
       messages: messages,
     };
   },
   /**
    * Handler for the "evaluateJS" request. This method evaluates the given
    * JavaScript string and sends back the result.
    *
    * @param object aRequest
    *        The JSON request object received from the Web Console client.
    * @return object
    *         The evaluation response packet.
    */
   onEvaluateJS: function WCA_onEvaluateJS(aRequest)
   {
     let input = aRequest.text;
     let timestamp = Date.now();
     let evalOptions = {
       bindObjectActor: aRequest.bindObjectActor,
       frameActor: aRequest.frameActor,
       url: aRequest.url,
     };
     let evalInfo = this.evalWithDebugger(input, evalOptions);
     let evalResult = evalInfo.result;
     let helperResult = evalInfo.helperResult;
     let result, errorMessage, errorGrip = null;
     if (evalResult) {
       if ("return" in evalResult) {
         result = evalResult.return;
       }
       else if ("yield" in evalResult) {
         result = evalResult.yield;
       }
       else if ("throw" in evalResult) {
         let error = evalResult.throw;
         errorGrip = this.createValueGrip(error);
         let errorToString = evalInfo.window
                             .evalInGlobalWithBindings("ex + ''", {ex: error});
         if (errorToString && typeof errorToString.return == "string") {
           errorMessage = errorToString.return;
         }
       }
     }
     return {
       from: this.actorID,
       input: input,
       result: this.createValueGrip(result),
       timestamp: timestamp,
       exception: errorGrip,
       exceptionMessage: errorMessage,
       helperResult: helperResult,
     };
   },
   /**
    * The Autocomplete request handler.
    *
    * @param object aRequest
    *        The request message - what input to autocomplete.
    * @return object
    *         The response message - matched properties.
    */
   onAutocomplete: function WCA_onAutocomplete(aRequest)
   {
     let frameActorId = aRequest.frameActor;
     let dbgObject = null;
     let environment = null;
     // This is the case of the paused debugger
     if (frameActorId) {
       let frameActor = this.conn.getActor(frameActorId);
       if (frameActor) {
         let frame = frameActor.frame;
         environment = frame.environment;
       }
       else {
         Cu.reportError("Web Console Actor: the frame actor was not found: " +
                        frameActorId);
       }
     }
     // This is the general case (non-paused debugger)
     else {
       dbgObject = this.dbg.makeGlobalObjectReference(this.evalWindow);
     }
     let result = JSPropertyProvider(dbgObject, environment, aRequest.text,
                                     aRequest.cursor, frameActorId) || {};
     let matches = result.matches || [];
     let reqText = aRequest.text.substr(0, aRequest.cursor);
     // We consider '$' as alphanumerc because it is used in the names of some
     // helper functions.
     let lastNonAlphaIsDot = /[.][a-zA-Z0-9$]*$/.test(reqText);
     if (!lastNonAlphaIsDot) {
       if (!this._jstermHelpersCache) {
         let helpers = {
           sandbox: Object.create(null)
         };
         JSTermHelpers(helpers);
         this._jstermHelpersCache = Object.getOwnPropertyNames(helpers.sandbox);
       }
       matches = matches.concat(this._jstermHelpersCache.filter(n => n.startsWith(result.matchProp)));
     }
     return {
       from: this.actorID,
       matches: matches.sort(),
       matchProp: result.matchProp,
     };
   },
   /**
    * The "clearMessagesCache" request handler.
    */
   onClearMessagesCache: function WCA_onClearMessagesCache()
   {
     // TODO: Bug 717611 - Web Console clear button does not clear cached errors
     let windowId = !this.parentActor.isRootActor ?
                    WebConsoleUtils.getInnerWindowId(this.window) : null;
     let ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"]
                               .getService(Ci.nsIConsoleAPIStorage);
     ConsoleAPIStorage.clearEvents(windowId);
     if (this.parentActor.isRootActor) {
       Services.console.logStringMessage(null); // for the Error Console
       Services.console.reset();
     }
     return {};
   },
   /**
    * The "getPreferences" request handler.
    *
    * @param object aRequest
    *        The request message - which preferences need to be retrieved.
    * @return object
    *         The response message - a { key: value } object map.
    */
   onGetPreferences: function WCA_onGetPreferences(aRequest)
   {
     let prefs = Object.create(null);
     for (let key of aRequest.preferences) {
       prefs[key] = !!this._prefs[key];
     }
     return { preferences: prefs };
   },
   /**
    * The "setPreferences" request handler.
    *
    * @param object aRequest
    *        The request message - which preferences need to be updated.
    */
   onSetPreferences: function WCA_onSetPreferences(aRequest)
   {
     for (let key in aRequest.preferences) {
       this._prefs[key] = aRequest.preferences[key];
       if (key == "NetworkMonitor.saveRequestAndResponseBodies" &&
           this.networkMonitor) {
         this.networkMonitor.saveRequestAndResponseBodies = this._prefs[key];
       }
     }
     return { updated: Object.keys(aRequest.preferences) };
   },
   //////////////////
   // End of request handlers.
   //////////////////
   /**
    * Create an object with the API we expose to the Web Console during
    * JavaScript evaluation.
    * This object inherits properties and methods from the Web Console actor.
    *
    * @private
    * @param object aDebuggerGlobal
    *        A Debugger.Object that wraps a content global. This is used for the
    *        JSTerm helpers.
    * @return object
    *         The same object as |this|, but with an added |sandbox| property.
    *         The sandbox holds methods and properties that can be used as
    *         bindings during JS evaluation.
    */
   _getJSTermHelpers: function WCA__getJSTermHelpers(aDebuggerGlobal)
   {
     let helpers = {
       window: this.evalWindow,
       chromeWindow: this.chromeWindow.bind(this),
       makeDebuggeeValue: aDebuggerGlobal.makeDebuggeeValue.bind(aDebuggerGlobal),
       createValueGrip: this.createValueGrip.bind(this),
       sandbox: Object.create(null),
       helperResult: null,
       consoleActor: this,
     };
     JSTermHelpers(helpers);
     // Make sure the helpers can be used during eval.
     for (let name in helpers.sandbox) {
       let desc = Object.getOwnPropertyDescriptor(helpers.sandbox, name);
       if (desc.get || desc.set) {
         continue;
       }
       helpers.sandbox[name] = aDebuggerGlobal.makeDebuggeeValue(desc.value);
     }
     return helpers;
   },
   /**
    * Evaluates a string using the debugger API.
    *
    * To allow the variables view to update properties from the Web Console we
    * provide the "bindObjectActor" mechanism: the Web Console tells the
    * ObjectActor ID for which it desires to evaluate an expression. The
    * Debugger.Object pointed at by the actor ID is bound such that it is
    * available during expression evaluation (evalInGlobalWithBindings()).
    *
    * Example:
    *   _self['foobar'] = 'test'
    * where |_self| refers to the desired object.
    *
    * The |frameActor| property allows the Web Console client to provide the
    * frame actor ID, such that the expression can be evaluated in the
    * user-selected stack frame.
    *
    * For the above to work we need the debugger and the Web Console to share
    * a connection, otherwise the Web Console actor will not find the frame
    * actor.
    *
    * The Debugger.Frame comes from the jsdebugger's Debugger instance, which
    * is different from the Web Console's Debugger instance. This means that
    * for evaluation to work, we need to create a new instance for the jsterm
    * helpers - they need to be Debugger.Objects coming from the jsdebugger's
    * Debugger instance.
    *
    * When |bindObjectActor| is used objects can come from different iframes,
    * from different domains. To avoid permission-related errors when objects
    * come from a different window, we also determine the object's own global,
    * such that evaluation happens in the context of that global. This means that
    * evaluation will happen in the object's iframe, rather than the top level
    * window.
    *
    * @param string aString
    *        String to evaluate.
    * @param object [aOptions]
    *        Options for evaluation:
    *        - bindObjectActor: the ObjectActor ID to use for evaluation.
    *          |evalWithBindings()| will be called with one additional binding:
    *          |_self| which will point to the Debugger.Object of the given
    *          ObjectActor.
    *        - frameActor: the FrameActor ID to use for evaluation. The given
    *        debugger frame is used for evaluation, instead of the global window.
    * @return object
    *         An object that holds the following properties:
    *         - dbg: the debugger where the string was evaluated.
    *         - frame: (optional) the frame where the string was evaluated.
    *         - window: the Debugger.Object for the global where the string was
    *         evaluated.
    *         - result: the result of the evaluation.
    *         - helperResult: any result coming from a JSTerm helper function.
    *         - url: the url to evaluate the script as. Defaults to
    *         "debugger eval code".
    */
   evalWithDebugger: function WCA_evalWithDebugger(aString, aOptions = {})
   {
     // The help function needs to be easy to guess, so we make the () optional.
     if (aString.trim() == "help" || aString.trim() == "?") {
       aString = "help()";
     }
     // Find the Debugger.Frame of the given FrameActor.
     let frame = null, frameActor = null;
     if (aOptions.frameActor) {
       frameActor = this.conn.getActor(aOptions.frameActor);
       if (frameActor) {
         frame = frameActor.frame;
       }
       else {
         Cu.reportError("Web Console Actor: the frame actor was not found: " +
                        aOptions.frameActor);
       }
     }
     // If we've been given a frame actor in whose scope we should evaluate the
     // expression, be sure to use that frame's Debugger (that is, the JavaScript
     // debugger's Debugger) for the whole operation, not the console's Debugger.
     // (One Debugger will treat a different Debugger's Debugger.Object instances
     // as ordinary objects, not as references to be followed, so mixing
     // debuggers causes strange behaviors.)
     let dbg = frame ? frameActor.threadActor.dbg : this.dbg;
     let dbgWindow = dbg.makeGlobalObjectReference(this.evalWindow);
     // If we have an object to bind to |_self|, create a Debugger.Object
     // referring to that object, belonging to dbg.
     let bindSelf = null;
     let dbgWindow = dbg.makeGlobalObjectReference(this.evalWindow);
     if (aOptions.bindObjectActor) {
       let objActor = this.getActorByID(aOptions.bindObjectActor);
       if (objActor) {
         let jsObj = objActor.obj.unsafeDereference();
         // If we use the makeDebuggeeValue method of jsObj's own global, then
         // we'll get a D.O that sees jsObj as viewed from its own compartment -
         // that is, without wrappers. The evalWithBindings call will then wrap
         // jsObj appropriately for the evaluation compartment.
         let global = Cu.getGlobalForObject(jsObj);
         dbgWindow = dbg.makeGlobalObjectReference(global);
         bindSelf = dbgWindow.makeDebuggeeValue(jsObj);
       }
     }
     // Get the JSTerm helpers for the given debugger window.
     let helpers = this._getJSTermHelpers(dbgWindow);
     let bindings = helpers.sandbox;
     if (bindSelf) {
       bindings._self = bindSelf;
     }
     // Check if the Debugger.Frame or Debugger.Object for the global include
     // $ or $$. We will not overwrite these functions with the jsterm helpers.
     let found$ = false, found$$ = false;
     if (frame) {
       let env = frame.environment;
       if (env) {
         found$ = !!env.find("$");
         found$$ = !!env.find("$$");
       }
     }
     else {
       found$ = !!dbgWindow.getOwnPropertyDescriptor("$");
       found$$ = !!dbgWindow.getOwnPropertyDescriptor("$$");
     }
     let $ = null, $$ = null;
     if (found$) {
       $ = bindings.$;
       delete bindings.$;
     }
     if (found$$) {
       $$ = bindings.$$;
       delete bindings.$$;
     }
     // Ready to evaluate the string.
     helpers.evalInput = aString;
     let evalOptions;
     if (typeof aOptions.url == "string") {
       evalOptions = { url: aOptions.url };
     }
     let result;
     if (frame) {
       result = frame.evalWithBindings(aString, bindings, evalOptions);
     }
     else {
       result = dbgWindow.evalInGlobalWithBindings(aString, bindings, evalOptions);
     }
     let helperResult = helpers.helperResult;
     delete helpers.evalInput;
     delete helpers.helperResult;
     if ($) {
       bindings.$ = $;
     }
     if ($$) {
       bindings.$$ = $$;
     }
     if (bindings._self) {
       delete bindings._self;
     }
     return {
       result: result,
       helperResult: helperResult,
       dbg: dbg,
       frame: frame,
       window: dbgWindow,
     };
   },
   //////////////////
   // Event handlers for various listeners.
   //////////////////
   /**
    * Handler for messages received from the ConsoleServiceListener. This method
    * sends the nsIConsoleMessage to the remote Web Console client.
    *
    * @param nsIConsoleMessage aMessage
    *        The message we need to send to the client.
    */
   onConsoleServiceMessage: function WCA_onConsoleServiceMessage(aMessage)
   {
     let packet;
     if (aMessage instanceof Ci.nsIScriptError) {
       packet = {
         from: this.actorID,
         type: "pageError",
         pageError: this.preparePageErrorForRemote(aMessage),
       };
     }
     else {
       packet = {
         from: this.actorID,
         type: "logMessage",
         message: this._createStringGrip(aMessage.message),
         timeStamp: aMessage.timeStamp,
       };
     }
     this.conn.send(packet);
   },
   /**
    * Prepare an nsIScriptError to be sent to the client.
    *
    * @param nsIScriptError aPageError
    *        The page error we need to send to the client.
    * @return object
    *         The object you can send to the remote client.
    */
   preparePageErrorForRemote: function WCA_preparePageErrorForRemote(aPageError)
   {
     let lineText = aPageError.sourceLine;
     if (lineText && lineText.length > DebuggerServer.LONG_STRING_INITIAL_LENGTH) {
       lineText = lineText.substr(0, DebuggerServer.LONG_STRING_INITIAL_LENGTH);
     }
     return {
       errorMessage: this._createStringGrip(aPageError.errorMessage),
       sourceName: aPageError.sourceName,
       lineText: lineText,
       lineNumber: aPageError.lineNumber,
       columnNumber: aPageError.columnNumber,
       category: aPageError.category,
       timeStamp: aPageError.timeStamp,
       warning: !!(aPageError.flags & aPageError.warningFlag),
       error: !!(aPageError.flags & aPageError.errorFlag),
       exception: !!(aPageError.flags & aPageError.exceptionFlag),
       strict: !!(aPageError.flags & aPageError.strictFlag),
       private: aPageError.isFromPrivateWindow,
     };
   },
   /**
    * Handler for window.console API calls received from the ConsoleAPIListener.
    * This method sends the object to the remote Web Console client.
    *
    * @see ConsoleAPIListener
    * @param object aMessage
    *        The console API call we need to send to the remote client.
    */
   onConsoleAPICall: function WCA_onConsoleAPICall(aMessage)
   {
     let packet = {
       from: this.actorID,
       type: "consoleAPICall",
       message: this.prepareConsoleMessageForRemote(aMessage),
     };
     this.conn.send(packet);
   },
   /**
    * Handler for network events. This method is invoked when a new network event
    * is about to be recorded.
    *
    * @see NetworkEventActor
    * @see NetworkMonitor from webconsole/utils.js
    *
    * @param object aEvent
    *        The initial network request event information.
    * @param nsIHttpChannel aChannel
    *        The network request nsIHttpChannel object.
    * @return object
    *         A new NetworkEventActor is returned. This is used for tracking the
    *         network request and response.
    */
   onNetworkEvent: function WCA_onNetworkEvent(aEvent, aChannel)
   {
     let actor = this.getNetworkEventActor(aChannel);
     actor.init(aEvent);
     let packet = {
       from: this.actorID,
       type: "networkEvent",
       eventActor: actor.grip(),
     };
     this.conn.send(packet);
     return actor;
   },
   /**
    * Get the NetworkEventActor for a nsIChannel, if it exists,
    * otherwise create a new one.
    *
    * @param nsIHttpChannel aChannel
    *        The channel for the network event.
    * @return object
    *         The NetworkEventActor for the given channel.
    */
   getNetworkEventActor: function WCA_getNetworkEventActor(aChannel) {
     let actor = this._netEvents.get(aChannel);
     if (actor) {
       // delete from map as we should only need to do this check once
       this._netEvents.delete(aChannel);
       actor.channel = null;
       return actor;
     }
     actor = new NetworkEventActor(aChannel, this);
     this._actorPool.addActor(actor);
     return actor;
   },
   /**
    * Send a new HTTP request from the target's window.
    *
    * @param object aMessage
    *        Object with 'request' - the HTTP request details.
    */
   onSendHTTPRequest: function WCA_onSendHTTPRequest(aMessage)
   {
     let details = aMessage.request;
     // send request from target's window
     let request = new this.window.XMLHttpRequest();
     request.open(details.method, details.url, true);
     for (let {name, value} of details.headers) {
       request.setRequestHeader(name, value);
     }
     request.send(details.body);
     let actor = this.getNetworkEventActor(request.channel);
     // map channel to actor so we can associate future events with it
     this._netEvents.set(request.channel, actor);
     return {
       from: this.actorID,
       eventActor: actor.grip()
     };
   },
   /**
    * Handler for file activity. This method sends the file request information
    * to the remote Web Console client.
    *
    * @see ConsoleProgressListener
    * @param string aFileURI
    *        The requested file URI.
    */
   onFileActivity: function WCA_onFileActivity(aFileURI)
   {
     let packet = {
       from: this.actorID,
       type: "fileActivity",
       uri: aFileURI,
     };
     this.conn.send(packet);
   },
   /**
    * Handler for reflow activity. This method forwards reflow events to the
    * remote Web Console client.
    *
    * @see ConsoleReflowListener
    * @param Object aReflowInfo
    */
   onReflowActivity: function WCA_onReflowActivity(aReflowInfo)
   {
     let packet = {
       from: this.actorID,
       type: "reflowActivity",
       interruptible: aReflowInfo.interruptible,
       start: aReflowInfo.start,
       end: aReflowInfo.end,
       sourceURL: aReflowInfo.sourceURL,
       sourceLine: aReflowInfo.sourceLine,
       functionName: aReflowInfo.functionName
     };
     this.conn.send(packet);
   },
   //////////////////
   // End of event handlers for various listeners.
   //////////////////
   /**
    * Prepare a message from the console API to be sent to the remote Web Console
    * instance.
    *
    * @param object aMessage
    *        The original message received from console-api-log-event.
    * @return object
    *         The object that can be sent to the remote client.
    */
   prepareConsoleMessageForRemote:
   function WCA_prepareConsoleMessageForRemote(aMessage)
   {
     let result = WebConsoleUtils.cloneObject(aMessage);
     delete result.wrappedJSObject;
     delete result.ID;
     delete result.innerID;
     result.arguments = Array.map(aMessage.arguments || [], (aObj) => {
       let dbgObj = this.makeDebuggeeValue(aObj, true);
       return this.createValueGrip(dbgObj);
     });
     result.styles = Array.map(aMessage.styles || [], (aString) => {
       return this.createValueGrip(aString);
     });
     return result;
   },
   /**
    * Find the XUL window that owns the content window.
    *
    * @return Window
    *         The XUL window that owns the content window.
    */
   chromeWindow: function WCA_chromeWindow()
   {
     let window = null;
     try {
       window = this.window.QueryInterface(Ci.nsIInterfaceRequestor)
              .getInterface(Ci.nsIWebNavigation).QueryInterface(Ci.nsIDocShell)
              .chromeEventHandler.ownerDocument.defaultView;
     }
     catch (ex) {
       // The above can fail because chromeEventHandler is not available for all
       // kinds of |this.window|.
     }
     return window;
   },
   /**
    * Notification observer for the "last-pb-context-exited" topic.
    *
    * @private
    * @param object aSubject
    *        Notification subject - in this case it is the inner window ID that
    *        was destroyed.
    * @param string aTopic
    *        Notification topic.
    */
   _onObserverNotification: function WCA__onObserverNotification(aSubject, aTopic)
   {
     switch (aTopic) {
       case "last-pb-context-exited":
         this.conn.send({
           from: this.actorID,
           type: "lastPrivateContextExited",
         });
         break;
     }
   },
   /**
    * The "will-navigate" progress listener. This is used to clear the current
    * eval scope.
    */
   _onWillNavigate: function WCA__onWillNavigate({ window, isTopLevel })
   {
     if (isTopLevel) {
       this._evalWindow = null;
       events.off(this.parentActor, "will-navigate", this._onWillNavigate);
       this._progressListenerActive = false;
     }
   },
 };
 WebConsoleActor.prototype.requestTypes =
 {
   startListeners: WebConsoleActor.prototype.onStartListeners,
   stopListeners: WebConsoleActor.prototype.onStopListeners,
   getCachedMessages: WebConsoleActor.prototype.onGetCachedMessages,
   evaluateJS: WebConsoleActor.prototype.onEvaluateJS,
   autocomplete: WebConsoleActor.prototype.onAutocomplete,
   clearMessagesCache: WebConsoleActor.prototype.onClearMessagesCache,
   getPreferences: WebConsoleActor.prototype.onGetPreferences,
   setPreferences: WebConsoleActor.prototype.onSetPreferences,
   sendHTTPRequest: WebConsoleActor.prototype.onSendHTTPRequest
 };
 /**
  * Creates an actor for a network event.
  *
  * @constructor
  * @param object aChannel
  *        The nsIChannel associated with this event.
  * @param object aWebConsoleActor
  *        The parent WebConsoleActor instance for this object.
  */
 function NetworkEventActor(aChannel, aWebConsoleActor)
 {
   this.parent = aWebConsoleActor;
   this.conn = this.parent.conn;
   this.channel = aChannel;
   this._request = {
     method: null,
     url: null,
     httpVersion: null,
     headers: [],
     cookies: [],
     headersSize: null,
     postData: {},
   };
   this._response = {
     headers: [],
     cookies: [],
     content: {},
   };
   this._timings = {};
   // Keep track of LongStringActors owned by this NetworkEventActor.
   this._longStringActors = new Set();
 }
 NetworkEventActor.prototype =
 {
   _request: null,
   _response: null,
   _timings: null,
   _longStringActors: null,
   actorPrefix: "netEvent",
   /**
    * Returns a grip for this actor for returning in a protocol message.
    */
   grip: function NEA_grip()
   {
     return {
       actor: this.actorID,
       startedDateTime: this._startedDateTime,
       url: this._request.url,
       method: this._request.method,
       isXHR: this._isXHR,
       private: this._private,
     };
   },
   /**
    * Releases this actor from the pool.
    */
   release: function NEA_release()
   {
     for (let grip of this._longStringActors) {
       let actor = this.parent.getActorByID(grip.actor);
       if (actor) {
         this.parent.releaseActor(actor);
       }
     }
     this._longStringActors = new Set();
     if (this.channel) {
       this.parent._netEvents.delete(this.channel);
     }
     this.parent.releaseActor(this);
   },
   /**
    * Handle a protocol request to release a grip.
    */
   onRelease: function NEA_onRelease()
   {
     this.release();
     return {};
   },
   /**
    * Set the properties of this actor based on it's corresponding
    * network event.
    *
    * @param object aNetworkEvent
    *        The network event associated with this actor.
    */
   init: function NEA_init(aNetworkEvent)
   {
     this._startedDateTime = aNetworkEvent.startedDateTime;
     this._isXHR = aNetworkEvent.isXHR;
     for (let prop of ['method', 'url', 'httpVersion', 'headersSize']) {
       this._request[prop] = aNetworkEvent[prop];
     }
     this._discardRequestBody = aNetworkEvent.discardRequestBody;
     this._discardResponseBody = aNetworkEvent.discardResponseBody;
     this._private = aNetworkEvent.private;
   },
   /**
    * The "getRequestHeaders" packet type handler.
    *
    * @return object
    *         The response packet - network request headers.
    */
   onGetRequestHeaders: function NEA_onGetRequestHeaders()
   {
     return {
       from: this.actorID,
       headers: this._request.headers,
       headersSize: this._request.headersSize,
     };
   },
   /**
    * The "getRequestCookies" packet type handler.
    *
    * @return object
    *         The response packet - network request cookies.
    */
   onGetRequestCookies: function NEA_onGetRequestCookies()
   {
     return {
       from: this.actorID,
       cookies: this._request.cookies,
     };
   },
   /**
    * The "getRequestPostData" packet type handler.
    *
    * @return object
    *         The response packet - network POST data.
    */
   onGetRequestPostData: function NEA_onGetRequestPostData()
   {
     return {
       from: this.actorID,
       postData: this._request.postData,
       postDataDiscarded: this._discardRequestBody,
     };
   },
   /**
    * The "getResponseHeaders" packet type handler.
    *
    * @return object
    *         The response packet - network response headers.
    */
   onGetResponseHeaders: function NEA_onGetResponseHeaders()
   {
     return {
       from: this.actorID,
       headers: this._response.headers,
       headersSize: this._response.headersSize,
     };
   },
   /**
    * The "getResponseCookies" packet type handler.
    *
    * @return object
    *         The response packet - network response cookies.
    */
   onGetResponseCookies: function NEA_onGetResponseCookies()
   {
     return {
       from: this.actorID,
       cookies: this._response.cookies,
     };
   },
   /**
    * The "getResponseContent" packet type handler.
    *
    * @return object
    *         The response packet - network response content.
    */
   onGetResponseContent: function NEA_onGetResponseContent()
   {
     return {
       from: this.actorID,
       content: this._response.content,
       contentDiscarded: this._discardResponseBody,
     };
   },
   /**
    * The "getEventTimings" packet type handler.
    *
    * @return object
    *         The response packet - network event timings.
    */
   onGetEventTimings: function NEA_onGetEventTimings()
   {
     return {
       from: this.actorID,
       timings: this._timings,
       totalTime: this._totalTime,
     };
   },
   /******************************************************************
    * Listeners for new network event data coming from NetworkMonitor.
    ******************************************************************/
   /**
    * Add network request headers.
    *
    * @param array aHeaders
    *        The request headers array.
    */
   addRequestHeaders: function NEA_addRequestHeaders(aHeaders)
   {
     this._request.headers = aHeaders;
     this._prepareHeaders(aHeaders);
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "requestHeaders",
       headers: aHeaders.length,
       headersSize: this._request.headersSize,
     };
     this.conn.send(packet);
   },
   /**
    * Add network request cookies.
    *
    * @param array aCookies
    *        The request cookies array.
    */
   addRequestCookies: function NEA_addRequestCookies(aCookies)
   {
     this._request.cookies = aCookies;
     this._prepareHeaders(aCookies);
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "requestCookies",
       cookies: aCookies.length,
     };
     this.conn.send(packet);
   },
   /**
    * Add network request POST data.
    *
    * @param object aPostData
    *        The request POST data.
    */
   addRequestPostData: function NEA_addRequestPostData(aPostData)
   {
     this._request.postData = aPostData;
     aPostData.text = this.parent._createStringGrip(aPostData.text);
     if (typeof aPostData.text == "object") {
       this._longStringActors.add(aPostData.text);
     }
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "requestPostData",
       dataSize: aPostData.text.length,
       discardRequestBody: this._discardRequestBody,
     };
     this.conn.send(packet);
   },
   /**
    * Add the initial network response information.
    *
    * @param object aInfo
    *        The response information.
    */
   addResponseStart: function NEA_addResponseStart(aInfo)
   {
     this._response.httpVersion = aInfo.httpVersion;
     this._response.status = aInfo.status;
     this._response.statusText = aInfo.statusText;
     this._response.headersSize = aInfo.headersSize;
     this._discardResponseBody = aInfo.discardResponseBody;
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "responseStart",
       response: aInfo,
     };
     this.conn.send(packet);
   },
   /**
    * Add network response headers.
    *
    * @param array aHeaders
    *        The response headers array.
    */
   addResponseHeaders: function NEA_addResponseHeaders(aHeaders)
   {
     this._response.headers = aHeaders;
     this._prepareHeaders(aHeaders);
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "responseHeaders",
       headers: aHeaders.length,
       headersSize: this._response.headersSize,
     };
     this.conn.send(packet);
   },
   /**
    * Add network response cookies.
    *
    * @param array aCookies
    *        The response cookies array.
    */
   addResponseCookies: function NEA_addResponseCookies(aCookies)
   {
     this._response.cookies = aCookies;
     this._prepareHeaders(aCookies);
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "responseCookies",
       cookies: aCookies.length,
     };
     this.conn.send(packet);
   },
   /**
    * Add network response content.
    *
    * @param object aContent
    *        The response content.
    * @param boolean aDiscardedResponseBody
    *        Tells if the response content was recorded or not.
    */
   addResponseContent:
   function NEA_addResponseContent(aContent, aDiscardedResponseBody)
   {
     this._response.content = aContent;
     aContent.text = this.parent._createStringGrip(aContent.text);
     if (typeof aContent.text == "object") {
       this._longStringActors.add(aContent.text);
     }
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "responseContent",
       mimeType: aContent.mimeType,
       contentSize: aContent.text.length,
       discardResponseBody: aDiscardedResponseBody,
     };
     this.conn.send(packet);
   },
   /**
    * Add network event timing information.
    *
    * @param number aTotal
    *        The total time of the network event.
    * @param object aTimings
    *        Timing details about the network event.
    */
   addEventTimings: function NEA_addEventTimings(aTotal, aTimings)
   {
     this._totalTime = aTotal;
     this._timings = aTimings;
     let packet = {
       from: this.actorID,
       type: "networkEventUpdate",
       updateType: "eventTimings",
       totalTime: aTotal,
     };
     this.conn.send(packet);
   },
   /**
    * Prepare the headers array to be sent to the client by using the
    * LongStringActor for the header values, when needed.
    *
    * @private
    * @param array aHeaders
    */
   _prepareHeaders: function NEA__prepareHeaders(aHeaders)
   {
     for (let header of aHeaders) {
       header.value = this.parent._createStringGrip(header.value);
       if (typeof header.value == "object") {
         this._longStringActors.add(header.value);
       }
     }
   },
 };
 NetworkEventActor.prototype.requestTypes =
 {
   "release": NetworkEventActor.prototype.onRelease,
   "getRequestHeaders": NetworkEventActor.prototype.onGetRequestHeaders,
   "getRequestCookies": NetworkEventActor.prototype.onGetRequestCookies,
   "getRequestPostData": NetworkEventActor.prototype.onGetRequestPostData,
   "getResponseHeaders": NetworkEventActor.prototype.onGetResponseHeaders,
   "getResponseCookies": NetworkEventActor.prototype.onGetResponseCookies,
   "getResponseContent": NetworkEventActor.prototype.onGetResponseContent,
   "getEventTimings": NetworkEventActor.prototype.onGetEventTimings,
 };
 exports.register = function(handle) {
   handle.addGlobalActor(WebConsoleActor, "consoleActor");
   handle.addTabActor(WebConsoleActor, "consoleActor");
 };
 exports.unregister = function(handle) {
   handle.removeGlobalActor(WebConsoleActor, "consoleActor");
   handle.removeTabActor(WebConsoleActor, "consoleActor");
 };