3123 lines
92 KiB
JavaScript
3123 lines
92 KiB
JavaScript
/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
|
|
/* 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 { Ci, Cu } = require("chrome");
|
|
const Services = require("Services");
|
|
const DevToolsUtils = require("devtools/shared/DevToolsUtils");
|
|
const { getStack, callFunctionWithAsyncStack } = require("devtools/shared/platform/stack");
|
|
|
|
const promise = Cu.import("resource://devtools/shared/deprecated-sync-thenables.js", {}).Promise;
|
|
|
|
loader.lazyRequireGetter(this, "events", "sdk/event/core");
|
|
loader.lazyRequireGetter(this, "WebConsoleClient", "devtools/shared/webconsole/client", true);
|
|
loader.lazyRequireGetter(this, "DebuggerSocket", "devtools/shared/security/socket", true);
|
|
loader.lazyRequireGetter(this, "Authentication", "devtools/shared/security/auth");
|
|
|
|
const noop = () => {};
|
|
|
|
/**
|
|
* TODO: Get rid of this API in favor of EventTarget (bug 1042642)
|
|
*
|
|
* Add simple event notification to a prototype object. Any object that has
|
|
* some use for event notifications or the observer pattern in general can be
|
|
* augmented with the necessary facilities by passing its prototype to this
|
|
* function.
|
|
*
|
|
* @param aProto object
|
|
* The prototype object that will be modified.
|
|
*/
|
|
function eventSource(aProto) {
|
|
/**
|
|
* Add a listener to the event source for a given event.
|
|
*
|
|
* @param aName string
|
|
* The event to listen for.
|
|
* @param aListener function
|
|
* Called when the event is fired. If the same listener
|
|
* is added more than once, it will be called once per
|
|
* addListener call.
|
|
*/
|
|
aProto.addListener = function (aName, aListener) {
|
|
if (typeof aListener != "function") {
|
|
throw TypeError("Listeners must be functions.");
|
|
}
|
|
|
|
if (!this._listeners) {
|
|
this._listeners = {};
|
|
}
|
|
|
|
this._getListeners(aName).push(aListener);
|
|
};
|
|
|
|
/**
|
|
* Add a listener to the event source for a given event. The
|
|
* listener will be removed after it is called for the first time.
|
|
*
|
|
* @param aName string
|
|
* The event to listen for.
|
|
* @param aListener function
|
|
* Called when the event is fired.
|
|
*/
|
|
aProto.addOneTimeListener = function (aName, aListener) {
|
|
let l = (...args) => {
|
|
this.removeListener(aName, l);
|
|
aListener.apply(null, args);
|
|
};
|
|
this.addListener(aName, l);
|
|
};
|
|
|
|
/**
|
|
* Remove a listener from the event source previously added with
|
|
* addListener().
|
|
*
|
|
* @param aName string
|
|
* The event name used during addListener to add the listener.
|
|
* @param aListener function
|
|
* The callback to remove. If addListener was called multiple
|
|
* times, all instances will be removed.
|
|
*/
|
|
aProto.removeListener = function (aName, aListener) {
|
|
if (!this._listeners || (aListener && !this._listeners[aName])) {
|
|
return;
|
|
}
|
|
|
|
if (!aListener) {
|
|
this._listeners[aName] = [];
|
|
}
|
|
else {
|
|
this._listeners[aName] =
|
|
this._listeners[aName].filter(function (l) { return l != aListener; });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns the listeners for the specified event name. If none are defined it
|
|
* initializes an empty list and returns that.
|
|
*
|
|
* @param aName string
|
|
* The event name.
|
|
*/
|
|
aProto._getListeners = function (aName) {
|
|
if (aName in this._listeners) {
|
|
return this._listeners[aName];
|
|
}
|
|
this._listeners[aName] = [];
|
|
return this._listeners[aName];
|
|
};
|
|
|
|
/**
|
|
* Notify listeners of an event.
|
|
*
|
|
* @param aName string
|
|
* The event to fire.
|
|
* @param arguments
|
|
* All arguments will be passed along to the listeners,
|
|
* including the name argument.
|
|
*/
|
|
aProto.emit = function () {
|
|
if (!this._listeners) {
|
|
return;
|
|
}
|
|
|
|
let name = arguments[0];
|
|
let listeners = this._getListeners(name).slice(0);
|
|
|
|
for (let listener of listeners) {
|
|
try {
|
|
listener.apply(null, arguments);
|
|
} catch (e) {
|
|
// Prevent a bad listener from interfering with the others.
|
|
DevToolsUtils.reportException("notify event '" + name + "'", e);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Set of protocol messages that affect thread state, and the
|
|
* state the actor is in after each message.
|
|
*/
|
|
const ThreadStateTypes = {
|
|
"paused": "paused",
|
|
"resumed": "attached",
|
|
"detached": "detached",
|
|
"running": "attached"
|
|
};
|
|
|
|
/**
|
|
* Set of protocol messages that are sent by the server without a prior request
|
|
* by the client.
|
|
*/
|
|
const UnsolicitedNotifications = {
|
|
"consoleAPICall": "consoleAPICall",
|
|
"eventNotification": "eventNotification",
|
|
"fileActivity": "fileActivity",
|
|
"lastPrivateContextExited": "lastPrivateContextExited",
|
|
"logMessage": "logMessage",
|
|
"networkEvent": "networkEvent",
|
|
"networkEventUpdate": "networkEventUpdate",
|
|
"newGlobal": "newGlobal",
|
|
"newScript": "newScript",
|
|
"tabDetached": "tabDetached",
|
|
"tabListChanged": "tabListChanged",
|
|
"reflowActivity": "reflowActivity",
|
|
"addonListChanged": "addonListChanged",
|
|
"workerListChanged": "workerListChanged",
|
|
"serviceWorkerRegistrationListChanged": "serviceWorkerRegistrationList",
|
|
"tabNavigated": "tabNavigated",
|
|
"frameUpdate": "frameUpdate",
|
|
"pageError": "pageError",
|
|
"documentLoad": "documentLoad",
|
|
"enteredFrame": "enteredFrame",
|
|
"exitedFrame": "exitedFrame",
|
|
"appOpen": "appOpen",
|
|
"appClose": "appClose",
|
|
"appInstall": "appInstall",
|
|
"appUninstall": "appUninstall",
|
|
"evaluationResult": "evaluationResult",
|
|
"newSource": "newSource",
|
|
"updatedSource": "updatedSource",
|
|
};
|
|
|
|
/**
|
|
* Set of pause types that are sent by the server and not as an immediate
|
|
* response to a client request.
|
|
*/
|
|
const UnsolicitedPauses = {
|
|
"resumeLimit": "resumeLimit",
|
|
"debuggerStatement": "debuggerStatement",
|
|
"breakpoint": "breakpoint",
|
|
"DOMEvent": "DOMEvent",
|
|
"watchpoint": "watchpoint",
|
|
"exception": "exception"
|
|
};
|
|
|
|
/**
|
|
* Creates a client for the remote debugging protocol server. This client
|
|
* provides the means to communicate with the server and exchange the messages
|
|
* required by the protocol in a traditional JavaScript API.
|
|
*/
|
|
const DebuggerClient = exports.DebuggerClient = function (aTransport)
|
|
{
|
|
this._transport = aTransport;
|
|
this._transport.hooks = this;
|
|
|
|
// Map actor ID to client instance for each actor type.
|
|
this._clients = new Map();
|
|
|
|
this._pendingRequests = new Map();
|
|
this._activeRequests = new Map();
|
|
this._eventsEnabled = true;
|
|
|
|
this.traits = {};
|
|
|
|
this.request = this.request.bind(this);
|
|
this.localTransport = this._transport.onOutputStreamReady === undefined;
|
|
|
|
/*
|
|
* As the first thing on the connection, expect a greeting packet from
|
|
* the connection's root actor.
|
|
*/
|
|
this.mainRoot = null;
|
|
this.expectReply("root", (aPacket) => {
|
|
this.mainRoot = new RootClient(this, aPacket);
|
|
this.emit("connected", aPacket.applicationType, aPacket.traits);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* A declarative helper for defining methods that send requests to the server.
|
|
*
|
|
* @param aPacketSkeleton
|
|
* The form of the packet to send. Can specify fields to be filled from
|
|
* the parameters by using the |args| function.
|
|
* @param before
|
|
* The function to call before sending the packet. Is passed the packet,
|
|
* and the return value is used as the new packet. The |this| context is
|
|
* the instance of the client object we are defining a method for.
|
|
* @param after
|
|
* The function to call after the response is received. It is passed the
|
|
* response, and the return value is considered the new response that
|
|
* will be passed to the callback. The |this| context is the instance of
|
|
* the client object we are defining a method for.
|
|
* @return Request
|
|
* The `Request` object that is a Promise object and resolves once
|
|
* we receive the response. (See request method for more details)
|
|
*/
|
|
DebuggerClient.requester = function (aPacketSkeleton, config = {}) {
|
|
let { before, after } = config;
|
|
return DevToolsUtils.makeInfallible(function (...args) {
|
|
let outgoingPacket = {
|
|
to: aPacketSkeleton.to || this.actor
|
|
};
|
|
|
|
let maxPosition = -1;
|
|
for (let k of Object.keys(aPacketSkeleton)) {
|
|
if (aPacketSkeleton[k] instanceof DebuggerClient.Argument) {
|
|
let { position } = aPacketSkeleton[k];
|
|
outgoingPacket[k] = aPacketSkeleton[k].getArgument(args);
|
|
maxPosition = Math.max(position, maxPosition);
|
|
} else {
|
|
outgoingPacket[k] = aPacketSkeleton[k];
|
|
}
|
|
}
|
|
|
|
if (before) {
|
|
outgoingPacket = before.call(this, outgoingPacket);
|
|
}
|
|
|
|
return this.request(outgoingPacket, DevToolsUtils.makeInfallible((aResponse) => {
|
|
if (after) {
|
|
let { from } = aResponse;
|
|
aResponse = after.call(this, aResponse);
|
|
if (!aResponse.from) {
|
|
aResponse.from = from;
|
|
}
|
|
}
|
|
|
|
// The callback is always the last parameter.
|
|
let thisCallback = args[maxPosition + 1];
|
|
if (thisCallback) {
|
|
thisCallback(aResponse);
|
|
}
|
|
}, "DebuggerClient.requester request callback"));
|
|
}, "DebuggerClient.requester");
|
|
};
|
|
|
|
function args(aPos) {
|
|
return new DebuggerClient.Argument(aPos);
|
|
}
|
|
|
|
DebuggerClient.Argument = function (aPosition) {
|
|
this.position = aPosition;
|
|
};
|
|
|
|
DebuggerClient.Argument.prototype.getArgument = function (aParams) {
|
|
if (!(this.position in aParams)) {
|
|
throw new Error("Bad index into params: " + this.position);
|
|
}
|
|
return aParams[this.position];
|
|
};
|
|
|
|
// Expose these to save callers the trouble of importing DebuggerSocket
|
|
DebuggerClient.socketConnect = function (options) {
|
|
// Defined here instead of just copying the function to allow lazy-load
|
|
return DebuggerSocket.connect(options);
|
|
};
|
|
DevToolsUtils.defineLazyGetter(DebuggerClient, "Authenticators", () => {
|
|
return Authentication.Authenticators;
|
|
});
|
|
DevToolsUtils.defineLazyGetter(DebuggerClient, "AuthenticationResult", () => {
|
|
return Authentication.AuthenticationResult;
|
|
});
|
|
|
|
DebuggerClient.prototype = {
|
|
/**
|
|
* Connect to the server and start exchanging protocol messages.
|
|
*
|
|
* @param aOnConnected function
|
|
* If specified, will be called when the greeting packet is
|
|
* received from the debugging server.
|
|
*
|
|
* @return Promise
|
|
* Resolves once connected with an array whose first element
|
|
* is the application type, by default "browser", and the second
|
|
* element is the traits object (help figure out the features
|
|
* and behaviors of the server we connect to. See RootActor).
|
|
*/
|
|
connect: function (aOnConnected) {
|
|
let deferred = promise.defer();
|
|
this.emit("connect");
|
|
|
|
// Also emit the event on the |DebuggerClient| object (not on the instance),
|
|
// so it's possible to track all instances.
|
|
events.emit(DebuggerClient, "connect", this);
|
|
|
|
this.addOneTimeListener("connected", (aName, aApplicationType, aTraits) => {
|
|
this.traits = aTraits;
|
|
if (aOnConnected) {
|
|
aOnConnected(aApplicationType, aTraits);
|
|
}
|
|
deferred.resolve([aApplicationType, aTraits]);
|
|
});
|
|
|
|
this._transport.ready();
|
|
return deferred.promise;
|
|
},
|
|
|
|
/**
|
|
* Shut down communication with the debugging server.
|
|
*
|
|
* @param aOnClosed function
|
|
* If specified, will be called when the debugging connection
|
|
* has been closed. This parameter is deprecated - please use
|
|
* the returned Promise.
|
|
* @return Promise
|
|
* Resolves after the underlying transport is closed.
|
|
*/
|
|
close: function (aOnClosed) {
|
|
let deferred = promise.defer();
|
|
if (aOnClosed) {
|
|
deferred.promise.then(aOnClosed);
|
|
}
|
|
|
|
// Disable detach event notifications, because event handlers will be in a
|
|
// cleared scope by the time they run.
|
|
this._eventsEnabled = false;
|
|
|
|
let cleanup = () => {
|
|
this._transport.close();
|
|
this._transport = null;
|
|
};
|
|
|
|
// If the connection is already closed,
|
|
// there is no need to detach client
|
|
// as we won't be able to send any message.
|
|
if (this._closed) {
|
|
cleanup();
|
|
deferred.resolve();
|
|
return deferred.promise;
|
|
}
|
|
|
|
this.addOneTimeListener("closed", deferred.resolve);
|
|
|
|
// Call each client's `detach` method by calling
|
|
// lastly registered ones first to give a chance
|
|
// to detach child clients first.
|
|
let clients = [...this._clients.values()];
|
|
this._clients.clear();
|
|
const detachClients = () => {
|
|
let client = clients.pop();
|
|
if (!client) {
|
|
// All clients detached.
|
|
cleanup();
|
|
return;
|
|
}
|
|
if (client.detach) {
|
|
client.detach(detachClients);
|
|
return;
|
|
}
|
|
detachClients();
|
|
};
|
|
detachClients();
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
/*
|
|
* This function exists only to preserve DebuggerClient's interface;
|
|
* new code should say 'client.mainRoot.listTabs()'.
|
|
*/
|
|
listTabs: function (aOnResponse) { return this.mainRoot.listTabs(aOnResponse); },
|
|
|
|
/*
|
|
* This function exists only to preserve DebuggerClient's interface;
|
|
* new code should say 'client.mainRoot.listAddons()'.
|
|
*/
|
|
listAddons: function (aOnResponse) { return this.mainRoot.listAddons(aOnResponse); },
|
|
|
|
getTab: function (aFilter) { return this.mainRoot.getTab(aFilter); },
|
|
|
|
/**
|
|
* Attach to a tab actor.
|
|
*
|
|
* @param string aTabActor
|
|
* The actor ID for the tab to attach.
|
|
* @param function aOnResponse
|
|
* Called with the response packet and a TabClient
|
|
* (which will be undefined on error).
|
|
*/
|
|
attachTab: function (aTabActor, aOnResponse = noop) {
|
|
if (this._clients.has(aTabActor)) {
|
|
let cachedTab = this._clients.get(aTabActor);
|
|
let cachedResponse = {
|
|
cacheDisabled: cachedTab.cacheDisabled,
|
|
javascriptEnabled: cachedTab.javascriptEnabled,
|
|
traits: cachedTab.traits,
|
|
};
|
|
DevToolsUtils.executeSoon(() => aOnResponse(cachedResponse, cachedTab));
|
|
return promise.resolve([cachedResponse, cachedTab]);
|
|
}
|
|
|
|
let packet = {
|
|
to: aTabActor,
|
|
type: "attach"
|
|
};
|
|
return this.request(packet).then(aResponse => {
|
|
let tabClient;
|
|
if (!aResponse.error) {
|
|
tabClient = new TabClient(this, aResponse);
|
|
this.registerClient(tabClient);
|
|
}
|
|
aOnResponse(aResponse, tabClient);
|
|
return [aResponse, tabClient];
|
|
});
|
|
},
|
|
|
|
attachWorker: function DC_attachWorker(aWorkerActor, aOnResponse = noop) {
|
|
let workerClient = this._clients.get(aWorkerActor);
|
|
if (workerClient !== undefined) {
|
|
let response = {
|
|
from: workerClient.actor,
|
|
type: "attached",
|
|
url: workerClient.url
|
|
};
|
|
DevToolsUtils.executeSoon(() => aOnResponse(response, workerClient));
|
|
return promise.resolve([response, workerClient]);
|
|
}
|
|
|
|
return this.request({ to: aWorkerActor, type: "attach" }).then(aResponse => {
|
|
if (aResponse.error) {
|
|
aOnResponse(aResponse, null);
|
|
return [aResponse, null];
|
|
}
|
|
|
|
let workerClient = new WorkerClient(this, aResponse);
|
|
this.registerClient(workerClient);
|
|
aOnResponse(aResponse, workerClient);
|
|
return [aResponse, workerClient];
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Attach to an addon actor.
|
|
*
|
|
* @param string aAddonActor
|
|
* The actor ID for the addon to attach.
|
|
* @param function aOnResponse
|
|
* Called with the response packet and a AddonClient
|
|
* (which will be undefined on error).
|
|
*/
|
|
attachAddon: function DC_attachAddon(aAddonActor, aOnResponse = noop) {
|
|
let packet = {
|
|
to: aAddonActor,
|
|
type: "attach"
|
|
};
|
|
return this.request(packet).then(aResponse => {
|
|
let addonClient;
|
|
if (!aResponse.error) {
|
|
addonClient = new AddonClient(this, aAddonActor);
|
|
this.registerClient(addonClient);
|
|
this.activeAddon = addonClient;
|
|
}
|
|
aOnResponse(aResponse, addonClient);
|
|
return [aResponse, addonClient];
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Attach to a Web Console actor.
|
|
*
|
|
* @param string aConsoleActor
|
|
* The ID for the console actor to attach to.
|
|
* @param array aListeners
|
|
* The console listeners you want to start.
|
|
* @param function aOnResponse
|
|
* Called with the response packet and a WebConsoleClient
|
|
* instance (which will be undefined on error).
|
|
*/
|
|
attachConsole:
|
|
function (aConsoleActor, aListeners, aOnResponse = noop) {
|
|
let packet = {
|
|
to: aConsoleActor,
|
|
type: "startListeners",
|
|
listeners: aListeners,
|
|
};
|
|
|
|
return this.request(packet).then(aResponse => {
|
|
let consoleClient;
|
|
if (!aResponse.error) {
|
|
if (this._clients.has(aConsoleActor)) {
|
|
consoleClient = this._clients.get(aConsoleActor);
|
|
} else {
|
|
consoleClient = new WebConsoleClient(this, aResponse);
|
|
this.registerClient(consoleClient);
|
|
}
|
|
}
|
|
aOnResponse(aResponse, consoleClient);
|
|
return [aResponse, consoleClient];
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Attach to a global-scoped thread actor for chrome debugging.
|
|
*
|
|
* @param string aThreadActor
|
|
* The actor ID for the thread to attach.
|
|
* @param function aOnResponse
|
|
* Called with the response packet and a ThreadClient
|
|
* (which will be undefined on error).
|
|
* @param object aOptions
|
|
* Configuration options.
|
|
* - useSourceMaps: whether to use source maps or not.
|
|
*/
|
|
attachThread: function (aThreadActor, aOnResponse = noop, aOptions = {}) {
|
|
if (this._clients.has(aThreadActor)) {
|
|
let client = this._clients.get(aThreadActor);
|
|
DevToolsUtils.executeSoon(() => aOnResponse({}, client));
|
|
return promise.resolve([{}, client]);
|
|
}
|
|
|
|
let packet = {
|
|
to: aThreadActor,
|
|
type: "attach",
|
|
options: aOptions
|
|
};
|
|
return this.request(packet).then(aResponse => {
|
|
if (!aResponse.error) {
|
|
var threadClient = new ThreadClient(this, aThreadActor);
|
|
this.registerClient(threadClient);
|
|
}
|
|
aOnResponse(aResponse, threadClient);
|
|
return [aResponse, threadClient];
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Attach to a trace actor.
|
|
*
|
|
* @param string aTraceActor
|
|
* The actor ID for the tracer to attach.
|
|
* @param function aOnResponse
|
|
* Called with the response packet and a TraceClient
|
|
* (which will be undefined on error).
|
|
*/
|
|
attachTracer: function (aTraceActor, aOnResponse = noop) {
|
|
if (this._clients.has(aTraceActor)) {
|
|
let client = this._clients.get(aTraceActor);
|
|
DevToolsUtils.executeSoon(() => aOnResponse({}, client));
|
|
return promise.resolve([{}, client]);
|
|
}
|
|
|
|
let packet = {
|
|
to: aTraceActor,
|
|
type: "attach"
|
|
};
|
|
return this.request(packet).then(aResponse => {
|
|
if (!aResponse.error) {
|
|
var traceClient = new TraceClient(this, aTraceActor);
|
|
this.registerClient(traceClient);
|
|
}
|
|
aOnResponse(aResponse, traceClient);
|
|
return [aResponse, traceClient];
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Fetch the ChromeActor for the main process or ChildProcessActor for a
|
|
* a given child process ID.
|
|
*
|
|
* @param number aId
|
|
* The ID for the process to attach (returned by `listProcesses`).
|
|
* Connected to the main process if omitted, or is 0.
|
|
*/
|
|
getProcess: function (aId) {
|
|
let packet = {
|
|
to: "root",
|
|
type: "getProcess"
|
|
};
|
|
if (typeof (aId) == "number") {
|
|
packet.id = aId;
|
|
}
|
|
return this.request(packet);
|
|
},
|
|
|
|
/**
|
|
* Release an object actor.
|
|
*
|
|
* @param string aActor
|
|
* The actor ID to send the request to.
|
|
* @param aOnResponse function
|
|
* If specified, will be called with the response packet when
|
|
* debugging server responds.
|
|
*/
|
|
release: DebuggerClient.requester({
|
|
to: args(0),
|
|
type: "release"
|
|
}),
|
|
|
|
/**
|
|
* Send a request to the debugging server.
|
|
*
|
|
* @param aRequest object
|
|
* A JSON packet to send to the debugging server.
|
|
* @param aOnResponse function
|
|
* If specified, will be called with the JSON response packet when
|
|
* debugging server responds.
|
|
* @return Request
|
|
* This object emits a number of events to allow you to respond to
|
|
* different parts of the request lifecycle.
|
|
* It is also a Promise object, with a `then` method, that is resolved
|
|
* whenever a JSON or a Bulk response is received; and is rejected
|
|
* if the response is an error.
|
|
* Note: This return value can be ignored if you are using JSON alone,
|
|
* because the callback provided in |aOnResponse| will be bound to the
|
|
* "json-reply" event automatically.
|
|
*
|
|
* Events emitted:
|
|
* * json-reply: The server replied with a JSON packet, which is
|
|
* passed as event data.
|
|
* * bulk-reply: The server replied with bulk data, which you can read
|
|
* using the event data object containing:
|
|
* * actor: Name of actor that received the packet
|
|
* * type: Name of actor's method that was called on receipt
|
|
* * length: Size of the data to be read
|
|
* * stream: This input stream should only be used directly if you
|
|
* can ensure that you will read exactly |length| bytes
|
|
* and will not close the stream when reading is complete
|
|
* * done: If you use the stream directly (instead of |copyTo|
|
|
* below), you must signal completion by resolving /
|
|
* rejecting this deferred. If it's rejected, the
|
|
* transport will be closed. If an Error is supplied as a
|
|
* rejection value, it will be logged via |dumpn|. If you
|
|
* do use |copyTo|, resolving is taken care of for you
|
|
* when copying completes.
|
|
* * copyTo: A helper function for getting your data out of the
|
|
* stream that meets the stream handling requirements
|
|
* above, and has the following signature:
|
|
* @param output nsIAsyncOutputStream
|
|
* The stream to copy to.
|
|
* @return Promise
|
|
* The promise is resolved when copying completes or
|
|
* rejected if any (unexpected) errors occur.
|
|
* This object also emits "progress" events for each chunk
|
|
* that is copied. See stream-utils.js.
|
|
*/
|
|
request: function (aRequest, aOnResponse) {
|
|
if (!this.mainRoot) {
|
|
throw Error("Have not yet received a hello packet from the server.");
|
|
}
|
|
let type = aRequest.type || "";
|
|
if (!aRequest.to) {
|
|
throw Error("'" + type + "' request packet has no destination.");
|
|
}
|
|
if (this._closed) {
|
|
let msg = "'" + type + "' request packet to " +
|
|
"'" + aRequest.to + "' " +
|
|
"can't be sent as the connection is closed.";
|
|
let resp = { error: "connectionClosed", message: msg };
|
|
if (aOnResponse) {
|
|
aOnResponse(resp);
|
|
}
|
|
return promise.reject(resp);
|
|
}
|
|
|
|
let request = new Request(aRequest);
|
|
request.format = "json";
|
|
request.stack = getStack();
|
|
if (aOnResponse) {
|
|
request.on("json-reply", aOnResponse);
|
|
}
|
|
|
|
this._sendOrQueueRequest(request);
|
|
|
|
// Implement a Promise like API on the returned object
|
|
// that resolves/rejects on request response
|
|
let deferred = promise.defer();
|
|
function listenerJson(resp) {
|
|
request.off("json-reply", listenerJson);
|
|
request.off("bulk-reply", listenerBulk);
|
|
if (resp.error) {
|
|
deferred.reject(resp);
|
|
} else {
|
|
deferred.resolve(resp);
|
|
}
|
|
}
|
|
function listenerBulk(resp) {
|
|
request.off("json-reply", listenerJson);
|
|
request.off("bulk-reply", listenerBulk);
|
|
deferred.resolve(resp);
|
|
}
|
|
request.on("json-reply", listenerJson);
|
|
request.on("bulk-reply", listenerBulk);
|
|
request.then = deferred.promise.then.bind(deferred.promise);
|
|
|
|
return request;
|
|
},
|
|
|
|
/**
|
|
* Transmit streaming data via a bulk request.
|
|
*
|
|
* This method initiates the bulk send process by queuing up the header data.
|
|
* The caller receives eventual access to a stream for writing.
|
|
*
|
|
* Since this opens up more options for how the server might respond (it could
|
|
* send back either JSON or bulk data), and the returned Request object emits
|
|
* events for different stages of the request process that you may want to
|
|
* react to.
|
|
*
|
|
* @param request Object
|
|
* This is modeled after the format of JSON packets above, but does not
|
|
* actually contain the data, but is instead just a routing header:
|
|
* * actor: Name of actor that will receive the packet
|
|
* * type: Name of actor's method that should be called on receipt
|
|
* * length: Size of the data to be sent
|
|
* @return Request
|
|
* This object emits a number of events to allow you to respond to
|
|
* different parts of the request lifecycle.
|
|
*
|
|
* Events emitted:
|
|
* * bulk-send-ready: Ready to send bulk data to the server, using the
|
|
* event data object containing:
|
|
* * stream: This output stream should only be used directly if
|
|
* you can ensure that you will write exactly |length|
|
|
* bytes and will not close the stream when writing is
|
|
* complete
|
|
* * done: If you use the stream directly (instead of |copyFrom|
|
|
* below), you must signal completion by resolving /
|
|
* rejecting this deferred. If it's rejected, the
|
|
* transport will be closed. If an Error is supplied as
|
|
* a rejection value, it will be logged via |dumpn|. If
|
|
* you do use |copyFrom|, resolving is taken care of for
|
|
* you when copying completes.
|
|
* * copyFrom: A helper function for getting your data onto the
|
|
* stream that meets the stream handling requirements
|
|
* above, and has the following signature:
|
|
* @param input nsIAsyncInputStream
|
|
* The stream to copy from.
|
|
* @return Promise
|
|
* The promise is resolved when copying completes or
|
|
* rejected if any (unexpected) errors occur.
|
|
* This object also emits "progress" events for each chunk
|
|
* that is copied. See stream-utils.js.
|
|
* * json-reply: The server replied with a JSON packet, which is
|
|
* passed as event data.
|
|
* * bulk-reply: The server replied with bulk data, which you can read
|
|
* using the event data object containing:
|
|
* * actor: Name of actor that received the packet
|
|
* * type: Name of actor's method that was called on receipt
|
|
* * length: Size of the data to be read
|
|
* * stream: This input stream should only be used directly if you
|
|
* can ensure that you will read exactly |length| bytes
|
|
* and will not close the stream when reading is complete
|
|
* * done: If you use the stream directly (instead of |copyTo|
|
|
* below), you must signal completion by resolving /
|
|
* rejecting this deferred. If it's rejected, the
|
|
* transport will be closed. If an Error is supplied as a
|
|
* rejection value, it will be logged via |dumpn|. If you
|
|
* do use |copyTo|, resolving is taken care of for you
|
|
* when copying completes.
|
|
* * copyTo: A helper function for getting your data out of the
|
|
* stream that meets the stream handling requirements
|
|
* above, and has the following signature:
|
|
* @param output nsIAsyncOutputStream
|
|
* The stream to copy to.
|
|
* @return Promise
|
|
* The promise is resolved when copying completes or
|
|
* rejected if any (unexpected) errors occur.
|
|
* This object also emits "progress" events for each chunk
|
|
* that is copied. See stream-utils.js.
|
|
*/
|
|
startBulkRequest: function (request) {
|
|
if (!this.traits.bulk) {
|
|
throw Error("Server doesn't support bulk transfers");
|
|
}
|
|
if (!this.mainRoot) {
|
|
throw Error("Have not yet received a hello packet from the server.");
|
|
}
|
|
if (!request.type) {
|
|
throw Error("Bulk packet is missing the required 'type' field.");
|
|
}
|
|
if (!request.actor) {
|
|
throw Error("'" + request.type + "' bulk packet has no destination.");
|
|
}
|
|
if (!request.length) {
|
|
throw Error("'" + request.type + "' bulk packet has no length.");
|
|
}
|
|
|
|
request = new Request(request);
|
|
request.format = "bulk";
|
|
|
|
this._sendOrQueueRequest(request);
|
|
|
|
return request;
|
|
},
|
|
|
|
/**
|
|
* If a new request can be sent immediately, do so. Otherwise, queue it.
|
|
*/
|
|
_sendOrQueueRequest(request) {
|
|
let actor = request.actor;
|
|
if (!this._activeRequests.has(actor)) {
|
|
this._sendRequest(request);
|
|
} else {
|
|
this._queueRequest(request);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Send a request.
|
|
* @throws Error if there is already an active request in flight for the same
|
|
* actor.
|
|
*/
|
|
_sendRequest(request) {
|
|
let actor = request.actor;
|
|
this.expectReply(actor, request);
|
|
|
|
if (request.format === "json") {
|
|
this._transport.send(request.request);
|
|
return false;
|
|
}
|
|
|
|
this._transport.startBulkSend(request.request).then((...args) => {
|
|
request.emit("bulk-send-ready", ...args);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Queue a request to be sent later. Queues are only drained when an in
|
|
* flight request to a given actor completes.
|
|
*/
|
|
_queueRequest(request) {
|
|
let actor = request.actor;
|
|
let queue = this._pendingRequests.get(actor) || [];
|
|
queue.push(request);
|
|
this._pendingRequests.set(actor, queue);
|
|
},
|
|
|
|
/**
|
|
* Attempt the next request to a given actor (if any).
|
|
*/
|
|
_attemptNextRequest(actor) {
|
|
if (this._activeRequests.has(actor)) {
|
|
return;
|
|
}
|
|
let queue = this._pendingRequests.get(actor);
|
|
if (!queue) {
|
|
return;
|
|
}
|
|
let request = queue.shift();
|
|
if (queue.length === 0) {
|
|
this._pendingRequests.delete(actor);
|
|
}
|
|
this._sendRequest(request);
|
|
},
|
|
|
|
/**
|
|
* Arrange to hand the next reply from |aActor| to the handler bound to
|
|
* |aRequest|.
|
|
*
|
|
* DebuggerClient.prototype.request / startBulkRequest usually takes care of
|
|
* establishing the handler for a given request, but in rare cases (well,
|
|
* greetings from new root actors, is the only case at the moment) we must be
|
|
* prepared for a "reply" that doesn't correspond to any request we sent.
|
|
*/
|
|
expectReply: function (aActor, aRequest) {
|
|
if (this._activeRequests.has(aActor)) {
|
|
throw Error("clashing handlers for next reply from " + uneval(aActor));
|
|
}
|
|
|
|
// If a handler is passed directly (as it is with the handler for the root
|
|
// actor greeting), create a dummy request to bind this to.
|
|
if (typeof aRequest === "function") {
|
|
let handler = aRequest;
|
|
aRequest = new Request();
|
|
aRequest.on("json-reply", handler);
|
|
}
|
|
|
|
this._activeRequests.set(aActor, aRequest);
|
|
},
|
|
|
|
// Transport hooks.
|
|
|
|
/**
|
|
* Called by DebuggerTransport to dispatch incoming packets as appropriate.
|
|
*
|
|
* @param aPacket object
|
|
* The incoming packet.
|
|
*/
|
|
onPacket: function (aPacket) {
|
|
if (!aPacket.from) {
|
|
DevToolsUtils.reportException(
|
|
"onPacket",
|
|
new Error("Server did not specify an actor, dropping packet: " +
|
|
JSON.stringify(aPacket)));
|
|
return;
|
|
}
|
|
|
|
// If we have a registered Front for this actor, let it handle the packet
|
|
// and skip all the rest of this unpleasantness.
|
|
let front = this.getActor(aPacket.from);
|
|
if (front) {
|
|
front.onPacket(aPacket);
|
|
return;
|
|
}
|
|
|
|
// Check for "forwardingCancelled" here instead of using a client to handle it.
|
|
// This is necessary because we might receive this event while the client is closing,
|
|
// and the clients have already been removed by that point.
|
|
if (this.mainRoot &&
|
|
aPacket.from == this.mainRoot.actor &&
|
|
aPacket.type == "forwardingCancelled") {
|
|
this.purgeRequests(aPacket.prefix);
|
|
return;
|
|
}
|
|
|
|
if (this._clients.has(aPacket.from) && aPacket.type) {
|
|
let client = this._clients.get(aPacket.from);
|
|
let type = aPacket.type;
|
|
if (client.events.indexOf(type) != -1) {
|
|
client.emit(type, aPacket);
|
|
// we ignore the rest, as the client is expected to handle this packet.
|
|
return;
|
|
}
|
|
}
|
|
|
|
let activeRequest;
|
|
// See if we have a handler function waiting for a reply from this
|
|
// actor. (Don't count unsolicited notifications or pauses as
|
|
// replies.)
|
|
if (this._activeRequests.has(aPacket.from) &&
|
|
!(aPacket.type in UnsolicitedNotifications) &&
|
|
!(aPacket.type == ThreadStateTypes.paused &&
|
|
aPacket.why.type in UnsolicitedPauses)) {
|
|
activeRequest = this._activeRequests.get(aPacket.from);
|
|
this._activeRequests.delete(aPacket.from);
|
|
}
|
|
|
|
// If there is a subsequent request for the same actor, hand it off to the
|
|
// transport. Delivery of packets on the other end is always async, even
|
|
// in the local transport case.
|
|
this._attemptNextRequest(aPacket.from);
|
|
|
|
// Packets that indicate thread state changes get special treatment.
|
|
if (aPacket.type in ThreadStateTypes &&
|
|
this._clients.has(aPacket.from) &&
|
|
typeof this._clients.get(aPacket.from)._onThreadState == "function") {
|
|
this._clients.get(aPacket.from)._onThreadState(aPacket);
|
|
}
|
|
|
|
// TODO: Bug 1151156 - Remove once Gecko 40 is on b2g-stable.
|
|
if (!this.traits.noNeedToFakeResumptionOnNavigation) {
|
|
// On navigation the server resumes, so the client must resume as well.
|
|
// We achieve that by generating a fake resumption packet that triggers
|
|
// the client's thread state change listeners.
|
|
if (aPacket.type == UnsolicitedNotifications.tabNavigated &&
|
|
this._clients.has(aPacket.from) &&
|
|
this._clients.get(aPacket.from).thread) {
|
|
let thread = this._clients.get(aPacket.from).thread;
|
|
let resumption = { from: thread._actor, type: "resumed" };
|
|
thread._onThreadState(resumption);
|
|
}
|
|
}
|
|
|
|
// Only try to notify listeners on events, not responses to requests
|
|
// that lack a packet type.
|
|
if (aPacket.type) {
|
|
this.emit(aPacket.type, aPacket);
|
|
}
|
|
|
|
if (activeRequest) {
|
|
let emitReply = () => activeRequest.emit("json-reply", aPacket);
|
|
if (activeRequest.stack) {
|
|
callFunctionWithAsyncStack(emitReply, activeRequest.stack,
|
|
"DevTools RDP");
|
|
} else {
|
|
emitReply();
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called by the DebuggerTransport to dispatch incoming bulk packets as
|
|
* appropriate.
|
|
*
|
|
* @param packet object
|
|
* The incoming packet, which contains:
|
|
* * actor: Name of actor that will receive the packet
|
|
* * type: Name of actor's method that should be called on receipt
|
|
* * length: Size of the data to be read
|
|
* * stream: This input stream should only be used directly if you can
|
|
* ensure that you will read exactly |length| bytes and will
|
|
* not close the stream when reading is complete
|
|
* * done: If you use the stream directly (instead of |copyTo|
|
|
* below), you must signal completion by resolving /
|
|
* rejecting this deferred. If it's rejected, the transport
|
|
* will be closed. If an Error is supplied as a rejection
|
|
* value, it will be logged via |dumpn|. If you do use
|
|
* |copyTo|, resolving is taken care of for you when copying
|
|
* completes.
|
|
* * copyTo: A helper function for getting your data out of the stream
|
|
* that meets the stream handling requirements above, and has
|
|
* the following signature:
|
|
* @param output nsIAsyncOutputStream
|
|
* The stream to copy to.
|
|
* @return Promise
|
|
* The promise is resolved when copying completes or rejected
|
|
* if any (unexpected) errors occur.
|
|
* This object also emits "progress" events for each chunk
|
|
* that is copied. See stream-utils.js.
|
|
*/
|
|
onBulkPacket: function (packet) {
|
|
let { actor, type, length } = packet;
|
|
|
|
if (!actor) {
|
|
DevToolsUtils.reportException(
|
|
"onBulkPacket",
|
|
new Error("Server did not specify an actor, dropping bulk packet: " +
|
|
JSON.stringify(packet)));
|
|
return;
|
|
}
|
|
|
|
// See if we have a handler function waiting for a reply from this
|
|
// actor.
|
|
if (!this._activeRequests.has(actor)) {
|
|
return;
|
|
}
|
|
|
|
let activeRequest = this._activeRequests.get(actor);
|
|
this._activeRequests.delete(actor);
|
|
|
|
// If there is a subsequent request for the same actor, hand it off to the
|
|
// transport. Delivery of packets on the other end is always async, even
|
|
// in the local transport case.
|
|
this._attemptNextRequest(actor);
|
|
|
|
activeRequest.emit("bulk-reply", packet);
|
|
},
|
|
|
|
/**
|
|
* Called by DebuggerTransport when the underlying stream is closed.
|
|
*
|
|
* @param aStatus nsresult
|
|
* The status code that corresponds to the reason for closing
|
|
* the stream.
|
|
*/
|
|
onClosed: function () {
|
|
this._closed = true;
|
|
this.emit("closed");
|
|
|
|
this.purgeRequests();
|
|
|
|
// The |_pools| array on the client-side currently is used only by
|
|
// protocol.js to store active fronts, mirroring the actor pools found in
|
|
// the server. So, read all usages of "pool" as "protocol.js front".
|
|
//
|
|
// In the normal case where we shutdown cleanly, the toolbox tells each tool
|
|
// to close, and they each call |destroy| on any fronts they were using.
|
|
// When |destroy| or |cleanup| is called on a protocol.js front, it also
|
|
// removes itself from the |_pools| array. Once the toolbox has shutdown,
|
|
// the connection is closed, and we reach here. All fronts (should have
|
|
// been) |destroy|ed, so |_pools| should empty.
|
|
//
|
|
// If the connection instead aborts unexpectedly, we may end up here with
|
|
// all fronts used during the life of the connection. So, we call |cleanup|
|
|
// on them clear their state, reject pending requests, and remove themselves
|
|
// from |_pools|. This saves the toolbox from hanging indefinitely, in case
|
|
// it waits for some server response before shutdown that will now never
|
|
// arrive.
|
|
for (let pool of this._pools) {
|
|
pool.cleanup();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Purge pending and active requests in this client.
|
|
*
|
|
* @param prefix string (optional)
|
|
* If a prefix is given, only requests for actor IDs that start with the prefix
|
|
* will be cleaned up. This is useful when forwarding of a portion of requests
|
|
* is cancelled on the server.
|
|
*/
|
|
purgeRequests(prefix = "") {
|
|
let reject = function (type, request) {
|
|
// Server can send packets on its own and client only pass a callback
|
|
// to expectReply, so that there is no request object.
|
|
let msg;
|
|
if (request.request) {
|
|
msg = "'" + request.request.type + "' " + type + " request packet" +
|
|
" to '" + request.actor + "' " +
|
|
"can't be sent as the connection just closed.";
|
|
} else {
|
|
msg = "server side packet can't be received as the connection just closed.";
|
|
}
|
|
let packet = { error: "connectionClosed", message: msg };
|
|
request.emit("json-reply", packet);
|
|
};
|
|
|
|
let pendingRequestsToReject = [];
|
|
this._pendingRequests.forEach((requests, actor) => {
|
|
if (!actor.startsWith(prefix)) {
|
|
return;
|
|
}
|
|
this._pendingRequests.delete(actor);
|
|
pendingRequestsToReject = pendingRequestsToReject.concat(requests);
|
|
});
|
|
pendingRequestsToReject.forEach(request => reject("pending", request));
|
|
|
|
let activeRequestsToReject = [];
|
|
this._activeRequests.forEach((request, actor) => {
|
|
if (!actor.startsWith(prefix)) {
|
|
return;
|
|
}
|
|
this._activeRequests.delete(actor);
|
|
activeRequestsToReject = activeRequestsToReject.concat(request);
|
|
});
|
|
activeRequestsToReject.forEach(request => reject("active", request));
|
|
},
|
|
|
|
registerClient: function (client) {
|
|
let actorID = client.actor;
|
|
if (!actorID) {
|
|
throw new Error("DebuggerServer.registerClient expects " +
|
|
"a client instance with an `actor` attribute.");
|
|
}
|
|
if (!Array.isArray(client.events)) {
|
|
throw new Error("DebuggerServer.registerClient expects " +
|
|
"a client instance with an `events` attribute " +
|
|
"that is an array.");
|
|
}
|
|
if (client.events.length > 0 && typeof (client.emit) != "function") {
|
|
throw new Error("DebuggerServer.registerClient expects " +
|
|
"a client instance with non-empty `events` array to" +
|
|
"have an `emit` function.");
|
|
}
|
|
if (this._clients.has(actorID)) {
|
|
throw new Error("DebuggerServer.registerClient already registered " +
|
|
"a client for this actor.");
|
|
}
|
|
this._clients.set(actorID, client);
|
|
},
|
|
|
|
unregisterClient: function (client) {
|
|
let actorID = client.actor;
|
|
if (!actorID) {
|
|
throw new Error("DebuggerServer.unregisterClient expects " +
|
|
"a Client instance with a `actor` attribute.");
|
|
}
|
|
this._clients.delete(actorID);
|
|
},
|
|
|
|
/**
|
|
* Actor lifetime management, echos the server's actor pools.
|
|
*/
|
|
__pools: null,
|
|
get _pools() {
|
|
if (this.__pools) {
|
|
return this.__pools;
|
|
}
|
|
this.__pools = new Set();
|
|
return this.__pools;
|
|
},
|
|
|
|
addActorPool: function (pool) {
|
|
this._pools.add(pool);
|
|
},
|
|
removeActorPool: function (pool) {
|
|
this._pools.delete(pool);
|
|
},
|
|
getActor: function (actorID) {
|
|
let pool = this.poolFor(actorID);
|
|
return pool ? pool.get(actorID) : null;
|
|
},
|
|
|
|
poolFor: function (actorID) {
|
|
for (let pool of this._pools) {
|
|
if (pool.has(actorID)) return pool;
|
|
}
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Currently attached addon.
|
|
*/
|
|
activeAddon: null
|
|
};
|
|
|
|
eventSource(DebuggerClient.prototype);
|
|
|
|
function Request(request) {
|
|
this.request = request;
|
|
}
|
|
|
|
Request.prototype = {
|
|
|
|
on: function (type, listener) {
|
|
events.on(this, type, listener);
|
|
},
|
|
|
|
off: function (type, listener) {
|
|
events.off(this, type, listener);
|
|
},
|
|
|
|
once: function (type, listener) {
|
|
events.once(this, type, listener);
|
|
},
|
|
|
|
emit: function (type, ...args) {
|
|
events.emit(this, type, ...args);
|
|
},
|
|
|
|
get actor() { return this.request.to || this.request.actor; }
|
|
|
|
};
|
|
|
|
/**
|
|
* Creates a tab client for the remote debugging protocol server. This client
|
|
* is a front to the tab actor created in the server side, hiding the protocol
|
|
* details in a traditional JavaScript API.
|
|
*
|
|
* @param aClient DebuggerClient
|
|
* The debugger client parent.
|
|
* @param aForm object
|
|
* The protocol form for this tab.
|
|
*/
|
|
function TabClient(aClient, aForm) {
|
|
this.client = aClient;
|
|
this._actor = aForm.from;
|
|
this._threadActor = aForm.threadActor;
|
|
this.javascriptEnabled = aForm.javascriptEnabled;
|
|
this.cacheDisabled = aForm.cacheDisabled;
|
|
this.thread = null;
|
|
this.request = this.client.request;
|
|
this.traits = aForm.traits || {};
|
|
this.events = ["workerListChanged"];
|
|
}
|
|
|
|
TabClient.prototype = {
|
|
get actor() { return this._actor; },
|
|
get _transport() { return this.client._transport; },
|
|
|
|
/**
|
|
* Attach to a thread actor.
|
|
*
|
|
* @param object aOptions
|
|
* Configuration options.
|
|
* - useSourceMaps: whether to use source maps or not.
|
|
* @param function aOnResponse
|
|
* Called with the response packet and a ThreadClient
|
|
* (which will be undefined on error).
|
|
*/
|
|
attachThread: function (aOptions = {}, aOnResponse = noop) {
|
|
if (this.thread) {
|
|
DevToolsUtils.executeSoon(() => aOnResponse({}, this.thread));
|
|
return promise.resolve([{}, this.thread]);
|
|
}
|
|
|
|
let packet = {
|
|
to: this._threadActor,
|
|
type: "attach",
|
|
options: aOptions
|
|
};
|
|
return this.request(packet).then(aResponse => {
|
|
if (!aResponse.error) {
|
|
this.thread = new ThreadClient(this, this._threadActor);
|
|
this.client.registerClient(this.thread);
|
|
}
|
|
aOnResponse(aResponse, this.thread);
|
|
return [aResponse, this.thread];
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Detach the client from the tab actor.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
detach: DebuggerClient.requester({
|
|
type: "detach"
|
|
}, {
|
|
before: function (aPacket) {
|
|
if (this.thread) {
|
|
this.thread.detach();
|
|
}
|
|
return aPacket;
|
|
},
|
|
after: function (aResponse) {
|
|
this.client.unregisterClient(this);
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Bring the window to the front.
|
|
*/
|
|
focus: DebuggerClient.requester({
|
|
type: "focus"
|
|
}, {}),
|
|
|
|
/**
|
|
* Reload the page in this tab.
|
|
*
|
|
* @param [optional] object options
|
|
* An object with a `force` property indicating whether or not
|
|
* this reload should skip the cache
|
|
*/
|
|
reload: function (options = { force: false }) {
|
|
return this._reload(options);
|
|
},
|
|
_reload: DebuggerClient.requester({
|
|
type: "reload",
|
|
options: args(0)
|
|
}),
|
|
|
|
/**
|
|
* Navigate to another URL.
|
|
*
|
|
* @param string url
|
|
* The URL to navigate to.
|
|
*/
|
|
navigateTo: DebuggerClient.requester({
|
|
type: "navigateTo",
|
|
url: args(0)
|
|
}),
|
|
|
|
/**
|
|
* Reconfigure the tab actor.
|
|
*
|
|
* @param object aOptions
|
|
* A dictionary object of the new options to use in the tab actor.
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
reconfigure: DebuggerClient.requester({
|
|
type: "reconfigure",
|
|
options: args(0)
|
|
}),
|
|
|
|
listWorkers: DebuggerClient.requester({
|
|
type: "listWorkers"
|
|
}),
|
|
|
|
attachWorker: function (aWorkerActor, aOnResponse) {
|
|
this.client.attachWorker(aWorkerActor, aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Resolve a location ({ url, line, column }) to its current
|
|
* source mapping location.
|
|
*
|
|
* @param {String} arg[0].url
|
|
* @param {Number} arg[0].line
|
|
* @param {Number?} arg[0].column
|
|
*/
|
|
resolveLocation: DebuggerClient.requester({
|
|
type: "resolveLocation",
|
|
location: args(0)
|
|
}),
|
|
};
|
|
|
|
eventSource(TabClient.prototype);
|
|
|
|
function WorkerClient(aClient, aForm) {
|
|
this.client = aClient;
|
|
this._actor = aForm.from;
|
|
this._isClosed = false;
|
|
this._url = aForm.url;
|
|
|
|
this._onClose = this._onClose.bind(this);
|
|
|
|
this.addListener("close", this._onClose);
|
|
|
|
this.traits = {};
|
|
}
|
|
|
|
WorkerClient.prototype = {
|
|
get _transport() {
|
|
return this.client._transport;
|
|
},
|
|
|
|
get request() {
|
|
return this.client.request;
|
|
},
|
|
|
|
get actor() {
|
|
return this._actor;
|
|
},
|
|
|
|
get url() {
|
|
return this._url;
|
|
},
|
|
|
|
get isClosed() {
|
|
return this._isClosed;
|
|
},
|
|
|
|
detach: DebuggerClient.requester({ type: "detach" }, {
|
|
after: function (aResponse) {
|
|
if (this.thread) {
|
|
this.client.unregisterClient(this.thread);
|
|
}
|
|
this.client.unregisterClient(this);
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
attachThread: function (aOptions = {}, aOnResponse = noop) {
|
|
if (this.thread) {
|
|
let response = [{
|
|
type: "connected",
|
|
threadActor: this.thread._actor,
|
|
consoleActor: this.consoleActor,
|
|
}, this.thread];
|
|
DevToolsUtils.executeSoon(() => aOnResponse(response));
|
|
return response;
|
|
}
|
|
|
|
// The connect call on server doesn't attach the thread as of version 44.
|
|
return this.request({
|
|
to: this._actor,
|
|
type: "connect",
|
|
options: aOptions,
|
|
}).then(connectReponse => {
|
|
if (connectReponse.error) {
|
|
aOnResponse(connectReponse, null);
|
|
return [connectResponse, null];
|
|
}
|
|
|
|
return this.request({
|
|
to: connectReponse.threadActor,
|
|
type: "attach",
|
|
options: aOptions
|
|
}).then(attachResponse => {
|
|
if (attachResponse.error) {
|
|
aOnResponse(attachResponse, null);
|
|
}
|
|
|
|
this.thread = new ThreadClient(this, connectReponse.threadActor);
|
|
this.consoleActor = connectReponse.consoleActor;
|
|
this.client.registerClient(this.thread);
|
|
|
|
aOnResponse(connectReponse, this.thread);
|
|
return [connectResponse, this.thread];
|
|
});
|
|
}, error => {
|
|
aOnResponse(error, null);
|
|
});
|
|
},
|
|
|
|
_onClose: function () {
|
|
this.removeListener("close", this._onClose);
|
|
|
|
if (this.thread) {
|
|
this.client.unregisterClient(this.thread);
|
|
}
|
|
this.client.unregisterClient(this);
|
|
this._isClosed = true;
|
|
},
|
|
|
|
reconfigure: function () {
|
|
return Promise.resolve();
|
|
},
|
|
|
|
events: ["close"]
|
|
};
|
|
|
|
eventSource(WorkerClient.prototype);
|
|
|
|
function AddonClient(aClient, aActor) {
|
|
this._client = aClient;
|
|
this._actor = aActor;
|
|
this.request = this._client.request;
|
|
this.events = [];
|
|
}
|
|
|
|
AddonClient.prototype = {
|
|
get actor() { return this._actor; },
|
|
get _transport() { return this._client._transport; },
|
|
|
|
/**
|
|
* Detach the client from the addon actor.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
detach: DebuggerClient.requester({
|
|
type: "detach"
|
|
}, {
|
|
after: function (aResponse) {
|
|
if (this._client.activeAddon === this) {
|
|
this._client.activeAddon = null;
|
|
}
|
|
this._client.unregisterClient(this);
|
|
return aResponse;
|
|
},
|
|
})
|
|
};
|
|
|
|
/**
|
|
* A RootClient object represents a root actor on the server. Each
|
|
* DebuggerClient keeps a RootClient instance representing the root actor
|
|
* for the initial connection; DebuggerClient's 'listTabs' and
|
|
* 'listChildProcesses' methods forward to that root actor.
|
|
*
|
|
* @param aClient object
|
|
* The client connection to which this actor belongs.
|
|
* @param aGreeting string
|
|
* The greeting packet from the root actor we're to represent.
|
|
*
|
|
* Properties of a RootClient instance:
|
|
*
|
|
* @property actor string
|
|
* The name of this child's root actor.
|
|
* @property applicationType string
|
|
* The application type, as given in the root actor's greeting packet.
|
|
* @property traits object
|
|
* The traits object, as given in the root actor's greeting packet.
|
|
*/
|
|
function RootClient(aClient, aGreeting) {
|
|
this._client = aClient;
|
|
this.actor = aGreeting.from;
|
|
this.applicationType = aGreeting.applicationType;
|
|
this.traits = aGreeting.traits;
|
|
}
|
|
exports.RootClient = RootClient;
|
|
|
|
RootClient.prototype = {
|
|
constructor: RootClient,
|
|
|
|
/**
|
|
* List the open tabs.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
listTabs: DebuggerClient.requester({ type: "listTabs" }),
|
|
|
|
/**
|
|
* List the installed addons.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
listAddons: DebuggerClient.requester({ type: "listAddons" }),
|
|
|
|
/**
|
|
* List the registered workers.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
listWorkers: DebuggerClient.requester({ type: "listWorkers" }),
|
|
|
|
/**
|
|
* List the registered service workers.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
listServiceWorkerRegistrations: DebuggerClient.requester({
|
|
type: "listServiceWorkerRegistrations"
|
|
}),
|
|
|
|
/**
|
|
* List the running processes.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
listProcesses: DebuggerClient.requester({ type: "listProcesses" }),
|
|
|
|
/**
|
|
* Fetch the TabActor for the currently selected tab, or for a specific
|
|
* tab given as first parameter.
|
|
*
|
|
* @param [optional] object aFilter
|
|
* A dictionary object with following optional attributes:
|
|
* - outerWindowID: used to match tabs in parent process
|
|
* - tabId: used to match tabs in child processes
|
|
* - tab: a reference to xul:tab element
|
|
* If nothing is specified, returns the actor for the currently
|
|
* selected tab.
|
|
*/
|
|
getTab: function (aFilter) {
|
|
let packet = {
|
|
to: this.actor,
|
|
type: "getTab"
|
|
};
|
|
|
|
if (aFilter) {
|
|
if (typeof (aFilter.outerWindowID) == "number") {
|
|
packet.outerWindowID = aFilter.outerWindowID;
|
|
} else if (typeof (aFilter.tabId) == "number") {
|
|
packet.tabId = aFilter.tabId;
|
|
} else if ("tab" in aFilter) {
|
|
let browser = aFilter.tab.linkedBrowser;
|
|
if (browser.frameLoader.tabParent) {
|
|
// Tabs in child process
|
|
packet.tabId = browser.frameLoader.tabParent.tabId;
|
|
} else if (browser.outerWindowID) {
|
|
// <xul:browser> tabs in parent process
|
|
packet.outerWindowID = browser.outerWindowID;
|
|
} else {
|
|
// <iframe mozbrowser> tabs in parent process
|
|
let windowUtils = browser.contentWindow
|
|
.QueryInterface(Ci.nsIInterfaceRequestor)
|
|
.getInterface(Ci.nsIDOMWindowUtils);
|
|
packet.outerWindowID = windowUtils.outerWindowID;
|
|
}
|
|
} else {
|
|
// Throw if a filter object have been passed but without
|
|
// any clearly idenfified filter.
|
|
throw new Error("Unsupported argument given to getTab request");
|
|
}
|
|
}
|
|
|
|
return this.request(packet);
|
|
},
|
|
|
|
/**
|
|
* Description of protocol's actors and methods.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
protocolDescription: DebuggerClient.requester({ type: "protocolDescription" }),
|
|
|
|
/*
|
|
* Methods constructed by DebuggerClient.requester require these forwards
|
|
* on their 'this'.
|
|
*/
|
|
get _transport() { return this._client._transport; },
|
|
get request() { return this._client.request; }
|
|
};
|
|
|
|
/**
|
|
* Creates a thread client for the remote debugging protocol server. This client
|
|
* is a front to the thread actor created in the server side, hiding the
|
|
* protocol details in a traditional JavaScript API.
|
|
*
|
|
* @param aClient DebuggerClient|TabClient
|
|
* The parent of the thread (tab for tab-scoped debuggers, DebuggerClient
|
|
* for chrome debuggers).
|
|
* @param aActor string
|
|
* The actor ID for this thread.
|
|
*/
|
|
function ThreadClient(aClient, aActor) {
|
|
this._parent = aClient;
|
|
this.client = aClient instanceof DebuggerClient ? aClient : aClient.client;
|
|
this._actor = aActor;
|
|
this._frameCache = [];
|
|
this._scriptCache = {};
|
|
this._pauseGrips = {};
|
|
this._threadGrips = {};
|
|
this.request = this.client.request;
|
|
}
|
|
|
|
ThreadClient.prototype = {
|
|
_state: "paused",
|
|
get state() { return this._state; },
|
|
get paused() { return this._state === "paused"; },
|
|
|
|
_pauseOnExceptions: false,
|
|
_ignoreCaughtExceptions: false,
|
|
_pauseOnDOMEvents: null,
|
|
|
|
_actor: null,
|
|
get actor() { return this._actor; },
|
|
|
|
get _transport() { return this.client._transport; },
|
|
|
|
_assertPaused: function (aCommand) {
|
|
if (!this.paused) {
|
|
throw Error(aCommand + " command sent while not paused. Currently " + this._state);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Resume a paused thread. If the optional aLimit parameter is present, then
|
|
* the thread will also pause when that limit is reached.
|
|
*
|
|
* @param [optional] object aLimit
|
|
* An object with a type property set to the appropriate limit (next,
|
|
* step, or finish) per the remote debugging protocol specification.
|
|
* Use null to specify no limit.
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
_doResume: DebuggerClient.requester({
|
|
type: "resume",
|
|
resumeLimit: args(0)
|
|
}, {
|
|
before: function (aPacket) {
|
|
this._assertPaused("resume");
|
|
|
|
// Put the client in a tentative "resuming" state so we can prevent
|
|
// further requests that should only be sent in the paused state.
|
|
this._previousState = this._state;
|
|
this._state = "resuming";
|
|
|
|
if (this._pauseOnExceptions) {
|
|
aPacket.pauseOnExceptions = this._pauseOnExceptions;
|
|
}
|
|
if (this._ignoreCaughtExceptions) {
|
|
aPacket.ignoreCaughtExceptions = this._ignoreCaughtExceptions;
|
|
}
|
|
if (this._pauseOnDOMEvents) {
|
|
aPacket.pauseOnDOMEvents = this._pauseOnDOMEvents;
|
|
}
|
|
return aPacket;
|
|
},
|
|
after: function (aResponse) {
|
|
if (aResponse.error && this._state == "resuming") {
|
|
// There was an error resuming, update the state to the new one
|
|
// reported by the server, if given (only on wrongState), otherwise
|
|
// reset back to the previous state.
|
|
if (aResponse.state) {
|
|
this._state = ThreadStateTypes[aResponse.state];
|
|
} else {
|
|
this._state = this._previousState;
|
|
}
|
|
}
|
|
delete this._previousState;
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Reconfigure the thread actor.
|
|
*
|
|
* @param object aOptions
|
|
* A dictionary object of the new options to use in the thread actor.
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
reconfigure: DebuggerClient.requester({
|
|
type: "reconfigure",
|
|
options: args(0)
|
|
}),
|
|
|
|
/**
|
|
* Resume a paused thread.
|
|
*/
|
|
resume: function (aOnResponse) {
|
|
return this._doResume(null, aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Resume then pause without stepping.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
resumeThenPause: function (aOnResponse) {
|
|
return this._doResume({ type: "break" }, aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Step over a function call.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
stepOver: function (aOnResponse) {
|
|
return this._doResume({ type: "next" }, aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Step into a function call.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
stepIn: function (aOnResponse) {
|
|
return this._doResume({ type: "step" }, aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Step out of a function call.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
stepOut: function (aOnResponse) {
|
|
return this._doResume({ type: "finish" }, aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Immediately interrupt a running thread.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
interrupt: function (aOnResponse) {
|
|
return this._doInterrupt(null, aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Pause execution right before the next JavaScript bytecode is executed.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
breakOnNext: function (aOnResponse) {
|
|
return this._doInterrupt("onNext", aOnResponse);
|
|
},
|
|
|
|
/**
|
|
* Interrupt a running thread.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
_doInterrupt: DebuggerClient.requester({
|
|
type: "interrupt",
|
|
when: args(0)
|
|
}),
|
|
|
|
/**
|
|
* Enable or disable pausing when an exception is thrown.
|
|
*
|
|
* @param boolean aFlag
|
|
* Enables pausing if true, disables otherwise.
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
pauseOnExceptions: function (aPauseOnExceptions,
|
|
aIgnoreCaughtExceptions,
|
|
aOnResponse = noop) {
|
|
this._pauseOnExceptions = aPauseOnExceptions;
|
|
this._ignoreCaughtExceptions = aIgnoreCaughtExceptions;
|
|
|
|
// Otherwise send the flag using a standard resume request.
|
|
if (!this.paused) {
|
|
return this.interrupt(aResponse => {
|
|
if (aResponse.error) {
|
|
// Can't continue if pausing failed.
|
|
aOnResponse(aResponse);
|
|
return aResponse;
|
|
}
|
|
return this.resume(aOnResponse);
|
|
});
|
|
}
|
|
|
|
aOnResponse();
|
|
return promise.resolve();
|
|
},
|
|
|
|
/**
|
|
* Enable pausing when the specified DOM events are triggered. Disabling
|
|
* pausing on an event can be realized by calling this method with the updated
|
|
* array of events that doesn't contain it.
|
|
*
|
|
* @param array|string events
|
|
* An array of strings, representing the DOM event types to pause on,
|
|
* or "*" to pause on all DOM events. Pass an empty array to
|
|
* completely disable pausing on DOM events.
|
|
* @param function onResponse
|
|
* Called with the response packet in a future turn of the event loop.
|
|
*/
|
|
pauseOnDOMEvents: function (events, onResponse = noop) {
|
|
this._pauseOnDOMEvents = events;
|
|
// If the debuggee is paused, the value of the array will be communicated in
|
|
// the next resumption. Otherwise we have to force a pause in order to send
|
|
// the array.
|
|
if (this.paused) {
|
|
DevToolsUtils.executeSoon(() => onResponse({}));
|
|
return {};
|
|
}
|
|
return this.interrupt(response => {
|
|
// Can't continue if pausing failed.
|
|
if (response.error) {
|
|
onResponse(response);
|
|
return response;
|
|
}
|
|
return this.resume(onResponse);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Send a clientEvaluate packet to the debuggee. Response
|
|
* will be a resume packet.
|
|
*
|
|
* @param string aFrame
|
|
* The actor ID of the frame where the evaluation should take place.
|
|
* @param string aExpression
|
|
* The expression that will be evaluated in the scope of the frame
|
|
* above.
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
eval: DebuggerClient.requester({
|
|
type: "clientEvaluate",
|
|
frame: args(0),
|
|
expression: args(1)
|
|
}, {
|
|
before: function (aPacket) {
|
|
this._assertPaused("eval");
|
|
// Put the client in a tentative "resuming" state so we can prevent
|
|
// further requests that should only be sent in the paused state.
|
|
this._state = "resuming";
|
|
return aPacket;
|
|
},
|
|
after: function (aResponse) {
|
|
if (aResponse.error) {
|
|
// There was an error resuming, back to paused state.
|
|
this._state = "paused";
|
|
}
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Detach from the thread actor.
|
|
*
|
|
* @param function aOnResponse
|
|
* Called with the response packet.
|
|
*/
|
|
detach: DebuggerClient.requester({
|
|
type: "detach"
|
|
}, {
|
|
after: function (aResponse) {
|
|
this.client.unregisterClient(this);
|
|
this._parent.thread = null;
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Release multiple thread-lifetime object actors. If any pause-lifetime
|
|
* actors are included in the request, a |notReleasable| error will return,
|
|
* but all the thread-lifetime ones will have been released.
|
|
*
|
|
* @param array actors
|
|
* An array with actor IDs to release.
|
|
*/
|
|
releaseMany: DebuggerClient.requester({
|
|
type: "releaseMany",
|
|
actors: args(0),
|
|
}),
|
|
|
|
/**
|
|
* Promote multiple pause-lifetime object actors to thread-lifetime ones.
|
|
*
|
|
* @param array actors
|
|
* An array with actor IDs to promote.
|
|
*/
|
|
threadGrips: DebuggerClient.requester({
|
|
type: "threadGrips",
|
|
actors: args(0)
|
|
}),
|
|
|
|
/**
|
|
* Return the event listeners defined on the page.
|
|
*
|
|
* @param aOnResponse Function
|
|
* Called with the thread's response.
|
|
*/
|
|
eventListeners: DebuggerClient.requester({
|
|
type: "eventListeners"
|
|
}),
|
|
|
|
/**
|
|
* Request the loaded sources for the current thread.
|
|
*
|
|
* @param aOnResponse Function
|
|
* Called with the thread's response.
|
|
*/
|
|
getSources: DebuggerClient.requester({
|
|
type: "sources"
|
|
}),
|
|
|
|
/**
|
|
* Clear the thread's source script cache. A scriptscleared event
|
|
* will be sent.
|
|
*/
|
|
_clearScripts: function () {
|
|
if (Object.keys(this._scriptCache).length > 0) {
|
|
this._scriptCache = {};
|
|
this.emit("scriptscleared");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Request frames from the callstack for the current thread.
|
|
*
|
|
* @param aStart integer
|
|
* The number of the youngest stack frame to return (the youngest
|
|
* frame is 0).
|
|
* @param aCount integer
|
|
* The maximum number of frames to return, or null to return all
|
|
* frames.
|
|
* @param aOnResponse function
|
|
* Called with the thread's response.
|
|
*/
|
|
getFrames: DebuggerClient.requester({
|
|
type: "frames",
|
|
start: args(0),
|
|
count: args(1)
|
|
}),
|
|
|
|
/**
|
|
* An array of cached frames. Clients can observe the framesadded and
|
|
* framescleared event to keep up to date on changes to this cache,
|
|
* and can fill it using the fillFrames method.
|
|
*/
|
|
get cachedFrames() { return this._frameCache; },
|
|
|
|
/**
|
|
* true if there are more stack frames available on the server.
|
|
*/
|
|
get moreFrames() {
|
|
return this.paused && (!this._frameCache || this._frameCache.length == 0
|
|
|| !this._frameCache[this._frameCache.length - 1].oldest);
|
|
},
|
|
|
|
/**
|
|
* Ensure that at least aTotal stack frames have been loaded in the
|
|
* ThreadClient's stack frame cache. A framesadded event will be
|
|
* sent when the stack frame cache is updated.
|
|
*
|
|
* @param aTotal number
|
|
* The minimum number of stack frames to be included.
|
|
* @param aCallback function
|
|
* Optional callback function called when frames have been loaded
|
|
* @returns true if a framesadded notification should be expected.
|
|
*/
|
|
fillFrames: function (aTotal, aCallback = noop) {
|
|
this._assertPaused("fillFrames");
|
|
if (this._frameCache.length >= aTotal) {
|
|
return false;
|
|
}
|
|
|
|
let numFrames = this._frameCache.length;
|
|
|
|
this.getFrames(numFrames, aTotal - numFrames, (aResponse) => {
|
|
if (aResponse.error) {
|
|
aCallback(aResponse);
|
|
return;
|
|
}
|
|
|
|
let threadGrips = DevToolsUtils.values(this._threadGrips);
|
|
|
|
for (let i in aResponse.frames) {
|
|
let frame = aResponse.frames[i];
|
|
if (!frame.where.source) {
|
|
// Older servers use urls instead, so we need to resolve
|
|
// them to source actors
|
|
for (let grip of threadGrips) {
|
|
if (grip instanceof SourceClient && grip.url === frame.url) {
|
|
frame.where.source = grip._form;
|
|
}
|
|
}
|
|
}
|
|
|
|
this._frameCache[frame.depth] = frame;
|
|
}
|
|
|
|
// If we got as many frames as we asked for, there might be more
|
|
// frames available.
|
|
this.emit("framesadded");
|
|
|
|
aCallback(aResponse);
|
|
});
|
|
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* Clear the thread's stack frame cache. A framescleared event
|
|
* will be sent.
|
|
*/
|
|
_clearFrames: function () {
|
|
if (this._frameCache.length > 0) {
|
|
this._frameCache = [];
|
|
this.emit("framescleared");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Return a ObjectClient object for the given object grip.
|
|
*
|
|
* @param aGrip object
|
|
* A pause-lifetime object grip returned by the protocol.
|
|
*/
|
|
pauseGrip: function (aGrip) {
|
|
if (aGrip.actor in this._pauseGrips) {
|
|
return this._pauseGrips[aGrip.actor];
|
|
}
|
|
|
|
let client = new ObjectClient(this.client, aGrip);
|
|
this._pauseGrips[aGrip.actor] = client;
|
|
return client;
|
|
},
|
|
|
|
/**
|
|
* Get or create a long string client, checking the grip client cache if it
|
|
* already exists.
|
|
*
|
|
* @param aGrip Object
|
|
* The long string grip returned by the protocol.
|
|
* @param aGripCacheName String
|
|
* The property name of the grip client cache to check for existing
|
|
* clients in.
|
|
*/
|
|
_longString: function (aGrip, aGripCacheName) {
|
|
if (aGrip.actor in this[aGripCacheName]) {
|
|
return this[aGripCacheName][aGrip.actor];
|
|
}
|
|
|
|
let client = new LongStringClient(this.client, aGrip);
|
|
this[aGripCacheName][aGrip.actor] = client;
|
|
return client;
|
|
},
|
|
|
|
/**
|
|
* Return an instance of LongStringClient for the given long string grip that
|
|
* is scoped to the current pause.
|
|
*
|
|
* @param aGrip Object
|
|
* The long string grip returned by the protocol.
|
|
*/
|
|
pauseLongString: function (aGrip) {
|
|
return this._longString(aGrip, "_pauseGrips");
|
|
},
|
|
|
|
/**
|
|
* Return an instance of LongStringClient for the given long string grip that
|
|
* is scoped to the thread lifetime.
|
|
*
|
|
* @param aGrip Object
|
|
* The long string grip returned by the protocol.
|
|
*/
|
|
threadLongString: function (aGrip) {
|
|
return this._longString(aGrip, "_threadGrips");
|
|
},
|
|
|
|
/**
|
|
* Clear and invalidate all the grip clients from the given cache.
|
|
*
|
|
* @param aGripCacheName
|
|
* The property name of the grip cache we want to clear.
|
|
*/
|
|
_clearObjectClients: function (aGripCacheName) {
|
|
for (let id in this[aGripCacheName]) {
|
|
this[aGripCacheName][id].valid = false;
|
|
}
|
|
this[aGripCacheName] = {};
|
|
},
|
|
|
|
/**
|
|
* Invalidate pause-lifetime grip clients and clear the list of current grip
|
|
* clients.
|
|
*/
|
|
_clearPauseGrips: function () {
|
|
this._clearObjectClients("_pauseGrips");
|
|
},
|
|
|
|
/**
|
|
* Invalidate thread-lifetime grip clients and clear the list of current grip
|
|
* clients.
|
|
*/
|
|
_clearThreadGrips: function () {
|
|
this._clearObjectClients("_threadGrips");
|
|
},
|
|
|
|
/**
|
|
* Handle thread state change by doing necessary cleanup and notifying all
|
|
* registered listeners.
|
|
*/
|
|
_onThreadState: function (aPacket) {
|
|
this._state = ThreadStateTypes[aPacket.type];
|
|
// The debugger UI may not be initialized yet so we want to keep
|
|
// the packet around so it knows what to pause state to display
|
|
// when it's initialized
|
|
this._lastPausePacket = aPacket.type === "resumed" ? null : aPacket;
|
|
this._clearFrames();
|
|
this._clearPauseGrips();
|
|
aPacket.type === ThreadStateTypes.detached && this._clearThreadGrips();
|
|
this.client._eventsEnabled && this.emit(aPacket.type, aPacket);
|
|
},
|
|
|
|
getLastPausePacket: function () {
|
|
return this._lastPausePacket;
|
|
},
|
|
|
|
/**
|
|
* Return an EnvironmentClient instance for the given environment actor form.
|
|
*/
|
|
environment: function (aForm) {
|
|
return new EnvironmentClient(this.client, aForm);
|
|
},
|
|
|
|
/**
|
|
* Return an instance of SourceClient for the given source actor form.
|
|
*/
|
|
source: function (aForm) {
|
|
if (aForm.actor in this._threadGrips) {
|
|
return this._threadGrips[aForm.actor];
|
|
}
|
|
|
|
return this._threadGrips[aForm.actor] = new SourceClient(this, aForm);
|
|
},
|
|
|
|
/**
|
|
* Request the prototype and own properties of mutlipleObjects.
|
|
*
|
|
* @param aOnResponse function
|
|
* Called with the request's response.
|
|
* @param actors [string]
|
|
* List of actor ID of the queried objects.
|
|
*/
|
|
getPrototypesAndProperties: DebuggerClient.requester({
|
|
type: "prototypesAndProperties",
|
|
actors: args(0)
|
|
}),
|
|
|
|
events: ["newSource"]
|
|
};
|
|
|
|
eventSource(ThreadClient.prototype);
|
|
|
|
/**
|
|
* Creates a tracing profiler client for the remote debugging protocol
|
|
* server. This client is a front to the trace actor created on the
|
|
* server side, hiding the protocol details in a traditional
|
|
* JavaScript API.
|
|
*
|
|
* @param aClient DebuggerClient
|
|
* The debugger client parent.
|
|
* @param aActor string
|
|
* The actor ID for this thread.
|
|
*/
|
|
function TraceClient(aClient, aActor) {
|
|
this._client = aClient;
|
|
this._actor = aActor;
|
|
this._activeTraces = new Set();
|
|
this._waitingPackets = new Map();
|
|
this._expectedPacket = 0;
|
|
this.request = this._client.request;
|
|
this.events = [];
|
|
}
|
|
|
|
TraceClient.prototype = {
|
|
get actor() { return this._actor; },
|
|
get tracing() { return this._activeTraces.size > 0; },
|
|
|
|
get _transport() { return this._client._transport; },
|
|
|
|
/**
|
|
* Detach from the trace actor.
|
|
*/
|
|
detach: DebuggerClient.requester({
|
|
type: "detach"
|
|
}, {
|
|
after: function (aResponse) {
|
|
this._client.unregisterClient(this);
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Start a new trace.
|
|
*
|
|
* @param aTrace [string]
|
|
* An array of trace types to be recorded by the new trace.
|
|
*
|
|
* @param aName string
|
|
* The name of the new trace.
|
|
*
|
|
* @param aOnResponse function
|
|
* Called with the request's response.
|
|
*/
|
|
startTrace: DebuggerClient.requester({
|
|
type: "startTrace",
|
|
name: args(1),
|
|
trace: args(0)
|
|
}, {
|
|
after: function (aResponse) {
|
|
if (aResponse.error) {
|
|
return aResponse;
|
|
}
|
|
|
|
if (!this.tracing) {
|
|
this._waitingPackets.clear();
|
|
this._expectedPacket = 0;
|
|
}
|
|
this._activeTraces.add(aResponse.name);
|
|
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* End a trace. If a name is provided, stop the named
|
|
* trace. Otherwise, stop the most recently started trace.
|
|
*
|
|
* @param aName string
|
|
* The name of the trace to stop.
|
|
*
|
|
* @param aOnResponse function
|
|
* Called with the request's response.
|
|
*/
|
|
stopTrace: DebuggerClient.requester({
|
|
type: "stopTrace",
|
|
name: args(0)
|
|
}, {
|
|
after: function (aResponse) {
|
|
if (aResponse.error) {
|
|
return aResponse;
|
|
}
|
|
|
|
this._activeTraces.delete(aResponse.name);
|
|
|
|
return aResponse;
|
|
},
|
|
})
|
|
};
|
|
|
|
/**
|
|
* Grip clients are used to retrieve information about the relevant object.
|
|
*
|
|
* @param aClient DebuggerClient
|
|
* The debugger client parent.
|
|
* @param aGrip object
|
|
* A pause-lifetime object grip returned by the protocol.
|
|
*/
|
|
function ObjectClient(aClient, aGrip)
|
|
{
|
|
this._grip = aGrip;
|
|
this._client = aClient;
|
|
this.request = this._client.request;
|
|
}
|
|
exports.ObjectClient = ObjectClient;
|
|
|
|
ObjectClient.prototype = {
|
|
get actor() { return this._grip.actor; },
|
|
get _transport() { return this._client._transport; },
|
|
|
|
valid: true,
|
|
|
|
get isFrozen() {
|
|
return this._grip.frozen;
|
|
},
|
|
get isSealed() {
|
|
return this._grip.sealed;
|
|
},
|
|
get isExtensible() {
|
|
return this._grip.extensible;
|
|
},
|
|
|
|
getDefinitionSite: DebuggerClient.requester({
|
|
type: "definitionSite"
|
|
}, {
|
|
before: function (aPacket) {
|
|
if (this._grip.class != "Function") {
|
|
throw new Error("getDefinitionSite is only valid for function grips.");
|
|
}
|
|
return aPacket;
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Request the names of a function's formal parameters.
|
|
*
|
|
* @param aOnResponse function
|
|
* Called with an object of the form:
|
|
* { parameterNames:[<parameterName>, ...] }
|
|
* where each <parameterName> is the name of a parameter.
|
|
*/
|
|
getParameterNames: DebuggerClient.requester({
|
|
type: "parameterNames"
|
|
}, {
|
|
before: function (aPacket) {
|
|
if (this._grip["class"] !== "Function") {
|
|
throw new Error("getParameterNames is only valid for function grips.");
|
|
}
|
|
return aPacket;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Request the names of the properties defined on the object and not its
|
|
* prototype.
|
|
*
|
|
* @param aOnResponse function Called with the request's response.
|
|
*/
|
|
getOwnPropertyNames: DebuggerClient.requester({
|
|
type: "ownPropertyNames"
|
|
}),
|
|
|
|
/**
|
|
* Request the prototype and own properties of the object.
|
|
*
|
|
* @param aOnResponse function Called with the request's response.
|
|
*/
|
|
getPrototypeAndProperties: DebuggerClient.requester({
|
|
type: "prototypeAndProperties"
|
|
}),
|
|
|
|
/**
|
|
* Request a PropertyIteratorClient instance to ease listing
|
|
* properties for this object.
|
|
*
|
|
* @param options Object
|
|
* A dictionary object with various boolean attributes:
|
|
* - ignoreIndexedProperties Boolean
|
|
* If true, filters out Array items.
|
|
* e.g. properties names between `0` and `object.length`.
|
|
* - ignoreNonIndexedProperties Boolean
|
|
* If true, filters out items that aren't array items
|
|
* e.g. properties names that are not a number between `0`
|
|
* and `object.length`.
|
|
* - sort Boolean
|
|
* If true, the iterator will sort the properties by name
|
|
* before dispatching them.
|
|
* @param aOnResponse function Called with the client instance.
|
|
*/
|
|
enumProperties: DebuggerClient.requester({
|
|
type: "enumProperties",
|
|
options: args(0)
|
|
}, {
|
|
after: function (aResponse) {
|
|
if (aResponse.iterator) {
|
|
return { iterator: new PropertyIteratorClient(this._client, aResponse.iterator) };
|
|
}
|
|
return aResponse;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Request a PropertyIteratorClient instance to enumerate entries in a
|
|
* Map/Set-like object.
|
|
*
|
|
* @param aOnResponse function Called with the request's response.
|
|
*/
|
|
enumEntries: DebuggerClient.requester({
|
|
type: "enumEntries"
|
|
}, {
|
|
before: function (packet) {
|
|
if (!["Map", "WeakMap", "Set", "WeakSet"].includes(this._grip.class)) {
|
|
throw new Error("enumEntries is only valid for Map/Set-like grips.");
|
|
}
|
|
return packet;
|
|
},
|
|
after: function (response) {
|
|
if (response.iterator) {
|
|
return {
|
|
iterator: new PropertyIteratorClient(this._client, response.iterator)
|
|
};
|
|
}
|
|
return response;
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Request the property descriptor of the object's specified property.
|
|
*
|
|
* @param aName string The name of the requested property.
|
|
* @param aOnResponse function Called with the request's response.
|
|
*/
|
|
getProperty: DebuggerClient.requester({
|
|
type: "property",
|
|
name: args(0)
|
|
}),
|
|
|
|
/**
|
|
* Request the prototype of the object.
|
|
*
|
|
* @param aOnResponse function Called with the request's response.
|
|
*/
|
|
getPrototype: DebuggerClient.requester({
|
|
type: "prototype"
|
|
}),
|
|
|
|
/**
|
|
* Request the display string of the object.
|
|
*
|
|
* @param aOnResponse function Called with the request's response.
|
|
*/
|
|
getDisplayString: DebuggerClient.requester({
|
|
type: "displayString"
|
|
}),
|
|
|
|
/**
|
|
* Request the scope of the object.
|
|
*
|
|
* @param aOnResponse function Called with the request's response.
|
|
*/
|
|
getScope: DebuggerClient.requester({
|
|
type: "scope"
|
|
}, {
|
|
before: function (aPacket) {
|
|
if (this._grip.class !== "Function") {
|
|
throw new Error("scope is only valid for function grips.");
|
|
}
|
|
return aPacket;
|
|
},
|
|
}),
|
|
|
|
/**
|
|
* Request the promises directly depending on the current promise.
|
|
*/
|
|
getDependentPromises: DebuggerClient.requester({
|
|
type: "dependentPromises"
|
|
}, {
|
|
before: function (aPacket) {
|
|
if (this._grip.class !== "Promise") {
|
|
throw new Error("getDependentPromises is only valid for promise " +
|
|
"grips.");
|
|
}
|
|
return aPacket;
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Request the stack to the promise's allocation point.
|
|
*/
|
|
getPromiseAllocationStack: DebuggerClient.requester({
|
|
type: "allocationStack"
|
|
}, {
|
|
before: function (aPacket) {
|
|
if (this._grip.class !== "Promise") {
|
|
throw new Error("getAllocationStack is only valid for promise grips.");
|
|
}
|
|
return aPacket;
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Request the stack to the promise's fulfillment point.
|
|
*/
|
|
getPromiseFulfillmentStack: DebuggerClient.requester({
|
|
type: "fulfillmentStack"
|
|
}, {
|
|
before: function (packet) {
|
|
if (this._grip.class !== "Promise") {
|
|
throw new Error("getPromiseFulfillmentStack is only valid for " +
|
|
"promise grips.");
|
|
}
|
|
return packet;
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Request the stack to the promise's rejection point.
|
|
*/
|
|
getPromiseRejectionStack: DebuggerClient.requester({
|
|
type: "rejectionStack"
|
|
}, {
|
|
before: function (packet) {
|
|
if (this._grip.class !== "Promise") {
|
|
throw new Error("getPromiseRejectionStack is only valid for " +
|
|
"promise grips.");
|
|
}
|
|
return packet;
|
|
}
|
|
})
|
|
};
|
|
|
|
/**
|
|
* A PropertyIteratorClient provides a way to access to property names and
|
|
* values of an object efficiently, slice by slice.
|
|
* Note that the properties can be sorted in the backend,
|
|
* this is controled while creating the PropertyIteratorClient
|
|
* from ObjectClient.enumProperties.
|
|
*
|
|
* @param aClient DebuggerClient
|
|
* The debugger client parent.
|
|
* @param aGrip Object
|
|
* A PropertyIteratorActor grip returned by the protocol via
|
|
* TabActor.enumProperties request.
|
|
*/
|
|
function PropertyIteratorClient(aClient, aGrip) {
|
|
this._grip = aGrip;
|
|
this._client = aClient;
|
|
this.request = this._client.request;
|
|
}
|
|
|
|
PropertyIteratorClient.prototype = {
|
|
get actor() { return this._grip.actor; },
|
|
|
|
/**
|
|
* Get the total number of properties available in the iterator.
|
|
*/
|
|
get count() { return this._grip.count; },
|
|
|
|
/**
|
|
* Get one or more property names that correspond to the positions in the
|
|
* indexes parameter.
|
|
*
|
|
* @param indexes Array
|
|
* An array of property indexes.
|
|
* @param aCallback Function
|
|
* The function called when we receive the property names.
|
|
*/
|
|
names: DebuggerClient.requester({
|
|
type: "names",
|
|
indexes: args(0)
|
|
}, {}),
|
|
|
|
/**
|
|
* Get a set of following property value(s).
|
|
*
|
|
* @param start Number
|
|
* The index of the first property to fetch.
|
|
* @param count Number
|
|
* The number of properties to fetch.
|
|
* @param aCallback Function
|
|
* The function called when we receive the property values.
|
|
*/
|
|
slice: DebuggerClient.requester({
|
|
type: "slice",
|
|
start: args(0),
|
|
count: args(1)
|
|
}, {}),
|
|
|
|
/**
|
|
* Get all the property values.
|
|
*
|
|
* @param aCallback Function
|
|
* The function called when we receive the property values.
|
|
*/
|
|
all: DebuggerClient.requester({
|
|
type: "all"
|
|
}, {}),
|
|
};
|
|
|
|
/**
|
|
* A LongStringClient provides a way to access "very long" strings from the
|
|
* debugger server.
|
|
*
|
|
* @param aClient DebuggerClient
|
|
* The debugger client parent.
|
|
* @param aGrip Object
|
|
* A pause-lifetime long string grip returned by the protocol.
|
|
*/
|
|
function LongStringClient(aClient, aGrip) {
|
|
this._grip = aGrip;
|
|
this._client = aClient;
|
|
this.request = this._client.request;
|
|
}
|
|
exports.LongStringClient = LongStringClient;
|
|
|
|
LongStringClient.prototype = {
|
|
get actor() { return this._grip.actor; },
|
|
get length() { return this._grip.length; },
|
|
get initial() { return this._grip.initial; },
|
|
get _transport() { return this._client._transport; },
|
|
|
|
valid: true,
|
|
|
|
/**
|
|
* Get the substring of this LongString from aStart to aEnd.
|
|
*
|
|
* @param aStart Number
|
|
* The starting index.
|
|
* @param aEnd Number
|
|
* The ending index.
|
|
* @param aCallback Function
|
|
* The function called when we receive the substring.
|
|
*/
|
|
substring: DebuggerClient.requester({
|
|
type: "substring",
|
|
start: args(0),
|
|
end: args(1)
|
|
}),
|
|
};
|
|
|
|
/**
|
|
* A SourceClient provides a way to access the source text of a script.
|
|
*
|
|
* @param aClient ThreadClient
|
|
* The thread client parent.
|
|
* @param aForm Object
|
|
* The form sent across the remote debugging protocol.
|
|
*/
|
|
function SourceClient(aClient, aForm) {
|
|
this._form = aForm;
|
|
this._isBlackBoxed = aForm.isBlackBoxed;
|
|
this._isPrettyPrinted = aForm.isPrettyPrinted;
|
|
this._activeThread = aClient;
|
|
this._client = aClient.client;
|
|
}
|
|
|
|
SourceClient.prototype = {
|
|
get _transport() {
|
|
return this._client._transport;
|
|
},
|
|
get isBlackBoxed() {
|
|
return this._isBlackBoxed;
|
|
},
|
|
get isPrettyPrinted() {
|
|
return this._isPrettyPrinted;
|
|
},
|
|
get actor() {
|
|
return this._form.actor;
|
|
},
|
|
get request() {
|
|
return this._client.request;
|
|
},
|
|
get url() {
|
|
return this._form.url;
|
|
},
|
|
|
|
/**
|
|
* Black box this SourceClient's source.
|
|
*
|
|
* @param aCallback Function
|
|
* The callback function called when we receive the response from the server.
|
|
*/
|
|
blackBox: DebuggerClient.requester({
|
|
type: "blackbox"
|
|
}, {
|
|
after: function (aResponse) {
|
|
if (!aResponse.error) {
|
|
this._isBlackBoxed = true;
|
|
if (this._activeThread) {
|
|
this._activeThread.emit("blackboxchange", this);
|
|
}
|
|
}
|
|
return aResponse;
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Un-black box this SourceClient's source.
|
|
*
|
|
* @param aCallback Function
|
|
* The callback function called when we receive the response from the server.
|
|
*/
|
|
unblackBox: DebuggerClient.requester({
|
|
type: "unblackbox"
|
|
}, {
|
|
after: function (aResponse) {
|
|
if (!aResponse.error) {
|
|
this._isBlackBoxed = false;
|
|
if (this._activeThread) {
|
|
this._activeThread.emit("blackboxchange", this);
|
|
}
|
|
}
|
|
return aResponse;
|
|
}
|
|
}),
|
|
|
|
/**
|
|
* Get Executable Lines from a source
|
|
*
|
|
* @param aCallback Function
|
|
* The callback function called when we receive the response from the server.
|
|
*/
|
|
getExecutableLines: function (cb = noop) {
|
|
let packet = {
|
|
to: this._form.actor,
|
|
type: "getExecutableLines"
|
|
};
|
|
|
|
return this._client.request(packet).then(res => {
|
|
cb(res.lines);
|
|
return res.lines;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Get a long string grip for this SourceClient's source.
|
|
*/
|
|
source: function (aCallback = noop) {
|
|
let packet = {
|
|
to: this._form.actor,
|
|
type: "source"
|
|
};
|
|
return this._client.request(packet).then(aResponse => {
|
|
return this._onSourceResponse(aResponse, aCallback);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Pretty print this source's text.
|
|
*/
|
|
prettyPrint: function (aIndent, aCallback = noop) {
|
|
const packet = {
|
|
to: this._form.actor,
|
|
type: "prettyPrint",
|
|
indent: aIndent
|
|
};
|
|
return this._client.request(packet).then(aResponse => {
|
|
if (!aResponse.error) {
|
|
this._isPrettyPrinted = true;
|
|
this._activeThread._clearFrames();
|
|
this._activeThread.emit("prettyprintchange", this);
|
|
}
|
|
return this._onSourceResponse(aResponse, aCallback);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Stop pretty printing this source's text.
|
|
*/
|
|
disablePrettyPrint: function (aCallback = noop) {
|
|
const packet = {
|
|
to: this._form.actor,
|
|
type: "disablePrettyPrint"
|
|
};
|
|
return this._client.request(packet).then(aResponse => {
|
|
if (!aResponse.error) {
|
|
this._isPrettyPrinted = false;
|
|
this._activeThread._clearFrames();
|
|
this._activeThread.emit("prettyprintchange", this);
|
|
}
|
|
return this._onSourceResponse(aResponse, aCallback);
|
|
});
|
|
},
|
|
|
|
_onSourceResponse: function (aResponse, aCallback) {
|
|
if (aResponse.error) {
|
|
aCallback(aResponse);
|
|
return aResponse;
|
|
}
|
|
|
|
if (typeof aResponse.source === "string") {
|
|
aCallback(aResponse);
|
|
return aResponse;
|
|
}
|
|
|
|
let { contentType, source } = aResponse;
|
|
let longString = this._activeThread.threadLongString(source);
|
|
return longString.substring(0, longString.length).then(function (aResponse) {
|
|
if (aResponse.error) {
|
|
aCallback(aResponse);
|
|
return aReponse;
|
|
}
|
|
|
|
let response = {
|
|
source: aResponse.substring,
|
|
contentType: contentType
|
|
};
|
|
aCallback(response);
|
|
return response;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Request to set a breakpoint in the specified location.
|
|
*
|
|
* @param object aLocation
|
|
* The location and condition of the breakpoint in
|
|
* the form of { line[, column, condition] }.
|
|
* @param function aOnResponse
|
|
* Called with the thread's response.
|
|
*/
|
|
setBreakpoint: function ({ line, column, condition, noSliding }, aOnResponse = noop) {
|
|
// A helper function that sets the breakpoint.
|
|
let doSetBreakpoint = aCallback => {
|
|
let root = this._client.mainRoot;
|
|
let location = {
|
|
line: line,
|
|
column: column
|
|
};
|
|
|
|
let packet = {
|
|
to: this.actor,
|
|
type: "setBreakpoint",
|
|
location: location,
|
|
condition: condition,
|
|
noSliding: noSliding
|
|
};
|
|
|
|
// Backwards compatibility: send the breakpoint request to the
|
|
// thread if the server doesn't support Debugger.Source actors.
|
|
if (!root.traits.debuggerSourceActors) {
|
|
packet.to = this._activeThread.actor;
|
|
packet.location.url = this.url;
|
|
}
|
|
|
|
return this._client.request(packet).then(aResponse => {
|
|
// Ignoring errors, since the user may be setting a breakpoint in a
|
|
// dead script that will reappear on a page reload.
|
|
let bpClient;
|
|
if (aResponse.actor) {
|
|
bpClient = new BreakpointClient(
|
|
this._client,
|
|
this,
|
|
aResponse.actor,
|
|
location,
|
|
root.traits.conditionalBreakpoints ? condition : undefined
|
|
);
|
|
}
|
|
aOnResponse(aResponse, bpClient);
|
|
if (aCallback) {
|
|
aCallback();
|
|
}
|
|
return [aResponse, bpClient];
|
|
});
|
|
};
|
|
|
|
// If the debuggee is paused, just set the breakpoint.
|
|
if (this._activeThread.paused) {
|
|
return doSetBreakpoint();
|
|
}
|
|
// Otherwise, force a pause in order to set the breakpoint.
|
|
return this._activeThread.interrupt().then(aResponse => {
|
|
if (aResponse.error) {
|
|
// Can't set the breakpoint if pausing failed.
|
|
aOnResponse(aResponse);
|
|
return aResponse;
|
|
}
|
|
|
|
const { type, why } = aResponse;
|
|
const cleanUp = type == "paused" && why.type == "interrupted"
|
|
? () => this._activeThread.resume()
|
|
: noop;
|
|
|
|
return doSetBreakpoint(cleanUp);
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Breakpoint clients are used to remove breakpoints that are no longer used.
|
|
*
|
|
* @param aClient DebuggerClient
|
|
* The debugger client parent.
|
|
* @param aSourceClient SourceClient
|
|
* The source where this breakpoint exists
|
|
* @param aActor string
|
|
* The actor ID for this breakpoint.
|
|
* @param aLocation object
|
|
* The location of the breakpoint. This is an object with two properties:
|
|
* url and line.
|
|
* @param aCondition string
|
|
* The conditional expression of the breakpoint
|
|
*/
|
|
function BreakpointClient(aClient, aSourceClient, aActor, aLocation, aCondition) {
|
|
this._client = aClient;
|
|
this._actor = aActor;
|
|
this.location = aLocation;
|
|
this.location.actor = aSourceClient.actor;
|
|
this.location.url = aSourceClient.url;
|
|
this.source = aSourceClient;
|
|
this.request = this._client.request;
|
|
|
|
// The condition property should only exist if it's a truthy value
|
|
if (aCondition) {
|
|
this.condition = aCondition;
|
|
}
|
|
}
|
|
|
|
BreakpointClient.prototype = {
|
|
|
|
_actor: null,
|
|
get actor() { return this._actor; },
|
|
get _transport() { return this._client._transport; },
|
|
|
|
/**
|
|
* Remove the breakpoint from the server.
|
|
*/
|
|
remove: DebuggerClient.requester({
|
|
type: "delete"
|
|
}),
|
|
|
|
/**
|
|
* Determines if this breakpoint has a condition
|
|
*/
|
|
hasCondition: function () {
|
|
let root = this._client.mainRoot;
|
|
// XXX bug 990137: We will remove support for client-side handling of
|
|
// conditional breakpoints
|
|
if (root.traits.conditionalBreakpoints) {
|
|
return "condition" in this;
|
|
} else {
|
|
return "conditionalExpression" in this;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get the condition of this breakpoint. Currently we have to
|
|
* support locally emulated conditional breakpoints until the
|
|
* debugger servers are updated (see bug 990137). We used a
|
|
* different property when moving it server-side to ensure that we
|
|
* are testing the right code.
|
|
*/
|
|
getCondition: function () {
|
|
let root = this._client.mainRoot;
|
|
if (root.traits.conditionalBreakpoints) {
|
|
return this.condition;
|
|
} else {
|
|
return this.conditionalExpression;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Set the condition of this breakpoint
|
|
*/
|
|
setCondition: function (gThreadClient, aCondition) {
|
|
let root = this._client.mainRoot;
|
|
let deferred = promise.defer();
|
|
|
|
if (root.traits.conditionalBreakpoints) {
|
|
let info = {
|
|
line: this.location.line,
|
|
column: this.location.column,
|
|
condition: aCondition
|
|
};
|
|
|
|
// Remove the current breakpoint and add a new one with the
|
|
// condition.
|
|
this.remove(aResponse => {
|
|
if (aResponse && aResponse.error) {
|
|
deferred.reject(aResponse);
|
|
return;
|
|
}
|
|
|
|
this.source.setBreakpoint(info, (aResponse, aNewBreakpoint) => {
|
|
if (aResponse && aResponse.error) {
|
|
deferred.reject(aResponse);
|
|
} else {
|
|
deferred.resolve(aNewBreakpoint);
|
|
}
|
|
});
|
|
});
|
|
} else {
|
|
// The property shouldn't even exist if the condition is blank
|
|
if (aCondition === "") {
|
|
delete this.conditionalExpression;
|
|
}
|
|
else {
|
|
this.conditionalExpression = aCondition;
|
|
}
|
|
deferred.resolve(this);
|
|
}
|
|
|
|
return deferred.promise;
|
|
}
|
|
};
|
|
|
|
eventSource(BreakpointClient.prototype);
|
|
|
|
/**
|
|
* Environment clients are used to manipulate the lexical environment actors.
|
|
*
|
|
* @param aClient DebuggerClient
|
|
* The debugger client parent.
|
|
* @param aForm Object
|
|
* The form sent across the remote debugging protocol.
|
|
*/
|
|
function EnvironmentClient(aClient, aForm) {
|
|
this._client = aClient;
|
|
this._form = aForm;
|
|
this.request = this._client.request;
|
|
}
|
|
exports.EnvironmentClient = EnvironmentClient;
|
|
|
|
EnvironmentClient.prototype = {
|
|
|
|
get actor() {
|
|
return this._form.actor;
|
|
},
|
|
get _transport() { return this._client._transport; },
|
|
|
|
/**
|
|
* Fetches the bindings introduced by this lexical environment.
|
|
*/
|
|
getBindings: DebuggerClient.requester({
|
|
type: "bindings"
|
|
}),
|
|
|
|
/**
|
|
* Changes the value of the identifier whose name is name (a string) to that
|
|
* represented by value (a grip).
|
|
*/
|
|
assign: DebuggerClient.requester({
|
|
type: "assign",
|
|
name: args(0),
|
|
value: args(1)
|
|
})
|
|
};
|
|
|
|
eventSource(EnvironmentClient.prototype);
|