Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 864 insertions, 0 deletions

diff --git a/devtools/server/actors/watcher.js b/devtools/server/actors/watcher.js
new file mode 100644
index 0000000000..97d2be01e4
--- /dev/null
+++ b/devtools/server/actors/watcher.js
@@ -0,0 +1,864 @@
+/* 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 { Actor } = require("resource://devtools/shared/protocol.js");
+const { watcherSpec } = require("resource://devtools/shared/specs/watcher.js");
+
+const Resources = require("resource://devtools/server/actors/resources/index.js");
+const { TargetActorRegistry } = ChromeUtils.importESModule(
+  "resource://devtools/server/actors/targets/target-actor-registry.sys.mjs",
+  {
+    loadInDevToolsLoader: false,
+  }
+);
+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 Targets = require("resource://devtools/server/actors/targets/index.js");
+const { getAllBrowsingContextsForContext } = ChromeUtils.importESModule(
+  "resource://devtools/server/actors/watcher/browsing-context-helpers.sys.mjs"
+);
+const {
+  SESSION_TYPES,
+} = require("resource://devtools/server/actors/watcher/session-context.js");
+
+const TARGET_HELPERS = {};
+loader.lazyRequireGetter(
+  TARGET_HELPERS,
+  Targets.TYPES.FRAME,
+  "resource://devtools/server/actors/watcher/target-helpers/frame-helper.js"
+);
+loader.lazyRequireGetter(
+  TARGET_HELPERS,
+  Targets.TYPES.PROCESS,
+  "resource://devtools/server/actors/watcher/target-helpers/process-helper.js"
+);
+loader.lazyRequireGetter(
+  TARGET_HELPERS,
+  Targets.TYPES.SERVICE_WORKER,
+  "devtools/server/actors/watcher/target-helpers/service-worker-helper"
+);
+loader.lazyRequireGetter(
+  TARGET_HELPERS,
+  Targets.TYPES.WORKER,
+  "resource://devtools/server/actors/watcher/target-helpers/worker-helper.js"
+);
+
+loader.lazyRequireGetter(
+  this,
+  "NetworkParentActor",
+  "resource://devtools/server/actors/network-monitor/network-parent.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "BlackboxingActor",
+  "resource://devtools/server/actors/blackboxing.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "BreakpointListActor",
+  "resource://devtools/server/actors/breakpoint-list.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "TargetConfigurationActor",
+  "resource://devtools/server/actors/target-configuration.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "ThreadConfigurationActor",
+  "resource://devtools/server/actors/thread-configuration.js",
+  true
+);
+
+exports.WatcherActor = class WatcherActor extends Actor {
+  /**
+   * Initialize a new WatcherActor which is the main entry point to debug
+   * something. The main features of this actor are to:
+   * - observe targets related to the context we are debugging.
+   *   This is done via watchTargets/unwatchTargets methods, and
+   *   target-available-form/target-destroyed-form events.
+   * - observe resources related to the observed targets.
+   *   This is done via watchResources/unwatchResources methods, and
+   *   resource-available-form/resource-updated-form/resource-destroyed-form events.
+   *   Note that these events are also emited on both the watcher actor,
+   *   for resources observed from the parent process, as well as on the
+   *   target actors, when the resources are observed from the target's process or thread.
+   *
+   * @param {DevToolsServerConnection} conn
+   *        The connection to use in order to communicate back to the client.
+   * @param {object} sessionContext
+   *        The Session Context to help know what is debugged.
+   *        See devtools/server/actors/watcher/session-context.js
+   * @param {Number} sessionContext.browserId: If this is a "browser-element" context type,
+   *        the "browserId" of the <browser> element we would like to debug.
+   * @param {Boolean} sessionContext.isServerTargetSwitchingEnabled: Flag to to know if we should
+   *        spawn new top level targets for the debugged context.
+   */
+  constructor(conn, sessionContext) {
+    super(conn, watcherSpec);
+    this._sessionContext = sessionContext;
+    if (sessionContext.type == SESSION_TYPES.BROWSER_ELEMENT) {
+      // Retrieve the <browser> element for the given browser ID
+      const browsingContext = BrowsingContext.getCurrentTopByBrowserId(
+        sessionContext.browserId
+      );
+      if (!browsingContext) {
+        throw new Error(
+          "Unable to retrieve the <browser> element for browserId=" +
+            sessionContext.browserId
+        );
+      }
+      this._browserElement = browsingContext.embedderElement;
+    }
+
+    // Sometimes we get iframe targets before the top-level targets
+    // mostly when doing bfcache navigations, lets cache the early iframes targets and
+    // flush them after the top-level target is available. See Bug 1726568 for details.
+    this._earlyIframeTargets = {};
+
+    // All currently available WindowGlobal target's form, keyed by `innerWindowId`.
+    //
+    // This helps to:
+    // - determine if the iframe targets are early or not.
+    //   i.e. if it is notified before its parent target is available.
+    // - notify the destruction of all children targets when a parent is destroyed.
+    //   i.e. have a reliable order of destruction between parent and children.
+    //
+    // Note that there should be just one top-level window target at a time,
+    // but there are certain cases when a new target is available before the
+    // old target is destroyed.
+    this._currentWindowGlobalTargets = new Map();
+  }
+
+  get sessionContext() {
+    return this._sessionContext;
+  }
+
+  /**
+   * If we are debugging only one Tab or Document, returns its BrowserElement.
+   * For Tabs, it will be the <browser> element used to load the web page.
+   *
+   * This is typicaly used to fetch:
+   * - its `browserId` attribute, which uniquely defines it,
+   * - its `browsingContextID` or `browsingContext`, which helps inspecting its content.
+   */
+  get browserElement() {
+    return this._browserElement;
+  }
+
+  getAllBrowsingContexts(options) {
+    return getAllBrowsingContextsForContext(this.sessionContext, options);
+  }
+
+  /**
+   * Helper to know if the context we are debugging has been already destroyed
+   */
+  isContextDestroyed() {
+    if (this.sessionContext.type == "browser-element") {
+      return !this.browserElement.browsingContext;
+    } else if (this.sessionContext.type == "webextension") {
+      return !BrowsingContext.get(this.sessionContext.addonBrowsingContextID);
+    } else if (this.sessionContext.type == "all") {
+      return false;
+    }
+    throw new Error(
+      "Unsupported session context type: " + this.sessionContext.type
+    );
+  }
+
+  destroy() {
+    // Force unwatching for all types, even if we weren't watching.
+    // This is fine as unwatchTarget is NOOP if we weren't already watching for this target type.
+    for (const targetType of Object.values(Targets.TYPES)) {
+      this.unwatchTargets(targetType);
+    }
+    this.unwatchResources(Object.values(Resources.TYPES));
+
+    WatcherRegistry.unregisterWatcher(this);
+
+    // Destroy the actor at the end so that its actorID keeps being defined.
+    super.destroy();
+  }
+
+  /*
+   * Get the list of the currently watched resources for this watcher.
+   *
+   * @return Array<String>
+   *         Returns the list of currently watched resource types.
+   */
+  get sessionData() {
+    return WatcherRegistry.getSessionData(this);
+  }
+
+  form() {
+    return {
+      actor: this.actorID,
+      // The resources and target traits should be removed all at the same time since the
+      // client has generic ways to deal with all of them (See Bug 1680280).
+      traits: {
+        ...this.sessionContext.supportedTargets,
+        resources: this.sessionContext.supportedResources,
+      },
+    };
+  }
+
+  /**
+   * Start watching for a new target type.
+   *
+   * This will instantiate Target Actors for existing debugging context of this type,
+   * but will also create actors as context of this type get created.
+   * The actors are notified to the client via "target-available-form" RDP events.
+   * We also notify about target actors destruction via "target-destroyed-form".
+   * Note that we are guaranteed to receive all existing target actor by the time this method
+   * resolves.
+   *
+   * @param {string} targetType
+   *        Type of context to observe. See Targets.TYPES object.
+   */
+  async watchTargets(targetType) {
+    WatcherRegistry.watchTargets(this, targetType);
+
+    const targetHelperModule = TARGET_HELPERS[targetType];
+    // Await the registration in order to ensure receiving the already existing targets
+    await targetHelperModule.createTargets(this);
+  }
+
+  /**
+   * Stop watching for a given target type.
+   *
+   * @param {string} targetType
+   *        Type of context to observe. See Targets.TYPES object.
+   * @param {object} options
+   * @param {boolean} options.isModeSwitching
+   *        true when this is called as the result of a change to the devtools.browsertoolbox.scope pref
+   */
+  unwatchTargets(targetType, options = {}) {
+    const isWatchingTargets = WatcherRegistry.unwatchTargets(
+      this,
+      targetType,
+      options
+    );
+    if (!isWatchingTargets) {
+      return;
+    }
+
+    const targetHelperModule = TARGET_HELPERS[targetType];
+    targetHelperModule.destroyTargets(this, options);
+
+    // Unregister the JS Window Actor if there is no more DevTools code observing any target/resource,
+    // unless we're switching mode (having both condition at the same time should only
+    // happen in tests).
+    if (!options.isModeSwitching) {
+      WatcherRegistry.maybeUnregisteringJSWindowActor();
+    }
+  }
+
+  /**
+   * Flush any early iframe targets relating to this top level
+   * window target.
+   * @param {number} topInnerWindowID
+   */
+  _flushIframeTargets(topInnerWindowID) {
+    while (this._earlyIframeTargets[topInnerWindowID]?.length > 0) {
+      const actor = this._earlyIframeTargets[topInnerWindowID].shift();
+      this.emit("target-available-form", actor);
+    }
+  }
+
+  /**
+   * Called by a Watcher module, whenever a new target is available
+   */
+  notifyTargetAvailable(actor) {
+    // Emit immediately for worker, process & extension targets
+    // as they don't have a parent browsing context.
+    if (!actor.traits?.isBrowsingContext) {
+      this.emit("target-available-form", actor);
+      return;
+    }
+
+    // If isBrowsingContext trait is true, we are processing a WindowGlobalTarget.
+    // (this trait should be renamed)
+    this._currentWindowGlobalTargets.set(actor.innerWindowId, actor);
+
+    // The top-level is always the same for the browser-toolbox
+    if (this.sessionContext.type == "all") {
+      this.emit("target-available-form", actor);
+      return;
+    }
+
+    if (actor.isTopLevelTarget) {
+      this.emit("target-available-form", actor);
+      // Flush any existing early iframe targets
+      this._flushIframeTargets(actor.innerWindowId);
+
+      if (this.sessionContext.type == SESSION_TYPES.BROWSER_ELEMENT) {
+        this.updateDomainSessionDataForServiceWorkers(actor.url);
+      }
+    } else if (this._currentWindowGlobalTargets.has(actor.topInnerWindowId)) {
+      // Emit the event immediately if the top-level target is already available
+      this.emit("target-available-form", actor);
+    } else if (this._earlyIframeTargets[actor.topInnerWindowId]) {
+      // Add the early iframe target to the list of other early targets.
+      this._earlyIframeTargets[actor.topInnerWindowId].push(actor);
+    } else {
+      // Set the first early iframe target
+      this._earlyIframeTargets[actor.topInnerWindowId] = [actor];
+    }
+  }
+
+  /**
+   * Called by a Watcher module, whenever a target has been destroyed
+   *
+   * @param {object} actor
+   *        the actor form of the target being destroyed
+   * @param {object} options
+   * @param {boolean} options.isModeSwitching
+   *        true when this is called as the result of a change to the devtools.browsertoolbox.scope pref
+   */
+  async notifyTargetDestroyed(actor, options = {}) {
+    // Emit immediately for worker, process & extension targets
+    // as they don't have a parent browsing context.
+    if (!actor.innerWindowId) {
+      this.emit("target-destroyed-form", actor, options);
+      return;
+    }
+    // Flush all iframe targets if we are destroying a top level target.
+    if (actor.isTopLevelTarget) {
+      // First compute the list of children actors, as notifyTargetDestroy will mutate _currentWindowGlobalTargets
+      const childrenActors = [
+        ...this._currentWindowGlobalTargets.values(),
+      ].filter(
+        form =>
+          form.topInnerWindowId == actor.innerWindowId &&
+          // Ignore the top level target itself, because its topInnerWindowId will be its innerWindowId
+          form.innerWindowId != actor.innerWindowId
+      );
+      childrenActors.map(form => this.notifyTargetDestroyed(form, options));
+    }
+    if (this._earlyIframeTargets[actor.innerWindowId]) {
+      delete this._earlyIframeTargets[actor.innerWindowId];
+    }
+    this._currentWindowGlobalTargets.delete(actor.innerWindowId);
+    const documentEventWatcher = Resources.getResourceWatcher(
+      this,
+      Resources.TYPES.DOCUMENT_EVENT
+    );
+    // If we have a Watcher class instantiated, ensure that target-destroyed is sent
+    // *after* DOCUMENT_EVENT's will-navigate. Otherwise this resource will have an undefined
+    // `targetFront` attribute, as it is associated with the target from which we navigate
+    // and not the one we navigate to.
+    //
+    // About documentEventWatcher check: We won't have any watcher class if we aren't
+    // using server side Watcher classes.
+    // i.e. when we are using the legacy listener for DOCUMENT_EVENT.
+    // This is still the case for all toolboxes but the one for local and remote tabs.
+    //
+    // About isServerTargetSwitchingEnabled check: if we are using the watcher class
+    // we may still use client side target, which will still use legacy listeners for
+    // will-navigate and so will-navigate will be emitted by the target actor itself.
+    //
+    // About isTopLevelTarget check: only top level targets emit will-navigate,
+    // so there is no reason to delay target-destroy for remote iframes.
+    if (
+      documentEventWatcher &&
+      this.sessionContext.isServerTargetSwitchingEnabled &&
+      actor.isTopLevelTarget
+    ) {
+      await documentEventWatcher.onceWillNavigateIsEmitted(actor.innerWindowId);
+    }
+    this.emit("target-destroyed-form", actor, options);
+  }
+
+  /**
+   * Given a browsingContextID, returns its parent browsingContextID. Returns null if a
+   * parent browsing context couldn't be found. Throws if the browsing context
+   * corresponding to the passed browsingContextID couldn't be found.
+   *
+   * @param {Integer} browsingContextID
+   * @returns {Integer|null}
+   */
+  getParentBrowsingContextID(browsingContextID) {
+    const browsingContext = BrowsingContext.get(browsingContextID);
+    if (!browsingContext) {
+      throw new Error(
+        `BrowsingContext with ID=${browsingContextID} doesn't exist.`
+      );
+    }
+    // Top-level documents of tabs, loaded in a <browser> element expose a null `parent`.
+    // i.e. Their BrowsingContext has no parent and is considered top level.
+    // But... in the context of the Browser Toolbox, we still consider them as child of the browser window.
+    // So, for them, fallback on `embedderWindowGlobal`, which will typically be the WindowGlobal for browser.xhtml.
+    if (browsingContext.parent) {
+      return browsingContext.parent.id;
+    }
+    if (browsingContext.embedderWindowGlobal) {
+      return browsingContext.embedderWindowGlobal.browsingContext.id;
+    }
+    return null;
+  }
+
+  /**
+   * Called by Resource Watchers, when new resources are available, updated or destroyed.
+   *
+   * @param String updateType
+   *        Can be "available", "updated" or "destroyed"
+   * @param Array<json> resources
+   *        List of all resource's form. A resource is a JSON object piped over to the client.
+   *        It can contain actor IDs, actor forms, to be manually marshalled by the client.
+   */
+  notifyResources(updateType, resources) {
+    if (resources.length === 0) {
+      // Don't try to emit if the resources array is empty.
+      return;
+    }
+
+    if (this.sessionContext.type == "webextension") {
+      this._overrideResourceBrowsingContextForWebExtension(resources);
+    }
+
+    this.emit(`resource-${updateType}-form`, resources);
+  }
+
+  /**
+   * For WebExtension, we have to hack all resource's browsingContextID
+   * in order to ensure emitting them with the fixed, original browsingContextID
+   * related to the fallback document created by devtools which always exists.
+   * The target's form will always be relating to that BrowsingContext IDs (browsing context ID and inner window id).
+   * Even if the target switches internally to another document via WindowGlobalTargetActor._setWindow.
+   *
+   * @param {Array<Objects>} List of resources
+   */
+  _overrideResourceBrowsingContextForWebExtension(resources) {
+    resources.forEach(resource => {
+      resource.browsingContextID = this.sessionContext.addonBrowsingContextID;
+    });
+  }
+
+  /**
+   * Try to retrieve a parent process TargetActor which is ignored by the
+   * TARGET_HELPERS. Examples:
+   * - top level target for the browser toolbox
+   * - xpcshell target for xpcshell debugging
+   *
+   * See comment in `watchResources`.
+   *
+   * @return {TargetActor|null} Matching target actor if any, null otherwise.
+   */
+  getTargetActorInParentProcess() {
+    if (TargetActorRegistry.xpcShellTargetActor) {
+      return TargetActorRegistry.xpcShellTargetActor;
+    }
+
+    // Note: For browser-element debugging, the WindowGlobalTargetActor returned here is created
+    // for a parent process page and lives in the parent process.
+    const actors = TargetActorRegistry.getTargetActors(
+      this.sessionContext,
+      this.conn.prefix
+    );
+
+    switch (this.sessionContext.type) {
+      case "all":
+        return actors.find(actor => actor.typeName === "parentProcessTarget");
+      case "browser-element":
+      case "webextension":
+        // All target actors for browser-element and webextension sessions
+        // should be created using the JS Window actors.
+        return null;
+      default:
+        throw new Error(
+          "Unsupported session context type: " + this.sessionContext.type
+        );
+    }
+  }
+
+  /**
+   * Start watching for a list of resource types.
+   * This should only resolve once all "already existing" resources of these types
+   * are notified to the client via resource-available-form event on related target actors.
+   *
+   * @param {Array<string>} resourceTypes
+   *        List of all types to listen to.
+   */
+  async watchResources(resourceTypes) {
+    // First process resources which have to be listened from the parent process
+    // (the watcher actor always runs in the parent process)
+    await Resources.watchResources(
+      this,
+      Resources.getParentProcessResourceTypes(resourceTypes)
+    );
+
+    // Bail out early if all resources were watched from parent process.
+    // In this scenario, we do not need to update these resource types in the WatcherRegistry
+    // as targets do not care about them.
+    if (!Resources.hasResourceTypesForTargets(resourceTypes)) {
+      return;
+    }
+
+    WatcherRegistry.watchResources(this, resourceTypes);
+
+    // Fetch resources from all existing targets
+    for (const targetType in TARGET_HELPERS) {
+      // We process frame targets even if we aren't watching them,
+      // because frame target helper codepath handles the top level target, if it runs in the *content* process.
+      // It will do another check to `isWatchingTargets(FRAME)` internally.
+      // Note that the workaround at the end of this method, using TargetActorRegistry
+      // is specific to top level target running in the *parent* process.
+      if (
+        !WatcherRegistry.isWatchingTargets(this, targetType) &&
+        targetType != Targets.TYPES.FRAME
+      ) {
+        continue;
+      }
+      const targetResourceTypes = Resources.getResourceTypesForTargetType(
+        resourceTypes,
+        targetType
+      );
+      if (!targetResourceTypes.length) {
+        continue;
+      }
+      const targetHelperModule = TARGET_HELPERS[targetType];
+      await targetHelperModule.addOrSetSessionDataEntry({
+        watcher: this,
+        type: "resources",
+        entries: targetResourceTypes,
+        updateType: "add",
+      });
+    }
+
+    /*
+     * The Watcher actor doesn't support watching the top level target
+     * (bug 1644397 and possibly some other followup).
+     *
+     * Because of that, we miss reaching these targets in the previous lines of this function.
+     * Since all BrowsingContext target actors register themselves to the TargetActorRegistry,
+     * we use it here in order to reach those missing targets, which are running in the
+     * parent process (where this WatcherActor lives as well):
+     *  - the parent process target (which inherits from WindowGlobalTargetActor)
+     *  - top level tab target for documents loaded in the parent process (e.g. about:robots).
+     *    When the tab loads document in the content process, the FrameTargetHelper will
+     *    reach it via the JSWindowActor API. Even if it uses MessageManager for anything
+     *    else (RDP packet forwarding, creation and destruction).
+     *
+     * We will eventually get rid of this code once all targets are properly supported by
+     * the Watcher Actor and we have target helpers for all of them.
+     */
+    const targetActor = this.getTargetActorInParentProcess();
+    if (targetActor) {
+      const targetActorResourceTypes = Resources.getResourceTypesForTargetType(
+        resourceTypes,
+        targetActor.targetType
+      );
+      await targetActor.addOrSetSessionDataEntry(
+        "resources",
+        targetActorResourceTypes,
+        false,
+        "add"
+      );
+    }
+  }
+
+  /**
+   * Stop watching for a list of resource types.
+   *
+   * @param {Array<string>} resourceTypes
+   *        List of all types to listen to.
+   */
+  unwatchResources(resourceTypes) {
+    // First process resources which are listened from the parent process
+    // (the watcher actor always runs in the parent process)
+    Resources.unwatchResources(
+      this,
+      Resources.getParentProcessResourceTypes(resourceTypes)
+    );
+
+    // Bail out early if all resources were all watched from parent process.
+    // In this scenario, we do not need to update these resource types in the WatcherRegistry
+    // as targets do not care about them.
+    if (!Resources.hasResourceTypesForTargets(resourceTypes)) {
+      return;
+    }
+
+    const isWatchingResources = WatcherRegistry.unwatchResources(
+      this,
+      resourceTypes
+    );
+    if (!isWatchingResources) {
+      return;
+    }
+
+    // Prevent trying to unwatch when the related BrowsingContext has already
+    // been destroyed
+    if (!this.isContextDestroyed()) {
+      for (const targetType in TARGET_HELPERS) {
+        // Frame target helper handles the top level target, if it runs in the content process
+        // so we should always process it. It does a second check to isWatchingTargets.
+        if (
+          !WatcherRegistry.isWatchingTargets(this, targetType) &&
+          targetType != Targets.TYPES.FRAME
+        ) {
+          continue;
+        }
+        const targetResourceTypes = Resources.getResourceTypesForTargetType(
+          resourceTypes,
+          targetType
+        );
+        if (!targetResourceTypes.length) {
+          continue;
+        }
+        const targetHelperModule = TARGET_HELPERS[targetType];
+        targetHelperModule.removeSessionDataEntry({
+          watcher: this,
+          type: "resources",
+          entries: targetResourceTypes,
+        });
+      }
+    }
+
+    // See comment in watchResources.
+    const targetActor = this.getTargetActorInParentProcess();
+    if (targetActor) {
+      const targetActorResourceTypes = Resources.getResourceTypesForTargetType(
+        resourceTypes,
+        targetActor.targetType
+      );
+      targetActor.removeSessionDataEntry("resources", targetActorResourceTypes);
+    }
+
+    // Unregister the JS Window Actor if there is no more DevTools code observing any target/resource
+    WatcherRegistry.maybeUnregisteringJSWindowActor();
+  }
+
+  clearResources(resourceTypes) {
+    // First process resources which have to be listened from the parent process
+    // (the watcher actor always runs in the parent process)
+    // TODO: content process / worker thread resources are not cleared. See Bug 1774573
+    Resources.clearResources(
+      this,
+      Resources.getParentProcessResourceTypes(resourceTypes)
+    );
+  }
+
+  /**
+   * Returns the network actor.
+   *
+   * @return {Object} actor
+   *        The network actor.
+   */
+  getNetworkParentActor() {
+    if (!this._networkParentActor) {
+      this._networkParentActor = new NetworkParentActor(this);
+    }
+
+    return this._networkParentActor;
+  }
+
+  /**
+   * Returns the blackboxing actor.
+   *
+   * @return {Object} actor
+   *        The blackboxing actor.
+   */
+  getBlackboxingActor() {
+    if (!this._blackboxingActor) {
+      this._blackboxingActor = new BlackboxingActor(this);
+    }
+
+    return this._blackboxingActor;
+  }
+
+  /**
+   * Returns the breakpoint list actor.
+   *
+   * @return {Object} actor
+   *        The breakpoint list actor.
+   */
+  getBreakpointListActor() {
+    if (!this._breakpointListActor) {
+      this._breakpointListActor = new BreakpointListActor(this);
+    }
+
+    return this._breakpointListActor;
+  }
+
+  /**
+   * Returns the target configuration actor.
+   *
+   * @return {Object} actor
+   *        The configuration actor.
+   */
+  getTargetConfigurationActor() {
+    if (!this._targetConfigurationListActor) {
+      this._targetConfigurationListActor = new TargetConfigurationActor(this);
+    }
+    return this._targetConfigurationListActor;
+  }
+
+  /**
+   * Returns the thread configuration actor.
+   *
+   * @return {Object} actor
+   *        The configuration actor.
+   */
+  getThreadConfigurationActor() {
+    if (!this._threadConfigurationListActor) {
+      this._threadConfigurationListActor = new ThreadConfigurationActor(this);
+    }
+    return this._threadConfigurationListActor;
+  }
+
+  /**
+   * Server internal API, called by other actors, but not by the client.
+   * Used to agrement some new entries for a given data type (watchers target, resources,
+   * breakpoints,...)
+   *
+   * @param {String} type
+   *        Data type to contribute to.
+   * @param {Array<*>} entries
+   *        List of values to add or set for this data type.
+   * @param {String} updateType
+   *        "add" will only add the new entries in the existing data set.
+   *        "set" will update the data set with the new entries.
+   */
+  async addOrSetDataEntry(type, entries, updateType) {
+    WatcherRegistry.addOrSetSessionDataEntry(this, type, entries, updateType);
+
+    await Promise.all(
+      Object.values(Targets.TYPES)
+        .filter(
+          targetType =>
+            // We process frame targets even if we aren't watching them,
+            // because frame target helper codepath handles the top level target, if it runs in the *content* process.
+            // It will do another check to `isWatchingTargets(FRAME)` internally.
+            // Note that the workaround at the end of this method, using TargetActorRegistry
+            // is specific to top level target running in the *parent* process.
+            WatcherRegistry.isWatchingTargets(this, targetType) ||
+            targetType === Targets.TYPES.FRAME
+        )
+        .map(async targetType => {
+          const targetHelperModule = TARGET_HELPERS[targetType];
+          await targetHelperModule.addOrSetSessionDataEntry({
+            watcher: this,
+            type,
+            entries,
+            updateType,
+          });
+        })
+    );
+
+    // See comment in watchResources
+    const targetActor = this.getTargetActorInParentProcess();
+    if (targetActor) {
+      await targetActor.addOrSetSessionDataEntry(
+        type,
+        entries,
+        false,
+        updateType
+      );
+    }
+  }
+
+  /**
+   * Server internal API, called by other actors, but not by the client.
+   * Used to remve some existing entries for a given data type (watchers target, resources,
+   * breakpoints,...)
+   *
+   * @param {String} type
+   *        Data type to modify.
+   * @param {Array<*>} entries
+   *        List of values to remove from this data type.
+   */
+  removeDataEntry(type, entries) {
+    WatcherRegistry.removeSessionDataEntry(this, type, entries);
+
+    Object.values(Targets.TYPES)
+      .filter(
+        targetType =>
+          // See comment in addOrSetDataEntry
+          WatcherRegistry.isWatchingTargets(this, targetType) ||
+          targetType === Targets.TYPES.FRAME
+      )
+      .forEach(targetType => {
+        const targetHelperModule = TARGET_HELPERS[targetType];
+        targetHelperModule.removeSessionDataEntry({
+          watcher: this,
+          type,
+          entries,
+        });
+      });
+
+    // See comment in addOrSetDataEntry
+    const targetActor = this.getTargetActorInParentProcess();
+    if (targetActor) {
+      targetActor.removeSessionDataEntry(type, entries);
+    }
+  }
+
+  /**
+   * Retrieve the current watched data for the provided type.
+   *
+   * @param {String} type
+   *        Data type to retrieve.
+   */
+  getSessionDataForType(type) {
+    return this.sessionData?.[type];
+  }
+
+  /**
+   * Special code dedicated to Service Worker debugging.
+   * This will notify the Service Worker JS Process Actors about the new top level page domain.
+   * So that we start tracking that domain's workers.
+   *
+   * @param {String} newTargetUrl
+   */
+  async updateDomainSessionDataForServiceWorkers(newTargetUrl) {
+    let host = "";
+    // Accessing `host` can throw on some URLs with no valid host like about:home.
+    // In such scenario, reset the host to an empty string.
+    try {
+      host = new URL(newTargetUrl).host;
+    } catch (e) {}
+
+    WatcherRegistry.addOrSetSessionDataEntry(
+      this,
+      "browser-element-host",
+      [host],
+      "set"
+    );
+
+    // This SessionData attribute is only used when debugging service workers.
+    // Avoid instantiating the JS Process Actors if we aren't watching for SW,
+    // or if we aren't watching for them just yet.
+    // But still update the WatcherRegistry, so that when we start watching
+    // and instantiate the target, the host will be set to the right value.
+    //
+    // Note that it is very important to avoid calling Service worker target helper's
+    // addOrSetSessionDataEntry. Otherwise, when we aren't watching for SW at all,
+    // we won't call destroyTargets on watcher actor destruction,
+    // and as a consequence never unregister the js process actor.
+    if (
+      !WatcherRegistry.isWatchingTargets(this, Targets.TYPES.SERVICE_WORKER)
+    ) {
+      return;
+    }
+
+    const targetHelperModule = TARGET_HELPERS[Targets.TYPES.SERVICE_WORKER];
+    await targetHelperModule.addOrSetSessionDataEntry({
+      watcher: this,
+      type: "browser-element-host",
+      entries: [host],
+      updateType: "set",
+    });
+  }
+};