gecko-dev/devtools/server/child.js

133 строки
4.9 KiB
JavaScript

/* 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";
/* global addEventListener, addMessageListener, removeMessageListener, sendAsyncMessage */
try {
var chromeGlobal = this;
// Encapsulate in its own scope to allows loading this frame script more than once.
(function () {
const { require } = ChromeUtils.import("resource://devtools/shared/Loader.jsm", {});
const DevToolsUtils = require("devtools/shared/DevToolsUtils");
const { dumpn } = DevToolsUtils;
const { DebuggerServer, ActorPool } = require("devtools/server/main");
DebuggerServer.init();
// We want a special server without any root actor and only tab actors.
// We are going to spawn a ContentActor instance in the next few lines,
// it is going to act like a root actor without being one.
DebuggerServer.registerActors({ tab: true });
let connections = new Map();
let onConnect = DevToolsUtils.makeInfallible(function (msg) {
removeMessageListener("debug:connect", onConnect);
let mm = msg.target;
let prefix = msg.data.prefix;
let addonId = msg.data.addonId;
// Using the JS debugger causes problems when we're trying to
// schedule those zone groups across different threads. Calling
// blockThreadedExecution causes Gecko to switch to a simpler
// single-threaded model until unblockThreadedExecution is
// called later. We cannot start the debugger until the callback
// passed to blockThreadedExecution has run, signaling that
// we're running single-threaded.
Cu.blockThreadedExecution(() => {
let conn = DebuggerServer.connectToParent(prefix, mm);
conn.parentMessageManager = mm;
connections.set(prefix, conn);
let actor;
if (addonId) {
const { WebExtensionChildActor } = require("devtools/server/actors/webextension");
actor = new WebExtensionChildActor(conn, chromeGlobal, prefix, addonId);
} else {
const { ContentActor } = require("devtools/server/actors/content");
actor = new ContentActor(conn, chromeGlobal, prefix);
}
let actorPool = new ActorPool(conn);
actorPool.addActor(actor);
conn.addActorPool(actorPool);
sendAsyncMessage("debug:actor", {actor: actor.form(), prefix: prefix});
});
});
addMessageListener("debug:connect", onConnect);
// Allows executing module setup helper from the parent process.
// See also: DebuggerServer.setupInChild()
let onSetupInChild = DevToolsUtils.makeInfallible(msg => {
let { module, setupChild, args } = msg.data;
let m;
try {
m = require(module);
if (!(setupChild in m)) {
dumpn(`ERROR: module '${module}' does not export '${setupChild}'`);
return false;
}
m[setupChild].apply(m, args);
} catch (e) {
let errorMessage =
"Exception during actor module setup running in the child process: ";
DevToolsUtils.reportException(errorMessage + e);
dumpn(`ERROR: ${errorMessage}\n\t module: '${module}'\n\t ` +
`setupChild: '${setupChild}'\n${DevToolsUtils.safeErrorString(e)}`);
return false;
}
if (msg.data.id) {
// Send a message back to know when it is processed
sendAsyncMessage("debug:setup-in-child-response", {id: msg.data.id});
}
return true;
});
addMessageListener("debug:setup-in-child", onSetupInChild);
let onDisconnect = DevToolsUtils.makeInfallible(function (msg) {
let prefix = msg.data.prefix;
let conn = connections.get(prefix);
if (!conn) {
// Several copies of this frame script can be running for a single frame since it
// is loaded once for each DevTools connection to the frame. If this disconnect
// request doesn't match a connection known here, ignore it.
return;
}
Cu.unblockThreadedExecution();
removeMessageListener("debug:disconnect", onDisconnect);
// Call DebuggerServerConnection.close to destroy all child actors. It should end up
// calling DebuggerServerConnection.onClosed that would actually cleanup all actor
// pools.
conn.close();
connections.delete(prefix);
});
addMessageListener("debug:disconnect", onDisconnect);
// In non-e10s mode, the "debug:disconnect" message isn't always received before the
// messageManager connection goes away. Watching for "unload" here ensures we close
// any connections when the frame is unloaded.
addEventListener("unload", () => {
for (let conn of connections.values()) {
conn.close();
}
connections.clear();
});
})();
} catch (e) {
dump(`Exception in app child process: ${e}\n`);
}