sousa-gecko/remote/shared/messagehandler/test/browser/browser_handle_simple_command.js

/* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

const { RootMessageHandler } = ChromeUtils.importESModule(
  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
);

// Test calling methods only implemented in the root version of a module.
add_task(async function test_rootModule_command() {
  const rootMessageHandler = createRootMessageHandler("session-id-rootModule");
  const rootValue = await rootMessageHandler.handleCommand({
    moduleName: "command",
    commandName: "testRootModule",
    destination: {
      type: RootMessageHandler.type,
    },
  });

  is(
    rootValue,
    "root-value",
    "Retrieved the expected value from testRootModule"
  );

  rootMessageHandler.destroy();
});

// Test calling methods only implemented in the windowglobal-in-root version of
// a module.
add_task(async function test_windowglobalInRootModule_command() {
  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;

  const rootMessageHandler = createRootMessageHandler(
    "session-id-windowglobalInRootModule"
  );
  const interceptedValue = await rootMessageHandler.handleCommand({
    moduleName: "command",
    commandName: "testInterceptModule",
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  is(
    interceptedValue,
    "intercepted-value",
    "Retrieved the expected value from testInterceptModule"
  );

  rootMessageHandler.destroy();
});

// Test calling methods only implemented in the windowglobal version of a
// module.
add_task(async function test_windowglobalModule_command() {
  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;

  const rootMessageHandler = createRootMessageHandler(
    "session-id-windowglobalModule"
  );
  const windowGlobalValue = await rootMessageHandler.handleCommand({
    moduleName: "command",
    commandName: "testWindowGlobalModule",
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  is(
    windowGlobalValue,
    "windowglobal-value",
    "Retrieved the expected value from testWindowGlobalModule"
  );

  rootMessageHandler.destroy();
});

// Test calling a windowglobal module as soon as possible.
add_task(async function test_windowglobalModule_early_command() {
  const rootMessageHandler = createRootMessageHandler(
    "session-id-windowglobalModule-early"
  );

  info("Setup an observer to send a command as soon as the context is created");
  const onContext = new Promise((resolve, reject) => {
    const onContextAttached = async browsingContext => {
      try {
        const result = await rootMessageHandler.handleCommand({
          moduleName: "command",
          commandName: "testWindowGlobalModule",
          destination: {
            type: WindowGlobalMessageHandler.type,
            id: browsingContext.id,
          },
        });
        info("Early command succeeded, resolve the retrieved value");
        resolve(result);
      } catch (e) {
        info("Early command failed, reject");
        reject(e);
      } finally {
        Services.obs.removeObserver(
          onContextAttached,
          "browsing-context-attached"
        );
      }
    };
    Services.obs.addObserver(onContextAttached, "browsing-context-attached");
  });

  const tab = await addTab("https://example.com/document-builder.sjs?html=tab");

  const windowGlobalValue = await onContext;
  is(
    windowGlobalValue,
    "windowglobal-value",
    "Retrieved the expected value from testWindowGlobalModule"
  );

  rootMessageHandler.destroy();

  gBrowser.removeTab(tab);
});

// Test calling a method on a module which is only available in the "windowglobal"
// folder. This will check that the MessageHandler/ModuleCache correctly moves
// on to the next layer when no implementation can be found in the root layer.
add_task(async function test_windowglobalOnlyModule_command() {
  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;

  const rootMessageHandler = createRootMessageHandler(
    "session-id-windowglobalOnlyModule"
  );
  const windowGlobalOnlyValue = await rootMessageHandler.handleCommand({
    moduleName: "commandwindowglobalonly",
    commandName: "testOnlyInWindowGlobal",
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  is(
    windowGlobalOnlyValue,
    "only-in-windowglobal",
    "Retrieved the expected value from testOnlyInWindowGlobal"
  );

  rootMessageHandler.destroy();
});

// Try to create 2 sessions which will both set values in individual modules
// via a command `testSetValue`, and then retrieve the values via another
// command `testGetValue`.
// This will ensure that different sessions use different module instances.
add_task(async function test_multisession() {
  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;

  const rootMessageHandler1 = createRootMessageHandler(
    "session-id-multisession-1"
  );
  const rootMessageHandler2 = createRootMessageHandler(
    "session-id-multisession-2"
  );

  info("Set value for session 1");
  await rootMessageHandler1.handleCommand({
    moduleName: "command",
    commandName: "testSetValue",
    params: { value: "session1-value" },
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  info("Set value for session 2");
  await rootMessageHandler2.handleCommand({
    moduleName: "command",
    commandName: "testSetValue",
    params: { value: "session2-value" },
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  const session1Value = await rootMessageHandler1.handleCommand({
    moduleName: "command",
    commandName: "testGetValue",
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  is(
    session1Value,
    "session1-value",
    "Retrieved the expected value for session 1"
  );

  const session2Value = await rootMessageHandler2.handleCommand({
    moduleName: "command",
    commandName: "testGetValue",
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  is(
    session2Value,
    "session2-value",
    "Retrieved the expected value for session 2"
  );

  rootMessageHandler1.destroy();
  rootMessageHandler2.destroy();
});

// Test calling a method from the windowglobal-in-root module which will
// internally forward to the windowglobal module and will return a composite
// result built both in parent and content process.
add_task(async function test_forwarding_command() {
  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;

  const rootMessageHandler = createRootMessageHandler("session-id-forwarding");
  const interceptAndForwardValue = await rootMessageHandler.handleCommand({
    moduleName: "command",
    commandName: "testInterceptAndForwardModule",
    params: { id: "value" },
    destination: {
      type: WindowGlobalMessageHandler.type,
      id: browsingContextId,
    },
  });

  is(
    interceptAndForwardValue,
    "intercepted-and-forward+forward-to-windowglobal-value",
    "Retrieved the expected value from testInterceptAndForwardModule"
  );

  rootMessageHandler.destroy();
});