Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

4 files changed, 1003 insertions, 0 deletions

diff --git a/remote/webdriver-bidi/modules/windowglobal/browsingContext.sys.mjs b/remote/webdriver-bidi/modules/windowglobal/browsingContext.sys.mjs
new file mode 100644
index 0000000000..675626353c
--- /dev/null
+++ b/remote/webdriver-bidi/modules/windowglobal/browsingContext.sys.mjs
@@ -0,0 +1,159 @@
+/* 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 { WindowGlobalBiDiModule } from "chrome://remote/content/webdriver-bidi/modules/WindowGlobalBiDiModule.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  LoadListener: "chrome://remote/content/shared/listeners/LoadListener.sys.mjs",
+});
+
+class BrowsingContextModule extends WindowGlobalBiDiModule {
+  #loadListener;
+  #subscribedEvents;
+
+  constructor(messageHandler) {
+    super(messageHandler);
+
+    // Setup the LoadListener as early as possible.
+    this.#loadListener = new lazy.LoadListener(this.messageHandler.window);
+    this.#loadListener.on("DOMContentLoaded", this.#onDOMContentLoaded);
+    this.#loadListener.on("load", this.#onLoad);
+
+    // Set of event names which have active subscriptions.
+    this.#subscribedEvents = new Set();
+  }
+
+  destroy() {
+    this.#loadListener.destroy();
+    this.#subscribedEvents = null;
+  }
+
+  #getNavigationInfo(data) {
+    return {
+      context: this.messageHandler.context,
+      // TODO: The navigation id should be a real id mapped to the navigation.
+      // See https://bugzilla.mozilla.org/show_bug.cgi?id=1763122
+      navigation: null,
+      timestamp: Date.now(),
+      url: data.target.URL,
+    };
+  }
+
+  #startListening() {
+    if (this.#subscribedEvents.size == 0) {
+      this.#loadListener.startListening();
+    }
+  }
+
+  #stopListening() {
+    if (this.#subscribedEvents.size == 0) {
+      this.#loadListener.stopListening();
+    }
+  }
+
+  #subscribeEvent(event) {
+    switch (event) {
+      case "browsingContext._documentInteractive":
+        this.#startListening();
+        this.#subscribedEvents.add("browsingContext._documentInteractive");
+        break;
+      case "browsingContext.domContentLoaded":
+        this.#startListening();
+        this.#subscribedEvents.add("browsingContext.domContentLoaded");
+        break;
+      case "browsingContext.load":
+        this.#startListening();
+        this.#subscribedEvents.add("browsingContext.load");
+        break;
+    }
+  }
+
+  #unsubscribeEvent(event) {
+    switch (event) {
+      case "browsingContext._documentInteractive":
+        this.#subscribedEvents.delete("browsingContext._documentInteractive");
+        break;
+      case "browsingContext.domContentLoaded":
+        this.#subscribedEvents.delete("browsingContext.domContentLoaded");
+        break;
+      case "browsingContext.load":
+        this.#subscribedEvents.delete("browsingContext.load");
+        break;
+    }
+
+    this.#stopListening();
+  }
+
+  #onDOMContentLoaded = (eventName, data) => {
+    if (this.#subscribedEvents.has("browsingContext._documentInteractive")) {
+      this.messageHandler.emitEvent("browsingContext._documentInteractive", {
+        baseURL: data.target.baseURI,
+        contextId: this.messageHandler.contextId,
+        documentURL: data.target.URL,
+        innerWindowId: this.messageHandler.innerWindowId,
+        readyState: data.target.readyState,
+      });
+    }
+
+    if (this.#subscribedEvents.has("browsingContext.domContentLoaded")) {
+      this.emitEvent(
+        "browsingContext.domContentLoaded",
+        this.#getNavigationInfo(data)
+      );
+    }
+  };
+
+  #onLoad = (eventName, data) => {
+    if (this.#subscribedEvents.has("browsingContext.load")) {
+      this.emitEvent("browsingContext.load", this.#getNavigationInfo(data));
+    }
+  };
+
+  /**
+   * Internal commands
+   */
+
+  _applySessionData(params) {
+    // TODO: Bug 1775231. Move this logic to a shared module or an abstract
+    // class.
+    const { category } = params;
+    if (category === "event") {
+      const filteredSessionData = params.sessionData.filter(item =>
+        this.messageHandler.matchesContext(item.contextDescriptor)
+      );
+      for (const event of this.#subscribedEvents.values()) {
+        const hasSessionItem = filteredSessionData.some(
+          item => item.value === event
+        );
+        // If there are no session items for this context, we should unsubscribe from the event.
+        if (!hasSessionItem) {
+          this.#unsubscribeEvent(event);
+        }
+      }
+
+      // Subscribe to all events, which have an item in SessionData.
+      for (const { value } of filteredSessionData) {
+        this.#subscribeEvent(value);
+      }
+    }
+  }
+
+  _getBaseURL() {
+    return this.messageHandler.window.document.baseURI;
+  }
+
+  _getScreenshotRect() {
+    const win = this.messageHandler.window;
+    return new DOMRect(
+      win.pageXOffset,
+      win.pageYOffset,
+      win.innerWidth,
+      win.innerHeight
+    );
+  }
+}
+
+export const browsingContext = BrowsingContextModule;
diff --git a/remote/webdriver-bidi/modules/windowglobal/input.sys.mjs b/remote/webdriver-bidi/modules/windowglobal/input.sys.mjs
new file mode 100644
index 0000000000..24259151ee
--- /dev/null
+++ b/remote/webdriver-bidi/modules/windowglobal/input.sys.mjs
@@ -0,0 +1,103 @@
+/* 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 { WindowGlobalBiDiModule } from "chrome://remote/content/webdriver-bidi/modules/WindowGlobalBiDiModule.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  action: "chrome://remote/content/shared/webdriver/Actions.sys.mjs",
+  deserialize: "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+  element: "chrome://remote/content/marionette/element.sys.mjs",
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+});
+
+class InputModule extends WindowGlobalBiDiModule {
+  #actionState;
+
+  constructor(messageHandler) {
+    super(messageHandler);
+
+    this.#actionState = null;
+  }
+
+  destroy() {}
+
+  async performActions(options) {
+    const { actions } = options;
+    if (this.#actionState === null) {
+      this.#actionState = new lazy.action.State({
+        specCompatPointerOrigin: true,
+      });
+    }
+
+    await this.#deserializeActionOrigins(actions);
+    const actionChain = lazy.action.Chain.fromJSON(this.#actionState, actions);
+    await actionChain.dispatch(this.#actionState, this.messageHandler.window);
+  }
+
+  async releaseActions() {
+    if (this.#actionState === null) {
+      return;
+    }
+    await this.#actionState.release(this.messageHandler.window);
+    this.#actionState = null;
+  }
+
+  /**
+   * In the provided array of input.SourceActions, replace all origins matching
+   * the input.ElementOrigin production with the Element corresponding to this
+   * origin.
+   *
+   * Note that this method replaces the content of the `actions` in place, and
+   * does not return a new array.
+   *
+   * @param {Array<input.SourceActions>} actions
+   *     The array of SourceActions to deserialize.
+   * @returns {Promise}
+   *     A promise which resolves when all ElementOrigin origins have been
+   *     deserialized.
+   */
+  async #deserializeActionOrigins(actions) {
+    const promises = [];
+    for (const actionsByTick of actions) {
+      for (const action of actionsByTick.actions) {
+        if (action.origin?.type === "element") {
+          promises.push(
+            (async () => {
+              action.origin = await this.#getElementFromElementOrigin(
+                action.origin
+              );
+            })()
+          );
+        }
+      }
+    }
+    return Promise.all(promises);
+  }
+
+  async #getElementFromElementOrigin(origin) {
+    const sharedReference = origin.element;
+    if (typeof sharedReference?.sharedId !== "string") {
+      throw new lazy.error.InvalidArgumentError(
+        `Expected "origin.element" to be a SharedReference, got: ${sharedReference}`
+      );
+    }
+
+    const realm = this.messageHandler.getRealm();
+
+    const element = lazy.deserialize(realm, sharedReference, {
+      nodeCache: this.nodeCache,
+    });
+    if (!lazy.element.isElement(element)) {
+      throw new lazy.error.NoSuchElementError(
+        `No element found for shared id: ${sharedReference.sharedId}`
+      );
+    }
+
+    return element;
+  }
+}
+
+export const input = InputModule;
diff --git a/remote/webdriver-bidi/modules/windowglobal/log.sys.mjs b/remote/webdriver-bidi/modules/windowglobal/log.sys.mjs
new file mode 100644
index 0000000000..ad83253804
--- /dev/null
+++ b/remote/webdriver-bidi/modules/windowglobal/log.sys.mjs
@@ -0,0 +1,258 @@
+/* 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 { WindowGlobalBiDiModule } from "chrome://remote/content/webdriver-bidi/modules/WindowGlobalBiDiModule.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ConsoleAPIListener:
+    "chrome://remote/content/shared/listeners/ConsoleAPIListener.sys.mjs",
+  ConsoleListener:
+    "chrome://remote/content/shared/listeners/ConsoleListener.sys.mjs",
+  isChromeFrame: "chrome://remote/content/shared/Stack.sys.mjs",
+  OwnershipModel: "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+  serialize: "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+  setDefaultSerializationOptions:
+    "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+});
+
+class LogModule extends WindowGlobalBiDiModule {
+  #consoleAPIListener;
+  #consoleMessageListener;
+  #subscribedEvents;
+
+  constructor(messageHandler) {
+    super(messageHandler);
+
+    // Create the console-api listener and listen on "message" events.
+    this.#consoleAPIListener = new lazy.ConsoleAPIListener(
+      this.messageHandler.innerWindowId
+    );
+    this.#consoleAPIListener.on("message", this.#onConsoleAPIMessage);
+
+    // Create the console listener and listen on error messages.
+    this.#consoleMessageListener = new lazy.ConsoleListener(
+      this.messageHandler.innerWindowId
+    );
+    this.#consoleMessageListener.on("error", this.#onJavaScriptError);
+
+    // Set of event names which have active subscriptions.
+    this.#subscribedEvents = new Set();
+  }
+
+  destroy() {
+    this.#consoleAPIListener.off("message", this.#onConsoleAPIMessage);
+    this.#consoleAPIListener.destroy();
+    this.#consoleMessageListener.off("error", this.#onJavaScriptError);
+    this.#consoleMessageListener.destroy();
+
+    this.#subscribedEvents = null;
+  }
+
+  #buildSource(realm) {
+    return {
+      realm: realm.id,
+      context: this.messageHandler.context,
+    };
+  }
+
+  /**
+   * Map the internal stacktrace representation to a WebDriver BiDi
+   * compatible one.
+   *
+   * Currently chrome frames will be filtered out until chrome scope
+   * is supported (bug 1722679).
+   *
+   * @param {Array<StackFrame>=} stackTrace
+   *     Stack frames to process.
+   *
+   * @returns {object=} Object, containing the list of frames as `callFrames`.
+   */
+  #buildStackTrace(stackTrace) {
+    if (stackTrace == undefined) {
+      return undefined;
+    }
+
+    const callFrames = stackTrace
+      .filter(frame => !lazy.isChromeFrame(frame))
+      .map(frame => {
+        return {
+          columnNumber: frame.columnNumber - 1,
+          functionName: frame.functionName,
+          lineNumber: frame.lineNumber - 1,
+          url: frame.filename,
+        };
+      });
+
+    return { callFrames };
+  }
+
+  #getLogEntryLevelFromConsoleMethod(method) {
+    switch (method) {
+      case "assert":
+      case "error":
+        return "error";
+      case "debug":
+      case "trace":
+        return "debug";
+      case "warn":
+        return "warn";
+      default:
+        return "info";
+    }
+  }
+
+  #onConsoleAPIMessage = (eventName, data = {}) => {
+    const {
+      // `arguments` cannot be used as variable name in functions
+      arguments: messageArguments,
+      // `level` corresponds to the console method used
+      level: method,
+      stacktrace,
+      timeStamp,
+    } = data;
+
+    // Step numbers below refer to the specifications at
+    //   https://w3c.github.io/webdriver-bidi/#event-log-entryAdded
+
+    // Translate the console message method to a log.LogEntry level
+    const logEntrylevel = this.#getLogEntryLevelFromConsoleMethod(method);
+
+    // Use the message's timeStamp or fallback on the current time value.
+    const timestamp = timeStamp || Date.now();
+
+    // Start assembling the text representation of the message.
+    let text = "";
+
+    // Formatters have already been applied at this points.
+    // message.arguments corresponds to the "formatted args" from the
+    // specifications.
+
+    // Concatenate all formatted arguments in text
+    // TODO: For m1 we only support string arguments, so we rely on the builtin
+    // toString for each argument which will be available in message.arguments.
+    const args = messageArguments || [];
+    text += args.map(String).join(" ");
+
+    // Serialize each arg as remote value.
+    const defaultRealm = this.messageHandler.getRealm();
+    const nodeCache = this.nodeCache;
+    const serializedArgs = [];
+    for (const arg of args) {
+      // Note that we can pass a default realm for now since realms are only
+      // involved when creating object references, which will not happen with
+      // OwnershipModel.None. This will be revisited in Bug 1742589.
+      serializedArgs.push(
+        lazy.serialize(
+          Cu.waiveXrays(arg),
+          lazy.setDefaultSerializationOptions(),
+          lazy.OwnershipModel.None,
+          new Map(),
+          defaultRealm,
+          {
+            nodeCache,
+          }
+        )
+      );
+    }
+
+    // Set source to an object which contains realm and browsing context.
+    // TODO: Bug 1742589. Use an actual realm from which the event came from.
+    const source = this.#buildSource(defaultRealm);
+
+    // Set stack trace only for certain methods.
+    let stackTrace;
+    if (["assert", "error", "trace", "warn"].includes(method)) {
+      stackTrace = this.#buildStackTrace(stacktrace);
+    }
+
+    // Build the ConsoleLogEntry
+    const entry = {
+      type: "console",
+      method,
+      source,
+      args: serializedArgs,
+      level: logEntrylevel,
+      text,
+      timestamp,
+      stackTrace,
+    };
+
+    // TODO: Those steps relate to:
+    // - emitting associated BrowsingContext. See log.entryAdded full support
+    //   in https://bugzilla.mozilla.org/show_bug.cgi?id=1724669#c0
+    // - handling cases where session doesn't exist or the event is not
+    //   monitored. The implementation differs from the spec here because we
+    //   only react to events if there is a session & if the session subscribed
+    //   to those events.
+
+    this.emitEvent("log.entryAdded", entry);
+  };
+
+  #onJavaScriptError = (eventName, data = {}) => {
+    const { level, message, stacktrace, timeStamp } = data;
+    const defaultRealm = this.messageHandler.getRealm();
+
+    // Build the JavascriptLogEntry
+    const entry = {
+      type: "javascript",
+      level,
+      // TODO: Bug 1742589. Use an actual realm from which the event came from.
+      source: this.#buildSource(defaultRealm),
+      text: message,
+      timestamp: timeStamp || Date.now(),
+      stackTrace: this.#buildStackTrace(stacktrace),
+    };
+
+    this.emitEvent("log.entryAdded", entry);
+  };
+
+  #subscribeEvent(event) {
+    if (event === "log.entryAdded") {
+      this.#consoleAPIListener.startListening();
+      this.#consoleMessageListener.startListening();
+      this.#subscribedEvents.add(event);
+    }
+  }
+
+  #unsubscribeEvent(event) {
+    if (event === "log.entryAdded") {
+      this.#consoleAPIListener.stopListening();
+      this.#consoleMessageListener.stopListening();
+      this.#subscribedEvents.delete(event);
+    }
+  }
+
+  /**
+   * Internal commands
+   */
+
+  _applySessionData(params) {
+    // TODO: Bug 1775231. Move this logic to a shared module or an abstract
+    // class.
+    const { category } = params;
+    if (category === "event") {
+      const filteredSessionData = params.sessionData.filter(item =>
+        this.messageHandler.matchesContext(item.contextDescriptor)
+      );
+      for (const event of this.#subscribedEvents.values()) {
+        const hasSessionItem = filteredSessionData.some(
+          item => item.value === event
+        );
+        // If there are no session items for this context, we should unsubscribe from the event.
+        if (!hasSessionItem) {
+          this.#unsubscribeEvent(event);
+        }
+      }
+
+      // Subscribe to all events, which have an item in SessionData.
+      for (const { value } of filteredSessionData) {
+        this.#subscribeEvent(value);
+      }
+    }
+  }
+}
+
+export const log = LogModule;
diff --git a/remote/webdriver-bidi/modules/windowglobal/script.sys.mjs b/remote/webdriver-bidi/modules/windowglobal/script.sys.mjs
new file mode 100644
index 0000000000..7b88f5c96e
--- /dev/null
+++ b/remote/webdriver-bidi/modules/windowglobal/script.sys.mjs
@@ -0,0 +1,483 @@
+/* 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 { WindowGlobalBiDiModule } from "chrome://remote/content/webdriver-bidi/modules/WindowGlobalBiDiModule.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  deserialize: "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  getFramesFromStack: "chrome://remote/content/shared/Stack.sys.mjs",
+  isChromeFrame: "chrome://remote/content/shared/Stack.sys.mjs",
+  OwnershipModel: "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+  serialize: "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+  setDefaultSerializationOptions:
+    "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+  stringify: "chrome://remote/content/webdriver-bidi/RemoteValue.sys.mjs",
+});
+
+/**
+ * @typedef {string} EvaluationStatus
+ */
+
+/**
+ * Enum of possible evaluation states.
+ *
+ * @readonly
+ * @enum {EvaluationStatus}
+ */
+const EvaluationStatus = {
+  Normal: "normal",
+  Throw: "throw",
+};
+
+class ScriptModule extends WindowGlobalBiDiModule {
+  #observerListening;
+  #preloadScripts;
+
+  constructor(messageHandler) {
+    super(messageHandler);
+
+    // Set of structs with an item named expression, which is a string,
+    // and an item named sandbox which is a string or null.
+    this.#preloadScripts = new Set();
+  }
+
+  destroy() {
+    this.#preloadScripts = null;
+
+    this.#stopObserving();
+  }
+
+  observe(subject, topic) {
+    if (topic !== "document-element-inserted") {
+      return;
+    }
+
+    const window = subject?.defaultView;
+
+    // Ignore events without a window and those from other tabs.
+    if (window === this.messageHandler.window) {
+      this.#evaluatePreloadScripts();
+    }
+  }
+
+  #buildExceptionDetails(exception, stack, realm, resultOwnership, options) {
+    exception = this.#toRawObject(exception);
+
+    // A stacktrace is mandatory to build exception details and a missing stack
+    // means we encountered an unexpected issue. Throw with an explicit error.
+    if (!stack) {
+      throw new Error(
+        `Missing stack, unable to build exceptionDetails for exception: ${lazy.stringify(
+          exception
+        )}`
+      );
+    }
+
+    const frames = lazy.getFramesFromStack(stack) || [];
+    const callFrames = frames
+      // Remove chrome/internal frames
+      .filter(frame => !lazy.isChromeFrame(frame))
+      // Translate frames from getFramesFromStack to frames expected by
+      // WebDriver BiDi.
+      .map(frame => {
+        return {
+          columnNumber: frame.columnNumber - 1,
+          functionName: frame.functionName,
+          lineNumber: frame.lineNumber - 1,
+          url: frame.filename,
+        };
+      });
+
+    return {
+      columnNumber: stack.column - 1,
+      exception: lazy.serialize(
+        exception,
+        lazy.setDefaultSerializationOptions(),
+        resultOwnership,
+        new Map(),
+        realm,
+        options
+      ),
+      lineNumber: stack.line - 1,
+      stackTrace: { callFrames },
+      text: lazy.stringify(exception),
+    };
+  }
+
+  async #buildReturnValue(
+    rv,
+    realm,
+    awaitPromise,
+    resultOwnership,
+    serializationOptions,
+    options
+  ) {
+    let evaluationStatus, exception, result, stack;
+
+    if ("return" in rv) {
+      evaluationStatus = EvaluationStatus.Normal;
+      if (
+        awaitPromise &&
+        // Only non-primitive return values are wrapped in Debugger.Object.
+        rv.return instanceof Debugger.Object &&
+        rv.return.isPromise
+      ) {
+        try {
+          // Force wrapping the promise resolution result in a Debugger.Object
+          // wrapper for consistency with the synchronous codepath.
+          const asyncResult = await rv.return.unsafeDereference();
+          result = realm.globalObjectReference.makeDebuggeeValue(asyncResult);
+        } catch (asyncException) {
+          evaluationStatus = EvaluationStatus.Throw;
+          exception =
+            realm.globalObjectReference.makeDebuggeeValue(asyncException);
+
+          // If the returned promise was rejected by calling its reject callback
+          // the stack will be available on promiseResolutionSite.
+          // Otherwise, (eg. rejected Promise chained with a then() call) we
+          // fallback on the promiseAllocationSite.
+          stack =
+            rv.return.promiseResolutionSite || rv.return.promiseAllocationSite;
+        }
+      } else {
+        // rv.return is a Debugger.Object or a primitive.
+        result = rv.return;
+      }
+    } else if ("throw" in rv) {
+      // rv.throw will be set if the evaluation synchronously failed, either if
+      // the script contains a syntax error or throws an exception.
+      evaluationStatus = EvaluationStatus.Throw;
+      exception = rv.throw;
+      stack = rv.stack;
+    }
+
+    switch (evaluationStatus) {
+      case EvaluationStatus.Normal:
+        return {
+          evaluationStatus,
+          result: lazy.serialize(
+            this.#toRawObject(result),
+            serializationOptions,
+            resultOwnership,
+            new Map(),
+            realm,
+            options
+          ),
+          realmId: realm.id,
+        };
+      case EvaluationStatus.Throw:
+        return {
+          evaluationStatus,
+          exceptionDetails: this.#buildExceptionDetails(
+            exception,
+            stack,
+            realm,
+            resultOwnership,
+            options
+          ),
+          realmId: realm.id,
+        };
+      default:
+        throw new lazy.error.UnsupportedOperationError(
+          `Unsupported completion value for expression evaluation`
+        );
+    }
+  }
+
+  /**
+   * Emit "script.message" event with provided data.
+   *
+   * @param {Realm} realm
+   * @param {ChannelProperties} channelProperties
+   * @param {RemoteValue} message
+   */
+  #emitScriptMessage = (realm, channelProperties, message) => {
+    const {
+      channel,
+      ownership: ownershipType = lazy.OwnershipModel.None,
+      serializationOptions,
+    } = channelProperties;
+
+    const data = lazy.serialize(
+      this.#toRawObject(message),
+      lazy.setDefaultSerializationOptions(serializationOptions),
+      ownershipType,
+      new Map(),
+      realm
+    );
+
+    this.emitEvent("script.message", {
+      channel,
+      data,
+      source: this.#getSource(realm),
+    });
+  };
+
+  #evaluatePreloadScripts() {
+    let resolveBlockerPromise;
+    const blockerPromise = new Promise(resolve => {
+      resolveBlockerPromise = resolve;
+    });
+
+    // Block script parsing.
+    this.messageHandler.window.document.blockParsing(blockerPromise);
+    for (const script of this.#preloadScripts.values()) {
+      const {
+        arguments: commandArguments,
+        functionDeclaration,
+        sandbox,
+      } = script;
+      const realm = this.messageHandler.getRealm({ sandboxName: sandbox });
+      const deserializedArguments = commandArguments.map(arg =>
+        lazy.deserialize(realm, arg, {
+          emitScriptMessage: this.#emitScriptMessage,
+        })
+      );
+      const rv = realm.executeInGlobalWithBindings(
+        functionDeclaration,
+        deserializedArguments
+      );
+
+      if ("throw" in rv) {
+        const exception = this.#toRawObject(rv.throw);
+        realm.reportError(lazy.stringify(exception), rv.stack);
+      }
+    }
+
+    // Continue script parsing.
+    resolveBlockerPromise();
+  }
+
+  #getSource(realm) {
+    return {
+      realm: realm.id,
+      context: this.messageHandler.context,
+    };
+  }
+
+  #startObserving() {
+    if (!this.#observerListening) {
+      Services.obs.addObserver(this, "document-element-inserted");
+      this.#observerListening = true;
+    }
+  }
+
+  #stopObserving() {
+    if (this.#observerListening) {
+      Services.obs.removeObserver(this, "document-element-inserted");
+      this.#observerListening = false;
+    }
+  }
+
+  #toRawObject(maybeDebuggerObject) {
+    if (maybeDebuggerObject instanceof Debugger.Object) {
+      // Retrieve the referent for the provided Debugger.object.
+      // See https://firefox-source-docs.mozilla.org/devtools-user/debugger-api/debugger.object/index.html
+      const rawObject = maybeDebuggerObject.unsafeDereference();
+
+      // TODO: Getters for Maps and Sets iterators return "Opaque" objects and
+      // are not iterable. RemoteValue.jsm' serializer should handle calling
+      // waiveXrays on Maps/Sets/... and then unwaiveXrays on entries but since
+      // we serialize with maxDepth=1, calling waiveXrays once on the root
+      // object allows to return correctly serialized values.
+      return Cu.waiveXrays(rawObject);
+    }
+
+    // If maybeDebuggerObject was not a Debugger.Object, it is a primitive value
+    // which can be used as is.
+    return maybeDebuggerObject;
+  }
+
+  /**
+   * Call a function in the current window global.
+   *
+   * @param {object} options
+   * @param {boolean} options.awaitPromise
+   *     Determines if the command should wait for the return value of the
+   *     expression to resolve, if this return value is a Promise.
+   * @param {Array<RemoteValue>=} options.commandArguments
+   *     The arguments to pass to the function call.
+   * @param {string} options.functionDeclaration
+   *     The body of the function to call.
+   * @param {string=} options.realmId
+   *     The id of the realm.
+   * @param {OwnershipModel} options.resultOwnership
+   *     The ownership model to use for the results of this evaluation.
+   * @param {string=} options.sandbox
+   *     The name of the sandbox.
+   * @param {SerializationOptions=} options.serializationOptions
+   *     An object which holds the information of how the result of evaluation
+   *     in case of ECMAScript objects should be serialized.
+   * @param {RemoteValue=} options.thisParameter
+   *     The value of the this keyword for the function call.
+   *
+   * @returns {object}
+   *     - evaluationStatus {EvaluationStatus} One of "normal", "throw".
+   *     - exceptionDetails {ExceptionDetails=} the details of the exception if
+   *     the evaluation status was "throw".
+   *     - result {RemoteValue=} the result of the evaluation serialized as a
+   *     RemoteValue if the evaluation status was "normal".
+   */
+  async callFunctionDeclaration(options) {
+    const {
+      awaitPromise,
+      commandArguments = null,
+      functionDeclaration,
+      realmId = null,
+      resultOwnership,
+      sandbox: sandboxName = null,
+      serializationOptions,
+      thisParameter = null,
+    } = options;
+
+    const realm = this.messageHandler.getRealm({ realmId, sandboxName });
+    const nodeCache = this.nodeCache;
+
+    const deserializedArguments =
+      commandArguments !== null
+        ? commandArguments.map(arg =>
+            lazy.deserialize(realm, arg, {
+              emitScriptMessage: this.#emitScriptMessage,
+              nodeCache,
+            })
+          )
+        : [];
+
+    const deserializedThis =
+      thisParameter !== null
+        ? lazy.deserialize(realm, thisParameter, {
+            emitScriptMessage: this.#emitScriptMessage,
+            nodeCache,
+          })
+        : null;
+
+    const rv = realm.executeInGlobalWithBindings(
+      functionDeclaration,
+      deserializedArguments,
+      deserializedThis
+    );
+
+    return this.#buildReturnValue(
+      rv,
+      realm,
+      awaitPromise,
+      resultOwnership,
+      serializationOptions,
+      {
+        nodeCache,
+      }
+    );
+  }
+
+  /**
+   * Delete the provided handles from the realm corresponding to the provided
+   * sandbox name.
+   *
+   * @param {object=} options
+   * @param {Array<string>} options.handles
+   *     Array of handle ids to disown.
+   * @param {string=} options.realmId
+   *     The id of the realm.
+   * @param {string=} options.sandbox
+   *     The name of the sandbox.
+   */
+  disownHandles(options) {
+    const { handles, realmId = null, sandbox: sandboxName = null } = options;
+    const realm = this.messageHandler.getRealm({ realmId, sandboxName });
+    for (const handle of handles) {
+      realm.removeObjectHandle(handle);
+    }
+  }
+
+  /**
+   * Evaluate a provided expression in the current window global.
+   *
+   * @param {object} options
+   * @param {boolean} options.awaitPromise
+   *     Determines if the command should wait for the return value of the
+   *     expression to resolve, if this return value is a Promise.
+   * @param {string} options.expression
+   *     The expression to evaluate.
+   * @param {string=} options.realmId
+   *     The id of the realm.
+   * @param {OwnershipModel} options.resultOwnership
+   *     The ownership model to use for the results of this evaluation.
+   * @param {string=} options.sandbox
+   *     The name of the sandbox.
+   *
+   * @returns {object}
+   *     - evaluationStatus {EvaluationStatus} One of "normal", "throw".
+   *     - exceptionDetails {ExceptionDetails=} the details of the exception if
+   *     the evaluation status was "throw".
+   *     - result {RemoteValue=} the result of the evaluation serialized as a
+   *     RemoteValue if the evaluation status was "normal".
+   */
+  async evaluateExpression(options) {
+    const {
+      awaitPromise,
+      expression,
+      realmId = null,
+      resultOwnership,
+      sandbox: sandboxName = null,
+      serializationOptions,
+    } = options;
+
+    const realm = this.messageHandler.getRealm({ realmId, sandboxName });
+
+    const rv = realm.executeInGlobal(expression);
+
+    return this.#buildReturnValue(
+      rv,
+      realm,
+      awaitPromise,
+      resultOwnership,
+      serializationOptions,
+      {
+        nodeCache: this.nodeCache,
+      }
+    );
+  }
+
+  /**
+   * Get realms for the current window global.
+   *
+   * @returns {Array<object>}
+   *     - context {BrowsingContext} The browsing context, associated with the realm.
+   *     - origin {string} The serialization of an origin.
+   *     - realm {string} The realm unique identifier.
+   *     - sandbox {string=} The name of the sandbox.
+   *     - type {RealmType.Window} The window realm type.
+   */
+  getWindowRealms() {
+    return Array.from(this.messageHandler.realms.values()).map(realm => {
+      const { context, origin, realm: id, sandbox, type } = realm.getInfo();
+      return { context, origin, realm: id, sandbox, type };
+    });
+  }
+
+  /**
+   * Internal commands
+   */
+
+  _applySessionData(params) {
+    // We only care about updates coming on context creation.
+    if (params.category === "preload-script" && params.initial) {
+      this.#preloadScripts = new Set();
+      for (const item of params.sessionData) {
+        if (this.messageHandler.matchesContext(item.contextDescriptor)) {
+          this.#preloadScripts.add(item.value);
+        }
+      }
+
+      if (this.#preloadScripts.size) {
+        this.#startObserving();
+      }
+    }
+  }
+}
+
+export const script = ScriptModule;