1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/* -*- 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 { ActorClassWithSpec } = require("devtools/shared/protocol");
const { breakpointSpec } = require("devtools/shared/specs/breakpoint");
/**
* 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);
}
}
}
exports.setBreakpointAtEntryPoints = setBreakpointAtEntryPoints;
/**
* BreakpointActors exist for the lifetime of their containing thread and are
* responsible for deleting breakpoints, handling breakpoint hits and
* associating breakpoints with scripts.
*/
let BreakpointActor = ActorClassWithSpec(breakpointSpec, {
/**
* Create a Breakpoint actor.
*
* @param ThreadActor threadActor
* The parent thread actor that contains this breakpoint.
* @param OriginalLocation originalLocation
* The original location of the breakpoint.
*/
initialize: function (threadActor, originalLocation) {
// The set of Debugger.Script instances that this breakpoint has been set
// upon.
this.scripts = new Set();
this.threadActor = threadActor;
this.originalLocation = originalLocation;
this.condition = null;
this.isPending = true;
},
disconnect: function () {
this.removeScripts();
},
hasScript: function (script) {
return this.scripts.has(script);
},
/**
* Called when this same breakpoint is added to another Debugger.Script
* instance.
*
* @param script Debugger.Script
* The new source script on which the breakpoint has been set.
*/
addScript: function (script) {
this.scripts.add(script);
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 frame.
*
* @param frame 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
* If the condition throws, this is the thrown message.
*/
checkCondition: function (frame) {
let completion = frame.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) {
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 frame Debugger.Frame
* The stack frame that contained the breakpoint.
*/
hit: function (frame) {
// Don't pause if we are currently stepping (in or over) or the frame is
// black-boxed.
let generatedLocation = this.threadActor.sources.getFrameLocation(frame);
let { originalSourceActor } = this.threadActor.unsafeSynchronize(
this.threadActor.sources.getOriginalLocation(generatedLocation));
let url = originalSourceActor.url;
if (this.threadActor.sources.isBlackBoxed(url)
|| frame.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(frame);
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(frame, reason);
},
/**
* Handle a protocol request to remove this breakpoint.
*/
delete: function () {
// 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();
}
});
exports.BreakpointActor = BreakpointActor;
|
