mirror of https://github.com/axmolengine/axmol.git
3922 lines
124 KiB
JavaScript
3922 lines
124 KiB
JavaScript
/* -*- indent-tabs-mode: nil; js-indent-level: 2; js-indent-level: 2 -*- */
|
|
/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
"use strict";
|
|
|
|
// const Services = require("Services");
|
|
// const { Cc, Ci, Cu, components, ChromeWorker } = require("chrome");
|
|
// const { ActorPool, OriginalLocation, GeneratedLocation } = require("devtools/server/actors/common");
|
|
// const { ObjectActor, createValueGrip, longStringGrip } = require("devtools/server/actors/object");
|
|
// const { DebuggerServer } = require("devtools/server/main");
|
|
// const DevToolsUtils = require("devtools/toolkit/DevToolsUtils");
|
|
const { dbg_assert, dumpn, update } = DevToolsUtils;
|
|
// const { dirname, joinURI } = require("devtools/toolkit/path");
|
|
// const promise = require("promise");
|
|
// const PromiseDebugging = require("PromiseDebugging");
|
|
// const xpcInspector = require("xpcInspector");
|
|
// const ScriptStore = require("./utils/ScriptStore");
|
|
// const { DevToolsWorker } = require("devtools/toolkit/shared/worker.js");
|
|
|
|
// const { defer, resolve, reject, all } = promise;
|
|
|
|
// loader.lazyGetter(this, "Debugger", () => {
|
|
// let Debugger = require("Debugger");
|
|
// hackDebugger(Debugger);
|
|
// return Debugger;
|
|
// });
|
|
// loader.lazyRequireGetter(this, "SourceMapConsumer", "source-map", true);
|
|
// loader.lazyRequireGetter(this, "SourceMapGenerator", "source-map", true);
|
|
// loader.lazyRequireGetter(this, "CssLogic", "devtools/styleinspector/css-logic", true);
|
|
// loader.lazyRequireGetter(this, "events", "sdk/event/core");
|
|
// loader.lazyRequireGetter(this, "mapURIToAddonID", "devtools/server/actors/utils/map-uri-to-addon-id");
|
|
// loader.lazyRequireGetter(this, "setTimeout", "sdk/timers", true);
|
|
|
|
var fetch = function(aURL, aOptions={ loadFromCache: true }) {
|
|
let deferred = defer();
|
|
let scheme;
|
|
let url = aURL.split(" -> ").pop();
|
|
let charset;
|
|
let filePath = url;
|
|
let contentType;
|
|
|
|
// try {
|
|
// scheme = Services.io.extractScheme(url);
|
|
// } catch (e) {
|
|
// In the xpcshell tests, the script url is the absolute path of the test
|
|
// file, which will make a malformed URI error be thrown. Add the file
|
|
// scheme prefix ourselves.
|
|
url = "file://" + url;
|
|
// scheme = Services.io.extractScheme(url);
|
|
// }
|
|
|
|
try {
|
|
let jsb = globalDebuggee.jsb;
|
|
let fileUtils = jsb.fileUtils;
|
|
let source = fileUtils.getStringFromFile(filePath);//NetUtil.readInputStreamToString(aStream, aStream.available());
|
|
if (!source)
|
|
{
|
|
deferred.reject("Request failed: " + url);
|
|
}
|
|
else
|
|
{
|
|
deferred.resolve(source);
|
|
}
|
|
} catch (ex) {
|
|
deferred.reject(ex);
|
|
}
|
|
|
|
return deferred.promise.then(source => {
|
|
return {
|
|
// content: convertToUnicode(source, charset),
|
|
content: DevToolsUtils.utf8to16(source),
|
|
contentType: contentType
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* A BreakpointActorMap is a map from locations to instances of BreakpointActor.
|
|
*/
|
|
function BreakpointActorMap() {
|
|
this._size = 0;
|
|
this._actors = {};
|
|
}
|
|
|
|
BreakpointActorMap.prototype = {
|
|
/**
|
|
* Return the number of BreakpointActors in this BreakpointActorMap.
|
|
*
|
|
* @returns Number
|
|
* The number of BreakpointActor in this BreakpointActorMap.
|
|
*/
|
|
get size() {
|
|
return this._size;
|
|
},
|
|
|
|
/**
|
|
* Generate all BreakpointActors that match the given location in
|
|
* this BreakpointActorMap.
|
|
*
|
|
* @param OriginalLocation location
|
|
* The location for which matching BreakpointActors should be generated.
|
|
*/
|
|
findActors: function* (location = new OriginalLocation()) {
|
|
// Fast shortcut for when we know we won't find any actors. Surprisingly
|
|
// enough, this speeds up refreshing when there are no breakpoints set by
|
|
// about 2x!
|
|
if (this.size === 0) {
|
|
return;
|
|
}
|
|
|
|
function* findKeys(object, key) {
|
|
if (key !== undefined) {
|
|
if (key in object) {
|
|
yield key;
|
|
}
|
|
}
|
|
else {
|
|
for (let key of Object.keys(object)) {
|
|
yield key;
|
|
}
|
|
}
|
|
}
|
|
|
|
let query = {
|
|
sourceActorID: location.originalSourceActor ? location.originalSourceActor.actorID : undefined,
|
|
line: location.originalLine,
|
|
};
|
|
|
|
// If location contains a line, assume we are searching for a whole line
|
|
// breakpoint, and set begin/endColumn accordingly. Otherwise, we are
|
|
// searching for all breakpoints, so begin/endColumn should be left unset.
|
|
if (location.originalLine) {
|
|
query.beginColumn = location.originalColumn ? location.originalColumn : 0;
|
|
query.endColumn = location.originalColumn ? location.originalColumn + 1 : Infinity;
|
|
} else {
|
|
query.beginColumn = location.originalColumn ? query.originalColumn : undefined;
|
|
query.endColumn = location.originalColumn ? query.originalColumn + 1 : undefined;
|
|
}
|
|
|
|
for (let sourceActorID of findKeys(this._actors, query.sourceActorID))
|
|
for (let line of findKeys(this._actors[sourceActorID], query.line))
|
|
for (let beginColumn of findKeys(this._actors[sourceActorID][line], query.beginColumn))
|
|
for (let endColumn of findKeys(this._actors[sourceActorID][line][beginColumn], query.endColumn)) {
|
|
yield this._actors[sourceActorID][line][beginColumn][endColumn];
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Return the BreakpointActor at the given location in this
|
|
* BreakpointActorMap.
|
|
*
|
|
* @param OriginalLocation location
|
|
* The location for which the BreakpointActor should be returned.
|
|
*
|
|
* @returns BreakpointActor actor
|
|
* The BreakpointActor at the given location.
|
|
*/
|
|
getActor: function (originalLocation) {
|
|
for (let actor of this.findActors(originalLocation)) {
|
|
return actor;
|
|
}
|
|
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Set the given BreakpointActor to the given location in this
|
|
* BreakpointActorMap.
|
|
*
|
|
* @param OriginalLocation location
|
|
* The location to which the given BreakpointActor should be set.
|
|
*
|
|
* @param BreakpointActor actor
|
|
* The BreakpointActor to be set to the given location.
|
|
*/
|
|
setActor: function (location, actor) {
|
|
let { originalSourceActor, originalLine, originalColumn } = location;
|
|
|
|
let sourceActorID = originalSourceActor.actorID;
|
|
let line = originalLine;
|
|
let beginColumn = originalColumn ? originalColumn : 0;
|
|
let endColumn = originalColumn ? originalColumn + 1 : Infinity;
|
|
|
|
if (!this._actors[sourceActorID]) {
|
|
this._actors[sourceActorID] = [];
|
|
}
|
|
if (!this._actors[sourceActorID][line]) {
|
|
this._actors[sourceActorID][line] = [];
|
|
}
|
|
if (!this._actors[sourceActorID][line][beginColumn]) {
|
|
this._actors[sourceActorID][line][beginColumn] = [];
|
|
}
|
|
if (!this._actors[sourceActorID][line][beginColumn][endColumn]) {
|
|
++this._size;
|
|
}
|
|
this._actors[sourceActorID][line][beginColumn][endColumn] = actor;
|
|
},
|
|
|
|
/**
|
|
* Delete the BreakpointActor from the given location in this
|
|
* BreakpointActorMap.
|
|
*
|
|
* @param OriginalLocation location
|
|
* The location from which the BreakpointActor should be deleted.
|
|
*/
|
|
deleteActor: function (location) {
|
|
let { originalSourceActor, originalLine, originalColumn } = location;
|
|
|
|
let sourceActorID = originalSourceActor.actorID;
|
|
let line = originalLine;
|
|
let beginColumn = originalColumn ? originalColumn : 0;
|
|
let endColumn = originalColumn ? originalColumn + 1 : Infinity;
|
|
|
|
if (this._actors[sourceActorID]) {
|
|
if (this._actors[sourceActorID][line]) {
|
|
if (this._actors[sourceActorID][line][beginColumn]) {
|
|
if (this._actors[sourceActorID][line][beginColumn][endColumn]) {
|
|
--this._size;
|
|
}
|
|
delete this._actors[sourceActorID][line][beginColumn][endColumn];
|
|
if (Object.keys(this._actors[sourceActorID][line][beginColumn]).length === 0) {
|
|
delete this._actors[sourceActorID][line][beginColumn];
|
|
}
|
|
}
|
|
if (Object.keys(this._actors[sourceActorID][line]).length === 0) {
|
|
delete this._actors[sourceActorID][line];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.BreakpointActorMap = BreakpointActorMap;
|
|
|
|
/**
|
|
* Keeps track of persistent sources across reloads and ties different
|
|
* source instances to the same actor id so that things like
|
|
* breakpoints survive reloads. ThreadSources uses this to force the
|
|
* same actorID on a SourceActor.
|
|
*/
|
|
function SourceActorStore() {
|
|
// source identifier --> actor id
|
|
this._sourceActorIds = Object.create(null);
|
|
}
|
|
|
|
SourceActorStore.prototype = {
|
|
/**
|
|
* Lookup an existing actor id that represents this source, if available.
|
|
*/
|
|
getReusableActorId: function(aSource, aOriginalUrl) {
|
|
let url = this.getUniqueKey(aSource, aOriginalUrl);
|
|
if (url && url in this._sourceActorIds) {
|
|
return this._sourceActorIds[url];
|
|
}
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Update a source with an actorID.
|
|
*/
|
|
setReusableActorId: function(aSource, aOriginalUrl, actorID) {
|
|
let url = this.getUniqueKey(aSource, aOriginalUrl);
|
|
if (url) {
|
|
this._sourceActorIds[url] = actorID;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Make a unique URL from a source that identifies it across reloads.
|
|
*/
|
|
getUniqueKey: function(aSource, aOriginalUrl) {
|
|
if (aOriginalUrl) {
|
|
// Original source from a sourcemap.
|
|
return aOriginalUrl;
|
|
}
|
|
else {
|
|
return getSourceURL(aSource);
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.SourceActorStore = SourceActorStore;
|
|
|
|
/**
|
|
* Manages pushing event loops and automatically pops and exits them in the
|
|
* correct order as they are resolved.
|
|
*
|
|
* @param ThreadActor thread
|
|
* The thread actor instance that owns this EventLoopStack.
|
|
* @param DebuggerServerConnection connection
|
|
* The remote protocol connection associated with this event loop stack.
|
|
* @param Object hooks
|
|
* An object with the following properties:
|
|
* - url: The URL string of the debuggee we are spinning an event loop
|
|
* for.
|
|
* - preNest: function called before entering a nested event loop
|
|
* - postNest: function called after exiting a nested event loop
|
|
*/
|
|
function EventLoopStack({ thread, connection, hooks }) {
|
|
this._hooks = hooks;
|
|
this._thread = thread;
|
|
this._connection = connection;
|
|
}
|
|
|
|
EventLoopStack.prototype = {
|
|
/**
|
|
* The number of nested event loops on the stack.
|
|
*/
|
|
get size() {
|
|
// return xpcInspector.eventLoopNestLevel;
|
|
return _getEventLoopNestLevel();
|
|
},
|
|
|
|
/**
|
|
* The URL of the debuggee who pushed the event loop on top of the stack.
|
|
*/
|
|
get lastPausedUrl() {
|
|
let url = null;
|
|
if (this.size > 0) {
|
|
try {
|
|
url = xpcInspector.lastNestRequestor.url
|
|
} catch (e) {
|
|
// The tab's URL getter may throw if the tab is destroyed by the time
|
|
// this code runs, but we don't really care at this point.
|
|
dumpn(e);
|
|
}
|
|
}
|
|
return url;
|
|
},
|
|
|
|
/**
|
|
* The DebuggerServerConnection of the debugger who pushed the event loop on
|
|
* top of the stack
|
|
*/
|
|
get lastConnection() {
|
|
return xpcInspector.lastNestRequestor._connection;
|
|
},
|
|
|
|
/**
|
|
* Push a new nested event loop onto the stack.
|
|
*
|
|
* @returns EventLoop
|
|
*/
|
|
push: function () {
|
|
return new EventLoop({
|
|
thread: this._thread,
|
|
connection: this._connection,
|
|
hooks: this._hooks
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* An object that represents a nested event loop. It is used as the nest
|
|
* requestor with nsIJSInspector instances.
|
|
*
|
|
* @param ThreadActor thread
|
|
* The thread actor that is creating this nested event loop.
|
|
* @param DebuggerServerConnection connection
|
|
* The remote protocol connection associated with this event loop.
|
|
* @param Object hooks
|
|
* The same hooks object passed into EventLoopStack during its
|
|
* initialization.
|
|
*/
|
|
function EventLoop({ thread, connection, hooks }) {
|
|
this._thread = thread;
|
|
this._hooks = hooks;
|
|
this._connection = connection;
|
|
|
|
this.enter = this.enter.bind(this);
|
|
this.resolve = this.resolve.bind(this);
|
|
}
|
|
|
|
EventLoop.prototype = {
|
|
entered: false,
|
|
resolved: false,
|
|
get url() { return this._hooks.url; },
|
|
|
|
/**
|
|
* Enter this nested event loop.
|
|
*/
|
|
enter: function () {
|
|
let nestData = this._hooks.preNest
|
|
? this._hooks.preNest()
|
|
: null;
|
|
|
|
this.entered = true;
|
|
// xpcInspector.enterNestedEventLoop(this);
|
|
_enterNestedEventLoop();
|
|
|
|
// Keep exiting nested event loops while the last requestor is resolved.
|
|
// if (xpcInspector.eventLoopNestLevel > 0) {
|
|
// const { resolved } = xpcInspector.lastNestRequestor;
|
|
// if (resolved) {
|
|
// xpcInspector.exitNestedEventLoop();
|
|
// }
|
|
// }
|
|
|
|
dbg_assert(this._thread.state === "running",
|
|
"Should be in the running state");
|
|
|
|
if (this._hooks.postNest) {
|
|
this._hooks.postNest(nestData);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Resolve this nested event loop.
|
|
*
|
|
* @returns boolean
|
|
* True if we exited this nested event loop because it was on top of
|
|
* the stack, false if there is another nested event loop above this
|
|
* one that hasn't resolved yet.
|
|
*/
|
|
resolve: function () {
|
|
if (!this.entered) {
|
|
throw new Error("Can't resolve an event loop before it has been entered!");
|
|
}
|
|
if (this.resolved) {
|
|
throw new Error("Already resolved this nested event loop!");
|
|
}
|
|
this.resolved = true;
|
|
// if (this === xpcInspector.lastNestRequestor)
|
|
{
|
|
// xpcInspector.exitNestedEventLoop();
|
|
_exitNestedEventLoop();
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* JSD2 actors.
|
|
*/
|
|
|
|
/**
|
|
* Creates a ThreadActor.
|
|
*
|
|
* ThreadActors manage a JSInspector object and manage execution/inspection
|
|
* of debuggees.
|
|
*
|
|
* @param aParent object
|
|
* This |ThreadActor|'s parent actor. It must implement the following
|
|
* properties:
|
|
* - url: The URL string of the debuggee.
|
|
* - window: The global window object.
|
|
* - preNest: Function called before entering a nested event loop.
|
|
* - postNest: Function called after exiting a nested event loop.
|
|
* - makeDebugger: A function that takes no arguments and instantiates
|
|
* a Debugger that manages its globals on its own.
|
|
* @param aGlobal object [optional]
|
|
* An optional (for content debugging only) reference to the content
|
|
* window.
|
|
*/
|
|
function ThreadActor(aParent, aGlobal)
|
|
{
|
|
this._state = "detached";
|
|
this._frameActors = [];
|
|
this._parent = aParent;
|
|
this._dbg = null;
|
|
this._gripDepth = 0;
|
|
this._threadLifetimePool = null;
|
|
this._tabClosed = false;
|
|
this._scripts = null;
|
|
this._pauseOnDOMEvents = null;
|
|
|
|
this._options = {
|
|
useSourceMaps: false,
|
|
autoBlackBox: false
|
|
};
|
|
|
|
this.breakpointActorMap = new BreakpointActorMap();
|
|
this.sourceActorStore = new SourceActorStore();
|
|
|
|
this._debuggerSourcesSeen = null;
|
|
|
|
// A map of actorID -> actor for breakpoints created and managed by the
|
|
// server.
|
|
this._hiddenBreakpoints = new Map();
|
|
|
|
this.global = aGlobal;
|
|
|
|
this._allEventsListener = this._allEventsListener.bind(this);
|
|
this.onNewGlobal = this.onNewGlobal.bind(this);
|
|
this.onNewSource = this.onNewSource.bind(this);
|
|
this.uncaughtExceptionHook = this.uncaughtExceptionHook.bind(this);
|
|
this.onDebuggerStatement = this.onDebuggerStatement.bind(this);
|
|
this.onNewScript = this.onNewScript.bind(this);
|
|
this.objectGrip = this.objectGrip.bind(this);
|
|
this.pauseObjectGrip = this.pauseObjectGrip.bind(this);
|
|
this._onWindowReady = this._onWindowReady.bind(this);
|
|
// events.on(this._parent, "window-ready", this._onWindowReady);
|
|
// Set a wrappedJSObject property so |this| can be sent via the observer svc
|
|
// for the xpcshell harness.
|
|
this.wrappedJSObject = this;
|
|
}
|
|
|
|
ThreadActor.prototype = {
|
|
// Used by the ObjectActor to keep track of the depth of grip() calls.
|
|
_gripDepth: null,
|
|
|
|
actorPrefix: "context",
|
|
|
|
get dbg() {
|
|
if (!this._dbg) {
|
|
this._dbg = this._parent.makeDebugger();
|
|
this._dbg.uncaughtExceptionHook = this.uncaughtExceptionHook;
|
|
this._dbg.onDebuggerStatement = this.onDebuggerStatement;
|
|
this._dbg.onNewScript = this.onNewScript;
|
|
// this._dbg.on("newGlobal", this.onNewGlobal);
|
|
// Keep the debugger disabled until a client attaches.
|
|
this._dbg.enabled = this._state != "detached";
|
|
}
|
|
return this._dbg;
|
|
},
|
|
|
|
get globalDebugObject() {
|
|
if (!this._parent.window) {
|
|
return null;
|
|
}
|
|
return this.dbg.makeGlobalObjectReference(this._parent.window);
|
|
},
|
|
|
|
get state() {
|
|
return this._state;
|
|
},
|
|
|
|
get attached() {
|
|
return this.state == "attached" ||
|
|
this.state == "running" ||
|
|
this.state == "paused";
|
|
},
|
|
|
|
get threadLifetimePool() {
|
|
if (!this._threadLifetimePool) {
|
|
this._threadLifetimePool = new ActorPool(this.conn);
|
|
this.conn.addActorPool(this._threadLifetimePool);
|
|
this._threadLifetimePool.objectActors = new WeakMap();
|
|
}
|
|
return this._threadLifetimePool;
|
|
},
|
|
|
|
get scripts() {
|
|
if (!this._scripts) {
|
|
this._scripts = new ScriptStore();
|
|
this._scripts.addScripts(this.dbg.findScripts());
|
|
}
|
|
return this._scripts;
|
|
},
|
|
|
|
get sources() {
|
|
return this._parent.sources;
|
|
},
|
|
|
|
get youngestFrame() {
|
|
if (this.state != "paused") {
|
|
return null;
|
|
}
|
|
return this.dbg.getNewestFrame();
|
|
},
|
|
|
|
_prettyPrintWorker: null,
|
|
get prettyPrintWorker() {
|
|
if (!this._prettyPrintWorker) {
|
|
this._prettyPrintWorker = new DevToolsWorker(
|
|
"resource://gre/modules/devtools/server/actors/pretty-print-worker.js",
|
|
{ name: "pretty-print",
|
|
verbose: dumpn.wantLogging }
|
|
);
|
|
}
|
|
return this._prettyPrintWorker;
|
|
},
|
|
|
|
/**
|
|
* Keep track of all of the nested event loops we use to pause the debuggee
|
|
* when we hit a breakpoint/debugger statement/etc in one place so we can
|
|
* resolve them when we get resume packets. We have more than one (and keep
|
|
* them in a stack) because we can pause within client evals.
|
|
*/
|
|
_threadPauseEventLoops: null,
|
|
_pushThreadPause: function () {
|
|
if (!this._threadPauseEventLoops) {
|
|
this._threadPauseEventLoops = [];
|
|
}
|
|
const eventLoop = this._nestedEventLoops.push();
|
|
this._threadPauseEventLoops.push(eventLoop);
|
|
eventLoop.enter();
|
|
},
|
|
_popThreadPause: function () {
|
|
const eventLoop = this._threadPauseEventLoops.pop();
|
|
dbg_assert(eventLoop, "Should have an event loop.");
|
|
eventLoop.resolve();
|
|
},
|
|
|
|
/**
|
|
* Remove all debuggees and clear out the thread's sources.
|
|
*/
|
|
clearDebuggees: function () {
|
|
if (this._dbg) {
|
|
this.dbg.removeAllDebuggees();
|
|
}
|
|
this._sources = null;
|
|
this._scripts = null;
|
|
},
|
|
|
|
/**
|
|
* Listener for our |Debugger|'s "newGlobal" event.
|
|
*/
|
|
onNewGlobal: function (aGlobal) {
|
|
// Notify the client.
|
|
this.conn.send({
|
|
from: this.actorID,
|
|
type: "newGlobal",
|
|
// TODO: after bug 801084 lands see if we need to JSONify this.
|
|
hostAnnotations: aGlobal.hostAnnotations
|
|
});
|
|
},
|
|
|
|
disconnect: function () {
|
|
dumpn("in ThreadActor.prototype.disconnect");
|
|
if (this._state == "paused") {
|
|
this.onResume();
|
|
}
|
|
|
|
// Blow away our source actor ID store because those IDs are only
|
|
// valid for this connection. This is ok because we never keep
|
|
// things like breakpoints across connections.
|
|
this._sourceActorStore = null;
|
|
|
|
// events.off(this._parent, "window-ready", this._onWindowReady);
|
|
this.clearDebuggees();
|
|
this.conn.removeActorPool(this._threadLifetimePool);
|
|
this._threadLifetimePool = null;
|
|
|
|
if (this._prettyPrintWorker) {
|
|
this._prettyPrintWorker.destroy();
|
|
this._prettyPrintWorker = null;
|
|
}
|
|
|
|
if (!this._dbg) {
|
|
return;
|
|
}
|
|
this._dbg.enabled = false;
|
|
this._dbg = null;
|
|
},
|
|
|
|
/**
|
|
* Disconnect the debugger and put the actor in the exited state.
|
|
*/
|
|
exit: function () {
|
|
this.disconnect();
|
|
this._state = "exited";
|
|
},
|
|
|
|
// Request handlers
|
|
onAttach: function (aRequest) {
|
|
if (this.state === "exited") {
|
|
return { type: "exited" };
|
|
}
|
|
|
|
if (this.state !== "detached") {
|
|
return { error: "wrongState",
|
|
message: "Current state is " + this.state };
|
|
}
|
|
|
|
this._state = "attached";
|
|
this._debuggerSourcesSeen = new Set();
|
|
|
|
update(this._options, aRequest.options || {});
|
|
this.sources.reconfigure(this._options);
|
|
this.sources.on('newSource', (name, source) => {
|
|
this.onNewSource(source);
|
|
});
|
|
|
|
// Initialize an event loop stack. This can't be done in the constructor,
|
|
// because this.conn is not yet initialized by the actor pool at that time.
|
|
this._nestedEventLoops = new EventLoopStack({
|
|
hooks: this._parent,
|
|
connection: this.conn,
|
|
thread: this
|
|
});
|
|
|
|
// this.dbg.addDebuggees();
|
|
this.dbg.enabled = true;
|
|
try {
|
|
// Put ourselves in the paused state.
|
|
let packet = this._paused();
|
|
if (!packet) {
|
|
return { error: "notAttached" };
|
|
}
|
|
packet.why = { type: "attached" };
|
|
|
|
this._restoreBreakpoints();
|
|
|
|
// Send the response to the attach request now (rather than
|
|
// returning it), because we're going to start a nested event loop
|
|
// here.
|
|
this.conn.send(packet);
|
|
|
|
// Start a nested event loop.
|
|
this._pushThreadPause();
|
|
|
|
// We already sent a response to this request, don't send one
|
|
// now.
|
|
return null;
|
|
} catch (e) {
|
|
reportError(e);
|
|
return { error: "notAttached", message: e.toString() };
|
|
}
|
|
},
|
|
|
|
onDetach: function (aRequest) {
|
|
this.disconnect();
|
|
this._state = "detached";
|
|
this._debuggerSourcesSeen = null;
|
|
|
|
DevToolsUtils.dumpn("ThreadActor.prototype.onDetach: returning 'detached' packet");
|
|
return {
|
|
type: "detached"
|
|
};
|
|
},
|
|
|
|
onReconfigure: function (aRequest) {
|
|
if (this.state == "exited") {
|
|
return { error: "wrongState" };
|
|
}
|
|
|
|
update(this._options, aRequest.options || {});
|
|
// Update the global source store
|
|
this.sources.reconfigure(this._options);
|
|
|
|
return {};
|
|
},
|
|
|
|
/**
|
|
* Pause the debuggee, by entering a nested event loop, and return a 'paused'
|
|
* packet to the client.
|
|
*
|
|
* @param Debugger.Frame aFrame
|
|
* The newest debuggee frame in the stack.
|
|
* @param object aReason
|
|
* An object with a 'type' property containing the reason for the pause.
|
|
* @param function onPacket
|
|
* Hook to modify the packet before it is sent. Feel free to return a
|
|
* promise.
|
|
*/
|
|
_pauseAndRespond: function (aFrame, aReason, onPacket=function (k) { return k; }) {
|
|
try {
|
|
let packet = this._paused(aFrame);
|
|
if (!packet) {
|
|
return undefined;
|
|
}
|
|
packet.why = aReason;
|
|
|
|
let generatedLocation = this.sources.getFrameLocation(aFrame);
|
|
this.sources.getOriginalLocation(generatedLocation)
|
|
.then((originalLocation) => {
|
|
if (!originalLocation.originalSourceActor) {
|
|
// The only time the source actor will be null is if there
|
|
// was a sourcemap and it tried to look up the original
|
|
// location but there was no original URL. This is a strange
|
|
// scenario so we simply don't pause.
|
|
DevToolsUtils.reportException(
|
|
'ThreadActor',
|
|
new Error('Attempted to pause in a script with a sourcemap but ' +
|
|
'could not find original location.')
|
|
);
|
|
|
|
return undefined;
|
|
}
|
|
|
|
packet.frame.where = {
|
|
source: originalLocation.originalSourceActor.form(),
|
|
line: originalLocation.originalLine,
|
|
column: originalLocation.originalColumn
|
|
};
|
|
resolve(onPacket(packet))
|
|
.then(null, error => {
|
|
reportError(error);
|
|
return {
|
|
error: "unknownError",
|
|
message: error.message + "\n" + error.stack
|
|
};
|
|
})
|
|
.then(packet => {
|
|
this.conn.send(packet);
|
|
});
|
|
});
|
|
|
|
this._pushThreadPause();
|
|
} catch(e) {
|
|
reportError(e, "Got an exception during TA__pauseAndRespond: ");
|
|
}
|
|
|
|
// If the browser tab has been closed, terminate the debuggee script
|
|
// instead of continuing. Executing JS after the content window is gone is
|
|
// a bad idea.
|
|
return this._tabClosed ? null : undefined;
|
|
},
|
|
|
|
/**
|
|
* Handle resume requests that include a forceCompletion request.
|
|
*
|
|
* @param Object aRequest
|
|
* The request packet received over the RDP.
|
|
* @returns A response packet.
|
|
*/
|
|
_forceCompletion: function (aRequest) {
|
|
// TODO: remove this when Debugger.Frame.prototype.pop is implemented in
|
|
// bug 736733.
|
|
return {
|
|
error: "notImplemented",
|
|
message: "forced completion is not yet implemented."
|
|
};
|
|
},
|
|
|
|
_makeOnEnterFrame: function ({ pauseAndRespond }) {
|
|
return aFrame => {
|
|
const generatedLocation = this.sources.getFrameLocation(aFrame);
|
|
let { originalSourceActor } = this.unsafeSynchronize(this.sources.getOriginalLocation(
|
|
generatedLocation));
|
|
let url = originalSourceActor.url;
|
|
|
|
return this.sources.isBlackBoxed(url)
|
|
? undefined
|
|
: pauseAndRespond(aFrame);
|
|
};
|
|
},
|
|
|
|
_makeOnPop: function ({ thread, pauseAndRespond, createValueGrip }) {
|
|
return function (aCompletion) {
|
|
// onPop is called with 'this' set to the current frame.
|
|
|
|
const generatedLocation = thread.sources.getFrameLocation(this);
|
|
const { originalSourceActor } = thread.unsafeSynchronize(thread.sources.getOriginalLocation(
|
|
generatedLocation));
|
|
const url = originalSourceActor.url;
|
|
|
|
if (thread.sources.isBlackBoxed(url)) {
|
|
return undefined;
|
|
}
|
|
|
|
// Note that we're popping this frame; we need to watch for
|
|
// subsequent step events on its caller.
|
|
this.reportedPop = true;
|
|
|
|
return pauseAndRespond(this, aPacket => {
|
|
aPacket.why.frameFinished = {};
|
|
if (!aCompletion) {
|
|
aPacket.why.frameFinished.terminated = true;
|
|
} else if (aCompletion.hasOwnProperty("return")) {
|
|
aPacket.why.frameFinished.return = createValueGrip(aCompletion.return);
|
|
} else if (aCompletion.hasOwnProperty("yield")) {
|
|
aPacket.why.frameFinished.return = createValueGrip(aCompletion.yield);
|
|
} else {
|
|
aPacket.why.frameFinished.throw = createValueGrip(aCompletion.throw);
|
|
}
|
|
return aPacket;
|
|
});
|
|
};
|
|
},
|
|
|
|
_makeOnStep: function ({ thread, pauseAndRespond, startFrame,
|
|
startLocation, steppingType }) {
|
|
// Breaking in place: we should always pause.
|
|
if (steppingType === "break") {
|
|
return function () {
|
|
return pauseAndRespond(this);
|
|
};
|
|
}
|
|
|
|
// Otherwise take what a "step" means into consideration.
|
|
return function () {
|
|
// onStep is called with 'this' set to the current frame.
|
|
|
|
const generatedLocation = thread.sources.getFrameLocation(this);
|
|
const newLocation = thread.unsafeSynchronize(thread.sources.getOriginalLocation(
|
|
generatedLocation));
|
|
|
|
// Cases when we should pause because we have executed enough to consider
|
|
// a "step" to have occurred:
|
|
//
|
|
// 1.1. We change frames.
|
|
// 1.2. We change URLs (can happen without changing frames thanks to
|
|
// source mapping).
|
|
// 1.3. We change lines.
|
|
//
|
|
// Cases when we should always continue execution, even if one of the
|
|
// above cases is true:
|
|
//
|
|
// 2.1. We are in a source mapped region, but inside a null mapping
|
|
// (doesn't correlate to any region of original source)
|
|
// 2.2. The source we are in is black boxed.
|
|
|
|
// Cases 2.1 and 2.2
|
|
if (newLocation.originalUrl == null
|
|
|| thread.sources.isBlackBoxed(newLocation.originalUrl)) {
|
|
return undefined;
|
|
}
|
|
|
|
// Cases 1.1, 1.2 and 1.3
|
|
if (this !== startFrame
|
|
|| startLocation.originalUrl !== newLocation.originalUrl
|
|
|| startLocation.originalLine !== newLocation.originalLine) {
|
|
return pauseAndRespond(this);
|
|
}
|
|
|
|
// Otherwise, let execution continue (we haven't executed enough code to
|
|
// consider this a "step" yet).
|
|
return undefined;
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Define the JS hook functions for stepping.
|
|
*/
|
|
_makeSteppingHooks: function (aStartLocation, steppingType) {
|
|
// Bind these methods and state because some of the hooks are called
|
|
// with 'this' set to the current frame. Rather than repeating the
|
|
// binding in each _makeOnX method, just do it once here and pass it
|
|
// in to each function.
|
|
const steppingHookState = {
|
|
pauseAndRespond: (aFrame, onPacket=k=>k) => {
|
|
return this._pauseAndRespond(aFrame, { type: "resumeLimit" }, onPacket);
|
|
},
|
|
createValueGrip: v => createValueGrip(v, this._pausePool,
|
|
this.objectGrip),
|
|
thread: this,
|
|
startFrame: this.youngestFrame,
|
|
startLocation: aStartLocation,
|
|
steppingType: steppingType
|
|
};
|
|
|
|
return {
|
|
onEnterFrame: this._makeOnEnterFrame(steppingHookState),
|
|
onPop: this._makeOnPop(steppingHookState),
|
|
onStep: this._makeOnStep(steppingHookState)
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Handle attaching the various stepping hooks we need to attach when we
|
|
* receive a resume request with a resumeLimit property.
|
|
*
|
|
* @param Object aRequest
|
|
* The request packet received over the RDP.
|
|
* @returns A promise that resolves to true once the hooks are attached, or is
|
|
* rejected with an error packet.
|
|
*/
|
|
_handleResumeLimit: function (aRequest) {
|
|
let steppingType = aRequest.resumeLimit.type;
|
|
if (["break", "step", "next", "finish"].indexOf(steppingType) == -1) {
|
|
return reject({ error: "badParameterType",
|
|
message: "Unknown resumeLimit type" });
|
|
}
|
|
|
|
const generatedLocation = this.sources.getFrameLocation(this.youngestFrame);
|
|
return this.sources.getOriginalLocation(generatedLocation)
|
|
.then(originalLocation => {
|
|
const { onEnterFrame, onPop, onStep } = this._makeSteppingHooks(originalLocation,
|
|
steppingType);
|
|
|
|
// Make sure there is still a frame on the stack if we are to continue
|
|
// stepping.
|
|
let stepFrame = this._getNextStepFrame(this.youngestFrame);
|
|
if (stepFrame) {
|
|
switch (steppingType) {
|
|
case "step":
|
|
this.dbg.onEnterFrame = onEnterFrame;
|
|
// Fall through.
|
|
case "break":
|
|
case "next":
|
|
if (stepFrame.script) {
|
|
stepFrame.onStep = onStep;
|
|
}
|
|
stepFrame.onPop = onPop;
|
|
break;
|
|
case "finish":
|
|
stepFrame.onPop = onPop;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Clear the onStep and onPop hooks from the given frame and all of the frames
|
|
* below it.
|
|
*
|
|
* @param Debugger.Frame aFrame
|
|
* The frame we want to clear the stepping hooks from.
|
|
*/
|
|
_clearSteppingHooks: function (aFrame) {
|
|
if (aFrame && aFrame.live) {
|
|
while (aFrame) {
|
|
aFrame.onStep = undefined;
|
|
aFrame.onPop = undefined;
|
|
aFrame = aFrame.older;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Listen to the debuggee's DOM events if we received a request to do so.
|
|
*
|
|
* @param Object aRequest
|
|
* The resume request packet received over the RDP.
|
|
*/
|
|
_maybeListenToEvents: function (aRequest) {
|
|
// Break-on-DOMEvents is only supported in content debugging.
|
|
let events = aRequest.pauseOnDOMEvents;
|
|
if (this.global && events &&
|
|
(events == "*" ||
|
|
(Array.isArray(events) && events.length))) {
|
|
this._pauseOnDOMEvents = events;
|
|
let els = Cc["@mozilla.org/eventlistenerservice;1"]
|
|
.getService(Ci.nsIEventListenerService);
|
|
els.addListenerForAllEvents(this.global, this._allEventsListener, true);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* If we are tasked with breaking on the load event, we have to add the
|
|
* listener early enough.
|
|
*/
|
|
_onWindowReady: function () {
|
|
this._maybeListenToEvents({
|
|
pauseOnDOMEvents: this._pauseOnDOMEvents
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Handle a protocol request to resume execution of the debuggee.
|
|
*/
|
|
onResume: function (aRequest) {
|
|
if (this._state !== "paused") {
|
|
return {
|
|
error: "wrongState",
|
|
message: "Can't resume when debuggee isn't paused. Current state is '"
|
|
+ this._state + "'"
|
|
};
|
|
}
|
|
|
|
// In case of multiple nested event loops (due to multiple debuggers open in
|
|
// different tabs or multiple debugger clients connected to the same tab)
|
|
// only allow resumption in a LIFO order.
|
|
if (this._nestedEventLoops.size && this._nestedEventLoops.lastPausedUrl
|
|
&& (this._nestedEventLoops.lastPausedUrl !== this._parent.url
|
|
|| this._nestedEventLoops.lastConnection !== this.conn)) {
|
|
return {
|
|
error: "wrongOrder",
|
|
message: "trying to resume in the wrong order.",
|
|
lastPausedUrl: this._nestedEventLoops.lastPausedUrl
|
|
};
|
|
}
|
|
|
|
if (aRequest && aRequest.forceCompletion) {
|
|
return this._forceCompletion(aRequest);
|
|
}
|
|
|
|
let resumeLimitHandled;
|
|
if (aRequest && aRequest.resumeLimit) {
|
|
resumeLimitHandled = this._handleResumeLimit(aRequest)
|
|
} else {
|
|
this._clearSteppingHooks(this.youngestFrame);
|
|
resumeLimitHandled = resolve(true);
|
|
}
|
|
|
|
return resumeLimitHandled.then(() => {
|
|
if (aRequest) {
|
|
this._options.pauseOnExceptions = aRequest.pauseOnExceptions;
|
|
this._options.ignoreCaughtExceptions = aRequest.ignoreCaughtExceptions;
|
|
this.maybePauseOnExceptions();
|
|
this._maybeListenToEvents(aRequest);
|
|
}
|
|
|
|
let packet = this._resumed();
|
|
this._popThreadPause();
|
|
// Tell anyone who cares of the resume (as of now, that's the xpcshell
|
|
// harness)
|
|
// if (Services.obs) {
|
|
// Services.obs.notifyObservers(this, "devtools-thread-resumed", null);
|
|
// }
|
|
return packet;
|
|
}, error => {
|
|
return error instanceof Error
|
|
? { error: "unknownError",
|
|
message: DevToolsUtils.safeErrorString(error) }
|
|
// It is a known error, and the promise was rejected with an error
|
|
// packet.
|
|
: error;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Spin up a nested event loop so we can synchronously resolve a promise.
|
|
*
|
|
* DON'T USE THIS UNLESS YOU ABSOLUTELY MUST! Nested event loops suck: the
|
|
* world's state can change out from underneath your feet because JS is no
|
|
* longer run-to-completion.
|
|
*
|
|
* @param aPromise
|
|
* The promise we want to resolve.
|
|
* @returns The promise's resolution.
|
|
*/
|
|
unsafeSynchronize: function(aPromise) {
|
|
let needNest = true;
|
|
let eventLoop;
|
|
let returnVal;
|
|
|
|
aPromise
|
|
.then((aResolvedVal) => {
|
|
needNest = false;
|
|
returnVal = aResolvedVal;
|
|
})
|
|
.then(null, (aError) => {
|
|
reportError(aError, "Error inside unsafeSynchronize:");
|
|
})
|
|
.then(() => {
|
|
if (eventLoop) {
|
|
eventLoop.resolve();
|
|
}
|
|
});
|
|
|
|
if (needNest) {
|
|
eventLoop = this._nestedEventLoops.push();
|
|
eventLoop.enter();
|
|
}
|
|
|
|
return returnVal;
|
|
},
|
|
|
|
/**
|
|
* Set the debugging hook to pause on exceptions if configured to do so.
|
|
*/
|
|
maybePauseOnExceptions: function() {
|
|
if (this._options.pauseOnExceptions) {
|
|
this.dbg.onExceptionUnwind = this.onExceptionUnwind.bind(this);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* A listener that gets called for every event fired on the page, when a list
|
|
* of interesting events was provided with the pauseOnDOMEvents property. It
|
|
* is used to set server-managed breakpoints on any existing event listeners
|
|
* for those events.
|
|
*
|
|
* @param Event event
|
|
* The event that was fired.
|
|
*/
|
|
_allEventsListener: function(event) {
|
|
if (this._pauseOnDOMEvents == "*" ||
|
|
this._pauseOnDOMEvents.indexOf(event.type) != -1) {
|
|
for (let listener of this._getAllEventListeners(event.target)) {
|
|
if (event.type == listener.type || this._pauseOnDOMEvents == "*") {
|
|
this._breakOnEnter(listener.script);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Return an array containing all the event listeners attached to the
|
|
* specified event target and its ancestors in the event target chain.
|
|
*
|
|
* @param EventTarget eventTarget
|
|
* The target the event was dispatched on.
|
|
* @returns Array
|
|
*/
|
|
_getAllEventListeners: function(eventTarget) {
|
|
let els = Cc["@mozilla.org/eventlistenerservice;1"]
|
|
.getService(Ci.nsIEventListenerService);
|
|
|
|
let targets = els.getEventTargetChainFor(eventTarget);
|
|
let listeners = [];
|
|
|
|
for (let target of targets) {
|
|
let handlers = els.getListenerInfoFor(target);
|
|
for (let handler of handlers) {
|
|
// Null is returned for all-events handlers, and native event listeners
|
|
// don't provide any listenerObject, which makes them not that useful to
|
|
// a JS debugger.
|
|
if (!handler || !handler.listenerObject || !handler.type)
|
|
continue;
|
|
// Create a listener-like object suitable for our purposes.
|
|
let l = Object.create(null);
|
|
l.type = handler.type;
|
|
let listener = handler.listenerObject;
|
|
let listenerDO = this.globalDebugObject.makeDebuggeeValue(listener);
|
|
// If the listener is an object with a 'handleEvent' method, use that.
|
|
if (listenerDO.class == "Object" || listenerDO.class == "XULElement") {
|
|
// For some events we don't have permission to access the
|
|
// 'handleEvent' property when running in content scope.
|
|
if (!listenerDO.unwrap()) {
|
|
continue;
|
|
}
|
|
let heDesc;
|
|
while (!heDesc && listenerDO) {
|
|
heDesc = listenerDO.getOwnPropertyDescriptor("handleEvent");
|
|
listenerDO = listenerDO.proto;
|
|
}
|
|
if (heDesc && heDesc.value) {
|
|
listenerDO = heDesc.value;
|
|
}
|
|
}
|
|
// When the listener is a bound function, we are actually interested in
|
|
// the target function.
|
|
while (listenerDO.isBoundFunction) {
|
|
listenerDO = listenerDO.boundTargetFunction;
|
|
}
|
|
l.script = listenerDO.script;
|
|
// Chrome listeners won't be converted to debuggee values, since their
|
|
// compartment is not added as a debuggee.
|
|
if (!l.script)
|
|
continue;
|
|
listeners.push(l);
|
|
}
|
|
}
|
|
return listeners;
|
|
},
|
|
|
|
/**
|
|
* Set a breakpoint on the first line of the given script that has an entry
|
|
* point.
|
|
*/
|
|
_breakOnEnter: function(script) {
|
|
let offsets = script.getAllOffsets();
|
|
for (let line = 0, n = offsets.length; line < n; line++) {
|
|
if (offsets[line]) {
|
|
// N.B. Hidden breakpoints do not have an original location, and are not
|
|
// stored in the breakpoint actor map.
|
|
let actor = new BreakpointActor(this);
|
|
this.threadLifetimePool.addActor(actor);
|
|
let scripts = this.scripts.getScriptsBySourceAndLine(script.source, line);
|
|
let entryPoints = findEntryPointsForLine(scripts, line);
|
|
setBreakpointAtEntryPoints(actor, entryPoints);
|
|
this._hiddenBreakpoints.set(actor.actorID, actor);
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Helper method that returns the next frame when stepping.
|
|
*/
|
|
_getNextStepFrame: function (aFrame) {
|
|
let stepFrame = aFrame.reportedPop ? aFrame.older : aFrame;
|
|
if (!stepFrame || !stepFrame.script) {
|
|
stepFrame = null;
|
|
}
|
|
return stepFrame;
|
|
},
|
|
|
|
onClientEvaluate: function (aRequest) {
|
|
if (this.state !== "paused") {
|
|
return { error: "wrongState",
|
|
message: "Debuggee must be paused to evaluate code." };
|
|
}
|
|
|
|
let frame = this._requestFrame(aRequest.frame);
|
|
if (!frame) {
|
|
return { error: "unknownFrame",
|
|
message: "Evaluation frame not found" };
|
|
}
|
|
|
|
if (!frame.environment) {
|
|
return { error: "notDebuggee",
|
|
message: "cannot access the environment of this frame." };
|
|
}
|
|
|
|
let youngest = this.youngestFrame;
|
|
|
|
// Put ourselves back in the running state and inform the client.
|
|
let resumedPacket = this._resumed();
|
|
this.conn.send(resumedPacket);
|
|
|
|
// Run the expression.
|
|
// XXX: test syntax errors
|
|
let completion = frame.eval(aRequest.expression);
|
|
|
|
// Put ourselves back in the pause state.
|
|
let packet = this._paused(youngest);
|
|
packet.why = { type: "clientEvaluated",
|
|
frameFinished: this.createProtocolCompletionValue(completion) };
|
|
|
|
// Return back to our previous pause's event loop.
|
|
return packet;
|
|
},
|
|
|
|
onFrames: function (aRequest) {
|
|
if (this.state !== "paused") {
|
|
return { error: "wrongState",
|
|
message: "Stack frames are only available while the debuggee is paused."};
|
|
}
|
|
|
|
let start = aRequest.start ? aRequest.start : 0;
|
|
let count = aRequest.count;
|
|
|
|
// Find the starting frame...
|
|
let frame = this.youngestFrame;
|
|
let i = 0;
|
|
while (frame && (i < start)) {
|
|
frame = frame.older;
|
|
i++;
|
|
}
|
|
|
|
// Return request.count frames, or all remaining
|
|
// frames if count is not defined.
|
|
let frames = [];
|
|
let promises = [];
|
|
for (; frame && (!count || i < (start + count)); i++, frame=frame.older) {
|
|
let form = this._createFrameActor(frame).form();
|
|
form.depth = i;
|
|
frames.push(form);
|
|
|
|
let promise = this.sources.getOriginalLocation(new GeneratedLocation(
|
|
this.sources.createNonSourceMappedActor(frame.script.source),
|
|
form.where.line,
|
|
form.where.column
|
|
)).then((originalLocation) => {
|
|
let sourceForm = originalLocation.originalSourceActor.form();
|
|
form.where = {
|
|
source: sourceForm,
|
|
line: originalLocation.originalLine,
|
|
column: originalLocation.originalColumn
|
|
};
|
|
form.source = sourceForm;
|
|
});
|
|
promises.push(promise);
|
|
}
|
|
|
|
return all(promises).then(function () {
|
|
return { frames: frames };
|
|
});
|
|
},
|
|
|
|
onReleaseMany: function (aRequest) {
|
|
if (!aRequest.actors) {
|
|
return { error: "missingParameter",
|
|
message: "no actors were specified" };
|
|
}
|
|
|
|
let res;
|
|
for (let actorID of aRequest.actors) {
|
|
let actor = this.threadLifetimePool.get(actorID);
|
|
if (!actor) {
|
|
if (!res) {
|
|
res = { error: "notReleasable",
|
|
message: "Only thread-lifetime actors can be released." };
|
|
}
|
|
continue;
|
|
}
|
|
actor.onRelease();
|
|
}
|
|
return res ? res : {};
|
|
},
|
|
|
|
/**
|
|
* Get the script and source lists from the debugger.
|
|
*/
|
|
_discoverSources: function () {
|
|
// Only get one script per Debugger.Source.
|
|
const sourcesToScripts = new Map();
|
|
const scripts = this.scripts.getAllScripts();
|
|
for (let i = 0, len = scripts.length; i < len; i++) {
|
|
let s = scripts[i];
|
|
if (s.source && s.source.url) {
|
|
sourcesToScripts.set(s.source, s);
|
|
}
|
|
}
|
|
|
|
// let arr = [];
|
|
// for (let [key, script] of sourcesToScripts) {
|
|
// arr.push(this.sources.createSourceActors(script.source));
|
|
// }
|
|
// return all(arr);
|
|
return all([...sourcesToScripts.values()].map(script => {
|
|
return this.sources.createSourceActors(script.source);
|
|
}));
|
|
},
|
|
|
|
onSources: function (aRequest) {
|
|
// let promise = this._discoverSources();
|
|
return this._discoverSources().then(() => {
|
|
// No need to flush the new source packets here, as we are sending the
|
|
// list of sources out immediately and we don't need to invoke the
|
|
// overhead of an RDP packet for every source right now. Let the default
|
|
// timeout flush the buffered packets.
|
|
|
|
return {
|
|
sources: this.sources.iter().map(s => s.form())
|
|
};
|
|
});
|
|
// return this._discoverSources().then(() => {
|
|
// // No need to flush the new source packets here, as we are sending the
|
|
// // list of sources out immediately and we don't need to invoke the
|
|
// // overhead of an RDP packet for every source right now. Let the default
|
|
// // timeout flush the buffered packets.
|
|
|
|
// return {
|
|
// sources: this.sources.iter().map(s => s.form())
|
|
// };
|
|
// });
|
|
},
|
|
|
|
/**
|
|
* Disassociate all breakpoint actors from their scripts and clear the
|
|
* breakpoint handlers. This method can be used when the thread actor intends
|
|
* to keep the breakpoint store, but needs to clear any actual breakpoints,
|
|
* e.g. due to a page navigation. This way the breakpoint actors' script
|
|
* caches won't hold on to the Debugger.Script objects leaking memory.
|
|
*/
|
|
disableAllBreakpoints: function () {
|
|
for (let bpActor of this.breakpointActorMap.findActors()) {
|
|
bpActor.removeScripts();
|
|
}
|
|
},
|
|
|
|
|
|
/**
|
|
* Handle a protocol request to pause the debuggee.
|
|
*/
|
|
onInterrupt: function (aRequest) {
|
|
if (this.state == "exited") {
|
|
return { type: "exited" };
|
|
} else if (this.state == "paused") {
|
|
// TODO: return the actual reason for the existing pause.
|
|
return { type: "paused", why: { type: "alreadyPaused" } };
|
|
} else if (this.state != "running") {
|
|
return { error: "wrongState",
|
|
message: "Received interrupt request in " + this.state +
|
|
" state." };
|
|
}
|
|
|
|
try {
|
|
// If execution should pause just before the next JavaScript bytecode is
|
|
// executed, just set an onEnterFrame handler.
|
|
if (aRequest.when == "onNext") {
|
|
let onEnterFrame = (aFrame) => {
|
|
return this._pauseAndRespond(aFrame, { type: "interrupted", onNext: true });
|
|
};
|
|
this.dbg.onEnterFrame = onEnterFrame;
|
|
|
|
return { type: "willInterrupt" };
|
|
}
|
|
|
|
// If execution should pause immediately, just put ourselves in the paused
|
|
// state.
|
|
let packet = this._paused();
|
|
if (!packet) {
|
|
return { error: "notInterrupted" };
|
|
}
|
|
packet.why = { type: "interrupted" };
|
|
|
|
// Send the response to the interrupt request now (rather than
|
|
// returning it), because we're going to start a nested event loop
|
|
// here.
|
|
this.conn.send(packet);
|
|
|
|
// Start a nested event loop.
|
|
this._pushThreadPause();
|
|
|
|
// We already sent a response to this request, don't send one
|
|
// now.
|
|
return null;
|
|
} catch (e) {
|
|
reportError(e);
|
|
return { error: "notInterrupted", message: e.toString() };
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Handle a protocol request to retrieve all the event listeners on the page.
|
|
*/
|
|
onEventListeners: function (aRequest) {
|
|
// This request is only supported in content debugging.
|
|
if (!this.global) {
|
|
return {
|
|
error: "notImplemented",
|
|
message: "eventListeners request is only supported in content debugging"
|
|
};
|
|
}
|
|
|
|
let els = Cc["@mozilla.org/eventlistenerservice;1"]
|
|
.getService(Ci.nsIEventListenerService);
|
|
|
|
let nodes = this.global.document.getElementsByTagName("*");
|
|
nodes = [this.global].concat([].slice.call(nodes));
|
|
let listeners = [];
|
|
|
|
for (let node of nodes) {
|
|
let handlers = els.getListenerInfoFor(node);
|
|
|
|
for (let handler of handlers) {
|
|
// Create a form object for serializing the listener via the protocol.
|
|
let listenerForm = Object.create(null);
|
|
let listener = handler.listenerObject;
|
|
// Native event listeners don't provide any listenerObject or type and
|
|
// are not that useful to a JS debugger.
|
|
if (!listener || !handler.type) {
|
|
continue;
|
|
}
|
|
|
|
// There will be no tagName if the event listener is set on the window.
|
|
let selector = node.tagName ? CssLogic.findCssSelector(node) : "window";
|
|
let nodeDO = this.globalDebugObject.makeDebuggeeValue(node);
|
|
listenerForm.node = {
|
|
selector: selector,
|
|
object: createValueGrip(nodeDO, this._pausePool, this.objectGrip)
|
|
};
|
|
listenerForm.type = handler.type;
|
|
listenerForm.capturing = handler.capturing;
|
|
listenerForm.allowsUntrusted = handler.allowsUntrusted;
|
|
listenerForm.inSystemEventGroup = handler.inSystemEventGroup;
|
|
let handlerName = "on" + listenerForm.type;
|
|
listenerForm.isEventHandler = false;
|
|
if (typeof node.hasAttribute !== "undefined") {
|
|
listenerForm.isEventHandler = !!node.hasAttribute(handlerName);
|
|
}
|
|
if (!!node[handlerName]) {
|
|
listenerForm.isEventHandler = !!node[handlerName];
|
|
}
|
|
// Get the Debugger.Object for the listener object.
|
|
let listenerDO = this.globalDebugObject.makeDebuggeeValue(listener);
|
|
// If the listener is an object with a 'handleEvent' method, use that.
|
|
if (listenerDO.class == "Object" || listenerDO.class == "XULElement") {
|
|
// For some events we don't have permission to access the
|
|
// 'handleEvent' property when running in content scope.
|
|
if (!listenerDO.unwrap()) {
|
|
continue;
|
|
}
|
|
let heDesc;
|
|
while (!heDesc && listenerDO) {
|
|
heDesc = listenerDO.getOwnPropertyDescriptor("handleEvent");
|
|
listenerDO = listenerDO.proto;
|
|
}
|
|
if (heDesc && heDesc.value) {
|
|
listenerDO = heDesc.value;
|
|
}
|
|
}
|
|
// When the listener is a bound function, we are actually interested in
|
|
// the target function.
|
|
while (listenerDO.isBoundFunction) {
|
|
listenerDO = listenerDO.boundTargetFunction;
|
|
}
|
|
listenerForm.function = createValueGrip(listenerDO, this._pausePool,
|
|
this.objectGrip);
|
|
listeners.push(listenerForm);
|
|
}
|
|
}
|
|
return { listeners: listeners };
|
|
},
|
|
|
|
/**
|
|
* Return the Debug.Frame for a frame mentioned by the protocol.
|
|
*/
|
|
_requestFrame: function (aFrameID) {
|
|
if (!aFrameID) {
|
|
return this.youngestFrame;
|
|
}
|
|
|
|
if (this._framePool.has(aFrameID)) {
|
|
return this._framePool.get(aFrameID).frame;
|
|
}
|
|
|
|
return undefined;
|
|
},
|
|
|
|
_paused: function (aFrame) {
|
|
// We don't handle nested pauses correctly. Don't try - if we're
|
|
// paused, just continue running whatever code triggered the pause.
|
|
// We don't want to actually have nested pauses (although we
|
|
// have nested event loops). If code runs in the debuggee during
|
|
// a pause, it should cause the actor to resume (dropping
|
|
// pause-lifetime actors etc) and then repause when complete.
|
|
|
|
if (this.state === "paused") {
|
|
return undefined;
|
|
}
|
|
|
|
// Clear stepping hooks.
|
|
this.dbg.onEnterFrame = undefined;
|
|
this.dbg.onExceptionUnwind = undefined;
|
|
if (aFrame) {
|
|
aFrame.onStep = undefined;
|
|
aFrame.onPop = undefined;
|
|
}
|
|
|
|
// Clear DOM event breakpoints.
|
|
// XPCShell tests don't use actual DOM windows for globals and cause
|
|
// removeListenerForAllEvents to throw.
|
|
// if (!isWorker && this.global && !this.global.toString().includes("Sandbox")) {
|
|
// let els = Cc["@mozilla.org/eventlistenerservice;1"]
|
|
// .getService(Ci.nsIEventListenerService);
|
|
// els.removeListenerForAllEvents(this.global, this._allEventsListener, true);
|
|
// for (let [,bp] of this._hiddenBreakpoints) {
|
|
// bp.onDelete();
|
|
// }
|
|
// this._hiddenBreakpoints.clear();
|
|
// }
|
|
|
|
this._state = "paused";
|
|
|
|
// Create the actor pool that will hold the pause actor and its
|
|
// children.
|
|
dbg_assert(!this._pausePool, "No pause pool should exist yet");
|
|
this._pausePool = new ActorPool(this.conn);
|
|
this.conn.addActorPool(this._pausePool);
|
|
|
|
// Give children of the pause pool a quick link back to the
|
|
// thread...
|
|
this._pausePool.threadActor = this;
|
|
|
|
// Create the pause actor itself...
|
|
dbg_assert(!this._pauseActor, "No pause actor should exist yet");
|
|
this._pauseActor = new PauseActor(this._pausePool);
|
|
this._pausePool.addActor(this._pauseActor);
|
|
|
|
// Update the list of frames.
|
|
let poppedFrames = this._updateFrames();
|
|
|
|
// Send off the paused packet and spin an event loop.
|
|
let packet = { from: this.actorID,
|
|
type: "paused",
|
|
actor: this._pauseActor.actorID };
|
|
if (aFrame) {
|
|
packet.frame = this._createFrameActor(aFrame).form();
|
|
}
|
|
|
|
if (poppedFrames) {
|
|
packet.poppedFrames = poppedFrames;
|
|
}
|
|
|
|
return packet;
|
|
},
|
|
|
|
_resumed: function () {
|
|
this._state = "running";
|
|
|
|
// Drop the actors in the pause actor pool.
|
|
this.conn.removeActorPool(this._pausePool);
|
|
|
|
this._pausePool = null;
|
|
this._pauseActor = null;
|
|
|
|
return { from: this.actorID, type: "resumed" };
|
|
},
|
|
|
|
/**
|
|
* Expire frame actors for frames that have been popped.
|
|
*
|
|
* @returns A list of actor IDs whose frames have been popped.
|
|
*/
|
|
_updateFrames: function () {
|
|
let popped = [];
|
|
|
|
// Create the actor pool that will hold the still-living frames.
|
|
let framePool = new ActorPool(this.conn);
|
|
let frameList = [];
|
|
|
|
for (let frameActor of this._frameActors) {
|
|
if (frameActor.frame.live) {
|
|
framePool.addActor(frameActor);
|
|
frameList.push(frameActor);
|
|
} else {
|
|
popped.push(frameActor.actorID);
|
|
}
|
|
}
|
|
|
|
// Remove the old frame actor pool, this will expire
|
|
// any actors that weren't added to the new pool.
|
|
if (this._framePool) {
|
|
this.conn.removeActorPool(this._framePool);
|
|
}
|
|
|
|
this._frameActors = frameList;
|
|
this._framePool = framePool;
|
|
this.conn.addActorPool(framePool);
|
|
|
|
return popped;
|
|
},
|
|
|
|
_createFrameActor: function (aFrame) {
|
|
if (aFrame.actor) {
|
|
return aFrame.actor;
|
|
}
|
|
|
|
let actor = new FrameActor(aFrame, this);
|
|
this._frameActors.push(actor);
|
|
this._framePool.addActor(actor);
|
|
aFrame.actor = actor;
|
|
|
|
return actor;
|
|
},
|
|
|
|
/**
|
|
* Create and return an environment actor that corresponds to the provided
|
|
* Debugger.Environment.
|
|
* @param Debugger.Environment aEnvironment
|
|
* The lexical environment we want to extract.
|
|
* @param object aPool
|
|
* The pool where the newly-created actor will be placed.
|
|
* @return The EnvironmentActor for aEnvironment or undefined for host
|
|
* functions or functions scoped to a non-debuggee global.
|
|
*/
|
|
createEnvironmentActor: function (aEnvironment, aPool) {
|
|
if (!aEnvironment) {
|
|
return undefined;
|
|
}
|
|
|
|
if (aEnvironment.actor) {
|
|
return aEnvironment.actor;
|
|
}
|
|
|
|
let actor = new EnvironmentActor(aEnvironment, this);
|
|
aPool.addActor(actor);
|
|
aEnvironment.actor = actor;
|
|
|
|
return actor;
|
|
},
|
|
|
|
/**
|
|
* Return a protocol completion value representing the given
|
|
* Debugger-provided completion value.
|
|
*/
|
|
createProtocolCompletionValue: function (aCompletion) {
|
|
let protoValue = {};
|
|
if (aCompletion == null) {
|
|
protoValue.terminated = true;
|
|
} else if ("return" in aCompletion) {
|
|
protoValue.return = createValueGrip(aCompletion.return,
|
|
this._pausePool, this.objectGrip);
|
|
} else if ("throw" in aCompletion) {
|
|
protoValue.throw = createValueGrip(aCompletion.throw,
|
|
this._pausePool, this.objectGrip);
|
|
} else {
|
|
protoValue.return = createValueGrip(aCompletion.yield,
|
|
this._pausePool, this.objectGrip);
|
|
}
|
|
return protoValue;
|
|
},
|
|
|
|
/**
|
|
* Create a grip for the given debuggee object.
|
|
*
|
|
* @param aValue Debugger.Object
|
|
* The debuggee object value.
|
|
* @param aPool ActorPool
|
|
* The actor pool where the new object actor will be added.
|
|
*/
|
|
objectGrip: function (aValue, aPool) {
|
|
if (!aPool.objectActors) {
|
|
aPool.objectActors = new WeakMap();
|
|
}
|
|
|
|
if (aPool.objectActors.has(aValue)) {
|
|
return aPool.objectActors.get(aValue).grip();
|
|
} else if (this.threadLifetimePool.objectActors.has(aValue)) {
|
|
return this.threadLifetimePool.objectActors.get(aValue).grip();
|
|
}
|
|
|
|
let actor = new PauseScopedObjectActor(aValue, {
|
|
getGripDepth: () => this._gripDepth,
|
|
incrementGripDepth: () => this._gripDepth++,
|
|
decrementGripDepth: () => this._gripDepth--,
|
|
createValueGrip: v => createValueGrip(v, this._pausePool,
|
|
this.pauseObjectGrip),
|
|
sources: () => this.sources,
|
|
createEnvironmentActor: (env, pool) =>
|
|
this.createEnvironmentActor(env, pool),
|
|
promote: () => this.threadObjectGrip(actor),
|
|
isThreadLifetimePool: () =>
|
|
actor.registeredPool !== this.threadLifetimePool,
|
|
getGlobalDebugObject: () => this.globalDebugObject
|
|
});
|
|
aPool.addActor(actor);
|
|
aPool.objectActors.set(aValue, actor);
|
|
return actor.grip();
|
|
},
|
|
|
|
/**
|
|
* Create a grip for the given debuggee object with a pause lifetime.
|
|
*
|
|
* @param aValue Debugger.Object
|
|
* The debuggee object value.
|
|
*/
|
|
pauseObjectGrip: function (aValue) {
|
|
if (!this._pausePool) {
|
|
throw "Object grip requested while not paused.";
|
|
}
|
|
|
|
return this.objectGrip(aValue, this._pausePool);
|
|
},
|
|
|
|
/**
|
|
* Extend the lifetime of the provided object actor to thread lifetime.
|
|
*
|
|
* @param aActor object
|
|
* The object actor.
|
|
*/
|
|
threadObjectGrip: function (aActor) {
|
|
// We want to reuse the existing actor ID, so we just remove it from the
|
|
// current pool's weak map and then let pool.addActor do the rest.
|
|
aActor.registeredPool.objectActors.delete(aActor.obj);
|
|
this.threadLifetimePool.addActor(aActor);
|
|
this.threadLifetimePool.objectActors.set(aActor.obj, aActor);
|
|
},
|
|
|
|
/**
|
|
* Handle a protocol request to promote multiple pause-lifetime grips to
|
|
* thread-lifetime grips.
|
|
*
|
|
* @param aRequest object
|
|
* The protocol request object.
|
|
*/
|
|
onThreadGrips: function (aRequest) {
|
|
if (this.state != "paused") {
|
|
return { error: "wrongState" };
|
|
}
|
|
|
|
if (!aRequest.actors) {
|
|
return { error: "missingParameter",
|
|
message: "no actors were specified" };
|
|
}
|
|
|
|
for (let actorID of aRequest.actors) {
|
|
let actor = this._pausePool.get(actorID);
|
|
if (actor) {
|
|
this.threadObjectGrip(actor);
|
|
}
|
|
}
|
|
return {};
|
|
},
|
|
|
|
/**
|
|
* Create a long string grip that is scoped to a pause.
|
|
*
|
|
* @param aString String
|
|
* The string we are creating a grip for.
|
|
*/
|
|
pauseLongStringGrip: function (aString) {
|
|
return longStringGrip(aString, this._pausePool);
|
|
},
|
|
|
|
/**
|
|
* Create a long string grip that is scoped to a thread.
|
|
*
|
|
* @param aString String
|
|
* The string we are creating a grip for.
|
|
*/
|
|
threadLongStringGrip: function (aString) {
|
|
return longStringGrip(aString, this._threadLifetimePool);
|
|
},
|
|
|
|
// JS Debugger API hooks.
|
|
|
|
/**
|
|
* A function that the engine calls when a call to a debug event hook,
|
|
* breakpoint handler, watchpoint handler, or similar function throws some
|
|
* exception.
|
|
*
|
|
* @param aException exception
|
|
* The exception that was thrown in the debugger code.
|
|
*/
|
|
uncaughtExceptionHook: function (aException) {
|
|
DevToolsUtils.dumpn("Got an exception: " + aException.message + "\n" + aException.stack);
|
|
},
|
|
|
|
/**
|
|
* A function that the engine calls when a debugger statement has been
|
|
* executed in the specified frame.
|
|
*
|
|
* @param aFrame Debugger.Frame
|
|
* The stack frame that contained the debugger statement.
|
|
*/
|
|
onDebuggerStatement: function (aFrame) {
|
|
// Don't pause if we are currently stepping (in or over) or the frame is
|
|
// black-boxed.
|
|
const generatedLocation = this.sources.getFrameLocation(aFrame);
|
|
const { originalSourceActor } = this.unsafeSynchronize(this.sources.getOriginalLocation(
|
|
generatedLocation));
|
|
const url = originalSourceActor ? originalSourceActor.url : null;
|
|
|
|
return this.sources.isBlackBoxed(url) || aFrame.onStep
|
|
? undefined
|
|
: this._pauseAndRespond(aFrame, { type: "debuggerStatement" });
|
|
},
|
|
|
|
/**
|
|
* A function that the engine calls when an exception has been thrown and has
|
|
* propagated to the specified frame.
|
|
*
|
|
* @param aFrame Debugger.Frame
|
|
* The youngest remaining stack frame.
|
|
* @param aValue object
|
|
* The exception that was thrown.
|
|
*/
|
|
onExceptionUnwind: function (aFrame, aValue) {
|
|
let willBeCaught = false;
|
|
for (let frame = aFrame; frame != null; frame = frame.older) {
|
|
if (frame.script.isInCatchScope(frame.offset)) {
|
|
willBeCaught = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (willBeCaught && this._options.ignoreCaughtExceptions) {
|
|
return undefined;
|
|
}
|
|
|
|
const generatedLocation = this.sources.getFrameLocation(aFrame);
|
|
const { sourceActor } = this.unsafeSynchronize(this.sources.getOriginalLocation(
|
|
generatedLocation));
|
|
const url = sourceActor ? sourceActor.url : null;
|
|
|
|
if (this.sources.isBlackBoxed(url)) {
|
|
return undefined;
|
|
}
|
|
|
|
try {
|
|
let packet = this._paused(aFrame);
|
|
if (!packet) {
|
|
return undefined;
|
|
}
|
|
|
|
packet.why = { type: "exception",
|
|
exception: createValueGrip(aValue, this._pausePool,
|
|
this.objectGrip)
|
|
};
|
|
this.conn.send(packet);
|
|
|
|
this._pushThreadPause();
|
|
} catch(e) {
|
|
reportError(e, "Got an exception during TA_onExceptionUnwind: ");
|
|
}
|
|
|
|
return undefined;
|
|
},
|
|
|
|
/**
|
|
* A function that the engine calls when a new script has been loaded into the
|
|
* scope of the specified debuggee global.
|
|
*
|
|
* @param aScript Debugger.Script
|
|
* The source script that has been loaded into a debuggee compartment.
|
|
* @param aGlobal Debugger.Object
|
|
* A Debugger.Object instance whose referent is the global object.
|
|
*/
|
|
onNewScript: function (aScript, aGlobal) {
|
|
this._addSource(aScript.source);
|
|
},
|
|
|
|
onNewSource: function (aSource) {
|
|
this.conn.send({
|
|
from: this.actorID,
|
|
type: "newSource",
|
|
source: aSource.form()
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Restore any pre-existing breakpoints to the sources that we have access to.
|
|
*/
|
|
_restoreBreakpoints: function () {
|
|
if (this.breakpointActorMap.size === 0) {
|
|
return;
|
|
}
|
|
|
|
for (let s of this.scripts.getSources()) {
|
|
this._addSource(s);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Add the provided source to the server cache.
|
|
*
|
|
* @param aSource Debugger.Source
|
|
* The source that will be stored.
|
|
* @returns true, if the source was added; false otherwise.
|
|
*/
|
|
_addSource: function (aSource) {
|
|
if (!this.sources.allowSource(aSource) || this._debuggerSourcesSeen.has(aSource)) {
|
|
return false;
|
|
}
|
|
|
|
// The scripts must be added to the ScriptStore before restoring
|
|
// breakpoints. If we try to add them to the ScriptStore any later, we can
|
|
// accidentally set a breakpoint in a top level script as a "closest match"
|
|
// because we wouldn't have added the child scripts to the ScriptStore yet.
|
|
this.scripts.addScripts(this.dbg.findScripts({ source: aSource }));
|
|
|
|
let sourceActor = this.sources.createNonSourceMappedActor(aSource);
|
|
|
|
// Go ahead and establish the source actors for this script, which
|
|
// fetches sourcemaps if available and sends onNewSource
|
|
// notifications.
|
|
//
|
|
// We need to use unsafeSynchronize here because if the page is being reloaded,
|
|
// this call will replace the previous set of source actors for this source
|
|
// with a new one. If the source actors have not been replaced by the time
|
|
// we try to reset the breakpoints below, their location objects will still
|
|
// point to the old set of source actors, which point to different scripts.
|
|
this.unsafeSynchronize(this.sources.createSourceActors(aSource));
|
|
|
|
// Set any stored breakpoints.
|
|
let promises = [];
|
|
|
|
for (let _actor of this.breakpointActorMap.findActors()) {
|
|
// XXX bug 1142115: We do async work in here, so we need to create a fresh
|
|
// binding because for/of does not yet do that in SpiderMonkey.
|
|
let actor = _actor;
|
|
|
|
if (actor.isPending) {
|
|
promises.push(actor.originalLocation.originalSourceActor._setBreakpoint(actor));
|
|
} else {
|
|
promises.push(this.sources.getAllGeneratedLocations(actor.originalLocation)
|
|
.then((generatedLocations) => {
|
|
if (generatedLocations.length > 0 &&
|
|
generatedLocations[0].generatedSourceActor.actorID === sourceActor.actorID) {
|
|
sourceActor._setBreakpointAtAllGeneratedLocations(
|
|
actor,
|
|
generatedLocations
|
|
);
|
|
}
|
|
}));
|
|
}
|
|
}
|
|
|
|
if (promises.length > 0) {
|
|
this.unsafeSynchronize(promise.all(promises));
|
|
}
|
|
|
|
this._debuggerSourcesSeen.add(aSource);
|
|
return true;
|
|
},
|
|
|
|
|
|
/**
|
|
* Get prototypes and properties of multiple objects.
|
|
*/
|
|
onPrototypesAndProperties: function (aRequest) {
|
|
let result = {};
|
|
for (let actorID of aRequest.actors) {
|
|
// This code assumes that there are no lazily loaded actors returned
|
|
// by this call.
|
|
let actor = this.conn.getActor(actorID);
|
|
if (!actor) {
|
|
return { from: this.actorID,
|
|
error: "noSuchActor" };
|
|
}
|
|
let handler = actor.onPrototypeAndProperties;
|
|
if (!handler) {
|
|
return { from: this.actorID,
|
|
error: "unrecognizedPacketType",
|
|
message: ('Actor "' + actorID +
|
|
'" does not recognize the packet type ' +
|
|
'"prototypeAndProperties"') };
|
|
}
|
|
result[actorID] = handler.call(actor, {});
|
|
}
|
|
return { from: this.actorID,
|
|
actors: result };
|
|
}
|
|
};
|
|
|
|
ThreadActor.prototype.requestTypes = {
|
|
"attach": ThreadActor.prototype.onAttach,
|
|
"detach": ThreadActor.prototype.onDetach,
|
|
"reconfigure": ThreadActor.prototype.onReconfigure,
|
|
"resume": ThreadActor.prototype.onResume,
|
|
"clientEvaluate": ThreadActor.prototype.onClientEvaluate,
|
|
"frames": ThreadActor.prototype.onFrames,
|
|
"interrupt": ThreadActor.prototype.onInterrupt,
|
|
"eventListeners": ThreadActor.prototype.onEventListeners,
|
|
"releaseMany": ThreadActor.prototype.onReleaseMany,
|
|
"sources": ThreadActor.prototype.onSources,
|
|
"threadGrips": ThreadActor.prototype.onThreadGrips,
|
|
"prototypesAndProperties": ThreadActor.prototype.onPrototypesAndProperties
|
|
};
|
|
|
|
exports.ThreadActor = ThreadActor;
|
|
|
|
/**
|
|
* Creates a PauseActor.
|
|
*
|
|
* PauseActors exist for the lifetime of a given debuggee pause. Used to
|
|
* scope pause-lifetime grips.
|
|
*
|
|
* @param ActorPool aPool
|
|
* The actor pool created for this pause.
|
|
*/
|
|
function PauseActor(aPool)
|
|
{
|
|
this.pool = aPool;
|
|
}
|
|
|
|
PauseActor.prototype = {
|
|
actorPrefix: "pause"
|
|
};
|
|
|
|
|
|
/**
|
|
* A base actor for any actors that should only respond receive messages in the
|
|
* paused state. Subclasses may expose a `threadActor` which is used to help
|
|
* determine when we are in a paused state. Subclasses should set their own
|
|
* "constructor" property if they want better error messages. You should never
|
|
* instantiate a PauseScopedActor directly, only through subclasses.
|
|
*/
|
|
function PauseScopedActor()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* A function decorator for creating methods to handle protocol messages that
|
|
* should only be received while in the paused state.
|
|
*
|
|
* @param aMethod Function
|
|
* The function we are decorating.
|
|
*/
|
|
PauseScopedActor.withPaused = function (aMethod) {
|
|
return function () {
|
|
if (this.isPaused()) {
|
|
return aMethod.apply(this, arguments);
|
|
} else {
|
|
return this._wrongState();
|
|
}
|
|
};
|
|
};
|
|
|
|
PauseScopedActor.prototype = {
|
|
|
|
/**
|
|
* Returns true if we are in the paused state.
|
|
*/
|
|
isPaused: function () {
|
|
// When there is not a ThreadActor available (like in the webconsole) we
|
|
// have to be optimistic and assume that we are paused so that we can
|
|
// respond to requests.
|
|
return this.threadActor ? this.threadActor.state === "paused" : true;
|
|
},
|
|
|
|
/**
|
|
* Returns the wrongState response packet for this actor.
|
|
*/
|
|
_wrongState: function () {
|
|
return {
|
|
error: "wrongState",
|
|
message: this.constructor.name +
|
|
" actors can only be accessed while the thread is paused."
|
|
};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Resolve a URI back to physical file.
|
|
*
|
|
* Of course, this works only for URIs pointing to local resources.
|
|
*
|
|
* @param aURI
|
|
* URI to resolve
|
|
* @return
|
|
* resolved nsIURI
|
|
*/
|
|
function resolveURIToLocalPath(aURI) {
|
|
let resolved;
|
|
switch (aURI.scheme) {
|
|
case "jar":
|
|
case "file":
|
|
return aURI;
|
|
|
|
case "chrome":
|
|
resolved = Cc["@mozilla.org/chrome/chrome-registry;1"].
|
|
getService(Ci.nsIChromeRegistry).convertChromeURL(aURI);
|
|
return resolveURIToLocalPath(resolved);
|
|
|
|
case "resource":
|
|
resolved = Cc["@mozilla.org/network/protocol;1?name=resource"].
|
|
getService(Ci.nsIResProtocolHandler).resolveURI(aURI);
|
|
aURI = Services.io.newURI(resolved, null, null);
|
|
return resolveURIToLocalPath(aURI);
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A SourceActor provides information about the source of a script. There
|
|
* are two kinds of source actors: ones that represent real source objects,
|
|
* and ones that represent non-existant "original" sources when the real
|
|
* sources are sourcemapped. When a source is sourcemapped, actors are
|
|
* created for both the "generated" and "original" sources, and the client will
|
|
* only see the original sources. We separate these because there isn't
|
|
* a 1:1 mapping of generated to original sources; one generated source
|
|
* may represent N original sources, so we need to create N + 1 separate
|
|
* actors.
|
|
*
|
|
* There are 4 different scenarios for sources that you should
|
|
* understand:
|
|
*
|
|
* - A single non-sourcemapped source that is not inlined in HTML
|
|
* (separate JS file, eval'ed code, etc)
|
|
* - A single sourcemapped source which creates N original sources
|
|
* - An HTML page with multiple inline scripts, which are distinct
|
|
* sources, but should be represented as a single source
|
|
* - A pretty-printed source (which may or may not be an original
|
|
* sourcemapped source), which generates a sourcemap for itself
|
|
*
|
|
* The complexity of `SourceActor` and `ThreadSources` are to handle
|
|
* all of thise cases and hopefully internalize the complexities.
|
|
*
|
|
* @param Debugger.Source source
|
|
* The source object we are representing.
|
|
* @param ThreadActor thread
|
|
* The current thread actor.
|
|
* @param String originalUrl
|
|
* Optional. For sourcemapped urls, the original url this is representing.
|
|
* @param Debugger.Source generatedSource
|
|
* Optional, passed in when aSourceMap is also passed in. The generated
|
|
* source object that introduced this source.
|
|
* @param String contentType
|
|
* Optional. The content type of this source, if immediately available.
|
|
*/
|
|
function SourceActor({ source, thread, originalUrl, generatedSource,
|
|
isInlineSource, contentType }) {
|
|
this._threadActor = thread;
|
|
this._originalUrl = originalUrl;
|
|
this._source = source;
|
|
this._generatedSource = generatedSource;
|
|
this._contentType = contentType;
|
|
this._isInlineSource = isInlineSource;
|
|
|
|
this.onSource = this.onSource.bind(this);
|
|
this._invertSourceMap = this._invertSourceMap.bind(this);
|
|
this._encodeAndSetSourceMapURL = this._encodeAndSetSourceMapURL.bind(this);
|
|
this._getSourceText = this._getSourceText.bind(this);
|
|
|
|
this._mapSourceToAddon();
|
|
|
|
if (this.threadActor.sources.isPrettyPrinted(this.url)) {
|
|
this._init = this.onPrettyPrint({
|
|
indent: this.threadActor.sources.prettyPrintIndent(this.url)
|
|
}).then(null, error => {
|
|
DevToolsUtils.reportException("SourceActor", error);
|
|
});
|
|
} else {
|
|
this._init = null;
|
|
}
|
|
}
|
|
|
|
SourceActor.prototype = {
|
|
constructor: SourceActor,
|
|
actorPrefix: "source",
|
|
|
|
_oldSourceMap: null,
|
|
_init: null,
|
|
_addonID: null,
|
|
_addonPath: null,
|
|
|
|
get isSourceMapped() {
|
|
return !this.isInlineSource && (
|
|
this._originalURL || this._generatedSource ||
|
|
this.threadActor.sources.isPrettyPrinted(this.url)
|
|
);
|
|
},
|
|
|
|
get isInlineSource() {
|
|
return this._isInlineSource;
|
|
},
|
|
|
|
get threadActor() { return this._threadActor; },
|
|
get sources() { return this._threadActor.sources; },
|
|
get dbg() { return this.threadActor.dbg; },
|
|
get scripts() { return this.threadActor.scripts; },
|
|
get source() { return this._source; },
|
|
get generatedSource() { return this._generatedSource; },
|
|
get breakpointActorMap() { return this.threadActor.breakpointActorMap; },
|
|
get url() {
|
|
if (this.source) {
|
|
return getSourceURL(this.source, this.threadActor._parent.window);
|
|
}
|
|
return this._originalUrl;
|
|
},
|
|
get addonID() { return this._addonID; },
|
|
get addonPath() { return this._addonPath; },
|
|
|
|
get prettyPrintWorker() {
|
|
return this.threadActor.prettyPrintWorker;
|
|
},
|
|
|
|
form: function () {
|
|
let source = this.source || this.generatedSource;
|
|
// This might not have a source or a generatedSource because we
|
|
// treat HTML pages with inline scripts as a special SourceActor
|
|
// that doesn't have either
|
|
let introductionUrl = null;
|
|
if (source && source.introductionScript) {
|
|
introductionUrl = source.introductionScript.source.url;
|
|
}
|
|
|
|
return {
|
|
actor: this.actorID,
|
|
url: this.url ? this.url.split(" -> ").pop() : null,
|
|
addonID: this._addonID,
|
|
addonPath: this._addonPath,
|
|
isBlackBoxed: this.threadActor.sources.isBlackBoxed(this.url),
|
|
isPrettyPrinted: this.threadActor.sources.isPrettyPrinted(this.url),
|
|
introductionUrl: introductionUrl ? introductionUrl.split(" -> ").pop() : null,
|
|
introductionType: source ? source.introductionType : null
|
|
};
|
|
},
|
|
|
|
disconnect: function () {
|
|
if (this.registeredPool && this.registeredPool.sourceActors) {
|
|
delete this.registeredPool.sourceActors[this.actorID];
|
|
}
|
|
},
|
|
|
|
_mapSourceToAddon: function() {
|
|
try {
|
|
var nsuri = Services.io.newURI(this.url.split(" -> ").pop(), null, null);
|
|
}
|
|
catch (e) {
|
|
// We can't do anything with an invalid URI
|
|
return;
|
|
}
|
|
|
|
let localURI = resolveURIToLocalPath(nsuri);
|
|
|
|
let id = {};
|
|
if (localURI && mapURIToAddonID(localURI, id)) {
|
|
this._addonID = id.value;
|
|
|
|
if (localURI instanceof Ci.nsIJARURI) {
|
|
// The path in the add-on is easy for jar: uris
|
|
this._addonPath = localURI.JAREntry;
|
|
}
|
|
else if (localURI instanceof Ci.nsIFileURL) {
|
|
// For file: uris walk up to find the last directory that is part of the
|
|
// add-on
|
|
let target = localURI.file;
|
|
let path = target.leafName;
|
|
|
|
// We can assume that the directory containing the source file is part
|
|
// of the add-on
|
|
let root = target.parent;
|
|
let file = root.parent;
|
|
while (file && mapURIToAddonID(Services.io.newFileURI(file), {})) {
|
|
path = root.leafName + "/" + path;
|
|
root = file;
|
|
file = file.parent;
|
|
}
|
|
|
|
if (!file) {
|
|
const error = new Error("Could not find the root of the add-on for " + this.url);
|
|
DevToolsUtils.reportException("SourceActor.prototype._mapSourceToAddon", error)
|
|
return;
|
|
}
|
|
|
|
this._addonPath = path;
|
|
}
|
|
}
|
|
},
|
|
|
|
_reportLoadSourceError: function (error, map=null) {
|
|
try {
|
|
DevToolsUtils.reportException("SourceActor", error);
|
|
|
|
JSON.stringify(this.form(), null, 4).split(/\n/g)
|
|
.forEach(line => console.error("\t", line));
|
|
|
|
if (!map) {
|
|
return;
|
|
}
|
|
|
|
console.error("\t", "source map's sourceRoot =", map.sourceRoot);
|
|
|
|
console.error("\t", "source map's sources =");
|
|
map.sources.forEach(s => {
|
|
let hasSourceContent = map.sourceContentFor(s, true);
|
|
console.error("\t\t", s, "\t",
|
|
hasSourceContent ? "has source content" : "no source content");
|
|
});
|
|
|
|
console.error("\t", "source map's sourcesContent =");
|
|
map.sourcesContent.forEach(c => {
|
|
if (c.length > 80) {
|
|
c = c.slice(0, 77) + "...";
|
|
}
|
|
c = c.replace(/\n/g, "\\n");
|
|
console.error("\t\t", c);
|
|
});
|
|
} catch (e) { }
|
|
},
|
|
|
|
_getSourceText: function () {
|
|
let toResolvedContent = t => ({
|
|
content: t,
|
|
contentType: this._contentType
|
|
});
|
|
|
|
let genSource = this.generatedSource || this.source;
|
|
return this.threadActor.sources.fetchSourceMap(genSource).then(map => {
|
|
if (map) {
|
|
try {
|
|
let sourceContent = map.sourceContentFor(this.url);
|
|
if (sourceContent) {
|
|
return toResolvedContent(sourceContent);
|
|
}
|
|
} catch (error) {
|
|
this._reportLoadSourceError(error, map);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Use `source.text` if it exists, is not the "no source"
|
|
// string, and the content type of the source is JavaScript. It
|
|
// will be "no source" if the Debugger API wasn't able to load
|
|
// the source because sources were discarded
|
|
// (javascript.options.discardSystemSource == true). Re-fetch
|
|
// non-JS sources to get the contentType from the headers.
|
|
if (this.source &&
|
|
this.source.text !== "[no source]" &&
|
|
this._contentType &&
|
|
this._contentType.indexOf('javascript') !== -1) {
|
|
return toResolvedContent(this.source.text);
|
|
}
|
|
else {
|
|
// Only load the HTML page source from cache (which exists when
|
|
// there are inline sources). Otherwise, we can't trust the
|
|
// cache because we are most likely here because we are
|
|
// fetching the original text for sourcemapped code, and the
|
|
// page hasn't requested it before (if it has, it was a
|
|
// previous debugging session).
|
|
let sourceFetched = fetch(this.url, { loadFromCache: this.isInlineSource });
|
|
|
|
// Record the contentType we just learned during fetching
|
|
return sourceFetched
|
|
.then(result => {
|
|
this._contentType = result.contentType;
|
|
return result;
|
|
}, error => {
|
|
this._reportLoadSourceError(error, map);
|
|
throw error;
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Get all executable lines from the current source
|
|
* @return Array - Executable lines of the current script
|
|
**/
|
|
getExecutableLines: function () {
|
|
// Check if the original source is source mapped
|
|
let packet = {
|
|
from: this.actorID
|
|
};
|
|
|
|
function sortLines(lines) {
|
|
// Converting the Set into an array
|
|
lines = [...lines];
|
|
lines.sort((a, b) => {
|
|
return a - b;
|
|
});
|
|
return lines;
|
|
}
|
|
|
|
if (this.generatedSource) {
|
|
return this.threadActor.sources.getSourceMap(this.generatedSource).then(sm => {
|
|
let lines = new Set();
|
|
|
|
// Position of executable lines in the generated source
|
|
let offsets = this.getExecutableOffsets(this.generatedSource, false);
|
|
for (let offset of offsets) {
|
|
let {line, source: sourceUrl} = sm.originalPositionFor({
|
|
line: offset.lineNumber,
|
|
column: offset.columnNumber
|
|
});
|
|
|
|
if (sourceUrl === this.url) {
|
|
lines.add(line);
|
|
}
|
|
}
|
|
|
|
packet.lines = sortLines(lines);
|
|
return packet;
|
|
});
|
|
}
|
|
|
|
let lines = this.getExecutableOffsets(this.source, true);
|
|
packet.lines = sortLines(lines);
|
|
return packet;
|
|
},
|
|
|
|
/**
|
|
* Extract all executable offsets from the given script
|
|
* @param String url - extract offsets of the script with this url
|
|
* @param Boolean onlyLine - will return only the line number
|
|
* @return Set - Executable offsets/lines of the script
|
|
**/
|
|
getExecutableOffsets: function (source, onlyLine) {
|
|
let offsets = new Set();
|
|
for (let s of this.threadActor.scripts.getScriptsBySource(source)) {
|
|
for (let offset of s.getAllColumnOffsets()) {
|
|
offsets.add(onlyLine ? offset.lineNumber : offset);
|
|
}
|
|
}
|
|
|
|
return offsets;
|
|
},
|
|
|
|
/**
|
|
* Handler for the "source" packet.
|
|
*/
|
|
onSource: function () {
|
|
return resolve(this._init)
|
|
.then(this._getSourceText)
|
|
.then(({ content, contentType }) => {
|
|
return {
|
|
from: this.actorID,
|
|
// source: createValueGrip(content, this.threadActor.threadLifetimePool,
|
|
// this.threadActor.objectGrip),
|
|
source: content,
|
|
contentType: contentType
|
|
};
|
|
})
|
|
.then(null, aError => {
|
|
reportError(aError, "Got an exception during SA_onSource: ");
|
|
return {
|
|
"from": this.actorID,
|
|
"error": this.url,
|
|
"message": "Could not load the source for " + this.url + ".\n"
|
|
+ DevToolsUtils.safeErrorString(aError)
|
|
};
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Handler for the "prettyPrint" packet.
|
|
*/
|
|
onPrettyPrint: function ({ indent }) {
|
|
this.threadActor.sources.prettyPrint(this.url, indent);
|
|
return this._getSourceText()
|
|
.then(this._sendToPrettyPrintWorker(indent))
|
|
.then(this._invertSourceMap)
|
|
.then(this._encodeAndSetSourceMapURL)
|
|
.then(() => {
|
|
// We need to reset `_init` now because we have already done the work of
|
|
// pretty printing, and don't want onSource to wait forever for
|
|
// initialization to complete.
|
|
this._init = null;
|
|
})
|
|
.then(this.onSource)
|
|
.then(null, error => {
|
|
this.onDisablePrettyPrint();
|
|
return {
|
|
from: this.actorID,
|
|
error: "prettyPrintError",
|
|
message: DevToolsUtils.safeErrorString(error)
|
|
};
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Return a function that sends a request to the pretty print worker, waits on
|
|
* the worker's response, and then returns the pretty printed code.
|
|
*
|
|
* @param Number aIndent
|
|
* The number of spaces to indent by the code by, when we send the
|
|
* request to the pretty print worker.
|
|
* @returns Function
|
|
* Returns a function which takes an AST, and returns a promise that
|
|
* is resolved with `{ code, mappings }` where `code` is the pretty
|
|
* printed code, and `mappings` is an array of source mappings.
|
|
*/
|
|
_sendToPrettyPrintWorker: function (aIndent) {
|
|
return ({ content }) => {
|
|
return this.prettyPrintWorker.performTask("pretty-print", {
|
|
url: this.url,
|
|
indent: aIndent,
|
|
source: content
|
|
})
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Invert a source map. So if a source map maps from a to b, return a new
|
|
* source map from b to a. We need to do this because the source map we get
|
|
* from _generatePrettyCodeAndMap goes the opposite way we want it to for
|
|
* debugging.
|
|
*
|
|
* Note that the source map is modified in place.
|
|
*/
|
|
_invertSourceMap: function ({ code, mappings }) {
|
|
const generator = new SourceMapGenerator({ file: this.url });
|
|
return DevToolsUtils.yieldingEach(mappings._array, m => {
|
|
let mapping = {
|
|
generated: {
|
|
line: m.originalLine,
|
|
column: m.originalColumn
|
|
}
|
|
};
|
|
if (m.source) {
|
|
mapping.source = m.source;
|
|
mapping.original = {
|
|
line: m.generatedLine,
|
|
column: m.generatedColumn
|
|
};
|
|
mapping.name = m.name;
|
|
}
|
|
generator.addMapping(mapping);
|
|
}).then(() => {
|
|
generator.setSourceContent(this.url, code);
|
|
let consumer = SourceMapConsumer.fromSourceMap(generator);
|
|
|
|
return {
|
|
code: code,
|
|
map: consumer
|
|
};
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Save the source map back to our thread's ThreadSources object so that
|
|
* stepping, breakpoints, debugger statements, etc can use it. If we are
|
|
* pretty printing a source mapped source, we need to compose the existing
|
|
* source map with our new one.
|
|
*/
|
|
_encodeAndSetSourceMapURL: function ({ map: sm }) {
|
|
let source = this.generatedSource || this.source;
|
|
let sources = this.threadActor.sources;
|
|
|
|
return sources.getSourceMap(source).then(prevMap => {
|
|
if (prevMap) {
|
|
// Compose the source maps
|
|
this._oldSourceMapping = {
|
|
url: source.sourceMapURL,
|
|
map: prevMap
|
|
};
|
|
|
|
prevMap = SourceMapGenerator.fromSourceMap(prevMap);
|
|
prevMap.applySourceMap(sm, this.url);
|
|
sm = SourceMapConsumer.fromSourceMap(prevMap);
|
|
}
|
|
|
|
let sources = this.threadActor.sources;
|
|
sources.clearSourceMapCache(source.sourceMapURL);
|
|
sources.setSourceMapHard(source, null, sm);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Handler for the "disablePrettyPrint" packet.
|
|
*/
|
|
onDisablePrettyPrint: function () {
|
|
let source = this.generatedSource || this.source;
|
|
let sources = this.threadActor.sources;
|
|
let sm = sources.getSourceMap(source);
|
|
|
|
sources.clearSourceMapCache(source.sourceMapURL, { hard: true });
|
|
|
|
if (this._oldSourceMapping) {
|
|
sources.setSourceMapHard(source,
|
|
this._oldSourceMapping.url,
|
|
this._oldSourceMapping.map);
|
|
this._oldSourceMapping = null;
|
|
}
|
|
|
|
this.threadActor.sources.disablePrettyPrint(this.url);
|
|
return this.onSource();
|
|
},
|
|
|
|
/**
|
|
* Handler for the "blackbox" packet.
|
|
*/
|
|
onBlackBox: function (aRequest) {
|
|
this.threadActor.sources.blackBox(this.url);
|
|
let packet = {
|
|
from: this.actorID
|
|
};
|
|
if (this.threadActor.state == "paused"
|
|
&& this.threadActor.youngestFrame
|
|
&& this.threadActor.youngestFrame.script.url == this.url) {
|
|
packet.pausedInSource = true;
|
|
}
|
|
return packet;
|
|
},
|
|
|
|
/**
|
|
* Handler for the "unblackbox" packet.
|
|
*/
|
|
onUnblackBox: function (aRequest) {
|
|
this.threadActor.sources.unblackBox(this.url);
|
|
return {
|
|
from: this.actorID
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Handle a request to set a breakpoint.
|
|
*
|
|
* @param JSON request
|
|
* A JSON object representing the request.
|
|
*
|
|
* @returns Promise
|
|
* A promise that resolves to a JSON object representing the
|
|
* response.
|
|
*/
|
|
onSetBreakpoint: function (request) {
|
|
if (this.threadActor.state !== "paused") {
|
|
return {
|
|
error: "wrongState",
|
|
message: "Cannot set breakpoint while debuggee is running."
|
|
};
|
|
}
|
|
|
|
let { location: { line, column }, condition } = request;
|
|
let location = new OriginalLocation(this, line, column);
|
|
return this._getOrCreateBreakpointActor(
|
|
location,
|
|
condition
|
|
).then((actor) => {
|
|
let response = {
|
|
actor: actor.actorID,
|
|
isPending: actor.isPending
|
|
};
|
|
|
|
let actualLocation = actor.originalLocation;
|
|
if (!actualLocation.equals(location)) {
|
|
response.actualLocation = actualLocation.toJSON();
|
|
}
|
|
|
|
return response;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Get or create a BreakpointActor for the given location in the original
|
|
* source, and ensure it is set as a breakpoint handler on all scripts that
|
|
* match the given location.
|
|
*
|
|
* @param OriginalLocation originalLocation
|
|
* An OriginalLocation representing the location of the breakpoint in
|
|
* the original source.
|
|
* @param String condition
|
|
* A string that is evaluated whenever the breakpoint is hit. If the
|
|
* string evaluates to false, the breakpoint is ignored.
|
|
*
|
|
* @returns BreakpointActor
|
|
* A BreakpointActor representing the breakpoint.
|
|
*/
|
|
_getOrCreateBreakpointActor: function (originalLocation, condition) {
|
|
let actor = this.breakpointActorMap.getActor(originalLocation);
|
|
if (!actor) {
|
|
actor = new BreakpointActor(this.threadActor, originalLocation);
|
|
this.threadActor.threadLifetimePool.addActor(actor);
|
|
this.breakpointActorMap.setActor(originalLocation, actor);
|
|
}
|
|
|
|
actor.condition = condition;
|
|
|
|
return this._setBreakpoint(actor);
|
|
},
|
|
|
|
/*
|
|
* Ensure the given BreakpointActor is set as a breakpoint handler on all
|
|
* scripts that match its location in the original source.
|
|
*
|
|
* If there are no scripts that match the location of the BreakpointActor,
|
|
* we slide its location to the next closest line (for line breakpoints) or
|
|
* column (for column breakpoint) that does.
|
|
*
|
|
* If breakpoint sliding fails, then either there are no scripts that contain
|
|
* any code for the given location, or they were all garbage collected before
|
|
* the debugger started running. We cannot distinguish between these two
|
|
* cases, so we insert the BreakpointActor in the BreakpointActorMap as
|
|
* a pending breakpoint. Whenever a new script is introduced, this method is
|
|
* called again for each pending breakpoint.
|
|
*
|
|
* @param BreakpointActor actor
|
|
* The BreakpointActor to be set as a breakpoint handler.
|
|
*
|
|
* @returns A Promise that resolves to the given BreakpointActor.
|
|
*/
|
|
_setBreakpoint: function (actor) {
|
|
let { originalLocation } = actor;
|
|
let { originalSourceActor, originalLine, originalColumn } = originalLocation;
|
|
|
|
return this._setBreakpointAtOriginalLocation(actor, originalLocation)
|
|
.then((actualLocation) => {
|
|
if (actualLocation) {
|
|
return actualLocation;
|
|
}
|
|
|
|
// There were no scripts that matched the given location, so we need to
|
|
// perform breakpoint sliding. We try to slide the breakpoint by column
|
|
// first, and if that fails, by line instead.
|
|
if (!this.isSourceMapped) {
|
|
if (originalColumn !== undefined) {
|
|
// To perform breakpoint sliding for column breakpoints, we need to
|
|
// build a map from column numbers to a list of entry points for each
|
|
// column, implemented as a sparse array. An entry point is a (script,
|
|
// offsets) pair, and represents all offsets in that script that are
|
|
// entry points for the corresponding column.
|
|
let columnToEntryPointsMap = [];
|
|
|
|
// Iterate over all scripts that correspond to this source actor and
|
|
// line number.
|
|
let scripts = this.scripts.getScriptsBySourceActor(this, originalLine);
|
|
for (let script of scripts) {
|
|
let columnToOffsetMap = script.getAllColumnOffsets()
|
|
.filter(({ lineNumber }) => {
|
|
return lineNumber === originalLine;
|
|
})
|
|
|
|
// Iterate over each column, and add their list of offsets to the
|
|
// map from column numbers to entry points by forming a (script,
|
|
// offsets) pair, where script is the current script, and offsets is
|
|
// the list of offsets for the current column.
|
|
for (let { columnNumber: column, offset } of columnToOffsetMap) {
|
|
let entryPoints = columnToEntryPointsMap[column];
|
|
if (!entryPoints) {
|
|
// We dont have a list of entry points for the current column
|
|
// number yet, so create it and add it to the map.
|
|
entryPoints = [];
|
|
columnToEntryPointsMap[column] = entryPoints;
|
|
}
|
|
entryPoints.push({ script, offsets: [offset] });
|
|
}
|
|
}
|
|
|
|
// Now that we have a map from column numbers to a list of entry points
|
|
// for each column, we can use it to perform breakpoint sliding. Start
|
|
// at the original column of the breakpoint actor, and keep
|
|
// incrementing it by one, until either we find a line that has at
|
|
// least one entry point, or we go past the last column in the map.
|
|
//
|
|
// Note that by computing the entire map up front, and implementing it
|
|
// as a sparse array, we can easily tell when we went past the last
|
|
// column in the map.
|
|
let actualColumn = originalColumn + 1;
|
|
while (actualColumn < columnToEntryPointsMap.length) {
|
|
let entryPoints = columnToEntryPointsMap[actualColumn];
|
|
if (entryPoints) {
|
|
setBreakpointAtEntryPoints(actor, entryPoints);
|
|
return new OriginalLocation(
|
|
originalSourceActor,
|
|
originalLine,
|
|
actualColumn
|
|
);
|
|
}
|
|
++actualColumn;
|
|
}
|
|
|
|
return originalLocation;
|
|
} else {
|
|
// To perform breakpoint sliding for line breakpoints, we need to
|
|
// build a map from line numbers to a list of entry points for each
|
|
// line, implemented as a sparse array. An entry point is a (script,
|
|
// offsets) pair, and represents all offsets in that script that are
|
|
// entry points for the corresponding line.
|
|
let lineToEntryPointsMap = [];
|
|
|
|
// Iterate over all scripts that correspond to this source actor.
|
|
let scripts = this.scripts.getScriptsBySourceActor(this);
|
|
for (let script of scripts) {
|
|
// Get all offsets for each line in the current script. This returns
|
|
// a map from line numbers fo a list of offsets for each line,
|
|
// implemented as a sparse array.
|
|
let lineToOffsetsMap = script.getAllOffsets();
|
|
|
|
// Iterate over each line, and add their list of offsets to the map
|
|
// from line numbers to entry points by forming a (script, offsets)
|
|
// pair, where script is the current script, and offsets is the list
|
|
// of offsets for the current line.
|
|
for (let line = 0; line < lineToOffsetsMap.length; ++line) {
|
|
let offsets = lineToOffsetsMap[line];
|
|
if (offsets) {
|
|
let entryPoints = lineToEntryPointsMap[line];
|
|
if (!entryPoints) {
|
|
// We dont have a list of entry points for the current line
|
|
// number yet, so create it and add it to the map.
|
|
entryPoints = [];
|
|
lineToEntryPointsMap[line] = entryPoints;
|
|
}
|
|
entryPoints.push({ script, offsets });
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now that we have a map from line numbers to a list of entry points
|
|
// for each line, we can use it to perform breakpoint sliding. Start
|
|
// at the original line of the breakpoint actor, and keep incrementing
|
|
// it by one, until either we find a line that has at least one entry
|
|
// point, or we go past the last line in the map.
|
|
//
|
|
// Note that by computing the entire map up front, and implementing it
|
|
// as a sparse array, we can easily tell when we went past the last
|
|
// line in the map.
|
|
let actualLine = originalLine + 1;
|
|
while (actualLine < lineToEntryPointsMap.length) {
|
|
let entryPoints = lineToEntryPointsMap[actualLine];
|
|
if (entryPoints) {
|
|
setBreakpointAtEntryPoints(actor, entryPoints);
|
|
break;
|
|
}
|
|
++actualLine;
|
|
}
|
|
if (actualLine >= lineToEntryPointsMap.length) {
|
|
// We went past the last line in the map, so breakpoint sliding
|
|
// failed. Keep the BreakpointActor in the BreakpointActorMap as a
|
|
// pending breakpoint, so we can try again whenever a new script is
|
|
// introduced.
|
|
return originalLocation;
|
|
}
|
|
|
|
return new OriginalLocation(
|
|
originalSourceActor,
|
|
actualLine
|
|
);
|
|
}
|
|
} else {
|
|
let slideByColumn = (actualColumn) => {
|
|
return this.sources.getAllGeneratedLocations(new OriginalLocation(
|
|
this,
|
|
originalLine,
|
|
actualColumn
|
|
)).then((generatedLocations) => {
|
|
// Because getAllGeneratedLocations will always return the list of
|
|
// generated locations for the closest column that is greater than
|
|
// the one we are searching for if no exact match can be found, if
|
|
// the list of generated locations is empty, we've reached the end
|
|
// of the original line, and sliding continues by line.
|
|
if (generatedLocations.length === 0) {
|
|
return slideByLine(originalLine + 1);
|
|
}
|
|
|
|
// If at least one script has an offset that matches one of the
|
|
// generated locations in the list, then breakpoint sliding
|
|
// succeeded.
|
|
if (this._setBreakpointAtAllGeneratedLocations(actor, generatedLocations)) {
|
|
return this.threadActor.sources.getOriginalLocation(generatedLocations[0]);
|
|
}
|
|
|
|
// Try the next column in the original source.
|
|
return slideByColumn(actualColumn + 1);
|
|
});
|
|
};
|
|
|
|
let slideByLine = (actualLine) => {
|
|
return this.sources.getAllGeneratedLocations(new OriginalLocation(
|
|
this,
|
|
actualLine
|
|
)).then((generatedLocations) => {
|
|
// Because getAllGeneratedLocations will always return the list of
|
|
// generated locations for the closest line that is greater than
|
|
// the one we are searching for if no exact match can be found, if
|
|
// the list of generated locations is empty, we've reached the end
|
|
// of the original source, and breakpoint sliding failed.
|
|
if (generatedLocations.length === 0) {
|
|
return originalLocation;
|
|
}
|
|
|
|
// If at least one script has an offset that matches one of the
|
|
// generated locations in the list, then breakpoint sliding
|
|
// succeeded.
|
|
if (this._setBreakpointAtAllGeneratedLocations(actor, generatedLocations)) {
|
|
return this.threadActor.sources.getOriginalLocation(generatedLocations[0]);
|
|
}
|
|
|
|
// Try the next line in the original source.
|
|
return slideByLine(actualLine + 1);
|
|
});
|
|
};
|
|
|
|
if (originalColumn !== undefined) {
|
|
return slideByColumn(originalColumn + 1);
|
|
} else {
|
|
return slideByLine(originalLine + 1);
|
|
}
|
|
}
|
|
}).then((actualLocation) => {
|
|
// If the actual location on which the BreakpointActor ended up being
|
|
// set differs from the original line that was requested, both the
|
|
// BreakpointActor and the BreakpointActorMap need to be updated
|
|
// accordingly.
|
|
if (!actualLocation.equals(originalLocation)) {
|
|
let existingActor = this.breakpointActorMap.getActor(actualLocation);
|
|
if (existingActor) {
|
|
actor.onDelete();
|
|
this.breakpointActorMap.deleteActor(originalLocation);
|
|
actor = existingActor;
|
|
} else {
|
|
this.breakpointActorMap.deleteActor(originalLocation);
|
|
actor.originalLocation = actualLocation;
|
|
this.breakpointActorMap.setActor(actualLocation, actor);
|
|
}
|
|
}
|
|
|
|
return actor;
|
|
});
|
|
},
|
|
|
|
_setBreakpointAtOriginalLocation: function (actor, originalLocation) {
|
|
if (!this.isSourceMapped) {
|
|
if (!this._setBreakpointAtGeneratedLocation(
|
|
actor,
|
|
GeneratedLocation.fromOriginalLocation(originalLocation)
|
|
)) {
|
|
// return promise.resolve(null);
|
|
return resolve(null);
|
|
}
|
|
|
|
// return promise.resolve(originalLocation);
|
|
return resolve(originalLocation);
|
|
} else {
|
|
return this.sources.getAllGeneratedLocations(originalLocation)
|
|
.then((generatedLocations) => {
|
|
if (!this._setBreakpointAtAllGeneratedLocations(
|
|
actor,
|
|
generatedLocations
|
|
)) {
|
|
return null;
|
|
}
|
|
|
|
return this.threadActor.sources.getOriginalLocation(generatedLocations[0]);
|
|
});
|
|
}
|
|
},
|
|
|
|
_setBreakpointAtAllGeneratedLocations: function (actor, generatedLocations) {
|
|
let success = false;
|
|
for (let generatedLocation of generatedLocations) {
|
|
if (this._setBreakpointAtGeneratedLocation(
|
|
actor,
|
|
generatedLocation
|
|
)) {
|
|
success = true;
|
|
}
|
|
}
|
|
return success;
|
|
},
|
|
|
|
/*
|
|
* Ensure the given BreakpointActor is set as breakpoint handler on all
|
|
* scripts that match the given location in the generated source.
|
|
*
|
|
* @param BreakpointActor actor
|
|
* The BreakpointActor to be set as a breakpoint handler.
|
|
* @param GeneratedLocation generatedLocation
|
|
* A GeneratedLocation representing the location in the generated
|
|
* source for which the given BreakpointActor is to be set as a
|
|
* breakpoint handler.
|
|
*
|
|
* @returns A Boolean that is true if the BreakpointActor was set as a
|
|
* breakpoint handler on at least one script, and false otherwise.
|
|
*/
|
|
_setBreakpointAtGeneratedLocation: function (actor, generatedLocation) {
|
|
let {
|
|
generatedSourceActor,
|
|
generatedLine,
|
|
generatedColumn,
|
|
generatedLastColumn
|
|
} = generatedLocation;
|
|
|
|
// Find all scripts that match the given source actor and line number.
|
|
let scripts = this.scripts.getScriptsBySourceActorAndLine(
|
|
generatedSourceActor,
|
|
generatedLine
|
|
);
|
|
|
|
scripts = scripts.filter((script) => !actor.hasScript(script));
|
|
|
|
// Find all entry points that correspond to the given location.
|
|
let entryPoints = [];
|
|
if (generatedColumn === undefined) {
|
|
// This is a line breakpoint, so we are interested in all offsets
|
|
// that correspond to the given line number.
|
|
for (let script of scripts) {
|
|
let offsets = script.getLineOffsets(generatedLine);
|
|
if (offsets.length > 0) {
|
|
entryPoints.push({ script, offsets });
|
|
}
|
|
}
|
|
} else {
|
|
// This is a column breakpoint, so we are interested in all column
|
|
// offsets that correspond to the given line *and* column number.
|
|
for (let script of scripts) {
|
|
let columnToOffsetMap = script.getAllColumnOffsets()
|
|
.filter(({ lineNumber }) => {
|
|
return lineNumber === generatedLine;
|
|
});
|
|
for (let { columnNumber: column, offset } of columnToOffsetMap) {
|
|
if (column >= generatedColumn && column <= generatedLastColumn) {
|
|
entryPoints.push({ script, offsets: [offset] });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (entryPoints.length === 0) {
|
|
return false;
|
|
}
|
|
setBreakpointAtEntryPoints(actor, entryPoints);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
SourceActor.prototype.requestTypes = {
|
|
"source": SourceActor.prototype.onSource,
|
|
"blackbox": SourceActor.prototype.onBlackBox,
|
|
"unblackbox": SourceActor.prototype.onUnblackBox,
|
|
"prettyPrint": SourceActor.prototype.onPrettyPrint,
|
|
"disablePrettyPrint": SourceActor.prototype.onDisablePrettyPrint,
|
|
"getExecutableLines": SourceActor.prototype.getExecutableLines,
|
|
"setBreakpoint": SourceActor.prototype.onSetBreakpoint
|
|
};
|
|
|
|
exports.SourceActor = SourceActor;
|
|
|
|
/**
|
|
* Creates a pause-scoped actor for the specified object.
|
|
* @see ObjectActor
|
|
*/
|
|
function PauseScopedObjectActor(obj, hooks) {
|
|
ObjectActor.call(this, obj, hooks);
|
|
this.hooks.promote = hooks.promote;
|
|
this.hooks.isThreadLifetimePool = hooks.isThreadLifetimePool;
|
|
}
|
|
|
|
PauseScopedObjectActor.prototype = Object.create(PauseScopedActor.prototype);
|
|
|
|
update(PauseScopedObjectActor.prototype, ObjectActor.prototype);
|
|
|
|
update(PauseScopedObjectActor.prototype, {
|
|
constructor: PauseScopedObjectActor,
|
|
actorPrefix: "pausedobj",
|
|
|
|
onOwnPropertyNames:
|
|
PauseScopedActor.withPaused(ObjectActor.prototype.onOwnPropertyNames),
|
|
|
|
onPrototypeAndProperties:
|
|
PauseScopedActor.withPaused(ObjectActor.prototype.onPrototypeAndProperties),
|
|
|
|
onPrototype: PauseScopedActor.withPaused(ObjectActor.prototype.onPrototype),
|
|
onProperty: PauseScopedActor.withPaused(ObjectActor.prototype.onProperty),
|
|
onDecompile: PauseScopedActor.withPaused(ObjectActor.prototype.onDecompile),
|
|
|
|
onDisplayString:
|
|
PauseScopedActor.withPaused(ObjectActor.prototype.onDisplayString),
|
|
|
|
onParameterNames:
|
|
PauseScopedActor.withPaused(ObjectActor.prototype.onParameterNames),
|
|
|
|
/**
|
|
* Handle a protocol request to promote a pause-lifetime grip to a
|
|
* thread-lifetime grip.
|
|
*
|
|
* @param aRequest object
|
|
* The protocol request object.
|
|
*/
|
|
onThreadGrip: PauseScopedActor.withPaused(function (aRequest) {
|
|
this.hooks.promote();
|
|
return {};
|
|
}),
|
|
|
|
/**
|
|
* Handle a protocol request to release a thread-lifetime grip.
|
|
*
|
|
* @param aRequest object
|
|
* The protocol request object.
|
|
*/
|
|
onRelease: PauseScopedActor.withPaused(function (aRequest) {
|
|
if (this.hooks.isThreadLifetimePool()) {
|
|
return { error: "notReleasable",
|
|
message: "Only thread-lifetime actors can be released." };
|
|
}
|
|
|
|
this.release();
|
|
return {};
|
|
}),
|
|
});
|
|
|
|
update(PauseScopedObjectActor.prototype.requestTypes, {
|
|
"threadGrip": PauseScopedObjectActor.prototype.onThreadGrip,
|
|
});
|
|
|
|
/**
|
|
* Creates an actor for the specified stack frame.
|
|
*
|
|
* @param aFrame Debugger.Frame
|
|
* The debuggee frame.
|
|
* @param aThreadActor ThreadActor
|
|
* The parent thread actor for this frame.
|
|
*/
|
|
function FrameActor(aFrame, aThreadActor)
|
|
{
|
|
this.frame = aFrame;
|
|
this.threadActor = aThreadActor;
|
|
}
|
|
|
|
FrameActor.prototype = {
|
|
actorPrefix: "frame",
|
|
|
|
/**
|
|
* A pool that contains frame-lifetime objects, like the environment.
|
|
*/
|
|
_frameLifetimePool: null,
|
|
get frameLifetimePool() {
|
|
if (!this._frameLifetimePool) {
|
|
this._frameLifetimePool = new ActorPool(this.conn);
|
|
this.conn.addActorPool(this._frameLifetimePool);
|
|
}
|
|
return this._frameLifetimePool;
|
|
},
|
|
|
|
/**
|
|
* Finalization handler that is called when the actor is being evicted from
|
|
* the pool.
|
|
*/
|
|
disconnect: function () {
|
|
this.conn.removeActorPool(this._frameLifetimePool);
|
|
this._frameLifetimePool = null;
|
|
},
|
|
|
|
/**
|
|
* Returns a frame form for use in a protocol message.
|
|
*/
|
|
form: function () {
|
|
let threadActor = this.threadActor;
|
|
let form = { actor: this.actorID,
|
|
type: this.frame.type };
|
|
if (this.frame.type === "call") {
|
|
form.callee = createValueGrip(this.frame.callee, threadActor._pausePool,
|
|
threadActor.objectGrip);
|
|
}
|
|
|
|
if (this.frame.environment) {
|
|
let envActor = threadActor.createEnvironmentActor(
|
|
this.frame.environment,
|
|
this.frameLifetimePool
|
|
);
|
|
form.environment = envActor.form();
|
|
}
|
|
form.this = createValueGrip(this.frame.this, threadActor._pausePool,
|
|
threadActor.objectGrip);
|
|
form.arguments = this._args();
|
|
if (this.frame.script) {
|
|
var generatedLocation = this.threadActor.sources.getFrameLocation(this.frame);
|
|
form.where = {
|
|
source: generatedLocation.generatedSourceActor.form(),
|
|
line: generatedLocation.generatedLine,
|
|
column: generatedLocation.generatedColumn
|
|
};
|
|
}
|
|
|
|
if (!this.frame.older) {
|
|
form.oldest = true;
|
|
}
|
|
|
|
return form;
|
|
},
|
|
|
|
_args: function () {
|
|
if (!this.frame.arguments) {
|
|
return [];
|
|
}
|
|
|
|
return this.frame.arguments.map(arg => createValueGrip(arg,
|
|
this.threadActor._pausePool, this.threadActor.objectGrip));
|
|
},
|
|
|
|
/**
|
|
* Handle a protocol request to pop this frame from the stack.
|
|
*
|
|
* @param aRequest object
|
|
* The protocol request object.
|
|
*/
|
|
onPop: function (aRequest) {
|
|
// TODO: remove this when Debugger.Frame.prototype.pop is implemented
|
|
if (typeof this.frame.pop != "function") {
|
|
return { error: "notImplemented",
|
|
message: "Popping frames is not yet implemented." };
|
|
}
|
|
|
|
while (this.frame != this.threadActor.dbg.getNewestFrame()) {
|
|
this.threadActor.dbg.getNewestFrame().pop();
|
|
}
|
|
this.frame.pop(aRequest.completionValue);
|
|
|
|
// TODO: return the watches property when frame pop watch actors are
|
|
// implemented.
|
|
return { from: this.actorID };
|
|
}
|
|
};
|
|
|
|
FrameActor.prototype.requestTypes = {
|
|
"pop": FrameActor.prototype.onPop,
|
|
};
|
|
|
|
|
|
/**
|
|
* Creates a BreakpointActor. BreakpointActors exist for the lifetime of their
|
|
* containing thread and are responsible for deleting breakpoints, handling
|
|
* breakpoint hits and associating breakpoints with scripts.
|
|
*
|
|
* @param ThreadActor aThreadActor
|
|
* The parent thread actor that contains this breakpoint.
|
|
* @param OriginalLocation aOriginalLocation
|
|
* The original location of the breakpoint.
|
|
*/
|
|
function BreakpointActor(aThreadActor, aOriginalLocation)
|
|
{
|
|
// The set of Debugger.Script instances that this breakpoint has been set
|
|
// upon.
|
|
this.scripts = new Set();
|
|
|
|
this.threadActor = aThreadActor;
|
|
this.originalLocation = aOriginalLocation;
|
|
this.condition = null;
|
|
this.isPending = true;
|
|
}
|
|
|
|
BreakpointActor.prototype = {
|
|
actorPrefix: "breakpoint",
|
|
condition: null,
|
|
|
|
disconnect: function () {
|
|
this.removeScripts();
|
|
},
|
|
|
|
hasScript: function (aScript) {
|
|
return this.scripts.has(aScript);
|
|
},
|
|
|
|
/**
|
|
* Called when this same breakpoint is added to another Debugger.Script
|
|
* instance.
|
|
*
|
|
* @param aScript Debugger.Script
|
|
* The new source script on which the breakpoint has been set.
|
|
* @param ThreadActor aThreadActor
|
|
* The parent thread actor that contains this breakpoint.
|
|
*/
|
|
addScript: function (aScript) {
|
|
this.scripts.add(aScript);
|
|
this.isPending = false;
|
|
},
|
|
|
|
/**
|
|
* Remove the breakpoints from associated scripts and clear the script cache.
|
|
*/
|
|
removeScripts: function () {
|
|
for (let script of this.scripts) {
|
|
script.clearBreakpoint(this);
|
|
}
|
|
this.scripts.clear();
|
|
},
|
|
|
|
/**
|
|
* Check if this breakpoint has a condition that doesn't error and
|
|
* evaluates to true in aFrame.
|
|
*
|
|
* @param aFrame Debugger.Frame
|
|
* The frame to evaluate the condition in
|
|
* @returns Object
|
|
* - result: boolean|undefined
|
|
* True when the conditional breakpoint should trigger a pause, false otherwise.
|
|
* If the condition evaluation failed/killed, `result` will be `undefined`.
|
|
* - message: string
|
|
* The thrown message converted to a string, when the condition throws.
|
|
*/
|
|
checkCondition: function(aFrame) {
|
|
let completion = aFrame.eval(this.condition);
|
|
if (completion) {
|
|
if (completion.throw) {
|
|
// The evaluation failed and threw
|
|
let message = "Unknown exception";
|
|
try {
|
|
if (completion.throw.getOwnPropertyDescriptor) {
|
|
message = completion.throw.getOwnPropertyDescriptor("message").value;
|
|
} else if (completion.toString) {
|
|
message = completion.toString();
|
|
}
|
|
} catch (ex) {}
|
|
return {
|
|
result: true,
|
|
message: message
|
|
};
|
|
} else if (completion.yield) {
|
|
dbg_assert(false,
|
|
"Shouldn't ever get yield completions from an eval");
|
|
} else {
|
|
return { result: completion.return ? true : false };
|
|
}
|
|
} else {
|
|
// The evaluation was killed (possibly by the slow script dialog)
|
|
return { result: undefined };
|
|
}
|
|
},
|
|
|
|
/**
|
|
* A function that the engine calls when a breakpoint has been hit.
|
|
*
|
|
* @param aFrame Debugger.Frame
|
|
* The stack frame that contained the breakpoint.
|
|
*/
|
|
hit: function (aFrame) {
|
|
// Don't pause if we are currently stepping (in or over) or the frame is
|
|
// black-boxed.
|
|
let generatedLocation = this.threadActor.sources.getFrameLocation(aFrame);
|
|
let { originalSourceActor } = this.threadActor.unsafeSynchronize(
|
|
this.threadActor.sources.getOriginalLocation(generatedLocation));
|
|
let url = originalSourceActor.url;
|
|
|
|
if (this.threadActor.sources.isBlackBoxed(url)
|
|
|| aFrame.onStep) {
|
|
return undefined;
|
|
}
|
|
|
|
let reason = {};
|
|
|
|
if (this.threadActor._hiddenBreakpoints.has(this.actorID)) {
|
|
reason.type = "pauseOnDOMEvents";
|
|
} else if (!this.condition) {
|
|
reason.type = "breakpoint";
|
|
// TODO: add the rest of the breakpoints on that line (bug 676602).
|
|
reason.actors = [ this.actorID ];
|
|
} else {
|
|
let { result, message } = this.checkCondition(aFrame)
|
|
|
|
if (result) {
|
|
if (!message) {
|
|
reason.type = "breakpoint";
|
|
} else {
|
|
reason.type = "breakpointConditionThrown";
|
|
reason.message = message;
|
|
}
|
|
reason.actors = [ this.actorID ];
|
|
} else {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
return this.threadActor._pauseAndRespond(aFrame, reason);
|
|
},
|
|
|
|
/**
|
|
* Handle a protocol request to remove this breakpoint.
|
|
*
|
|
* @param aRequest object
|
|
* The protocol request object.
|
|
*/
|
|
onDelete: function (aRequest) {
|
|
// Remove from the breakpoint store.
|
|
if (this.originalLocation) {
|
|
this.threadActor.breakpointActorMap.deleteActor(this.originalLocation);
|
|
}
|
|
this.threadActor.threadLifetimePool.removeActor(this);
|
|
// Remove the actual breakpoint from the associated scripts.
|
|
this.removeScripts();
|
|
return { from: this.actorID };
|
|
}
|
|
};
|
|
|
|
BreakpointActor.prototype.requestTypes = {
|
|
"delete": BreakpointActor.prototype.onDelete
|
|
};
|
|
|
|
/**
|
|
* Creates an EnvironmentActor. EnvironmentActors are responsible for listing
|
|
* the bindings introduced by a lexical environment and assigning new values to
|
|
* those identifier bindings.
|
|
*
|
|
* @param Debugger.Environment aEnvironment
|
|
* The lexical environment that will be used to create the actor.
|
|
* @param ThreadActor aThreadActor
|
|
* The parent thread actor that contains this environment.
|
|
*/
|
|
function EnvironmentActor(aEnvironment, aThreadActor)
|
|
{
|
|
this.obj = aEnvironment;
|
|
this.threadActor = aThreadActor;
|
|
}
|
|
|
|
EnvironmentActor.prototype = {
|
|
actorPrefix: "environment",
|
|
|
|
/**
|
|
* Return an environment form for use in a protocol message.
|
|
*/
|
|
form: function () {
|
|
let form = { actor: this.actorID };
|
|
|
|
// What is this environment's type?
|
|
if (this.obj.type == "declarative") {
|
|
form.type = this.obj.callee ? "function" : "block";
|
|
} else {
|
|
form.type = this.obj.type;
|
|
}
|
|
|
|
// Does this environment have a parent?
|
|
if (this.obj.parent) {
|
|
form.parent = (this.threadActor
|
|
.createEnvironmentActor(this.obj.parent,
|
|
this.registeredPool)
|
|
.form());
|
|
}
|
|
|
|
// Does this environment reflect the properties of an object as variables?
|
|
if (this.obj.type == "object" || this.obj.type == "with") {
|
|
form.object = createValueGrip(this.obj.object,
|
|
this.registeredPool, this.threadActor.objectGrip);
|
|
}
|
|
|
|
// Is this the environment created for a function call?
|
|
if (this.obj.callee) {
|
|
form.function = createValueGrip(this.obj.callee,
|
|
this.registeredPool, this.threadActor.objectGrip);
|
|
}
|
|
|
|
// Shall we list this environment's bindings?
|
|
if (this.obj.type == "declarative") {
|
|
form.bindings = this._bindings();
|
|
}
|
|
|
|
return form;
|
|
},
|
|
|
|
/**
|
|
* Return the identifier bindings object as required by the remote protocol
|
|
* specification.
|
|
*/
|
|
_bindings: function () {
|
|
let bindings = { arguments: [], variables: {} };
|
|
|
|
// TODO: this part should be removed in favor of the commented-out part
|
|
// below when getVariableDescriptor lands (bug 725815).
|
|
if (typeof this.obj.getVariable != "function") {
|
|
//if (typeof this.obj.getVariableDescriptor != "function") {
|
|
return bindings;
|
|
}
|
|
|
|
let parameterNames;
|
|
if (this.obj.callee) {
|
|
parameterNames = this.obj.callee.parameterNames;
|
|
} else {
|
|
parameterNames = [];
|
|
}
|
|
for (let name of parameterNames) {
|
|
let arg = {};
|
|
let value = this.obj.getVariable(name);
|
|
|
|
// TODO: this part should be removed in favor of the commented-out part
|
|
// below when getVariableDescriptor lands (bug 725815).
|
|
let desc = {
|
|
value: value,
|
|
configurable: false,
|
|
writable: !(value && value.optimizedOut),
|
|
enumerable: true
|
|
};
|
|
|
|
// let desc = this.obj.getVariableDescriptor(name);
|
|
let descForm = {
|
|
enumerable: true,
|
|
configurable: desc.configurable
|
|
};
|
|
if ("value" in desc) {
|
|
descForm.value = createValueGrip(desc.value,
|
|
this.registeredPool, this.threadActor.objectGrip);
|
|
descForm.writable = desc.writable;
|
|
} else {
|
|
descForm.get = createValueGrip(desc.get, this.registeredPool,
|
|
this.threadActor.objectGrip);
|
|
descForm.set = createValueGrip(desc.set, this.registeredPool,
|
|
this.threadActor.objectGrip);
|
|
}
|
|
arg[name] = descForm;
|
|
bindings.arguments.push(arg);
|
|
}
|
|
|
|
for (let name of this.obj.names()) {
|
|
if (bindings.arguments.some(function exists(element) {
|
|
return !!element[name];
|
|
})) {
|
|
continue;
|
|
}
|
|
|
|
let value = this.obj.getVariable(name);
|
|
|
|
// TODO: this part should be removed in favor of the commented-out part
|
|
// below when getVariableDescriptor lands.
|
|
let desc = {
|
|
value: value,
|
|
configurable: false,
|
|
writable: !(value &&
|
|
(value.optimizedOut ||
|
|
value.uninitialized ||
|
|
value.missingArguments)),
|
|
enumerable: true
|
|
};
|
|
|
|
//let desc = this.obj.getVariableDescriptor(name);
|
|
let descForm = {
|
|
enumerable: true,
|
|
configurable: desc.configurable
|
|
};
|
|
if ("value" in desc) {
|
|
descForm.value = createValueGrip(desc.value,
|
|
this.registeredPool, this.threadActor.objectGrip);
|
|
descForm.writable = desc.writable;
|
|
} else {
|
|
descForm.get = createValueGrip(desc.get || undefined,
|
|
this.registeredPool, this.threadActor.objectGrip);
|
|
descForm.set = createValueGrip(desc.set || undefined,
|
|
this.registeredPool, this.threadActor.objectGrip);
|
|
}
|
|
bindings.variables[name] = descForm;
|
|
}
|
|
|
|
return bindings;
|
|
},
|
|
|
|
/**
|
|
* Handle a protocol request to change the value of a variable bound in this
|
|
* lexical environment.
|
|
*
|
|
* @param aRequest object
|
|
* The protocol request object.
|
|
*/
|
|
onAssign: function (aRequest) {
|
|
// TODO: enable the commented-out part when getVariableDescriptor lands
|
|
// (bug 725815).
|
|
/*let desc = this.obj.getVariableDescriptor(aRequest.name);
|
|
|
|
if (!desc.writable) {
|
|
return { error: "immutableBinding",
|
|
message: "Changing the value of an immutable binding is not " +
|
|
"allowed" };
|
|
}*/
|
|
|
|
try {
|
|
this.obj.setVariable(aRequest.name, aRequest.value);
|
|
} catch (e) {
|
|
if (e instanceof Debugger.DebuggeeWouldRun) {
|
|
return { error: "threadWouldRun",
|
|
cause: e.cause ? e.cause : "setter",
|
|
message: "Assigning a value would cause the debuggee to run" };
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
return { from: this.actorID };
|
|
},
|
|
|
|
/**
|
|
* Handle a protocol request to fully enumerate the bindings introduced by the
|
|
* lexical environment.
|
|
*
|
|
* @param aRequest object
|
|
* The protocol request object.
|
|
*/
|
|
onBindings: function (aRequest) {
|
|
return { from: this.actorID,
|
|
bindings: this._bindings() };
|
|
}
|
|
};
|
|
|
|
EnvironmentActor.prototype.requestTypes = {
|
|
"assign": EnvironmentActor.prototype.onAssign,
|
|
"bindings": EnvironmentActor.prototype.onBindings
|
|
};
|
|
|
|
exports.EnvironmentActor = EnvironmentActor;
|
|
|
|
function hackDebugger(Debugger) {
|
|
// TODO: Improve native code instead of hacking on top of it
|
|
|
|
/**
|
|
* Override the toString method in order to get more meaningful script output
|
|
* for debugging the debugger.
|
|
*/
|
|
Debugger.Script.prototype.toString = function() {
|
|
let output = "";
|
|
if (this.url) {
|
|
output += this.url;
|
|
}
|
|
if (typeof this.staticLevel != "undefined") {
|
|
output += ":L" + this.staticLevel;
|
|
}
|
|
if (typeof this.startLine != "undefined") {
|
|
output += ":" + this.startLine;
|
|
if (this.lineCount && this.lineCount > 1) {
|
|
output += "-" + (this.startLine + this.lineCount - 1);
|
|
}
|
|
}
|
|
if (typeof this.startLine != "undefined") {
|
|
output += ":" + this.startLine;
|
|
if (this.lineCount && this.lineCount > 1) {
|
|
output += "-" + (this.startLine + this.lineCount - 1);
|
|
}
|
|
}
|
|
if (this.strictMode) {
|
|
output += ":strict";
|
|
}
|
|
return output;
|
|
};
|
|
|
|
/**
|
|
* Helper property for quickly getting to the line number a stack frame is
|
|
* currently paused at.
|
|
*/
|
|
Object.defineProperty(Debugger.Frame.prototype, "line", {
|
|
configurable: true,
|
|
get: function() {
|
|
if (this.script) {
|
|
return this.script.getOffsetLine(this.offset);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* Creates an actor for handling chrome debugging. ChromeDebuggerActor is a
|
|
* thin wrapper over ThreadActor, slightly changing some of its behavior.
|
|
*
|
|
* @param aConnection object
|
|
* The DebuggerServerConnection with which this ChromeDebuggerActor
|
|
* is associated. (Currently unused, but required to make this
|
|
* constructor usable with addGlobalActor.)
|
|
*
|
|
* @param aParent object
|
|
* This actor's parent actor. See ThreadActor for a list of expected
|
|
* properties.
|
|
*/
|
|
function ChromeDebuggerActor(aConnection, aParent)
|
|
{
|
|
ThreadActor.call(this, aParent);
|
|
}
|
|
|
|
ChromeDebuggerActor.prototype = Object.create(ThreadActor.prototype);
|
|
|
|
update(ChromeDebuggerActor.prototype, {
|
|
constructor: ChromeDebuggerActor,
|
|
|
|
// A constant prefix that will be used to form the actor ID by the server.
|
|
actorPrefix: "chromeDebugger"
|
|
});
|
|
|
|
exports.ChromeDebuggerActor = ChromeDebuggerActor;
|
|
|
|
/**
|
|
* Creates an actor for handling add-on debugging. AddonThreadActor is
|
|
* a thin wrapper over ThreadActor.
|
|
*
|
|
* @param aConnection object
|
|
* The DebuggerServerConnection with which this AddonThreadActor
|
|
* is associated. (Currently unused, but required to make this
|
|
* constructor usable with addGlobalActor.)
|
|
*
|
|
* @param aParent object
|
|
* This actor's parent actor. See ThreadActor for a list of expected
|
|
* properties.
|
|
*/
|
|
function AddonThreadActor(aConnect, aParent) {
|
|
ThreadActor.call(this, aParent);
|
|
}
|
|
|
|
AddonThreadActor.prototype = Object.create(ThreadActor.prototype);
|
|
|
|
update(AddonThreadActor.prototype, {
|
|
constructor: AddonThreadActor,
|
|
|
|
// A constant prefix that will be used to form the actor ID by the server.
|
|
actorPrefix: "addonThread"
|
|
});
|
|
|
|
exports.AddonThreadActor = AddonThreadActor;
|
|
|
|
// Utility functions.
|
|
|
|
/**
|
|
* Report the given error in the error console and to stdout.
|
|
*
|
|
* @param Error aError
|
|
* The error object you wish to report.
|
|
* @param String aPrefix
|
|
* An optional prefix for the reported error message.
|
|
*/
|
|
// var oldReportError = reportError;
|
|
function reportError(aError, aPrefix="") {
|
|
// dbg_assert(aError instanceof Error, "Must pass Error objects to reportError");
|
|
let msg = aPrefix + aError.message + ":\n" + aError.stack;
|
|
// oldReportError(msg);
|
|
log(msg);
|
|
}
|
|
|
|
function isEvalSource(source) {
|
|
let introType = source.introductionType;
|
|
// These are all the sources that are essentially eval-ed (either
|
|
// by calling eval or passing a string to one of these functions).
|
|
return (introType === 'eval' ||
|
|
introType === 'Function' ||
|
|
introType === 'eventHandler' ||
|
|
introType === 'setTimeout' ||
|
|
introType === 'setInterval');
|
|
}
|
|
exports.isEvalSource = isEvalSource;
|
|
|
|
function getSourceURL(source, window) {
|
|
if (isEvalSource(source)) {
|
|
// Eval sources have no urls, but they might have a `displayURL`
|
|
// created with the sourceURL pragma. If the introduction script
|
|
// is a non-eval script, generate an full absolute URL relative to it.
|
|
|
|
if (source.displayURL && source.introductionScript &&
|
|
!isEvalSource(source.introductionScript.source)) {
|
|
|
|
if (source.introductionScript.source.url === 'debugger eval code') {
|
|
if (window) {
|
|
// If this is a named eval script created from the console, make it
|
|
// relative to the current page. window is only available
|
|
// when we care about this.
|
|
return joinURI(window.location.href, source.displayURL);
|
|
}
|
|
}
|
|
else {
|
|
return joinURI(dirname(source.introductionScript.source.url),
|
|
source.displayURL);
|
|
}
|
|
}
|
|
|
|
return source.displayURL;
|
|
}
|
|
else if (source.url === 'debugger eval code') {
|
|
// Treat code evaluated by the console as unnamed eval scripts
|
|
return null;
|
|
}
|
|
return source.url;
|
|
}
|
|
exports.getSourceURL = getSourceURL;
|
|
|
|
/**
|
|
* Find the scripts which contain offsets that are an entry point to the given
|
|
* line.
|
|
*
|
|
* @param Array scripts
|
|
* The set of Debugger.Scripts to consider.
|
|
* @param Number line
|
|
* The line we are searching for entry points into.
|
|
* @returns Array of objects of the form { script, offsets } where:
|
|
* - script is a Debugger.Script
|
|
* - offsets is an array of offsets that are entry points into the
|
|
* given line.
|
|
*/
|
|
function findEntryPointsForLine(scripts, line) {
|
|
const entryPoints = [];
|
|
for (let script of scripts) {
|
|
const offsets = script.getLineOffsets(line);
|
|
if (offsets.length) {
|
|
entryPoints.push({ script, offsets });
|
|
}
|
|
}
|
|
return entryPoints;
|
|
}
|
|
|
|
/**
|
|
* Set breakpoints on all the given entry points with the given
|
|
* BreakpointActor as the handler.
|
|
*
|
|
* @param BreakpointActor actor
|
|
* The actor handling the breakpoint hits.
|
|
* @param Array entryPoints
|
|
* An array of objects of the form `{ script, offsets }`.
|
|
*/
|
|
function setBreakpointAtEntryPoints(actor, entryPoints) {
|
|
for (let { script, offsets } of entryPoints) {
|
|
actor.addScript(script);
|
|
for (let offset of offsets) {
|
|
script.setBreakpoint(offset, actor);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unwrap a global that is wrapped in a |Debugger.Object|, or if the global has
|
|
* become a dead object, return |undefined|.
|
|
*
|
|
* @param Debugger.Object wrappedGlobal
|
|
* The |Debugger.Object| which wraps a global.
|
|
*
|
|
* @returns {Object|undefined}
|
|
* Returns the unwrapped global object or |undefined| if unwrapping
|
|
* failed.
|
|
*/
|
|
exports.unwrapDebuggerObjectGlobal = wrappedGlobal => {
|
|
try {
|
|
// Because of bug 991399 we sometimes get nuked window references here. We
|
|
// just bail out in that case.
|
|
//
|
|
// Note that addon sandboxes have a DOMWindow as their prototype. So make
|
|
// sure that we can touch the prototype too (whatever it is), in case _it_
|
|
// is it a nuked window reference. We force stringification to make sure
|
|
// that any dead object proxies make themselves known.
|
|
let global = wrappedGlobal.unsafeDereference();
|
|
Object.getPrototypeOf(global) + "";
|
|
return global;
|
|
}
|
|
catch (e) {
|
|
return undefined;
|
|
}
|
|
};
|