tor-browser

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

failed.tentative.https.html (4467B)

      1 <!DOCTYPE html>
      2 <meta charset=utf-8>
      3 <meta name="timeout" content="long">
      4 <title>WebTransport API: bfcache failed</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('custom-response.py?:status=404');
     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    // make sure it isn't immediately freed
     30    try {
     31      window.wt = new WebTransport(url);
     32      await window.wt.ready;
     33      assert_unreached('Opened invalid URL');
     34    } catch(e) {
     35    }
     36  },
     37  argsBeforeNavigation: [url],
     38  shouldBeCached: true
     39 }, "A failed WebTransport on MainThread must allow bfcache");
     40 
     41 // we can't have runWebTransportBfcacheTest use [scripts] to load the helper.js
     42 // script into the test, due to the same baseurl issue, so just do this inline
     43 
     44 runWebTransportBfcacheTest({
     45  funcBeforeNavigation: async (worker_string, url) => {
     46    let next_request_id = 0;
     47    function postToWorkerAndWait(worker, data) {
     48      return new Promise(resolve => {
     49        data.rqid = next_request_id++;
     50        worker.postMessage(data);
     51        const listener = event => {
     52          if (event.data.rqid !== data.rqid)
     53            return;
     54          worker.removeEventListener('message', listener);
     55          resolve(event.data);
     56        };
     57        worker.addEventListener('message', listener);
     58      });
     59    };
     60 
     61    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
     62    window.worker = new SharedWorker(URL.createObjectURL(workerBlob));
     63    worker.port.start();
     64    await postToWorkerAndWait(worker.port, { op: "open", url: url });
     65  },
     66  argsBeforeNavigation: [worker_string, url],
     67  shouldBeCached: true
     68 }, "A failed WebTransport in a shared worker must allow bfcache");
     69 
     70 runWebTransportBfcacheTest({
     71  funcBeforeNavigation: async (worker_string, url) => {
     72    let next_request_id = 0;
     73    function postToWorkerAndWait(worker, data) {
     74      return new Promise(resolve => {
     75        data.rqid = next_request_id++;
     76        worker.postMessage(data);
     77        const listener = event => {
     78          if (event.data.rqid !== data.rqid)
     79            return;
     80          worker.removeEventListener('message', listener);
     81          resolve(event.data);
     82        };
     83        worker.addEventListener('message', listener);
     84      });
     85    };
     86 
     87    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
     88    window.worker = new Worker(URL.createObjectURL(workerBlob));
     89    await postToWorkerAndWait(window.worker, { op: "open", url: url });
     90  },
     91  argsBeforeNavigation: [worker_string, url],
     92  shouldBeCached: true
     93 }, "A failed WebTransport in a worker must allow bfcache");
     94 
     95 runWebTransportBfcacheTest({
     96  funcBeforeNavigation: async (worker_string, url) => {
     97    let next_request_id = 0;
     98    function postToWorkerAndWait(worker, data) {
     99      return new Promise(resolve => {
    100        data.rqid = next_request_id++;
    101        worker.postMessage(data);
    102        const listener = event => {
    103          if (event.data.rqid !== data.rqid)
    104            return;
    105          worker.removeEventListener('message', listener);
    106          resolve(event.data);
    107        };
    108        worker.addEventListener('message', listener);
    109      });
    110    };
    111 
    112    let workerBlob = new Blob([worker_string],  { type:'text/javascript' });
    113    window.worker = new Worker(URL.createObjectURL(workerBlob));
    114    await postToWorkerAndWait(window.worker, { op: "open", url: url });
    115  },
    116  argsBeforeNavigation: [worker_string, url],
    117  shouldBeCached: true
    118 }, "A failed WebTransport in a nested worker must allow bfcache");
    119 
    120 </script>