sousa-gecko/dom/workers/test/test_WorkerDebugger.xhtml

<?xml version="1.0"?>
<!--
  Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/
-->
<window title="Test for WorkerDebugger"
        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">

  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
  <script src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/>
  <script type="application/javascript" src="dom_worker_helper.js"/>

  <script type="application/javascript">
  <![CDATA[

    const WORKER_URL = "WorkerDebugger_worker.js";
    const CHILD_WORKER_URL = "WorkerDebugger_childWorker.js";
    const SHARED_WORKER_URL = "WorkerDebugger_sharedWorker.js";

    addTaskWithBothWorkerDebuggers(
      async function runTest() {
        info("Create a top-level chrome worker that creates a non-top-level " +
             "content worker and wait for their debuggers to be registered.");
        let promise = waitForMultiple([
          waitForRegister(WORKER_URL),
          waitForRegister(CHILD_WORKER_URL)
        ]);
        worker = new ChromeWorker(WORKER_URL, { name: "worker name" });
        let [dbg, childDbg] = await promise;

        info("Check that the top-level chrome worker debugger has the " +
             "correct properties.");
        is(dbg.isChrome, true,
           "Chrome worker debugger should be chrome.");
        is(dbg.parent, null,
           "Top-level debugger should not have parent.");
        is(dbg.type, Ci.nsIWorkerDebugger.TYPE_DEDICATED,
           "Chrome worker debugger should be dedicated.");
        if (dbg.isRemote) {
          // A remote worker debugger lives in the parent process and has no
          // window object there; consumers use windowIDs instead (bug 1944240).
          is(dbg.window, null,
             "Remote top-level worker debugger has no window in the parent.");
        } else {
          is(dbg.window, window,
             "Top-level dedicated worker debugger should have window.");
        }
        is(dbg.name, "worker name",
           "Top-level worker name is exposed via name attribute.");

        info("Check that the non-top-level content worker debugger has the " +
             "correct properties.");
        is(childDbg.isChrome, false,
           "Content worker debugger should be content.");
        is(childDbg.parent, dbg,
           "Non-top-level worker debugger should have parent.");
        is(childDbg.type, Ci.nsIWorkerDebugger.TYPE_DEDICATED,
           "Content worker debugger should be dedicated.");
        if (childDbg.isRemote) {
          is(childDbg.window, null,
             "Remote non-top-level worker debugger has no window in the parent.");
        } else {
          is(childDbg.window, window,
             "Non-top-level worker debugger should have window.");
        }
        is(childDbg.name, "",
           "Non-top-level worker doesn't have a custom name");

        info("Terminate the top-level chrome worker and the non-top-level " +
             "content worker, and wait for their debuggers to be " +
             "unregistered and closed.");
        promise = waitForMultiple([
          waitForUnregister(CHILD_WORKER_URL),
          waitForDebuggerClose(childDbg),
          waitForUnregister(WORKER_URL),
          waitForDebuggerClose(dbg),
        ]);
        worker.terminate();
        await promise;

        info("Create a shared worker and wait for its debugger to be " +
             "registered");
        promise = waitForRegister(SHARED_WORKER_URL);
        worker = new SharedWorker(SHARED_WORKER_URL);
        let sharedDbg = await promise;

        info("Check that the shared worker debugger has the correct " +
             "properties.");
        is(sharedDbg.isChrome, false,
           "Shared worker debugger should be content.");
        is(sharedDbg.parent, null,
           "Shared worker debugger should not have parent.");
        is(sharedDbg.type, Ci.nsIWorkerDebugger.TYPE_SHARED,
           "Shared worker debugger should be shared.");
        is(sharedDbg.window, null,
           "Shared worker debugger should not have window.");

        info("Create a shared worker with the same URL and check that its " +
             "debugger is not registered again.");
        let listener = {
          onRegistered () {
            ok(false,
               "Shared worker debugger should not be registered again.");
          },
        };
        wdm.addListener(listener);

        let secondWorker = new SharedWorker(SHARED_WORKER_URL);

        info("Send a message to the shared worker to tell it to close " +
             "itself, and wait for its debugger to be closed.");
        promise = waitForMultiple([
          waitForUnregister(SHARED_WORKER_URL),
          waitForDebuggerClose(sharedDbg)
        ]);
        secondWorker.port.start();
        secondWorker.port.postMessage("close");
        await promise;
        worker = null;
        secondWorker = null;

        info("Create a SharedWorker again for the infinite loop test.")
        promise = waitForRegister(SHARED_WORKER_URL);
        // Give it an explicit name so we don't reuse the above SharedWorker.
        worker = new SharedWorker(SHARED_WORKER_URL, "loopy");
        sharedDbg = await promise;

        info("Send a message to the shared worker to tell it to close " +
             "itself, then loop forever, and wait for its debugger to be closed.");
        promise = waitForMultiple([
          waitForUnregister(SHARED_WORKER_URL),
          waitForDebuggerClose(sharedDbg)
        ]);

        // When the closing process begins, we schedule a timer to terminate
        // the worker in case it's in an infinite loop, which is exactly what
        // we do in this test.  The default delay is 30 seconds.  This test
        // previously waited 15 seconds for reasons that were poorly justified.
        // We now set it to 100ms because we just want to make sure that the
        // timeout mechanism to force cancellation from the parent properly
        // works (as long as the parent thread isn't blocked).
        await SpecialPowers.pushPrefEnv({"set": [[ "dom.worker.canceling.timeoutMilliseconds", 100 ]]});

        worker.port.start();
        worker.port.postMessage("close_loop");
        await promise;

        wdm.removeListener(listener);
      }
    );

  ]]>
  </script>

  <body xmlns="http://www.w3.org/1999/xhtml">
    <p id="display"></p>
    <div id="content" style="display:none;"></div>
    <pre id="test"></pre>
  </body>
  <label id="test-result"/>
</window>