path: root/dom/tests/browser/browser_localStorage_fis.js

const HELPER_PAGE_URL =
  "https://example.com/browser/dom/tests/browser/page_localstorage.html";
const HELPER_PAGE_COOP_COEP_URL =
  "https://example.com/browser/dom/tests/browser/page_localstorage_coop+coep.html";
const HELPER_PAGE_ORIGIN = "https://example.com/";

let testDir = gTestPath.substr(0, gTestPath.lastIndexOf("/"));
Services.scriptloader.loadSubScript(testDir + "/helper_localStorage.js", this);

/* import-globals-from helper_localStorage.js */

// We spin up a ton of child processes.
requestLongerTimeout(4);

/**
 * Verify the basics of our multi-e10s localStorage support with fission.
 * We are focused on whitebox testing two things.
 * When this is being written, broadcast filtering is not in place, but the test
 * is intended to attempt to verify that its implementation does not break things.
 *
 * 1) That pages see the same localStorage state in a timely fashion when
 *    engaging in non-conflicting operations.  We are not testing races or
 *    conflict resolution; the spec does not cover that.
 *
 * 2) That there are no edge-cases related to when the Storage instance is
 *    created for the page or the StorageCache for the origin.  (StorageCache is
 *    what actually backs the Storage binding exposed to the page.)  This
 *    matters because the following reasons can exist for them to be created:
 *    - Preload, on the basis of knowing the origin uses localStorage.  The
 *      interesting edge case is when we have the same origin open in different
 *      processes and the origin starts using localStorage when it did not
 *      before.  Preload will not have instantiated bindings, which could impact
 *      correctness.
 *    - The page accessing localStorage for read or write purposes.  This is the
 *      obvious, boring one.
 *    - The page adding a "storage" listener.  This is less obvious and
 *      interacts with the preload edge-case mentioned above.  The page needs to
 *      hear "storage" events even if the page has not touched localStorage
 *      itself and its origin had nothing stored in localStorage when the page
 *      was created.
 *
 * According to current fission implementation, same origin pages will be loaded
 * by the same process, which process type is webIsolated=. And thanks to
 * Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers support,
 * it is possible to load the same origin page by a special process, which type
 * is webCOOP+COEP=. These are the only two processes can be used to test
 * localStroage consistency between tabs in different tabs.
 *
 * We use the two child pages for testing, page_localstorage.html and
 * page_localstorage_coop+coep.html. Their content are the same, but
 * page_localstorage_coop+coep.html will be loaded with its ^headers^ file.
 * These pages provide followings
 * - can be instructed to listen for and record "storage" events
 * - can be instructed to issue a series of localStorage writes
 * - can be instructed to return the current entire localStorage contents
 *
 * To test localStorage consistency, four subtests are used.
 * Test case 1: one writer tab and one reader tab
 *   The writer tab issues a series of write operations, then verify the
 *   localStorage contents from the reader tab.
 *
 * Test case 2: one writer tab and one listener tab
 *   The writer tab issues a series of write operations, then verify the recorded
 *   storage events from the listener tab.
 *
 * Test case 3: one writeThenRead tab and one readThenWrite tab
 *   The writeThenRead first issues a series write of operations, and then verify
 *   the recorded storage events and localStorage contents from readThenWrite
 *   tab. After that readThenWrite tab issues a series of write operations, then
 *   verify the results from writeThenRead tab.
 *
 * Test case 4: one writer tab and one lateOpenSeesPreload tab
 *   The writer tab issues a series write of operations. Then open the
 *   lateOpenSeesPreload tab to make sure preloads exists.
 */

/**
 * Shared constants for test cases
 */
const noSentinelCheck = null;
const initialSentinel = "initial";
const initialWriteMutations = [
  // [key (null=clear), newValue (null=delete), oldValue (verification)]
  ["getsCleared", "1", null],
  ["alsoGetsCleared", "2", null],
  [null, null, null],
  ["stays", "3", null],
  ["clobbered", "pre", null],
  ["getsDeletedLater", "4", null],
  ["getsDeletedImmediately", "5", null],
  ["getsDeletedImmediately", null, "5"],
  ["alsoStays", "6", null],
  ["getsDeletedLater", null, "4"],
  ["clobbered", "post", "pre"],
];
const initialWriteState = {
  stays: "3",
  clobbered: "post",
  alsoStays: "6",
};

const lastWriteSentinel = "lastWrite";
const lastWriteMutations = [
  ["lastStays", "20", null],
  ["lastDeleted", "21", null],
  ["lastClobbered", "lastPre", null],
  ["lastClobbered", "lastPost", "lastPre"],
  ["lastDeleted", null, "21"],
];
const lastWriteState = Object.assign({}, initialWriteState, {
  lastStays: "20",
  lastClobbered: "lastPost",
});

/**
 * Test case 1: one writer tab and one reader tab
 * Test steps
 *   1. Clear origin storage to make sure no data and preloads.
 *   2. Open the writer and reader tabs and verify preloads do not exist.
 *      Open writer tab in webIsolated= process
 *      Open reader tab in webCOOP+COEP= process
 *   3. Issue a series write operations in the writer tab, and then verify the
 *      storage state on the tab.
 *   4. Verify the storage state on the reader tab.
 *   5. Issue another series write operations in the writer tab, and then verify
 *      the storage state on the tab.
 *   6. Verify the storage state on the reader tab.
 *   7. Close tabs and clear origin storage.
 */
add_task(async function () {
  if (!Services.domStorageManager.nextGenLocalStorageEnabled) {
    ok(true, "Test ignored when the next gen local storage is not enabled.");
    return;
  }

  await SpecialPowers.pushPrefEnv({
    set: [
      // Stop the preallocated process manager from speculatively creating
      // processes.  Our test explicitly asserts on whether preload happened or
      // not for each tab's process.  This information is loaded and latched by
      // the StorageDBParent constructor which the child process's
      // LocalStorageManager() constructor causes to be created via a call to
      // LocalStorageCache::StartDatabase().  Although the service is lazily
      // created and should not have been created prior to our opening the tab,
      // it's safest to ensure the process simply didn't exist before we ask for
      // it.
      //
      // This is done in conjunction with our use of forceNewProcess when
      // opening tabs.  There would be no point if we weren't also requesting a
      // new process.
      ["dom.ipc.processPrelaunch.enabled", false],
      // Enable LocalStorage's testing API so we can explicitly trigger a flush
      // when needed.
      ["dom.storage.testing", true],
    ],
  });

  // Ensure that there is no localstorage data or potential false positives for
  // localstorage preloads by forcing the origin to be cleared prior to the
  // start of our test.
  await clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);

  // Make sure mOriginsHavingData gets updated.
  await triggerAndWaitForLocalStorageFlush();

  // - Open tabs.  Don't configure any of them yet.
  const knownTabs = new KnownTabs();
  const writerTab = await openTestTab(
    HELPER_PAGE_URL,
    "writer",
    knownTabs,
    true
  );
  const readerTab = await openTestTab(
    HELPER_PAGE_COOP_COEP_URL,
    "reader",
    knownTabs,
    true
  );
  // Sanity check that preloading did not occur in the tabs.
  await verifyTabPreload(writerTab, false, HELPER_PAGE_ORIGIN);
  await verifyTabPreload(readerTab, false, HELPER_PAGE_ORIGIN);

  // - Issue the initial batch of writes and verify.
  info("initial writes");
  await mutateTabStorage(writerTab, initialWriteMutations, initialSentinel);

  // We expect the writer tab to have the correct state because it just did the
  // writes.  We do not perform a sentinel-check because the writes should be
  // locally available and consistent.
  await verifyTabStorageState(writerTab, initialWriteState, noSentinelCheck);
  // We expect the reader tab to retrieve the current localStorage state from
  // the database.
  await verifyTabStorageState(readerTab, initialWriteState, initialSentinel);

  // - Issue last set of writes from writerTab.
  info("last set of writes");
  await mutateTabStorage(writerTab, lastWriteMutations, lastWriteSentinel);

  // The writer performed the writes, no need to wait for the sentinel.
  await verifyTabStorageState(writerTab, lastWriteState, noSentinelCheck);
  // We need to wait for the sentinel to show up for the reader.
  await verifyTabStorageState(readerTab, lastWriteState, lastWriteSentinel);

  // - Clean up.
  await cleanupTabs(knownTabs);

  clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);
});

/**
 * Test case 2: one writer tab and one linsener tab
 * Test steps
 *   1. Clear origin storage to make sure no data and preloads.
 *   2. Open the writer and listener tabs and verify preloads do not exist.
 *      Open writer tab in webIsolated= process
 *      Open listener tab in webCOOP+COEP= process
 *   3. Ask the listener tab to listen and record storage events.
 *   4. Issue a series write operations in the writer tab, and then verify the
 *      storage state on the tab.
 *   5. Verify the storage events record from the listener tab is as expected.
 *   6. Verify the storage state on the listener tab.
 *   7. Ask the listener tab to listen and record storage events.
 *   8. Issue another series write operations in the writer tab, and then verify
 *      the storage state on the tab.
 *   9. Verify the storage events record from the listener tab is as expected.
 *   10. Verify the storage state on the listener tab.
 *   11. Close tabs and clear origin storage.
 */
add_task(async function () {
  if (!Services.domStorageManager.nextGenLocalStorageEnabled) {
    ok(true, "Test ignored when the next gen local storage is not enabled.");
    return;
  }

  await SpecialPowers.pushPrefEnv({
    set: [
      ["dom.ipc.processPrelaunch.enabled", false],
      ["dom.storage.testing", true],
    ],
  });

  // Ensure that there is no localstorage data or potential false positives for
  // localstorage preloads by forcing the origin to be cleared prior to the
  // start of our test.
  await clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);

  // Make sure mOriginsHavingData gets updated.
  await triggerAndWaitForLocalStorageFlush();

  // - Open tabs.  Don't configure any of them yet.
  const knownTabs = new KnownTabs();
  const writerTab = await openTestTab(
    HELPER_PAGE_URL,
    "writer",
    knownTabs,
    true
  );
  const listenerTab = await openTestTab(
    HELPER_PAGE_COOP_COEP_URL,
    "listener",
    knownTabs,
    true
  );
  // Sanity check that preloading did not occur in the tabs.
  await verifyTabPreload(writerTab, false, HELPER_PAGE_ORIGIN);
  await verifyTabPreload(listenerTab, false, HELPER_PAGE_ORIGIN);

  // - Ask the listener tab to listen and record the storage events..
  await recordTabStorageEvents(listenerTab, initialSentinel);

  // - Issue the initial batch of writes and verify.
  info("initial writes");
  await mutateTabStorage(writerTab, initialWriteMutations, initialSentinel);

  // We expect the writer tab to have the correct state because it just did the
  // writes.  We do not perform a sentinel-check because the writes should be
  // locally available and consistent.
  await verifyTabStorageState(writerTab, initialWriteState, noSentinelCheck);
  // We expect the listener tab to have heard all events despite preload not
  // having occurred and despite not issuing any reads or writes itself.  We
  // intentionally check the events before the state because we're most
  // interested in adding the listener having had a side-effect of subscribing
  // to changes for the process.
  //
  // We ensure it had a chance to hear all of the events because we told
  // recordTabStorageEvents to listen for the given sentinel.  The state check
  // then does not need to do a sentinel check.
  await verifyTabStorageEvents(
    listenerTab,
    initialWriteMutations,
    initialSentinel
  );
  await verifyTabStorageState(listenerTab, initialWriteState, noSentinelCheck);

  // - Ask the listener tab to listen and record the storage events.
  await recordTabStorageEvents(listenerTab, lastWriteSentinel);

  // - Issue last set of writes from writerTab.
  info("last set of writes");
  await mutateTabStorage(writerTab, lastWriteMutations, lastWriteSentinel);

  // The writer performed the writes, no need to wait for the sentinel.
  await verifyTabStorageState(writerTab, lastWriteState, noSentinelCheck);
  // Wait for the sentinel event to be received, then check.
  await verifyTabStorageEvents(
    listenerTab,
    lastWriteMutations,
    lastWriteSentinel
  );
  await verifyTabStorageState(listenerTab, lastWriteState, noSentinelCheck);

  // - Clean up.
  await cleanupTabs(knownTabs);

  clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);
});

/**
 * Test case 3: one writeThenRead tab and one readThenWrite tab
 * Test steps
 *   1. Clear origin storage to make sure no data and preloads.
 *   2. Open the writeThenRead and readThenWrite tabs and verify preloads do not
 *      exist.
 *      Open writeThenRead tab in webIsolated= process
 *      Open readThenWrite tab in webCOOP+COEP= process
 *   3. Ask the readThenWrite tab to listen and record storage events.
 *   4. Issue a series write operations in the writeThenRead tab, and then verify
 *      the storage state on the tab.
 *   5. Verify the storage events record from the readThenWrite tab is as
 *      expected.
 *   6. Verify the storage state on the readThenWrite tab.
 *   7. Ask the writeThenRead tab to listen and record storage events.
 *   8. Issue another series write operations in the readThenWrite tab, and then
 *      verify the storage state on the tab.
 *   9. Verify the storage events record from the writeThenRead tab is as
 *      expected.
 *   10. Verify the storage state on the writeThenRead tab.
 *   11. Close tabs and clear origin storage.
 **/
add_task(async function () {
  if (!Services.domStorageManager.nextGenLocalStorageEnabled) {
    ok(true, "Test ignored when the next gen local storage is not enabled.");
    return;
  }

  await SpecialPowers.pushPrefEnv({
    set: [
      ["dom.ipc.processPrelaunch.enabled", false],
      ["dom.storage.testing", true],
    ],
  });

  // Ensure that there is no localstorage data or potential false positives for
  // localstorage preloads by forcing the origin to be cleared prior to the
  // start of our test.
  await clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);

  // Make sure mOriginsHavingData gets updated.
  await triggerAndWaitForLocalStorageFlush();

  // - Open tabs.  Don't configure any of them yet.
  const knownTabs = new KnownTabs();
  const writeThenReadTab = await openTestTab(
    HELPER_PAGE_URL,
    "writerthenread",
    knownTabs,
    true
  );
  const readThenWriteTab = await openTestTab(
    HELPER_PAGE_COOP_COEP_URL,
    "readthenwrite",
    knownTabs,
    true
  );
  // Sanity check that preloading did not occur in the tabs.
  await verifyTabPreload(writeThenReadTab, false, HELPER_PAGE_ORIGIN);
  await verifyTabPreload(readThenWriteTab, false, HELPER_PAGE_ORIGIN);

  // - Ask readThenWrite tab to listen and record storageEvents.
  await recordTabStorageEvents(readThenWriteTab, initialSentinel);

  // - Issue the initial batch of writes and verify.
  info("initial writes");
  await mutateTabStorage(
    writeThenReadTab,
    initialWriteMutations,
    initialSentinel
  );

  // We expect the writer tab to have the correct state because it just did the
  // writes.  We do not perform a sentinel-check because the writes should be
  // locally available and consistent.
  await verifyTabStorageState(
    writeThenReadTab,
    initialWriteState,
    noSentinelCheck
  );

  // We expect the listener tab to have heard all events despite preload not
  // having occurred and despite not issuing any reads or writes itself.  We
  // intentionally check the events before the state because we're most
  // interested in adding the listener having had a side-effect of subscribing
  // to changes for the process.
  //
  // We ensure it had a chance to hear all of the events because we told
  // recordTabStorageEvents to listen for the given sentinel.  The state check
  // then does not need to do a sentinel check.
  await verifyTabStorageEvents(
    readThenWriteTab,
    initialWriteMutations,
    initialSentinel
  );
  await verifyTabStorageState(
    readThenWriteTab,
    initialWriteState,
    noSentinelCheck
  );

  // - Issue last set of writes from writerTab.
  info("last set of writes");
  await recordTabStorageEvents(writeThenReadTab, lastWriteSentinel);

  await mutateTabStorage(
    readThenWriteTab,
    lastWriteMutations,
    lastWriteSentinel
  );

  // The writer performed the writes, no need to wait for the sentinel.
  await verifyTabStorageState(
    readThenWriteTab,
    lastWriteState,
    noSentinelCheck
  );
  // Wait for the sentinel event to be received, then check.
  await verifyTabStorageEvents(
    writeThenReadTab,
    lastWriteMutations,
    lastWriteSentinel
  );
  await verifyTabStorageState(
    writeThenReadTab,
    lastWriteState,
    noSentinelCheck
  );

  // - Clean up.
  await cleanupTabs(knownTabs);

  clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);
});

/**
 * Test case 4: one writerRead tab and one lateOpenSeesPreload tab
 * Test steps
 *   1. Clear origin storage to make sure no data and preloads.
 *   2. Open the writer tab and verify preloads do not exist.
 *      Open writer tab in webIsolated= process
 *   3. Issue a series write operations in the writer tab, and then verify the
 *      storage state on the tab.
 *   4. Issue another series write operations in the writer tab, and then verify
 *      the storage state on the tab.
 *   5. Open lateOpenSeesPreload tab in webCOOP+COEP process
 *   6. Verify the preloads on the lateOpenSeesPreload tab
 *   7. Close tabs and clear origin storage.
 */
add_task(async function () {
  await SpecialPowers.pushPrefEnv({
    set: [
      ["dom.ipc.processPrelaunch.enabled", false],
      ["dom.storage.testing", true],
    ],
  });

  // Ensure that there is no localstorage data or potential false positives for
  // localstorage preloads by forcing the origin to be cleared prior to the
  // start of our test.
  await clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);

  // Make sure mOriginsHavingData gets updated.
  await triggerAndWaitForLocalStorageFlush();

  // - Open tabs.  Don't configure any of them yet.
  const knownTabs = new KnownTabs();
  const writerTab = await openTestTab(
    HELPER_PAGE_URL,
    "writer",
    knownTabs,
    true
  );
  // Sanity check that preloading did not occur in the tabs.
  await verifyTabPreload(writerTab, false, HELPER_PAGE_ORIGIN);

  // - Configure the tabs.

  // - Issue the initial batch of writes and verify.
  info("initial writes");
  await mutateTabStorage(writerTab, initialWriteMutations, initialSentinel);

  // We expect the writer tab to have the correct state because it just did the
  // writes.  We do not perform a sentinel-check because the writes should be
  // locally available and consistent.
  await verifyTabStorageState(writerTab, initialWriteState, noSentinelCheck);

  // - Force a LocalStorage DB flush so mOriginsHavingData is updated.
  // mOriginsHavingData is only updated when the storage thread runs its
  // accumulated operations during the flush.  If we don't initiate and ensure
  // that a flush has occurred before moving on to the next step,
  // mOriginsHavingData may not include our origin when it's sent down to the
  // child process.
  info("flush to make preload check work");
  await triggerAndWaitForLocalStorageFlush();

  // - Open a fresh tab and make sure it sees the precache/preload
  info("late open preload check");
  const lateOpenSeesPreload = await openTestTab(
    HELPER_PAGE_COOP_COEP_URL,
    "lateOpenSeesPreload",
    knownTabs,
    true
  );
  await verifyTabPreload(lateOpenSeesPreload, true, HELPER_PAGE_ORIGIN);

  // - Clean up.
  await cleanupTabs(knownTabs);

  clearOriginStorageEnsuringNoPreload(HELPER_PAGE_ORIGIN);
});