Add m-esr52 at 52.6.0

1 files changed, 652 insertions, 0 deletions

diff --git a/devtools/shared/webconsole/client.js b/devtools/shared/webconsole/client.js
new file mode 100644
index 000000000..4cc5deedf
--- /dev/null
+++ b/devtools/shared/webconsole/client.js
@@ -0,0 +1,652 @@
+/* -*- 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";
+
+const DevToolsUtils = require("devtools/shared/DevToolsUtils");
+const EventEmitter = require("devtools/shared/event-emitter");
+const promise = require("promise");
+const defer = require("devtools/shared/defer");
+const {LongStringClient} = require("devtools/shared/client/main");
+
+/**
+ * A WebConsoleClient is used as a front end for the WebConsoleActor that is
+ * created on the server, hiding implementation details.
+ *
+ * @param object debuggerClient
+ *        The DebuggerClient instance we live for.
+ * @param object response
+ *        The response packet received from the "startListeners" request sent to
+ *        the WebConsoleActor.
+ */
+function WebConsoleClient(debuggerClient, response) {
+  this._actor = response.from;
+  this._client = debuggerClient;
+  this._longStrings = {};
+  this.traits = response.traits || {};
+  this.events = [];
+  this._networkRequests = new Map();
+
+  this.pendingEvaluationResults = new Map();
+  this.onEvaluationResult = this.onEvaluationResult.bind(this);
+  this.onNetworkEvent = this._onNetworkEvent.bind(this);
+  this.onNetworkEventUpdate = this._onNetworkEventUpdate.bind(this);
+
+  this._client.addListener("evaluationResult", this.onEvaluationResult);
+  this._client.addListener("networkEvent", this.onNetworkEvent);
+  this._client.addListener("networkEventUpdate", this.onNetworkEventUpdate);
+  EventEmitter.decorate(this);
+}
+
+exports.WebConsoleClient = WebConsoleClient;
+
+WebConsoleClient.prototype = {
+  _longStrings: null,
+  traits: null,
+
+  /**
+   * Holds the network requests currently displayed by the Web Console. Each key
+   * represents the connection ID and the value is network request information.
+   * @private
+   * @type object
+   */
+  _networkRequests: null,
+
+  getNetworkRequest(actorId) {
+    return this._networkRequests.get(actorId);
+  },
+
+  hasNetworkRequest(actorId) {
+    return this._networkRequests.has(actorId);
+  },
+
+  removeNetworkRequest(actorId) {
+    this._networkRequests.delete(actorId);
+  },
+
+  getNetworkEvents() {
+    return this._networkRequests.values();
+  },
+
+  get actor() {
+    return this._actor;
+  },
+
+  /**
+   * The "networkEvent" message type handler. We redirect any message to
+   * the UI for displaying.
+   *
+   * @private
+   * @param string type
+   *        Message type.
+   * @param object packet
+   *        The message received from the server.
+   */
+  _onNetworkEvent: function (type, packet) {
+    if (packet.from == this._actor) {
+      let actor = packet.eventActor;
+      let networkInfo = {
+        _type: "NetworkEvent",
+        timeStamp: actor.timeStamp,
+        node: null,
+        actor: actor.actor,
+        discardRequestBody: true,
+        discardResponseBody: true,
+        startedDateTime: actor.startedDateTime,
+        request: {
+          url: actor.url,
+          method: actor.method,
+        },
+        isXHR: actor.isXHR,
+        cause: actor.cause,
+        response: {},
+        timings: {},
+        // track the list of network event updates
+        updates: [],
+        private: actor.private,
+        fromCache: actor.fromCache,
+        fromServiceWorker: actor.fromServiceWorker
+      };
+      this._networkRequests.set(actor.actor, networkInfo);
+
+      this.emit("networkEvent", networkInfo);
+    }
+  },
+
+  /**
+   * The "networkEventUpdate" message type handler. We redirect any message to
+   * the UI for displaying.
+   *
+   * @private
+   * @param string type
+   *        Message type.
+   * @param object packet
+   *        The message received from the server.
+   */
+  _onNetworkEventUpdate: function (type, packet) {
+    let networkInfo = this.getNetworkRequest(packet.from);
+    if (!networkInfo) {
+      return;
+    }
+
+    networkInfo.updates.push(packet.updateType);
+
+    switch (packet.updateType) {
+      case "requestHeaders":
+        networkInfo.request.headersSize = packet.headersSize;
+        break;
+      case "requestPostData":
+        networkInfo.discardRequestBody = packet.discardRequestBody;
+        networkInfo.request.bodySize = packet.dataSize;
+        break;
+      case "responseStart":
+        networkInfo.response.httpVersion = packet.response.httpVersion;
+        networkInfo.response.status = packet.response.status;
+        networkInfo.response.statusText = packet.response.statusText;
+        networkInfo.response.headersSize = packet.response.headersSize;
+        networkInfo.response.remoteAddress = packet.response.remoteAddress;
+        networkInfo.response.remotePort = packet.response.remotePort;
+        networkInfo.discardResponseBody = packet.response.discardResponseBody;
+        break;
+      case "responseContent":
+        networkInfo.response.content = {
+          mimeType: packet.mimeType,
+        };
+        networkInfo.response.bodySize = packet.contentSize;
+        networkInfo.response.transferredSize = packet.transferredSize;
+        networkInfo.discardResponseBody = packet.discardResponseBody;
+        break;
+      case "eventTimings":
+        networkInfo.totalTime = packet.totalTime;
+        break;
+      case "securityInfo":
+        networkInfo.securityInfo = packet.state;
+        break;
+    }
+
+    this.emit("networkEventUpdate", {
+      packet: packet,
+      networkInfo
+    });
+  },
+
+  /**
+   * Retrieve the cached messages from the server.
+   *
+   * @see this.CACHED_MESSAGES
+   * @param array types
+   *        The array of message types you want from the server. See
+   *        this.CACHED_MESSAGES for known types.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getCachedMessages: function (types, onResponse) {
+    let packet = {
+      to: this._actor,
+      type: "getCachedMessages",
+      messageTypes: types,
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Inspect the properties of an object.
+   *
+   * @param string actor
+   *        The WebConsoleObjectActor ID to send the request to.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  inspectObjectProperties: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "inspectProperties",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Evaluate a JavaScript expression.
+   *
+   * @param string string
+   *        The code you want to evaluate.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   * @param object [options={}]
+   *        Options for evaluation:
+   *
+   *        - bindObjectActor: an ObjectActor ID. The OA holds a reference to
+   *        a Debugger.Object that wraps a content object. This option allows
+   *        you to bind |_self| to the D.O of the given OA, during string
+   *        evaluation.
+   *
+   *        See: Debugger.Object.executeInGlobalWithBindings() for information
+   *        about bindings.
+   *
+   *        Use case: the variable view needs to update objects and it does so
+   *        by knowing the ObjectActor it inspects and binding |_self| to the
+   *        D.O of the OA. As such, variable view sends strings like these for
+   *        eval:
+   *          _self["prop"] = value;
+   *
+   *        - frameActor: a FrameActor ID. The FA holds a reference to
+   *        a Debugger.Frame. This option allows you to evaluate the string in
+   *        the frame of the given FA.
+   *
+   *        - url: the url to evaluate the script as. Defaults to
+   *        "debugger eval code".
+   *
+   *        - selectedNodeActor: the NodeActor ID of the current
+   *        selection in the Inspector, if such a selection
+   *        exists. This is used by helper functions that can
+   *        reference the currently selected node in the Inspector,
+   *        like $0.
+   */
+  evaluateJS: function (string, onResponse, options = {}) {
+    let packet = {
+      to: this._actor,
+      type: "evaluateJS",
+      text: string,
+      bindObjectActor: options.bindObjectActor,
+      frameActor: options.frameActor,
+      url: options.url,
+      selectedNodeActor: options.selectedNodeActor,
+      selectedObjectActor: options.selectedObjectActor,
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Evaluate a JavaScript expression asynchronously.
+   * See evaluateJS for parameter and response information.
+   */
+  evaluateJSAsync: function (string, onResponse, options = {}) {
+    // Pre-37 servers don't support async evaluation.
+    if (!this.traits.evaluateJSAsync) {
+      this.evaluateJS(string, onResponse, options);
+      return;
+    }
+
+    let packet = {
+      to: this._actor,
+      type: "evaluateJSAsync",
+      text: string,
+      bindObjectActor: options.bindObjectActor,
+      frameActor: options.frameActor,
+      url: options.url,
+      selectedNodeActor: options.selectedNodeActor,
+      selectedObjectActor: options.selectedObjectActor,
+    };
+
+    this._client.request(packet, response => {
+      // Null check this in case the client has been detached while waiting
+      // for a response.
+      if (this.pendingEvaluationResults) {
+        this.pendingEvaluationResults.set(response.resultID, onResponse);
+      }
+    });
+  },
+
+  /**
+   * Handler for the actors's unsolicited evaluationResult packet.
+   */
+  onEvaluationResult: function (notification, packet) {
+    // The client on the main thread can receive notification packets from
+    // multiple webconsole actors: the one on the main thread and the ones
+    // on worker threads.  So make sure we should be handling this request.
+    if (packet.from !== this._actor) {
+      return;
+    }
+
+    // Find the associated callback based on this ID, and fire it.
+    // In a sync evaluation, this would have already been called in
+    // direct response to the client.request function.
+    let onResponse = this.pendingEvaluationResults.get(packet.resultID);
+    if (onResponse) {
+      onResponse(packet);
+      this.pendingEvaluationResults.delete(packet.resultID);
+    } else {
+      DevToolsUtils.reportException("onEvaluationResult",
+        "No response handler for an evaluateJSAsync result (resultID: " +
+                                    packet.resultID + ")");
+    }
+  },
+
+  /**
+   * Autocomplete a JavaScript expression.
+   *
+   * @param string string
+   *        The code you want to autocomplete.
+   * @param number cursor
+   *        Cursor location inside the string. Index starts from 0.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   * @param string frameActor
+   *        The id of the frame actor that made the call.
+   */
+  autocomplete: function (string, cursor, onResponse, frameActor) {
+    let packet = {
+      to: this._actor,
+      type: "autocomplete",
+      text: string,
+      cursor: cursor,
+      frameActor: frameActor,
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Clear the cache of messages (page errors and console API calls).
+   */
+  clearMessagesCache: function () {
+    let packet = {
+      to: this._actor,
+      type: "clearMessagesCache",
+    };
+    this._client.request(packet);
+  },
+
+  /**
+   * Get Web Console-related preferences on the server.
+   *
+   * @param array preferences
+   *        An array with the preferences you want to retrieve.
+   * @param function [onResponse]
+   *        Optional function to invoke when the response is received.
+   */
+  getPreferences: function (preferences, onResponse) {
+    let packet = {
+      to: this._actor,
+      type: "getPreferences",
+      preferences: preferences,
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Set Web Console-related preferences on the server.
+   *
+   * @param object preferences
+   *        An object with the preferences you want to change.
+   * @param function [onResponse]
+   *        Optional function to invoke when the response is received.
+   */
+  setPreferences: function (preferences, onResponse) {
+    let packet = {
+      to: this._actor,
+      type: "setPreferences",
+      preferences: preferences,
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the request headers from the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getRequestHeaders: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getRequestHeaders",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the request cookies from the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getRequestCookies: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getRequestCookies",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the request post data from the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getRequestPostData: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getRequestPostData",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the response headers from the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getResponseHeaders: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getResponseHeaders",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the response cookies from the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getResponseCookies: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getResponseCookies",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the response content from the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getResponseContent: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getResponseContent",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the timing information for the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getEventTimings: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getEventTimings",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Retrieve the security information for the given NetworkEventActor.
+   *
+   * @param string actor
+   *        The NetworkEventActor ID.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  getSecurityInfo: function (actor, onResponse) {
+    let packet = {
+      to: actor,
+      type: "getSecurityInfo",
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Send a HTTP request with the given data.
+   *
+   * @param string data
+   *        The details of the HTTP request.
+   * @param function onResponse
+   *        The function invoked when the response is received.
+   */
+  sendHTTPRequest: function (data, onResponse) {
+    let packet = {
+      to: this._actor,
+      type: "sendHTTPRequest",
+      request: data
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Start the given Web Console listeners.
+   *
+   * @see this.LISTENERS
+   * @param array listeners
+   *        Array of listeners you want to start. See this.LISTENERS for
+   *        known listeners.
+   * @param function onResponse
+   *        Function to invoke when the server response is received.
+   */
+  startListeners: function (listeners, onResponse) {
+    let packet = {
+      to: this._actor,
+      type: "startListeners",
+      listeners: listeners,
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Stop the given Web Console listeners.
+   *
+   * @see this.LISTENERS
+   * @param array listeners
+   *        Array of listeners you want to stop. See this.LISTENERS for
+   *        known listeners.
+   * @param function onResponse
+   *        Function to invoke when the server response is received.
+   */
+  stopListeners: function (listeners, onResponse) {
+    let packet = {
+      to: this._actor,
+      type: "stopListeners",
+      listeners: listeners,
+    };
+    this._client.request(packet, onResponse);
+  },
+
+  /**
+   * Return an instance of LongStringClient for the given long string grip.
+   *
+   * @param object grip
+   *        The long string grip returned by the protocol.
+   * @return object
+   *         The LongStringClient for the given long string grip.
+   */
+  longString: function (grip) {
+    if (grip.actor in this._longStrings) {
+      return this._longStrings[grip.actor];
+    }
+
+    let client = new LongStringClient(this._client, grip);
+    this._longStrings[grip.actor] = client;
+    return client;
+  },
+
+  /**
+   * Close the WebConsoleClient. This stops all the listeners on the server and
+   * detaches from the console actor.
+   *
+   * @param function onResponse
+   *        Function to invoke when the server response is received.
+   */
+  detach: function (onResponse) {
+    this._client.removeListener("evaluationResult", this.onEvaluationResult);
+    this._client.removeListener("networkEvent", this.onNetworkEvent);
+    this._client.removeListener("networkEventUpdate",
+                                this.onNetworkEventUpdate);
+    this.stopListeners(null, onResponse);
+    this._longStrings = null;
+    this._client = null;
+    this.pendingEvaluationResults.clear();
+    this.pendingEvaluationResults = null;
+    this.clearNetworkRequests();
+    this._networkRequests = null;
+  },
+
+  clearNetworkRequests: function () {
+    this._networkRequests.clear();
+  },
+
+  /**
+   * Fetches the full text of a LongString.
+   *
+   * @param object | string stringGrip
+   *        The long string grip containing the corresponding actor.
+   *        If you pass in a plain string (by accident or because you're lazy),
+   *        then a promise of the same string is simply returned.
+   * @return object Promise
+   *         A promise that is resolved when the full string contents
+   *         are available, or rejected if something goes wrong.
+   */
+  getString: function (stringGrip) {
+    // Make sure this is a long string.
+    if (typeof stringGrip != "object" || stringGrip.type != "longString") {
+      // Go home string, you're drunk.
+      return promise.resolve(stringGrip);
+    }
+
+    // Fetch the long string only once.
+    if (stringGrip._fullText) {
+      return stringGrip._fullText.promise;
+    }
+
+    let deferred = stringGrip._fullText = defer();
+    let { initial, length } = stringGrip;
+    let longStringClient = this.longString(stringGrip);
+
+    longStringClient.substring(initial.length, length, response => {
+      if (response.error) {
+        DevToolsUtils.reportException("getString",
+            response.error + ": " + response.message);
+
+        deferred.reject(response);
+        return;
+      }
+      deferred.resolve(initial + response.substring);
+    });
+
+    return deferred.promise;
+  }
+};