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);
});
