diff options
Diffstat (limited to 'devtools/shared/webconsole/client.js')
| -rw-r--r-- | devtools/shared/webconsole/client.js | 652 |
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; + } +}; |