tor-browser

browser_multie10s_update.js (5032B)

---

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