1 files changed, 154 insertions, 0 deletions
diff --git a/remote/shared/messagehandler/RootMessageHandler.sys.mjs b/remote/shared/messagehandler/RootMessageHandler.sys.mjs
new file mode 100644
index 0000000000..cf64bb4502
--- /dev/null
+++ b/remote/shared/messagehandler/RootMessageHandler.sys.mjs
@@ -0,0 +1,154 @@
+/* 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 { MessageHandler } from "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  FrameTransport:
+    "chrome://remote/content/shared/messagehandler/transports/FrameTransport.sys.mjs",
+  SessionData:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
+  SessionDataMethod:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
+  WindowGlobalMessageHandler:
+    "chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs",
+});
+
+/**
+ * A RootMessageHandler is the root node of a MessageHandler network. It lives
+ * in the parent process. It can forward commands to MessageHandlers in other
+ * layers (at the moment WindowGlobalMessageHandlers in content processes).
+ */
+export class RootMessageHandler extends MessageHandler {
+  #frameTransport;
+  #sessionData;
+
+  /**
+   * Returns the RootMessageHandler module path.
+   *
+   * @return {String}
+   */
+  static get modulePath() {
+    return "root";
+  }
+
+  /**
+   * Returns the RootMessageHandler type.
+   *
+   * @return {String}
+   */
+  static get type() {
+    return "ROOT";
+  }
+
+  /**
+   * The ROOT MessageHandler is unique for a given MessageHandler network
+   * (ie for a given sessionId). Reuse the type as context id here.
+   */
+  static getIdFromContext(context) {
+    return RootMessageHandler.type;
+  }
+
+  /**
+   * Create a new RootMessageHandler instance.
+   *
+   * @param {String} sessionId
+   *     ID of the session the handler is used for.
+   */
+  constructor(sessionId) {
+    super(sessionId, null);
+
+    this.#frameTransport = new lazy.FrameTransport(this);
+    this.#sessionData = new lazy.SessionData(this);
+  }
+
+  get sessionData() {
+    return this.#sessionData;
+  }
+
+  destroy() {
+    this.#sessionData.destroy();
+    super.destroy();
+  }
+
+  /**
+   * Add new session data items of a given module, category and
+   * contextDescriptor.
+   *
+   * Forwards the call to the SessionData instance owned by this
+   * RootMessageHandler and propagates the information via a command to existing
+   * MessageHandlers.
+   */
+  addSessionData(sessionData = {}) {
+    sessionData.method = lazy.SessionDataMethod.Add;
+    return this.updateSessionData([sessionData]);
+  }
+
+  /**
+   * Emit a public protocol event. This event will be sent over to the client.
+   *
+   * @param {String} name
+   *     Name of the event. Protocol level events should be of the
+   *     form [module name].[event name].
+   * @param {Object} data
+   *     The event's data.
+   */
+  emitProtocolEvent(name, data) {
+    this.emit("message-handler-protocol-event", {
+      name,
+      data,
+      sessionId: this.sessionId,
+    });
+  }
+
+  /**
+   * Forward the provided command to WINDOW_GLOBAL MessageHandlers via the
+   * FrameTransport.
+   *
+   * @param {Command} command
+   *     The command to forward. See type definition in MessageHandler.js
+   * @return {Promise}
+   *     Returns a promise that resolves with the result of the command.
+   */
+  forwardCommand(command) {
+    switch (command.destination.type) {
+      case lazy.WindowGlobalMessageHandler.type:
+        return this.#frameTransport.forwardCommand(command);
+      default:
+        throw new Error(
+          `Cannot forward command to "${command.destination.type}" from "${this.constructor.type}".`
+        );
+    }
+  }
+
+  matchesContext() {
+    return true;
+  }
+
+  /**
+   * Remove session data items of a given module, category and
+   * contextDescriptor.
+   *
+   * Forwards the call to the SessionData instance owned by this
+   * RootMessageHandler and propagates the information via a command to existing
+   * MessageHandlers.
+   */
+  removeSessionData(sessionData = {}) {
+    sessionData.method = lazy.SessionDataMethod.Remove;
+    return this.updateSessionData([sessionData]);
+  }
+
+  /**
+   * Update session data items of a given module, category and
+   * contextDescriptor.
+   *
+   * Forwards the call to the SessionData instance owned by this
+   * RootMessageHandler.
+   */
+  async updateSessionData(sessionData = []) {
+    await this.#sessionData.updateSessionData(sessionData);
+  }
+}