tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

closed.tentative.https.html (4522B)

      1 <!DOCTYPE html>
      2 <meta charset=utf-8>
      3 <meta name="timeout" content="long">
      4 <title>WebTransport API: bfcache closed</title>
      5 <link rel=help href="https://w3c.github.io/webtransport/">
      6 <script src="/resources/testharness.js"></script>
      7 <script src="/resources/testharnessreport.js"></script>
      8 <script src="/common/utils.js"></script>
      9 <script src="/common/dispatcher/dispatcher.js"></script>
     10 <script src="/html/browsers/browsing-the-web/back-forward-cache/resources/helper.sub.js"></script>
     11 <script src="/common/get-host-info.sub.js"></script>
     12 <script type="module">
     13 
     14 import { runWebTransportBfcacheTest } from "./helpers.js";
     15 import { webtransport_url } from "./ports.sub.js";
     16 import { worker_function } from "./worker.js";
     17 
     18 const id = token();
     19 const url = webtransport_url(`client-close.py?token=${id}`);
     20 
     21 // We can't load ./worker.js in runWebTransportBfcacheTest, because it uses
     22 // execute_script, and so the baseurl is helper.sub.js's baseurl.
     23 // We also can't pass a worker to it.  So, load the worker as a string, and pass
     24 // the string and turn it into a worker via a Blob.  Fun!
     25 const worker_string = worker_function.toString().replace(/^async function .+\{?|\}$/g, '');
     26 
     27 runWebTransportBfcacheTest({
     28  funcBeforeNavigation: async (url) => {
     29    window.wt = new WebTransport(url);
     30    await window.wt.ready;
     31    window.wt.close();
     32    await window.wt.closed;
     33  },
     34  argsBeforeNavigation: [url],
     35  shouldBeCached: true
     36 }, "A closed WebTransport on MainThread must allow bfcache");
     37 
     38 // we can't have runWebTransportBfcacheTest use [scripts] to load the helper.js
     39 // script into the test, due to the same baseurl issue, so just do this inline
     40 
     41 runWebTransportBfcacheTest({
     42  funcBeforeNavigation: async (worker_string, url) => {
     43    let next_request_id = 0;
     44    function postToWorkerAndWait(worker, data) {
     45      return new Promise(resolve => {
     46        data.rqid = next_request_id++;
     47        worker.postMessage(data);
     48        const listener = event => {
     49          if (event.data.rqid !== data.rqid)
     50            return;
     51          worker.removeEventListener('message', listener);
     52          resolve(event.data);
     53        };
     54        worker.addEventListener('message', listener);
     55      });
     56    };
     57 
     58    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
     59    window.worker = new SharedWorker(URL.createObjectURL(workerBlob));
     60    worker.port.start();
     61    await postToWorkerAndWait(worker.port, { op: "openandclose", url: url });
     62  },
     63  argsBeforeNavigation: [worker_string, url],
     64  shouldBeCached: true
     65 }, "A closed WebTransport in a shared worker must allow bfcache");
     66 
     67 runWebTransportBfcacheTest({
     68  funcBeforeNavigation: async (worker_string, url) => {
     69    let next_request_id = 0;
     70    function postToWorkerAndWait(worker, data) {
     71      return new Promise(resolve => {
     72        data.rqid = next_request_id++;
     73        worker.postMessage(data);
     74        const listener = event => {
     75          if (event.data.rqid !== data.rqid)
     76            return;
     77          worker.removeEventListener('message', listener);
     78          resolve(event.data);
     79        };
     80        worker.addEventListener('message', listener);
     81      });
     82    };
     83 
     84    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
     85    window.worker = new Worker(URL.createObjectURL(workerBlob));
     86    await postToWorkerAndWait(window.worker, { op: "open", url: url });
     87    await postToWorkerAndWait(window.worker, { op: "close" });
     88  },
     89  argsBeforeNavigation: [worker_string, url],
     90  shouldBeCached: true
     91 }, "A closed WebTransport in a worker must allow bfcache");
     92 
     93 runWebTransportBfcacheTest({
     94  funcBeforeNavigation: async (worker_string, url) => {
     95    let next_request_id = 0;
     96    function postToWorkerAndWait(worker, data) {
     97      return new Promise(resolve => {
     98        data.rqid = next_request_id++;
     99        worker.postMessage(data);
    100        const listener = event => {
    101          if (event.data.rqid !== data.rqid)
    102            return;
    103          worker.removeEventListener('message', listener);
    104          resolve(event.data);
    105        };
    106        worker.addEventListener('message', listener);
    107      });
    108    };
    109 
    110    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
    111    window.worker = new Worker(URL.createObjectURL(workerBlob));
    112    await postToWorkerAndWait(window.worker, { op: "open", url: url });
    113    await postToWorkerAndWait(window.worker, { op: "close" });
    114  },
    115  argsBeforeNavigation: [worker_string, url],
    116  shouldBeCached: true
    117 }, "A closed WebTransport in a nested worker must allow bfcache");
    118 
    119 </script>