tor-browser

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

connected.tentative.https.html (4405B)

      1 <!DOCTYPE html>
      2 <meta charset=utf-8>
      3 <meta name="timeout" content="long">
      4 <title>WebTransport API: bfcache connected</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, which is
     23 // the main wpt test directory.
     24 // We also can't pass a worker to it.  So, load the worker as a string, and pass
     25 // the string and turn it into a worker via a Blob.  Fun!
     26 const worker_string = worker_function.toString().replace(/^async function .+\{?|\}$/g, '');
     27 
     28 runWebTransportBfcacheTest({
     29  funcBeforeNavigation: async (url) => {
     30    window.wt = new WebTransport(url);
     31    await window.wt.ready;
     32  },
     33  argsBeforeNavigation: [url],
     34  shouldBeCached: false
     35 }, "A connected WebTransport on MainThread must prevent bfcache");
     36 
     37 // we can't have runWebTransportBfcacheTest use [scripts] to load the helper.js
     38 // script into the test, due to the same baseurl issue, so just do this inline
     39 
     40 runWebTransportBfcacheTest({
     41  funcBeforeNavigation: async (worker_string, url) => {
     42    let next_request_id = 0;
     43    function postToWorkerAndWait(worker, data) {
     44      return new Promise(resolve => {
     45        data.rqid = next_request_id++;
     46        worker.postMessage(data);
     47        const listener = event => {
     48          if (event.data.rqid !== data.rqid)
     49            return;
     50          worker.removeEventListener('message', listener);
     51          resolve(event.data);
     52        };
     53        worker.addEventListener('message', listener);
     54      });
     55    };
     56 
     57    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
     58    window.worker = new SharedWorker(URL.createObjectURL(workerBlob));
     59    worker.port.start();
     60    await postToWorkerAndWait(worker.port, { op: "open", url: url });
     61  },
     62  argsBeforeNavigation: [worker_string, url],
     63  shouldBeCached: false
     64 }, "A connected WebTransport in a shared worker must prevent bfcache");
     65 
     66 runWebTransportBfcacheTest({
     67  funcBeforeNavigation: async (worker_string, url) => {
     68    let next_request_id = 0;
     69    function postToWorkerAndWait(worker, data) {
     70      return new Promise(resolve => {
     71        data.rqid = next_request_id++;
     72        worker.postMessage(data);
     73        const listener = event => {
     74          if (event.data.rqid !== data.rqid)
     75            return;
     76          worker.removeEventListener('message', listener);
     77          resolve(event.data);
     78        };
     79        worker.addEventListener('message', listener);
     80      });
     81    };
     82 
     83    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
     84    window.worker = new Worker(URL.createObjectURL(workerBlob));
     85    await postToWorkerAndWait(window.worker, { op: "open", url: url });
     86  },
     87  argsBeforeNavigation: [worker_string, url],
     88  shouldBeCached: false
     89 }, "A connected WebTransport in a worker must prevent bfcache");
     90 
     91 runWebTransportBfcacheTest({
     92  funcBeforeNavigation: async (worker_string, url) => {
     93    let next_request_id = 0;
     94    function postToWorkerAndWait(worker, data) {
     95      return new Promise(resolve => {
     96        data.rqid = next_request_id++;
     97        worker.postMessage(data);
     98        const listener = event => {
     99          if (event.data.rqid !== data.rqid)
    100            return;
    101          worker.removeEventListener('message', listener);
    102          resolve(event.data);
    103        };
    104        worker.addEventListener('message', listener);
    105      });
    106    };
    107 
    108    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
    109    window.worker = new Worker(URL.createObjectURL(workerBlob));
    110    await postToWorkerAndWait(window.worker, { op: "open", url: url });
    111  },
    112  argsBeforeNavigation: [worker_string, url],
    113  shouldBeCached: false
    114 }, "A connected WebTransport in a nested worker must prevent bfcache");
    115 
    116 </script>