tor-browser

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

dedicated-worker.https.html (6473B)

      1 <!doctype html>
      2 <title>COEP and dedicated worker</title>
      3 <script src=/resources/testharness.js></script>
      4 <script src=/resources/testharnessreport.js></script>
      5 <script src="/common/get-host-info.sub.js"></script>
      6 <script src="resources/worker-support.js"></script>
      7 <body>
      8 <script>
      9 
     10 const targetUrl = resolveUrl("/common/blank.html", {
     11    host: get_host_info().REMOTE_HOST,
     12 }).href;
     13 
     14 function workerUrl(options) {
     15  return resolveUrl("resources/dedicated-worker.js", options);
     16 }
     17 
     18 async function createWorker(t, url, options) {
     19  const { ownerCoep, workerOptions } = options || {};
     20 
     21  const frameUrl = resolveUrl("/common/blank.html", {
     22    coep: ownerCoep,
     23  });
     24  const frame = await withIframe(t, frameUrl);
     25 
     26  return new frame.contentWindow.Worker(url, workerOptions);
     27 }
     28 
     29 promise_test(async (t) => {
     30  const worker = await createWorker(t, workerUrl());
     31  worker.onerror = t.unreached_func('Worker.onerror should not be called');
     32 
     33  worker.postMessage(targetUrl);
     34 
     35  const result = await waitForMessage(worker);
     36  assert_equals(result.data, 'LOADED');
     37 }, 'COEP: none worker in COEP: none frame');
     38 
     39 promise_test(async (t) => {
     40  const worker = await createWorker(t, workerUrl(), {
     41    ownerCoep: "require-corp",
     42  });
     43  await new Promise(resolve => {
     44    worker.onerror = resolve;
     45  });
     46 }, 'COEP: none worker in COEP: require-corp frame');
     47 
     48 promise_test(async (t) => {
     49  const worker = await createWorker(t, workerUrl({ coep: "require-corp" }));
     50  worker.onerror = t.unreached_func('Worker.onerror should not be called');
     51 
     52  worker.postMessage(targetUrl);
     53 
     54  const result = await waitForMessage(worker);
     55  assert_equals(result.data, 'FAILED');
     56 }, 'COEP: require-corp worker in COEP: none frame');
     57 
     58 promise_test(async (t) => {
     59  const worker = await createWorker(t, workerUrl({ coep: "require-corp" }), {
     60    ownerCoep: "require-corp",
     61  });
     62  worker.onerror = t.unreached_func('Worker.onerror should not be called');
     63 
     64  worker.postMessage(targetUrl);
     65 
     66  const result = await waitForMessage(worker);
     67  assert_equals(result.data, 'FAILED');
     68 }, 'COEP: require-corp worker in COEP: require-corp frame');
     69 
     70 promise_test(async (t) => {
     71  const worker = await createWorker(t, workerUrl(), {
     72    workerOptions: { type: 'module' },
     73  });
     74  worker.onerror = t.unreached_func('Worker.onerror should not be called');
     75 
     76  worker.postMessage(targetUrl);
     77 
     78  const result = await waitForMessage(worker);
     79  assert_equals(result.data, 'LOADED');
     80 }, 'COEP: none module worker in COEP: none frame');
     81 
     82 promise_test(async (t) => {
     83  const worker = await createWorker(t, workerUrl(), {
     84    ownerCoep: "require-corp",
     85    workerOptions: { type: 'module' },
     86  });
     87  await new Promise(resolve => {
     88    worker.onerror = resolve;
     89  });
     90 }, 'COEP: none module worker in COEP: require-corp frame');
     91 
     92 promise_test(async (t) => {
     93  const worker = await createWorker(t, workerUrl({ coep: "require-corp" }), {
     94    workerOptions: { type: 'module' },
     95  });
     96  worker.onerror = t.unreached_func('Worker.onerror should not be called');
     97 
     98  worker.postMessage(targetUrl);
     99 
    100  const result = await waitForMessage(worker);
    101  assert_equals(result.data, 'FAILED');
    102 }, 'COEP: require-corp module worker in COEP: none frame');
    103 
    104 promise_test(async (t) => {
    105  const worker = await createWorker(t, workerUrl({ coep: "require-corp" }), {
    106    ownerCoep: "require-corp",
    107    workerOptions: { type: 'module' },
    108  });
    109  worker.onerror = t.unreached_func('Worker.onerror should not be called');
    110 
    111  worker.postMessage(targetUrl);
    112 
    113  const result = await waitForMessage(worker);
    114  assert_equals(result.data, 'FAILED');
    115 }, 'COEP: require-corp module worker in COEP: require-corp frame');
    116 
    117 promise_test(async (t) => {
    118  const url = await createLocalUrl(t, {
    119    url: workerUrl(),
    120    creatorCoep: "require-corp",
    121    scheme: "blob",
    122  });
    123 
    124  const worker = await createWorker(t, url, { ownerCoep: "require-corp" });
    125  worker.onerror = t.unreached_func('Worker.onerror should not be called');
    126 
    127  worker.postMessage(targetUrl);
    128 
    129  const result = await waitForMessage(worker);
    130  assert_equals(result.data, 'FAILED');
    131 }, "COEP: worker inherits COEP for blob URL.");
    132 
    133 promise_test(async (t) => {
    134  const url = await createLocalUrl(t, {
    135    url: workerUrl(),
    136    creatorCoep: "require-corp",
    137    scheme: "blob",
    138  });
    139 
    140  const worker = await createWorker(t, url);
    141  worker.onerror = t.unreached_func('Worker.onerror should not be called');
    142 
    143  worker.postMessage(targetUrl);
    144 
    145  const result = await waitForMessage(worker);
    146  assert_equals(result.data, 'FAILED');
    147 }, "COEP: worker inherits COEP from blob URL creator, not owner.");
    148 
    149 promise_test(async (t) => {
    150  const url = await createLocalUrl(t, {
    151    url: workerUrl(),
    152    creatorCoep: "require-corp",
    153    scheme: "data",
    154  });
    155 
    156  const worker = await createWorker(t, url, { ownerCoep: "require-corp" });
    157  worker.onerror = t.unreached_func('Worker.onerror should not be called');
    158 
    159  worker.postMessage(targetUrl);
    160 
    161  const result = await waitForMessage(worker);
    162  assert_equals(result.data, 'FAILED');
    163 }, "COEP: worker inherits COEP for data URL.");
    164 
    165 promise_test(async (t) => {
    166  const url = await createLocalUrl(t, {
    167    url: workerUrl(),
    168    creatorCoep: "require-corp",
    169    scheme: "data",
    170  });
    171 
    172  const worker = await createWorker(t, url);
    173  worker.onerror = t.unreached_func('Worker.onerror should not be called');
    174 
    175  worker.postMessage(targetUrl);
    176 
    177  const result = await waitForMessage(worker);
    178  assert_equals(result.data, 'LOADED');
    179 }, "COEP: worker inherits COEP from owner, not data URL creator.");
    180 
    181 promise_test(async (t) => {
    182  const url = await createLocalUrl(t, {
    183    url: workerUrl(),
    184    creatorCoep: "require-corp",
    185    scheme: "filesystem",
    186  });
    187 
    188  const worker = await createWorker(t, url, { ownerCoep: "require-corp" });
    189  worker.onerror = t.unreached_func('Worker.onerror should not be called');
    190 
    191  worker.postMessage(targetUrl);
    192 
    193  const result = await waitForMessage(worker);
    194  assert_equals(result.data, 'FAILED');
    195 }, "COEP: worker inherits COEP for filesystem URL.");
    196 
    197 promise_test(async (t) => {
    198  const url = await createLocalUrl(t, {
    199    url: workerUrl(),
    200    creatorCoep: "require-corp",
    201    scheme: "filesystem",
    202  });
    203 
    204  const worker = await createWorker(t, url);
    205  worker.onerror = t.unreached_func('Worker.onerror should not be called');
    206 
    207  worker.postMessage(targetUrl);
    208 
    209  const result = await waitForMessage(worker);
    210  assert_equals(result.data, 'FAILED');
    211 }, "COEP: worker inherits COEP from filesystem URL creator, not owner.");
    212 
    213 </script>
    214 </body>