sousa-gecko/devtools/server/tests/browser/browser_storage_dynamic_windows.js

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

"use strict";

Services.scriptloader.loadSubScript(
  "chrome://mochitests/content/browser/devtools/server/tests/browser/storage-helpers.js",
  this
);

// beforeReload references an object representing the initialized state of the
// storage actor.
const beforeReload = {
  cookies: {
    "http://test1.example.org": ["c1", "cs2", "c3", "uc1"],
    "http://sectest1.example.org": ["uc1", "cs2"],
  },
  "indexed-db": {
    "http://test1.example.org": [
      JSON.stringify(["idb1", "obj1"]),
      JSON.stringify(["idb1", "obj2"]),
      JSON.stringify(["idb2", "obj3"]),
    ],
    "http://sectest1.example.org": [],
  },
  "local-storage": {
    "http://test1.example.org": ["ls1", "ls2"],
    "http://sectest1.example.org": ["iframe-u-ls1"],
  },
  "session-storage": {
    "http://test1.example.org": ["ss1"],
    "http://sectest1.example.org": ["iframe-u-ss1", "iframe-u-ss2"],
  },
};

// afterIframeAdded references the items added when an iframe containing storage
// items is added to the page.
const afterIframeAdded = {
  cookies: {
    "https://sectest1.example.org": [
      getCookieId("cs2", ".example.org", "/"),
      getCookieId(
        "sc1",
        "sectest1.example.org",
        "/browser/devtools/server/tests/browser"
      ),
    ],
    "http://sectest1.example.org": [
      getCookieId(
        "sc1",
        "sectest1.example.org",
        "/browser/devtools/server/tests/browser"
      ),
    ],
  },
  "indexed-db": {
    // empty because indexed db creation happens after the page load, so at
    // the time of window-ready, there was no indexed db present.
    "https://sectest1.example.org": [],
  },
  "local-storage": {
    "https://sectest1.example.org": ["iframe-s-ls1"],
  },
  "session-storage": {
    "https://sectest1.example.org": ["iframe-s-ss1"],
  },
};

// afterIframeRemoved references the items deleted when an iframe containing
// storage items is removed from the page.
const afterIframeRemoved = {
  cookies: {
    "http://sectest1.example.org": [],
  },
  "indexed-db": {
    "http://sectest1.example.org": [],
  },
  "local-storage": {
    "http://sectest1.example.org": [],
  },
  "session-storage": {
    "http://sectest1.example.org": [],
  },
};

add_task(async function () {
  const { commands } = await openTabAndSetupStorage(
    MAIN_DOMAIN + "storage-dynamic-windows.html"
  );

  const { resourceCommand } = commands;
  const { TYPES } = resourceCommand;
  const allResources = {};
  const onAvailable = resources => {
    for (const resource of resources) {
      is(
        resource.targetFront.targetType,
        commands.targetCommand.TYPES.FRAME,
        "Each storage resource has a valid 'targetFront' attribute"
      );
      // Because we have iframes, we have distinct targets, each spawning their own storage resource
      if (allResources[resource.resourceType]) {
        allResources[resource.resourceType].push(resource);
      } else {
        allResources[resource.resourceType] = [resource];
      }
    }
  };
  const parentProcessStorages = [TYPES.COOKIE, TYPES.INDEXED_DB];
  const contentProcessStorages = [TYPES.LOCAL_STORAGE, TYPES.SESSION_STORAGE];
  const allStorages = [...parentProcessStorages, ...contentProcessStorages];
  await resourceCommand.watchResources(allStorages, { onAvailable });
  is(
    Object.keys(allStorages).length,
    allStorages.length,
    "Got all the storage resources"
  );

  // Do a copy of all the initial storages as test function may spawn new resources for the same
  // type and override the initial ones.
  // We do not call unwatchResources as it would clear its cache and next call
  // to watchResources with ignoreExistingResources would break and reprocess all resources again.
  const initialResources = Object.assign({}, allResources);

  testWindowsBeforeReload(initialResources);

  await testAddIframe(commands, initialResources, {
    contentProcessStorages,
    parentProcessStorages,
  });

  await testRemoveIframe(commands, initialResources, {
    contentProcessStorages,
    parentProcessStorages,
  });

  await clearStorage();

  // Forcing GC/CC to get rid of docshells and windows created by this test.
  forceCollections();
  await commands.destroy();
  forceCollections();
});

function testWindowsBeforeReload(resources) {
  for (const storageType in beforeReload) {
    ok(resources[storageType], `${storageType} storage actor is present`);

    const hosts = {};
    for (const resource of resources[storageType]) {
      for (const [hostType, hostValues] of Object.entries(resource.hosts)) {
        if (!hosts[hostType]) {
          hosts[hostType] = [];
        }

        hosts[hostType].push(hostValues);
      }
    }

    // If this test is run with chrome debugging enabled we get an extra
    // key for "chrome". We don't want the test to fail in this case, so
    // ignore it.
    if (storageType == "indexedDB") {
      delete hosts.chrome;
    }

    is(
      Object.keys(hosts).length,
      Object.keys(beforeReload[storageType]).length,
      `Number of hosts for ${storageType} match`
    );
    for (const host in beforeReload[storageType]) {
      ok(hosts[host], `Host ${host} is present`);
    }
  }
}

/**
 * Wait for new storage resources to be created of the given types.
 */
async function waitForNewResourcesAndUpdates(commands, resourceTypes) {
  // When fission is off, we don't expect any new resource
  if (resourceTypes.length === 0) {
    return { newResources: [], updates: [] };
  }
  const { resourceCommand } = commands;
  let resolve;
  const promise = new Promise(r => (resolve = r));
  const allResources = {};
  const allUpdates = {};
  const onAvailable = resources => {
    for (const resource of resources) {
      if (resource.resourceType in allResources) {
        ok(false, `Got multiple ${resource.resourceTypes} resources`);
      }
      allResources[resource.resourceType] = resource;
      ok(true, `Got resource for ${resource.resourceType}`);

      // Stop watching for resources when we got them all
      if (Object.keys(allResources).length == resourceTypes.length) {
        resourceCommand.unwatchResources(resourceTypes, {
          onAvailable,
        });
      }

      // But also listen for updates on each new resource
      resource.once("single-store-update").then(update => {
        ok(true, `Got updates for ${resource.resourceType}`);
        allUpdates[resource.resourceType] = update;

        // Resolve only once we got all the updates, for all the resources
        if (Object.keys(allUpdates).length == resourceTypes.length) {
          resolve({ newResources: allResources, updates: allUpdates });
        }
      });
    }
  };
  await resourceCommand.watchResources(resourceTypes, {
    onAvailable,
    ignoreExistingResources: true,
  });
  return promise;
}

/**
 * Wait for single-store-update events on all the given storage resources.
 */
function waitForResourceUpdates(resources, resourceTypes) {
  const allUpdates = {};
  const promises = [];
  for (const type of resourceTypes) {
    // Resolves once any of the many resources for the given storage type updates
    const promise = Promise.any(
      resources[type].map(resource => resource.once("single-store-update"))
    );
    promise.then(update => {
      ok(true, `Got updates for ${type}`);
      allUpdates[type] = update;
    });
    promises.push(promise);
  }
  return Promise.all(promises).then(() => allUpdates);
}

async function testAddIframe(
  commands,
  resources,
  { contentProcessStorages, parentProcessStorages }
) {
  info("Testing if new iframe addition works properly");

  // Expect:
  // - new resources alongside single-store-update events for content process storages
  // - only single-store-update events for previous resources for parent process storages
  const onResources = waitForNewResourcesAndUpdates(
    commands,
    contentProcessStorages
  );
  const onUpdates = waitForResourceUpdates(resources, parentProcessStorages);

  await SpecialPowers.spawn(
    gBrowser.selectedBrowser,
    [ALT_DOMAIN_SECURED],
    secured => {
      const doc = content.document;

      const iframe = doc.createElement("iframe");
      iframe.src = secured + "storage-secured-iframe.html";

      doc.querySelector("body").appendChild(iframe);
    }
  );

  info("Wait for all resources");
  const { newResources, updates } = await onResources;
  info("Wait for all updates");
  const previousResourceUpdates = await onUpdates;

  for (const resourceType of contentProcessStorages) {
    const resource = newResources[resourceType];
    const expected = afterIframeAdded[resourceType];
    // The resource only comes with hosts, without any values.
    // Each host will be an empty array.
    Assert.deepEqual(
      Object.keys(resource.hosts),
      Object.keys(expected),
      `List of hosts for resource ${resourceType} is correct`
    );
    for (const host in resource.hosts) {
      is(
        resource.hosts[host].length,
        0,
        "For new resources, each host has no value and is an empty array"
      );
    }
    const update = updates[resourceType];
    const storageKey = resourceTypeToStorageKey(resourceType);
    Assert.deepEqual(
      update.added[storageKey],
      expected,
      "We get an update after the resource, with the host values"
    );
  }

  for (const resourceType of parentProcessStorages) {
    const expected = afterIframeAdded[resourceType];
    const update = previousResourceUpdates[resourceType];
    const storageKey = resourceTypeToStorageKey(resourceType);
    Assert.deepEqual(
      update.added[storageKey],
      expected,
      `We get an update after the resource ${resourceType}, with the host values`
    );
  }

  return newResources;
}

async function testRemoveIframe(
  commands,
  resources,
  { contentProcessStorages, parentProcessStorages }
) {
  info("Testing if iframe removal works properly");

  // We only get updates for parent process storages, content process storage
  // resources are wiped via their related target destruction.
  const onUpdates = waitForResourceUpdates(resources, parentProcessStorages);

  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => {
    for (const iframe of content.document.querySelectorAll("iframe")) {
      if (iframe.src.startsWith("http:")) {
        iframe.remove();
        break;
      }
    }
  });

  info("Wait for all updates");
  const previousResourceUpdates = await onUpdates;

  for (const resourceType of parentProcessStorages) {
    const expected = afterIframeRemoved[resourceType];
    const update = previousResourceUpdates[resourceType];
    const storageKey = resourceTypeToStorageKey(resourceType);
    Assert.deepEqual(
      update.deleted[storageKey],
      expected,
      `We get an update after the resource ${resourceType}, with the host values`
    );
  }

  // The iframe target is destroyed, which ends up destroying related resources
  const destroyedResourceTypes = [];
  for (const storageType in resources) {
    for (const resource of resources[storageType]) {
      if (resource.isDestroyed()) {
        destroyedResourceTypes.push(resource.resourceType);
      }
    }
  }
  Assert.deepEqual(
    destroyedResourceTypes.sort(),
    contentProcessStorages.sort(),
    "Content process storage resources have been destroyed [local and session storages]"
  );
}

/**
 * single-store-update emits objects using attributes with old "storage key" namings,
 * which is different from resource type namings.
 */
function resourceTypeToStorageKey(resourceType) {
  if (resourceType == "local-storage") {
    return "localStorage";
  }
  if (resourceType == "session-storage") {
    return "sessionStorage";
  }
  if (resourceType == "indexed-db") {
    return "indexedDB";
  }
  return resourceType;
}