Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 147 insertions, 0 deletions

diff --git a/dom/serviceworkers/test/isolated/multi-e10s-update/browser_multie10s_update.js b/dom/serviceworkers/test/isolated/multi-e10s-update/browser_multie10s_update.js
new file mode 100644
index 0000000000..457d47863c
--- /dev/null
+++ b/dom/serviceworkers/test/isolated/multi-e10s-update/browser_multie10s_update.js
@@ -0,0 +1,147 @@
+"use strict";
+
+// Testing if 2 child processes are correctly managed when they both try to do
+// an SW update.
+
+const BASE_URI =
+  "http://mochi.test:8888/browser/dom/serviceworkers/test/isolated/multi-e10s-update/";
+
+add_task(async function test_update() {
+  info("Setting the prefs to having multi-e10s enabled");
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["dom.ipc.processCount", 4],
+      ["dom.serviceWorkers.enabled", true],
+      ["dom.serviceWorkers.testing.enabled", true],
+    ],
+  });
+
+  let url = BASE_URI + "file_multie10s_update.html";
+
+  info("Creating the first tab...");
+  let tab1 = BrowserTestUtils.addTab(gBrowser, url);
+  let browser1 = gBrowser.getBrowserForTab(tab1);
+  await BrowserTestUtils.browserLoaded(browser1);
+
+  info("Creating the second tab...");
+  let tab2 = BrowserTestUtils.addTab(gBrowser, url);
+  let browser2 = gBrowser.getBrowserForTab(tab2);
+  await BrowserTestUtils.browserLoaded(browser2);
+
+  let sw = BASE_URI + "server_multie10s_update.sjs";
+
+  info("Let's make sure there are no existing registrations...");
+  let existingCount = await SpecialPowers.spawn(
+    browser1,
+    [],
+    async function () {
+      const regs = await content.navigator.serviceWorker.getRegistrations();
+      return regs.length;
+    }
+  );
+  is(existingCount, 0, "Previous tests should have cleaned up!");
+
+  info("Let's start the test...");
+  /* eslint-disable no-shadow */
+  let status = await SpecialPowers.spawn(browser1, [sw], function (url) {
+    // Let the SW be served immediately once by triggering a relase immediately.
+    // We don't need to await this.  We do this from a frame script because
+    // it has fetch.
+    content.fetch(url + "?release");
+
+    // Registration of the SW
+    return (
+      content.navigator.serviceWorker
+        .register(url)
+
+        // Activation
+        .then(function (r) {
+          content.registration = r;
+          return new content.window.Promise(resolve => {
+            let worker = r.installing;
+            worker.addEventListener("statechange", () => {
+              if (worker.state === "installed") {
+                resolve(true);
+              }
+            });
+          });
+        })
+
+        // Waiting for the result.
+        .then(() => {
+          return new content.window.Promise(resolveResults => {
+            // Once both updates have been issued and a single update has failed, we
+            // can tell the .sjs to release a single copy of the SW script.
+            let updateCount = 0;
+            const uc = new content.window.BroadcastChannel("update");
+            // This promise tracks the updates tally.
+            const updatesIssued = new Promise(resolveUpdatesIssued => {
+              uc.onmessage = function (e) {
+                updateCount++;
+                console.log("got update() number", updateCount);
+                if (updateCount === 2) {
+                  resolveUpdatesIssued();
+                }
+              };
+            });
+
+            let results = [];
+            const rc = new content.window.BroadcastChannel("result");
+            // This promise resolves when an update has failed.
+            const oneFailed = new Promise(resolveOneFailed => {
+              rc.onmessage = function (e) {
+                console.log("got result", e.data);
+                results.push(e.data);
+                if (e.data === 1) {
+                  resolveOneFailed();
+                }
+                if (results.length != 2) {
+                  return;
+                }
+
+                resolveResults(results[0] + results[1]);
+              };
+            });
+
+            Promise.all([updatesIssued, oneFailed]).then(() => {
+              console.log("releasing update");
+              content.fetch(url + "?release").catch(ex => {
+                console.error("problem releasing:", ex);
+              });
+            });
+
+            // Let's inform the tabs.
+            const sc = new content.window.BroadcastChannel("start");
+            sc.postMessage("go");
+          });
+        })
+    );
+  });
+  /* eslint-enable no-shadow */
+
+  if (status == 0) {
+    ok(false, "both succeeded. This is wrong.");
+  } else if (status == 1) {
+    ok(true, "one succeded, one failed. This is good.");
+  } else {
+    ok(false, "both failed. This is definitely wrong.");
+  }
+
+  // let's clean up the registration and get the fetch count.  The count
+  // should be 1 for the initial fetch and 1 for the update.
+  /* eslint-disable no-shadow */
+  const count = await SpecialPowers.spawn(browser1, [sw], async function (url) {
+    // We stored the registration on the frame script's wrapper, hence directly
+    // accesss content without using wrappedJSObject.
+    await content.registration.unregister();
+    const { count } = await content
+      .fetch(url + "?get-and-clear-count")
+      .then(r => r.json());
+    return count;
+  });
+  /* eslint-enable no-shadow */
+  is(count, 2, "SW should have been fetched only twice");
+
+  BrowserTestUtils.removeTab(tab1);
+  BrowserTestUtils.removeTab(tab2);
+});