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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/* 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/>. */
import { setupCommands, clientCommands } from "./firefox/commands";
import { setupCreate, createPause } from "./firefox/create";
import { features } from "../utils/prefs";
import { recordEvent } from "../utils/telemetry";
import sourceQueue from "../utils/source-queue";
let actions;
let commands;
let targetCommand;
let resourceCommand;
export async function onConnect(_commands, _resourceCommand, _actions, store) {
actions = _actions;
commands = _commands;
targetCommand = _commands.targetCommand;
resourceCommand = _resourceCommand;
setupCommands(commands);
setupCreate({ store });
sourceQueue.initialize(actions);
const { descriptorFront } = commands;
// For tab, browser and webextension toolboxes, we want to enable watching for
// worker targets as soon as the debugger is opened.
// And also for service workers, if the related experimental feature is enabled
if (
descriptorFront.isTabDescriptor ||
descriptorFront.isWebExtensionDescriptor ||
descriptorFront.isBrowserProcessDescriptor
) {
targetCommand.listenForWorkers = true;
if (descriptorFront.isLocalTab && features.windowlessServiceWorkers) {
targetCommand.listenForServiceWorkers = true;
}
await targetCommand.startListening();
}
const options = {
// `pauseWorkersUntilAttach` is one option set when the debugger panel is opened rather that from the toolbox.
// The reason is to support early breakpoints in workers, which will force the workers to pause
// and later on (when TargetMixin.attachThread is called) resume worker execution, after passing the breakpoints.
// We only observe workers when the debugger panel is opened (see the few lines before and listenForWorkers = true).
// So if we were passing `pauseWorkersUntilAttach=true` from the toolbox code, workers would freeze as we would not watch
// for their targets and not resume them.
pauseWorkersUntilAttach: true,
// Bug 1719615 - Immediately turn on WASM debugging when the debugger opens.
// We avoid enabling that as soon as DevTools open as WASM generates different kind of machine code
// with debugging instruction which significantly increase the memory usage.
observeWasm: true,
};
await commands.threadConfigurationCommand.updateConfiguration(options);
await targetCommand.watchTargets({
types: targetCommand.ALL_TYPES,
onAvailable: onTargetAvailable,
onDestroyed: onTargetDestroyed,
});
// Use independant listeners for SOURCE and THREAD_STATE in order to ease
// doing batching and notify about a set of SOURCE's in one redux action.
await resourceCommand.watchResources([resourceCommand.TYPES.SOURCE], {
onAvailable: onSourceAvailable,
});
await resourceCommand.watchResources([resourceCommand.TYPES.THREAD_STATE], {
onAvailable: onThreadStateAvailable,
});
await resourceCommand.watchResources([resourceCommand.TYPES.JSTRACER_STATE], {
onAvailable: onTracingStateAvailable,
});
await resourceCommand.watchResources([resourceCommand.TYPES.ERROR_MESSAGE], {
onAvailable: actions.addExceptionFromResources,
});
await resourceCommand.watchResources([resourceCommand.TYPES.DOCUMENT_EVENT], {
onAvailable: onDocumentEventAvailable,
// we only care about future events for DOCUMENT_EVENT
ignoreExistingResources: true,
});
}
export function onDisconnect() {
targetCommand.unwatchTargets({
types: targetCommand.ALL_TYPES,
onAvailable: onTargetAvailable,
onDestroyed: onTargetDestroyed,
});
resourceCommand.unwatchResources([resourceCommand.TYPES.SOURCE], {
onAvailable: onSourceAvailable,
});
resourceCommand.unwatchResources([resourceCommand.TYPES.THREAD_STATE], {
onAvailable: onThreadStateAvailable,
});
resourceCommand.unwatchResources([resourceCommand.TYPES.JSTRACER_STATE], {
onAvailable: onTracingStateAvailable,
});
resourceCommand.unwatchResources([resourceCommand.TYPES.ERROR_MESSAGE], {
onAvailable: actions.addExceptionFromResources,
});
resourceCommand.unwatchResources([resourceCommand.TYPES.DOCUMENT_EVENT], {
onAvailable: onDocumentEventAvailable,
});
sourceQueue.clear();
}
async function onTargetAvailable({ targetFront }) {
const isBrowserToolbox = commands.descriptorFront.isBrowserProcessDescriptor;
const isNonTopLevelFrameTarget =
!targetFront.isTopLevel &&
targetFront.targetType === targetCommand.TYPES.FRAME;
if (isBrowserToolbox && isNonTopLevelFrameTarget) {
// In the BrowserToolbox, non-top-level frame targets are already
// debugged via content-process targets.
// Do not attach the thread here, as it was already done by the
// corresponding content-process target.
return;
}
if (!targetFront.isTopLevel) {
await actions.addTarget(targetFront);
return;
}
// At this point, we expect the target and its thread to be attached.
const { threadFront } = targetFront;
if (!threadFront) {
console.error("The thread for", targetFront, "isn't attached.");
return;
}
// Retrieve possible event listener breakpoints
actions.getEventListenerBreakpointTypes().catch(e => console.error(e));
// Initialize the event breakpoints on the thread up front so that
// they are active once attached.
actions.addEventListenerBreakpoints([]).catch(e => console.error(e));
await actions.addTarget(targetFront);
}
function onTargetDestroyed({ targetFront }) {
actions.removeTarget(targetFront);
}
async function onSourceAvailable(sources) {
await actions.newGeneratedSources(sources);
}
async function onThreadStateAvailable(resources) {
for (const resource of resources) {
if (resource.targetFront.isDestroyed()) {
continue;
}
const threadFront = await resource.targetFront.getFront("thread");
if (resource.state == "paused") {
const pause = await createPause(threadFront.actorID, resource);
await actions.paused(pause);
recordEvent("pause", { reason: resource.why.type });
} else if (resource.state == "resumed") {
await actions.resumed(threadFront.actorID);
}
}
}
async function onTracingStateAvailable(resources) {
for (const resource of resources) {
if (resource.targetFront.isDestroyed()) {
continue;
}
const threadFront = await resource.targetFront.getFront("thread");
await actions.tracingToggled(threadFront.actor, resource.enabled);
}
}
function onDocumentEventAvailable(events) {
for (const event of events) {
// Only consider top level document, and ignore remote iframes top document
if (!event.targetFront.isTopLevel) continue;
// The browser toolbox debugger doesn't support the iframe dropdown.
// you will always see all the sources of all targets of your debugging context.
//
// But still allow it to clear the debugger when reloading the addon, or when
// switching between fallback document and other addon document.
if (
event.isFrameSwitching &&
!commands.descriptorFront.isWebExtensionDescriptor
) {
continue;
}
if (event.name == "will-navigate") {
actions.willNavigate({ url: event.newURI });
} else if (event.name == "dom-complete") {
actions.navigated();
}
}
}
export { clientCommands };
|
