tor-browser

extendable-event-async-waituntil.js (7811B)

---

// This worker calls waitUntil() and respondWith() asynchronously and
// reports back to the test whether they threw.
//
// These test cases are confusing. Bear in mind that the event is active
// (calling waitUntil() is allowed) if:
// * The pending promise count is not 0, or
// * The event dispatch flag is set.

// Controlled by 'init'/'done' messages.
var resolveLockPromise;
var port;

self.addEventListener('message', function(event) {
   var waitPromise;
   var resolveTestPromise;

   switch (event.data.step) {
     case 'init':
       event.waitUntil(new Promise((res) => { resolveLockPromise = res; }));
       port = event.data.port;
       break;
     case 'done':
       resolveLockPromise();
       break;

     // Throws because waitUntil() is called in a task after event dispatch
     // finishes.
     case 'no-current-extension-different-task':
       async_task_waituntil(event).then(reportResultExpecting('InvalidStateError'));
       break;

     // OK because waitUntil() is called in a microtask that runs after the
     // event handler runs, while the event dispatch flag is still set.
     case 'no-current-extension-different-microtask':
       async_microtask_waituntil(event).then(reportResultExpecting('OK'));
       break;

     // OK because the second waitUntil() is called while the first waitUntil()
     // promise is still pending.
     case 'current-extension-different-task':
       event.waitUntil(new Promise((res) => { resolveTestPromise = res; }));
       async_task_waituntil(event).then(reportResultExpecting('OK')).then(resolveTestPromise);
       break;

     // OK because all promises involved resolve "immediately", so the second
     // waitUntil() is called during the microtask checkpoint at the end of
     // event dispatching, when the event dispatch flag is still set.
     case 'during-event-dispatch-current-extension-expired-same-microtask-turn':
       waitPromise = Promise.resolve();
       event.waitUntil(waitPromise);
       waitPromise.then(() => { return sync_waituntil(event); })
         .then(reportResultExpecting('OK'))
       break;

     // OK for the same reason as above.
     case 'during-event-dispatch-current-extension-expired-same-microtask-turn-extra':
       waitPromise = Promise.resolve();
       event.waitUntil(waitPromise);
       waitPromise.then(() => { return async_microtask_waituntil(event); })
         .then(reportResultExpecting('OK'))
       break;


     // OK because the pending promise count is decremented in a microtask
     // queued upon fulfillment of the first waitUntil() promise, so the second
     // waitUntil() is called while the pending promise count is still
     // positive.
     case 'after-event-dispatch-current-extension-expired-same-microtask-turn':
       waitPromise = makeNewTaskPromise();
       event.waitUntil(waitPromise);
       waitPromise.then(() => { return sync_waituntil(event); })
         .then(reportResultExpecting('OK'))
       break;

     // Throws because the second waitUntil() is called after the pending
     // promise count was decremented to 0.
     case 'after-event-dispatch-current-extension-expired-same-microtask-turn-extra':
       waitPromise = makeNewTaskPromise();
       event.waitUntil(waitPromise);
       waitPromise.then(() => { return async_microtask_waituntil(event); })
         .then(reportResultExpecting('InvalidStateError'))
       break;

     // Throws because the second waitUntil() is called in a new task, after
     // first waitUntil() promise settled and the event dispatch flag is unset.
     case 'current-extension-expired-different-task':
       event.waitUntil(Promise.resolve());
       async_task_waituntil(event).then(reportResultExpecting('InvalidStateError'));
       break;

     case 'script-extendable-event':
       self.dispatchEvent(new ExtendableEvent('nontrustedevent'));
       break;
   }

   event.source.postMessage('ACK');
 });

self.addEventListener('fetch', function(event) {
 const path = new URL(event.request.url).pathname;
 const step = path.substring(path.lastIndexOf('/') + 1);
 let response;
 switch (step) {
   // OK because waitUntil() is called while the respondWith() promise is still
   // unsettled, so the pending promise count is positive.
   case 'pending-respondwith-async-waituntil':
     var resolveFetch;
     response = new Promise((res) => { resolveFetch = res; });
     event.respondWith(response);
     async_task_waituntil(event)
       .then(reportResultExpecting('OK'))
       .then(() => { resolveFetch(new Response('OK')); });
     break;

   // OK because all promises involved resolve "immediately", so waitUntil() is
   // called during the microtask checkpoint at the end of event dispatching,
   // when the event dispatch flag is still set.
   case 'during-event-dispatch-respondwith-microtask-sync-waituntil':
     response = Promise.resolve(new Response('RESP'));
     event.respondWith(response);
     response.then(() => { return sync_waituntil(event); })
       .then(reportResultExpecting('OK'));
     break;

   // OK because all promises involved resolve "immediately", so waitUntil() is
   // called during the microtask checkpoint at the end of event dispatching,
   // when the event dispatch flag is still set.
   case 'during-event-dispatch-respondwith-microtask-async-waituntil':
     response = Promise.resolve(new Response('RESP'));
     event.respondWith(response);
     response.then(() => { return async_microtask_waituntil(event); })
       .then(reportResultExpecting('OK'));
     break;

   // OK because the pending promise count is decremented in a microtask queued
   // upon fulfillment of the respondWith() promise, so waitUntil() is called
   // while the pending promise count is still positive.
   case 'after-event-dispatch-respondwith-microtask-sync-waituntil':
     response = makeNewTaskPromise().then(() => {return new Response('RESP');});
     event.respondWith(response);
     response.then(() => { return sync_waituntil(event); })
       .then(reportResultExpecting('OK'));
     break;


   // Throws because waitUntil() is called after the pending promise count was
   // decremented to 0.
   case 'after-event-dispatch-respondwith-microtask-async-waituntil':
     response = makeNewTaskPromise().then(() => {return new Response('RESP');});
     event.respondWith(response);
     response.then(() => { return async_microtask_waituntil(event); })
       .then(reportResultExpecting('InvalidStateError'))
     break;
 }
});

self.addEventListener('nontrustedevent', function(event) {
   sync_waituntil(event).then(reportResultExpecting('InvalidStateError'));
 });

function reportResultExpecting(expectedResult) {
 return function (result) {
   port.postMessage({result : result, expected: expectedResult});
   return result;
 };
}

function sync_waituntil(event) {
 return new Promise((res, rej) => {
   try {
     event.waitUntil(Promise.resolve());
     res('OK');
   } catch (error) {
     res(error.name);
   }
 });
}

function async_microtask_waituntil(event) {
 return new Promise((res, rej) => {
   Promise.resolve().then(() => {
     try {
       event.waitUntil(Promise.resolve());
       res('OK');
     } catch (error) {
       res(error.name);
     }
   });
 });
}

function async_task_waituntil(event) {
 return new Promise((res, rej) => {
   setTimeout(() => {
     try {
       event.waitUntil(Promise.resolve());
       res('OK');
     } catch (error) {
       res(error.name);
     }
   }, 0);
 });
}

// Returns a promise that settles in a separate task.
function makeNewTaskPromise() {
 return new Promise(resolve => {
   setTimeout(resolve, 0);
 });
}