tor-browser

helper_localStorage.js (10196B)

---

/* 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/. */

// Simple tab wrapper abstracting our messaging mechanism;
class KnownTab {
 constructor(name, tab) {
   this.name = name;
   this.tab = tab;
 }

 cleanup() {
   this.tab = null;
 }
}

// Simple data structure class to help us track opened tabs and their pids.
class KnownTabs {
 constructor() {
   this.byPid = new Map();
   this.byName = new Map();
 }

 cleanup() {
   for (let key of this.byPid.keys()) {
     this.byPid[key] = null;
   }
   this.byPid = null;
   this.byName = null;
 }
}

/**
* Open our helper page in a tab in its own content process, asserting that it
* really is in its own process.  We initially load and wait for about:blank to
* load, and only then loadURI to our actual page.  This is to ensure that
* LocalStorageManager has had an opportunity to be created and populate
* mOriginsHavingData.
*
* (nsGlobalWindow will reliably create LocalStorageManager as a side-effect of
* the unconditional call to nsGlobalWindow::PreloadLocalStorage.  This will
* reliably create the StorageDBChild instance, and its corresponding
* StorageDBParent will send the set of origins when it is constructed.)
*/
async function openTestTab(
 helperPageUrl,
 name,
 knownTabs,
 shouldLoadInNewProcess
) {
 let realUrl = helperPageUrl + "?" + encodeURIComponent(name);
 // Load and wait for about:blank.
 let tab = await BrowserTestUtils.openNewForegroundTab({
   gBrowser,
   opening: "about:blank",
   forceNewProcess: true,
 });
 ok(!knownTabs.byName.has(name), "tab needs its own name: " + name);

 let knownTab = new KnownTab(name, tab);
 knownTabs.byName.set(name, knownTab);

 // Now trigger the actual load of our page.
 BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, realUrl);
 await BrowserTestUtils.browserLoaded(tab.linkedBrowser);

 let pid = tab.linkedBrowser.frameLoader.remoteTab.osPid;
 if (shouldLoadInNewProcess) {
   ok(
     !knownTabs.byPid.has(pid),
     "tab should be loaded in new process, pid: " + pid
   );
 } else {
   ok(
     knownTabs.byPid.has(pid),
     "tab should be loaded in the same process, new pid: " + pid
   );
 }

 if (knownTabs.byPid.has(pid)) {
   knownTabs.byPid.get(pid).set(name, knownTab);
 } else {
   let pidMap = new Map();
   pidMap.set(name, knownTab);
   knownTabs.byPid.set(pid, pidMap);
 }

 return knownTab;
}

/**
* Close all the tabs we opened.
*/
async function cleanupTabs(knownTabs) {
 for (let knownTab of knownTabs.byName.values()) {
   BrowserTestUtils.removeTab(knownTab.tab);
   knownTab.cleanup();
 }
 knownTabs.cleanup();
}

/**
* Wait for a LocalStorage flush to occur.  This notification can occur as a
* result of any of:
* - The normal, hardcoded 5-second flush timer.
* - InsertDBOp seeing a preload op for an origin with outstanding changes.
* - Us generating a "domstorage-test-flush-force" observer notification.
*/
function waitForLocalStorageFlush() {
 if (Services.domStorageManager.nextGenLocalStorageEnabled) {
   return new Promise(resolve => executeSoon(resolve));
 }

 return new Promise(function (resolve) {
   let observer = {
     observe() {
       SpecialPowers.removeObserver(observer, "domstorage-test-flushed");
       resolve();
     },
   };
   SpecialPowers.addObserver(observer, "domstorage-test-flushed");
 });
}

/**
* Trigger and wait for a flush.  This is only necessary for forcing
* mOriginsHavingData to be updated.  Normal operations exposed to content know
* to automatically flush when necessary for correctness.
*
* The notification we're waiting for to verify flushing is fundamentally
* ambiguous (see waitForLocalStorageFlush), so we actually trigger the flush
* twice and wait twice.  In the event there was a race, there will be 3 flush
* notifications, but correctness is guaranteed after the second notification.
*/
function triggerAndWaitForLocalStorageFlush() {
 if (Services.domStorageManager.nextGenLocalStorageEnabled) {
   return new Promise(resolve => executeSoon(resolve));
 }

 SpecialPowers.notifyObservers(null, "domstorage-test-flush-force");
 // This first wait is ambiguous...
 return waitForLocalStorageFlush().then(function () {
   // So issue a second flush and wait for that.
   SpecialPowers.notifyObservers(null, "domstorage-test-flush-force");
   return waitForLocalStorageFlush();
 });
}

/**
* Clear the origin's storage so that "OriginsHavingData" will return false for
* our origin.  Note that this is only the case for AsyncClear() which is
* explicitly issued against a cache, or AsyncClearAll() which we can trigger
* by wiping all storage.  However, the more targeted domain clearings that
* we can trigger via observer, AsyncClearMatchingOrigin and
* AsyncClearMatchingOriginAttributes will not clear the hashtable entry for
* the origin.
*
* So we explicitly access the cache here in the parent for the origin and issue
* an explicit clear.  Clearing all storage might be a little easier but seems
* like asking for intermittent failures.
*/
function clearOriginStorageEnsuringNoPreload(origin) {
 let principal =
   Services.scriptSecurityManager.createContentPrincipalFromOrigin(origin);

 if (Services.domStorageManager.nextGenLocalStorageEnabled) {
   let request = Services.qms.clearStoragesForClient(
     principal,
     "ls",
     "default"
   );
   let promise = new Promise(resolve => {
     request.callback = () => {
       resolve();
     };
   });
   return promise;
 }

 // We want to use createStorage to force the cache to be created so we can
 // issue the clear.  It's possible for getStorage to return false but for the
 // origin preload hash to still have our origin in it.
 let storage = Services.domStorageManager.createStorage(
   null,
   principal,
   principal,
   ""
 );
 storage.clear();

 // We also need to trigger a flush os that mOriginsHavingData gets updated.
 // The inherent flush race is fine here because
 return triggerAndWaitForLocalStorageFlush();
}

async function verifyTabPreload(knownTab, expectStorageExists, origin) {
 let storageExists = await SpecialPowers.spawn(
   knownTab.tab.linkedBrowser,
   [origin],
   function (origin) {
     let principal =
       Services.scriptSecurityManager.createContentPrincipalFromOrigin(origin);
     if (Services.domStorageManager.nextGenLocalStorageEnabled) {
       return Services.domStorageManager.isPreloaded(principal);
     }
     return !!Services.domStorageManager.getStorage(
       null,
       principal,
       principal
     );
   }
 );
 is(storageExists, expectStorageExists, "Storage existence === preload");
}

/**
* Instruct the given tab to execute the given series of mutations.  For
* simplicity, the mutations representation matches the expected events rep.
*/
async function mutateTabStorage(knownTab, mutations, sentinelValue) {
 await SpecialPowers.spawn(
   knownTab.tab.linkedBrowser,
   [{ mutations, sentinelValue }],
   function (args) {
     return content.wrappedJSObject.mutateStorage(Cu.cloneInto(args, content));
   }
 );
}

/**
* Instruct the given tab to add a "storage" event listener and record all
* received events.  verifyTabStorageEvents is the corresponding method to
* check and assert the recorded events.
*/
async function recordTabStorageEvents(knownTab, sentinelValue) {
 await SpecialPowers.spawn(
   knownTab.tab.linkedBrowser,
   [sentinelValue],
   function (sentinelValue) {
     return content.wrappedJSObject.listenForStorageEvents(sentinelValue);
   }
 );
}

/**
* Retrieve the current localStorage contents perceived by the tab and assert
* that they match the provided expected state.
*
* If maybeSentinel is non-null, it's assumed to be a string that identifies the
* value we should be waiting for the sentinel key to take on.  This is
* necessary because we cannot make any assumptions about when state will be
* propagated to the given process.  See the comments in
* page_localstorage_e10s.js for more context.  In general, a sentinel value is
* required for correctness unless the process in question is the one where the
* writes were performed or verifyTabStorageEvents was used.
*/
async function verifyTabStorageState(knownTab, expectedState, maybeSentinel) {
 let actualState = await SpecialPowers.spawn(
   knownTab.tab.linkedBrowser,
   [maybeSentinel],
   function (maybeSentinel) {
     return content.wrappedJSObject.getStorageState(maybeSentinel);
   }
 );

 for (let [expectedKey, expectedValue] of Object.entries(expectedState)) {
   ok(actualState.hasOwnProperty(expectedKey), "key present: " + expectedKey);
   is(actualState[expectedKey], expectedValue, "value correct");
 }
 for (let actualKey of Object.keys(actualState)) {
   if (!expectedState.hasOwnProperty(actualKey)) {
     ok(false, "actual state has key it shouldn't have: " + actualKey);
   }
 }
}

/**
* Retrieve and clear the storage events recorded by the tab and assert that
* they match the provided expected events.  For simplicity, the expected events
* representation is the same as that used by mutateTabStorage.
*
* Note that by convention for test readability we are passed a 3rd argument of
* the sentinel value, but we don't actually care what it is.
*/
async function verifyTabStorageEvents(knownTab, expectedEvents) {
 let actualEvents = await SpecialPowers.spawn(
   knownTab.tab.linkedBrowser,
   [],
   function () {
     return content.wrappedJSObject.returnAndClearStorageEvents();
   }
 );

 is(actualEvents.length, expectedEvents.length, "right number of events");
 for (let i = 0; i < actualEvents.length; i++) {
   let [actualKey, actualNewValue, actualOldValue] = actualEvents[i];
   let [expectedKey, expectedNewValue, expectedOldValue] = expectedEvents[i];
   is(actualKey, expectedKey, "keys match");
   is(actualNewValue, expectedNewValue, "new values match");
   is(actualOldValue, expectedOldValue, "old values match");
 }
}