Import wpt@5e1a3b80cea8d36774d2afd78b29a74792e9f15a

third_party/WebKit/LayoutTests/imported/wpt/service-workers/service-worker/extendable-event-async-waituntil.https.html

Index: third_party/WebKit/LayoutTests/imported/wpt/service-workers/service-worker/extendable-event-async-waituntil.https.html
diff --git a/third_party/WebKit/LayoutTests/imported/wpt/service-workers/service-worker/extendable-event-async-waituntil.https.html b/third_party/WebKit/LayoutTests/imported/wpt/service-workers/service-worker/extendable-event-async-waituntil.https.html
index c06bf84ab2dbdd034deea8610ef4735d4e9a9345..783a712ee4c842a9953cb707b78564a2c0ec45e7 100644
--- a/third_party/WebKit/LayoutTests/imported/wpt/service-workers/service-worker/extendable-event-async-waituntil.https.html
+++ b/third_party/WebKit/LayoutTests/imported/wpt/service-workers/service-worker/extendable-event-async-waituntil.https.html
@@ -4,27 +4,79 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="resources/test-helpers.sub.js"></script>
 <script>
-promise_test(function(t) {
-    var script = 'resources/extendable-event-async-waituntil.js';
-    var scope = 'resources/async-waituntil';
-    var worker;
-
-    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');
+
+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); }
+        });
+
+        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.');
 </script>