workers.https.html (3621B)
1 <!DOCTYPE html> 2 <meta charset=utf-8> 3 <title>Web Locks API: Workers</title> 4 <link rel=help href="https://w3c.github.io/web-locks/"> 5 <script src="/resources/testharness.js"></script> 6 <script src="/resources/testharnessreport.js"></script> 7 <script src="resources/helpers.js"></script> 8 <script> 9 'use strict'; 10 11 promise_test(async t => { 12 assert_implements(navigator.locks); 13 const worker = new Worker('resources/worker.js'); 14 t.add_cleanup(() => { worker.terminate(); }); 15 16 const res = 'shared resource 1'; 17 18 const lock_id = (await postToWorkerAndWait( 19 worker, {op: 'request', name: res, mode: 'shared'})).lock_id; 20 21 await navigator.locks.request(res, {mode: 'shared'}, async lock => { 22 await postToWorkerAndWait(worker, {op: 'release', lock_id}); 23 }); 24 25 }, 'Window and Worker - shared mode'); 26 27 promise_test(async t => { 28 assert_implements(navigator.locks); 29 const worker = new Worker('resources/worker.js'); 30 t.add_cleanup(() => { worker.terminate(); }); 31 32 const res = 'exclusive resource 1'; 33 34 // worker acquires the lock. 35 const lock_id = (await postToWorkerAndWait( 36 worker, {op: 'request', name: res})).lock_id; 37 38 // This request should be blocked. 39 let lock_granted = false; 40 const blocked = navigator.locks.request( 41 res, lock => { lock_granted = true; }); 42 43 // Verify we can't get it. 44 let available = undefined; 45 await navigator.locks.request( 46 res, {ifAvailable: true}, lock => { available = lock !== null; }); 47 assert_false(available); 48 assert_false(lock_granted); 49 50 // Ask the worker to release it. 51 await postToWorkerAndWait(worker, {op: 'release', lock_id}); 52 53 // Now we've got it. 54 const lock2 = await blocked; 55 assert_true(lock_granted); 56 57 }, 'Window and Worker - exclusive mode'); 58 59 promise_test(async t => { 60 assert_implements(navigator.locks); 61 const worker1 = new Worker('resources/worker.js'); 62 const worker2 = new Worker('resources/worker.js'); 63 t.add_cleanup(() => { worker1.terminate(); worker2.terminate(); }); 64 65 const res = 'exclusive resource 2'; 66 67 // worker1 acquires the lock. 68 const lock_id = (await postToWorkerAndWait( 69 worker1, {op: 'request', name: res})).lock_id; 70 71 // This request should be blocked. 72 let lock_granted = false; 73 const blocked = postToWorkerAndWait( 74 worker2, {op: 'request', name: res}); 75 blocked.then(f => { lock_granted = true; }); 76 77 // Verify worker2 can't get it. 78 assert_true((await postToWorkerAndWait(worker2, { 79 op: 'request', name: res, ifAvailable: true 80 })).failed, 'Lock request should have failed'); 81 assert_false(lock_granted); 82 83 // Ask worker1 to release it. 84 await postToWorkerAndWait(worker1, {op: 'release', lock_id}); 85 86 // Now worker2 can get it. 87 const lock = await blocked; 88 assert_true(lock_granted); 89 90 }, 'Worker and Worker - exclusive mode'); 91 92 promise_test(async t => { 93 assert_implements(navigator.locks); 94 const worker = new Worker('resources/worker.js'); 95 96 const res = 'exclusive resource 3'; 97 98 // Worker acquires the lock. 99 await postToWorkerAndWait(worker, {op: 'request', name: res}); 100 101 // This request should be blocked. 102 let lock_granted = false; 103 const blocked = navigator.locks.request( 104 res, lock => { lock_granted = true; }); 105 106 // Verify we can't get it. 107 let available = undefined; 108 await navigator.locks.request( 109 res, {ifAvailable: true}, lock => { available = lock !== null; }); 110 assert_false(available); 111 assert_false(lock_granted); 112 113 // Implicitly release it by terminating the worker. 114 worker.terminate(); 115 116 // Now we've got it. 117 const lock = await blocked; 118 assert_true(lock_granted); 119 120 }, 'Terminated Worker - exclusive mode'); 121 122 </script>