From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../js-window-actor/DevToolsFrameParent.sys.mjs | 272 +++++++++++++++++++++ 1 file changed, 272 insertions(+) create mode 100644 devtools/server/connectors/js-window-actor/DevToolsFrameParent.sys.mjs (limited to 'devtools/server/connectors/js-window-actor/DevToolsFrameParent.sys.mjs') diff --git a/devtools/server/connectors/js-window-actor/DevToolsFrameParent.sys.mjs b/devtools/server/connectors/js-window-actor/DevToolsFrameParent.sys.mjs new file mode 100644 index 0000000000..867453a798 --- /dev/null +++ b/devtools/server/connectors/js-window-actor/DevToolsFrameParent.sys.mjs @@ -0,0 +1,272 @@ +/* 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 { loader } from "resource://devtools/shared/loader/Loader.sys.mjs"; +import { EventEmitter } from "resource://gre/modules/EventEmitter.sys.mjs"; + +const { WatcherRegistry } = ChromeUtils.importESModule( + "resource://devtools/server/actors/watcher/WatcherRegistry.sys.mjs", + { + // WatcherRegistry needs to be a true singleton and loads ActorManagerParent + // which also has to be a true singleton. + loadInDevToolsLoader: false, + } +); + +const lazy = {}; + +loader.lazyRequireGetter( + lazy, + "JsWindowActorTransport", + "resource://devtools/shared/transport/js-window-actor-transport.js", + true +); + +export class DevToolsFrameParent extends JSWindowActorParent { + constructor() { + super(); + + // Map of DevToolsServerConnection's used to forward the messages from/to + // the client. The connections run in the parent process, as this code. We + // may have more than one when there is more than one client debugging the + // same frame. For example, a content toolbox and the browser toolbox. + // + // The map is indexed by the connection prefix. + // The values are objects containing the following properties: + // - actor: the frame target actor(as a form) + // - connection: the DevToolsServerConnection used to communicate with the + // frame target actor + // - prefix: the forwarding prefix used by the connection to know + // how to forward packets to the frame target + // - transport: the JsWindowActorTransport + // + // Reminder about prefixes: all DevToolsServerConnections have a `prefix` + // which can be considered as a kind of id. On top of this, parent process + // DevToolsServerConnections also have forwarding prefixes because they are + // responsible for forwarding messages to content process connections. + this._connections = new Map(); + + this._onConnectionClosed = this._onConnectionClosed.bind(this); + EventEmitter.decorate(this); + } + + /** + * Request the content process to create the Frame Target if there is one + * already available that matches the Browsing Context ID + */ + async instantiateTarget({ + watcherActorID, + connectionPrefix, + sessionContext, + sessionData, + }) { + await this.sendQuery("DevToolsFrameParent:instantiate-already-available", { + watcherActorID, + connectionPrefix, + sessionContext, + sessionData, + }); + } + + /** + * @param {object} arg + * @param {object} arg.sessionContext + * @param {object} arg.options + * @param {boolean} arg.options.isModeSwitching + * true when this is called as the result of a change to the devtools.browsertoolbox.scope pref + */ + destroyTarget({ watcherActorID, sessionContext, options }) { + this.sendAsyncMessage("DevToolsFrameParent:destroy", { + watcherActorID, + sessionContext, + options, + }); + } + + /** + * Communicate to the content process that some data have been added. + */ + async addSessionDataEntry({ watcherActorID, sessionContext, type, entries }) { + try { + await this.sendQuery("DevToolsFrameParent:addSessionDataEntry", { + watcherActorID, + sessionContext, + type, + entries, + }); + } catch (e) { + console.warn( + "Failed to add session data entry for frame targets in browsing context", + this.browsingContext.id + ); + console.warn(e); + } + } + + /** + * Communicate to the content process that some data have been removed. + */ + removeSessionDataEntry({ watcherActorID, sessionContext, type, entries }) { + this.sendAsyncMessage("DevToolsFrameParent:removeSessionDataEntry", { + watcherActorID, + sessionContext, + type, + entries, + }); + } + + connectFromContent({ watcherActorID, forwardingPrefix, actor }) { + const watcher = WatcherRegistry.getWatcher(watcherActorID); + + if (!watcher) { + throw new Error( + `Watcher Actor with ID '${watcherActorID}' can't be found.` + ); + } + const connection = watcher.conn; + + connection.on("closed", this._onConnectionClosed); + + // Create a js-window-actor based transport. + const transport = new lazy.JsWindowActorTransport(this, forwardingPrefix); + transport.hooks = { + onPacket: connection.send.bind(connection), + onTransportClosed() {}, + }; + transport.ready(); + + connection.setForwarding(forwardingPrefix, transport); + + this._connections.set(watcher.conn.prefix, { + watcher, + connection, + // This prefix is the prefix of the DevToolsServerConnection, running + // in the content process, for which we should forward packets to, based on its prefix. + // While `watcher.connection` is also a DevToolsServerConnection, but from this process, + // the parent process. It is the one receiving Client packets and the one, from which + // we should forward packets from. + forwardingPrefix, + transport, + actor, + }); + + watcher.notifyTargetAvailable(actor); + } + + _onConnectionClosed(status, connectionPrefix) { + this._unregisterWatcher(connectionPrefix); + } + + /** + * Given a watcher connection prefix, unregister everything related to the Watcher + * in this JSWindowActor. + * + * @param {String} connectionPrefix + * The connection prefix of the watcher to unregister + */ + async _unregisterWatcher(connectionPrefix) { + const connectionInfo = this._connections.get(connectionPrefix); + if (!connectionInfo) { + return; + } + const { forwardingPrefix, transport, connection } = connectionInfo; + this._connections.delete(connectionPrefix); + + connection.off("closed", this._onConnectionClosed); + if (transport) { + // If we have a child transport, the actor has already + // been created. We need to stop using this transport. + transport.close(); + } + + connection.cancelForwarding(forwardingPrefix); + } + + /** + * Destroy everything that we did related to the current WindowGlobal that + * this JSWindow Actor represents: + * - close all transports that were used as bridge to communicate with the + * DevToolsFrameChild, running in the content process + * - unregister these transports from DevToolsServer (cancelForwarding) + * - notify the client, via the WatcherActor that all related targets, + * one per client/connection are all destroyed + * + * Note that with bfcacheInParent, we may reuse a JSWindowActor pair after closing all connections. + * This is can happen outside of the destruction of the actor. + * We may reuse a DevToolsFrameParent and DevToolsFrameChild pair. + * When navigating away, we will destroy them and call this method. + * Then when navigating back, we will reuse the same instances. + * So that we should be careful to keep the class fully function and only clear all its state. + * + * @param {object} options + * @param {boolean} options.isModeSwitching + * true when this is called as the result of a change to the devtools.browsertoolbox.scope pref + */ + _closeAllConnections(options) { + for (const { actor, watcher } of this._connections.values()) { + watcher.notifyTargetDestroyed(actor, options); + this._unregisterWatcher(watcher.conn.prefix); + } + this._connections.clear(); + } + + /** + * Supported Queries + */ + + sendPacket(packet, prefix) { + this.sendAsyncMessage("DevToolsFrameParent:packet", { packet, prefix }); + } + + /** + * JsWindowActor API + */ + + receiveMessage(message) { + switch (message.name) { + case "DevToolsFrameChild:connectFromContent": + return this.connectFromContent(message.data); + case "DevToolsFrameChild:packet": + return this.emit("packet-received", message); + case "DevToolsFrameChild:destroy": + for (const { form, watcherActorID } of message.data.actors) { + const watcher = WatcherRegistry.getWatcher(watcherActorID); + // As we instruct to destroy all targets when the watcher is destroyed, + // we may easily receive the target destruction notification *after* + // the watcher has been removed from the registry. + if (watcher) { + watcher.notifyTargetDestroyed(form, message.data.options); + this._unregisterWatcher(watcher.conn.prefix); + } + } + return null; + case "DevToolsFrameChild:bf-cache-navigation-pageshow": + for (const watcherActor of WatcherRegistry.getWatchersForBrowserId( + this.browsingContext.browserId + )) { + watcherActor.emit("bf-cache-navigation-pageshow", { + windowGlobal: this.browsingContext.currentWindowGlobal, + }); + } + return null; + case "DevToolsFrameChild:bf-cache-navigation-pagehide": + for (const watcherActor of WatcherRegistry.getWatchersForBrowserId( + this.browsingContext.browserId + )) { + watcherActor.emit("bf-cache-navigation-pagehide", { + windowGlobal: this.browsingContext.currentWindowGlobal, + }); + } + return null; + default: + throw new Error( + "Unsupported message in DevToolsFrameParent: " + message.name + ); + } + } + + didDestroy() { + this._closeAllConnections(); + } +} -- cgit v1.2.3