Backed out changeset 15f15b242acd (bug 1263304)
authorCarsten "Tomcat" Book <cbook@mozilla.com>
Fri, 11 Nov 2016 10:47:38 +0100
changeset 352181 5ad94ec48c1f2a2f1d0abf629dd7eb851691d65d
parent 352180 7687c3f7a82d59b3a345db60e3fce25551f2649d
child 352182 167f1634a22ac71b9fbc0262769b97dfd27cb1ca
push id6795
push userjlund@mozilla.com
push dateMon, 23 Jan 2017 14:19:46 +0000
treeherdermozilla-esr52@76101b503191 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1263304
milestone52.0a1
backs out15f15b242acd7d6a8e0355b660cf16e604b68e47
Backed out changeset 15f15b242acd (bug 1263304)
testing/web-platform/tests/service-workers/service-worker/extendable-event-async-waituntil.https.html
testing/web-platform/tests/service-workers/service-worker/resources/extendable-event-async-waituntil.js
--- a/testing/web-platform/tests/service-workers/service-worker/extendable-event-async-waituntil.https.html
+++ b/testing/web-platform/tests/service-workers/service-worker/extendable-event-async-waituntil.https.html
@@ -1,82 +1,30 @@
 <!DOCTYPE html>
 <script src="/resources/testharness.js"></script>
 <script src="resources/testharness-helpers.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="resources/test-helpers.sub.js"></script>
 <script>
-
-function sync_message(worker, message, transfer) {
-  let wait = new Promise((res, rej) => {
-    navigator.serviceWorker.addEventListener('message', function(e) {
-        if (e.data === 'ACK') {
-          res();
-        } else {
-          rej();
-        }
-      });
-    });
-  worker.postMessage(message, transfer);
-  return wait;
-}
-
-function runTest(test, step, testBody) {
-  var scope = './resources/' + step;
-  var script = 'resources/extendable-event-async-waituntil.js?' + scope;
-  service_worker_unregister_and_register(test, script, scope)
-    .then(function(registration) {
-        let worker = registration.installing;
-        var channel = new MessageChannel();
-        var saw_message = new Promise(function(resolve) {
-          channel.port1.onmessage = function(e) { resolve(e.data); }
-        });
+promise_test(function(t) {
+    var script = 'resources/extendable-event-async-waituntil.js';
+    var scope = 'resources/async-waituntil';
+    var worker;
 
-        wait_for_state(test, worker, 'activated')
-          .then(function() {
-              return sync_message(worker, { step: 'init', port: channel.port2 },
-                [channel.port2]);
-            })
-          .then(function() { return testBody(worker); })
-          .then(function() { return saw_message; })
-          .then(function(output) {
-              assert_equals(output.result, output.expected);
-            })
-          .then(function() { return sync_message(worker, { step: 'done' }); })
-          .then(() => { service_worker_unregister_and_done(test, scope); })
-          .catch(unreached_rejection(test));
-      });
-}
-
-function msg_event_test(scope, test) {
-  var testBody = function(worker) {
-    return sync_message(worker, { step: scope });
-  };
-  runTest(test, scope, testBody);
-}
-
-async_test(msg_event_test.bind(this, 'no-current-extension-different-task'),
-  'Test calling waitUntil in a different task without an existing extension throws');
-
-async_test(msg_event_test.bind(this, 'no-current-extension-different-microtask'),
-  'Test calling waitUntil in a different microtask without an existing extension throws');
-
-async_test(msg_event_test.bind(this, 'current-extension-different-task'),
-  'Test calling waitUntil in a different task with an existing extension succeeds');
-
-async_test(msg_event_test.bind(this, 'current-extension-expired-same-microtask-turn'),
-  'Test calling waitUntil with an existing extension promise handler succeeds');
-
-// The promise handler will queue a new microtask after the check for new
-// extensions was performed.
-async_test(msg_event_test.bind(this, 'current-extension-expired-same-microtask-turn-extra'),
-  'Test calling waitUntil at the end of the microtask turn throws');
-
-async_test(msg_event_test.bind(this, 'current-extension-expired-different-task'),
-  'Test calling waitUntil after the current extension expired in a different task fails');
-
-async_test(function(t) {
-    var testBody = function(worker) {
-      return with_iframe('./resources/pending-respondwith-async-waituntil/dummy.html');
-    }
-    runTest(t, 'pending-respondwith-async-waituntil', testBody);
-  }, 'Test calling waitUntil asynchronously with pending respondWith promise.');
+    return service_worker_unregister_and_register(t, script, scope)
+      .then(function(registration) {
+          worker = registration.installing;
+          return wait_for_state(t, worker, 'activated');
+        })
+      .then(function() {
+          var channel = new MessageChannel();
+          var saw_message = new Promise(function(resolve) {
+              channel.port1.onmessage = function(e) { resolve(e.data); }
+            });
+          worker.postMessage({port: channel.port2}, [channel.port2]);
+          return saw_message;
+        })
+      .then(function(message) {
+          assert_equals(message, 'PASS');
+          return service_worker_unregister_and_done(t, scope);
+        })
+  }, 'Calling waitUntil asynchronously throws an exception');
 </script>
--- a/testing/web-platform/tests/service-workers/service-worker/resources/extendable-event-async-waituntil.js
+++ b/testing/web-platform/tests/service-workers/service-worker/resources/extendable-event-async-waituntil.js
@@ -1,100 +1,20 @@
-// controlled by 'init'/'done' messages.
-var resolveLockPromise;
-var port;
+var result = 'FAIL: did not throw.';
 
 self.addEventListener('message', function(event) {
-    var waitPromise;
-    var resolveTestPromise;
+    event.data.port.postMessage(result);
+  });
 
-    switch (event.data.step) {
-      case 'init':
-        event.waitUntil(new Promise((res) => { resolveLockPromise = res; }));
-        port = event.data.port;
-        break;
-      case 'done':
-        resolveLockPromise();
-        break;
-      case 'no-current-extension-different-task':
-        async_task_waituntil(event).then(reportResultExpecting('InvalidStateError'));
-        break;
-      case 'no-current-extension-different-microtask':
-        async_microtask_waituntil(event).then(reportResultExpecting('InvalidStateError'));
-        break;
-      case 'current-extension-different-task':
-        event.waitUntil(new Promise((res) => { resolveTestPromise = res; }));
-        async_task_waituntil(event).then(reportResultExpecting('OK')).then(resolveTestPromise);
-        break;
-      case 'current-extension-expired-same-microtask-turn':
-        waitPromise = Promise.resolve();
-        event.waitUntil(waitPromise);
-        waitPromise.then(() => { return sync_waituntil(event); })
-          .then(reportResultExpecting('OK'))
-        break;
-      case 'current-extension-expired-same-microtask-turn-extra':
-        // The promise handler queues a new microtask *after* the check for new
-        // extensions was performed.
-        waitPromise = Promise.resolve();
-        event.waitUntil(waitPromise);
-        waitPromise.then(() => { return async_microtask_waituntil(event); })
-          .then(reportResultExpecting('InvalidStateError'))
-        break;
-      case 'current-extension-expired-different-task':
-        event.waitUntil(Promise.resolve());
-        async_task_waituntil(event).then(reportResultExpecting('InvalidStateError'));
-        break;
-    }
-    event.source.postMessage('ACK');
+self.addEventListener('install', function(event) {
+    self.installEvent = event;
   });
 
-self.addEventListener('fetch', function(event) {
-    var resolveFetch;
-    let response = new Promise((res) => { resolveFetch = res; });
-    event.respondWith(response);
-    async_task_waituntil(event)
-      .then(reportResultExpecting('OK'))
-      .then(() => { resolveFetch(new Response('OK')); });
-  });
-
-function reportResultExpecting(expectedResult) {
-  return function (result) {
-    port.postMessage({result : result, expected: expectedResult});
-    return result;
-  };
-}
-
-function sync_waituntil(event) {
-  return new Promise((res, rej) => {
+self.addEventListener('activate', function(event) {
     try {
-        event.waitUntil(Promise.resolve());
-        res('OK');
-      } catch (error) {
-        res(error.name);
-      }
+      self.installEvent.waitUntil(new Promise(function(){}));
+    } catch (error) {
+      if (error.name == 'InvalidStateError')
+        result = 'PASS';
+      else
+        result = 'FAIL: unexpected exception: ' + error;
+    }
   });
-}
-
-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);
-  });
-}