Changeset 246363 – WebKit

trunk/LayoutTests/ChangeLog

-                      r246362
+                      r246363
+-06-12  Youenn Fablet  <youenn@apple.com>
+        Update WPT service workers test up to 0df7c68
+        https://bugs.webkit.org/show_bug.cgi?id=198720
+        Reviewed by Eric Carlson.
+        * TestExpectations:
+        * tests-options.json:
 -06-12  Truitt Savell  <tsavell@apple.com>

trunk/LayoutTests/TestExpectations

r246330	r246363
2453	2453
2454	2454	webkit.org/b/182311 imported/w3c/web-platform-tests/service-workers/service-worker/navigation-redirect.https.html [ Skip ]
	2455	imported/w3c/web-platform-tests/service-workers/service-worker/svg-target-reftest.https.html [ ImageOnlyFailure ]
2455	2456
2456	2457	webkit.org/b/90980 fast/forms/textarea/textarea-state-restore.html [ Pass Timeout ]

trunk/LayoutTests/imported/w3c/ChangeLog

-                      r246339
+                      r246363
+-06-12  Youenn Fablet  <youenn@apple.com>
+        Update WPT service workers test up to 0df7c68
+        https://bugs.webkit.org/show_bug.cgi?id=198720
+        Reviewed by Eric Carlson.
+        * web-platform-tests/service-workers: Resynced.
 -06-11  Devin Rousso  <drousso@apple.com>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/cache-storage/script-tests/cache-match.js

-                      r238592
+                      r246363
         });
   }, 'Cache.match supports ignoreVary');
+cache_test(function(cache) {
+    let has_cache_name = false;
+    const opts = {
+      get cacheName() {
+        has_cache_name = true;
+        return undefined;
+      }
+    };
+    return self.caches.open('foo')
+      .then(function() {
+          return cache.match('bar', opts);
+        })
+      .then(function() {
+          assert_false(has_cache_name,
+                       'Cache.match does not support cacheName option ' +
+                       'which was removed in CacheQueryOptions.');
+        });
+  }, 'Cache.match does not support cacheName option');
 prepopulated_cache_test(simple_entries, function(cache, entries) {
 …
   }, 'cors-exposed header should be stored correctly.');
+cache_test(async (cache) => {
+    // A URL that should load a resource with a known mime type.
+    const url = '/service-workers/cache-storage/resources/blank.html';
+    const expected_mime_type = 'text/html';
+    // Verify we get the expected mime type from the network.  Note,
+    // we cannot use an exact match here since some browsers append
+    // character encoding information to the blob.type value.
+    const net_response = await fetch(url);
+    const net_mime_type = (await net_response.blob()).type;
+    assert_true(net_mime_type.includes(expected_mime_type),
+                'network response should include the expected mime type');
+    // Verify we get the exact same mime type when reading the same
+    // URL resource back out of the cache.
+    await cache.add(url);
+    const cache_response = await cache.match(url);
+    const cache_mime_type = (await cache_response.blob()).type;
+    assert_equals(cache_mime_type, net_mime_type,
+                  'network and cache response mime types should match');
+  }, 'MIME type should be set from content-header correctly.');
+cache_test(async (cache) => {
+    const url = '/dummy';
+    const original_type = 'text/html';
+    const init_with_headers = {
+      headers: {
+        'content-type': original_type
+      }
+    }
+    // Verify constructing a synthetic response with a content-type header
+    // gets the correct mime type.
+    const response = new Response('hello world', init_with_headers);
+    const original_response_type = (await response.blob()).type;
+    assert_true(original_response_type.includes(original_type),
+                'original response should include the expected mime type');
+    // Verify overwriting the content-type header does not change the mime
+    // type.  It should be fixed at Response construction time.
+    const overwritten_response = new Response('hello world', init_with_headers);
+    overwritten_response.headers.set('content-type', 'text/plain');
+    const overwritten_response_type = (await overwritten_response.blob()).type;
+    assert_equals(overwritten_response_type, original_response_type,
+                  'original and overwritten response mime types should match');
+    // Verify the Response read from Cache uses the original mime type
+    // computed when it was first constructed.
+    const tmp = new Response('hello world', init_with_headers);
+    tmp.headers.set('content-type', 'text/plain');
+    await cache.put(url, tmp);
+    const cache_response = await cache.match(url);
+    const cache_mime_type = (await cache_response.blob()).type;
+    assert_equals(cache_mime_type, original_response_type,
+                  'original and cached overwritten response mime types ' +
+                  'should match');
+  }, 'MIME type should be frozen at response construction.');
 done();

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/cache-storage/serviceworker/cache-match.https-expected.txt

-                      r238592
+                      r246363
 PASS Cache.match supports ignoreMethod
 PASS Cache.match supports ignoreVary
+FAIL Cache.match does not support cacheName option assert_false: Cache.match does not support cacheName option which was removed in CacheQueryOptions. expected false got true
 PASS Cache.match with URL containing fragment
 PASS Cache.match with string fragment "http" as query
 …
 PASS Cache produces large Responses that can be cloned and read correctly.
 FAIL cors-exposed header should be stored correctly. assert_equals: expected (string) "bar" but got (object) null
+FAIL MIME type should be set from content-header correctly. assert_equals: network and cache response mime types should match expected "text/html" but got ""
+FAIL MIME type should be frozen at response construction. assert_equals: original and cached overwritten response mime types should match expected "text/html" but got ""

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/cache-storage/window/cache-match.https-expected.txt

-                      r238592
+                      r246363
 PASS Cache.match supports ignoreMethod
 PASS Cache.match supports ignoreVary
+FAIL Cache.match does not support cacheName option assert_false: Cache.match does not support cacheName option which was removed in CacheQueryOptions. expected false got true
 PASS Cache.match with URL containing fragment
 PASS Cache.match with string fragment "http" as query
 …
 PASS Cache produces large Responses that can be cloned and read correctly.
 FAIL cors-exposed header should be stored correctly. assert_equals: expected (string) "bar" but got (object) null
+FAIL MIME type should be set from content-header correctly. assert_equals: network and cache response mime types should match expected "text/html" but got ""
+FAIL MIME type should be frozen at response construction. assert_equals: original and cached overwritten response mime types should match expected "text/html" but got ""

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/cache-storage/worker/cache-match.https-expected.txt

-                      r238592
+                      r246363
 PASS Cache.match supports ignoreMethod
 PASS Cache.match supports ignoreVary
+FAIL Cache.match does not support cacheName option assert_false: Cache.match does not support cacheName option which was removed in CacheQueryOptions. expected false got true
 PASS Cache.match with URL containing fragment
 PASS Cache.match with string fragment "http" as query
 …
 PASS Cache produces large Responses that can be cloned and read correctly.
 FAIL cors-exposed header should be stored correctly. assert_equals: expected (string) "bar" but got (object) null
+FAIL MIME type should be set from content-header correctly. assert_equals: network and cache response mime types should match expected "text/html" but got ""
+FAIL MIME type should be frozen at response construction. assert_equals: original and cached overwritten response mime types should match expected "text/html" but got ""

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/Service-Worker-Allowed-header.https-expected.txt

-                      r238592
+                      r246363
 PASS Registering outside Service-Worker-Allowed path
 PASS Registering outside Service-Worker-Allowed path with parent reference
+PASS Service-Worker-Allowed is cross-origin to script, registering on a normally allowed scope
+PASS Service-Worker-Allowed is cross-origin to script, registering on a normally disallowed scope
+FAIL Service-Worker-Allowed is cross-origin to script, registering on a normally allowed scope assert_unreached: Should have rejected: undefined Reached unreachable code
+FAIL Service-Worker-Allowed is cross-origin to script, registering on a normally disallowed scope assert_unreached: Should have rejected: undefined Reached unreachable code
 PASS Service-Worker-Allowed is cross-origin to page, same-origin to script

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/Service-Worker-Allowed-header.https.html

-                      r238592
+                      r246363
+}
+promise_test(async t => {
+  const script = build_script_url('/allowed-path');
+  const scope = '/allowed-path';
+  const registration = await service_worker_unregister_and_register(
+      t, script, scope);
+  assert_true(registration instanceof ServiceWorkerRegistration, 'registered');
+  assert_equals(registration.scope, normalizeURL(scope));
+  return registration.unregister();
+}, 'Registering within Service-Worker-Allowed path');
+// register_test is a promise_test that registers a service worker.
+function register_test(script, scope, description) {
+  promise_test(async t => {
+    t.add_cleanup(() => {
+      return service_worker_unregister(t, scope);
+    });
+promise_test(async t => {
+  const script = build_script_url(new URL('/allowed-path', document.location));
+  const scope = '/allowed-path';
+  const registration = await service_worker_unregister_and_register(
+      t, script, scope);
+  assert_true(registration instanceof ServiceWorkerRegistration, 'registered');
+  assert_equals(registration.scope, normalizeURL(scope));
+  return registration.unregister();
+}, 'Registering within Service-Worker-Allowed path (absolute URL)');
+    const registration = await service_worker_unregister_and_register(
+        t, script, scope);
+    assert_true(registration instanceof ServiceWorkerRegistration, 'registered');
+    assert_equals(registration.scope, normalizeURL(scope));
+  }, description);
+}
+promise_test(async t => {
+  const script = build_script_url('../allowed-path-with-parent');
+  const scope = 'allowed-path-with-parent';
+  const registration = await service_worker_unregister_and_register(
+      t, script, scope);
+  assert_true(registration instanceof ServiceWorkerRegistration, 'registered');
+  assert_equals(registration.scope, normalizeURL(scope));
+  return registration.unregister();
+}, 'Registering within Service-Worker-Allowed path with parent reference');
+// register_fail_test is like register_test but expects a SecurityError.
+function register_fail_test(script, scope, description) {
+  promise_test(async t => {
+    t.add_cleanup(() => {
+      return service_worker_unregister(t, scope);
+    });
+promise_test(async t => {
+  const script = build_script_url('../allowed-path');
+  const scope = '/disallowed-path';
+  await service_worker_unregister(t, scope);
+  return promise_rejects(t,
+      'SecurityError',
+      navigator.serviceWorker.register(script, {scope: scope}),
+      'register should fail');
+}, 'Registering outside Service-Worker-Allowed path');
+    await service_worker_unregister(t, scope);
+    await promise_rejects(t,
+                          'SecurityError',
+                          navigator.serviceWorker.register(script, {scope}));
+  }, description);
+}
+promise_test(async t => {
+  const script = build_script_url('../allowed-path-with-parent');
+  const scope = '/allowed-path-with-parent';
+  await service_worker_unregister(t, scope);
+  return promise_rejects(t,
+      'SecurityError',
+      navigator.serviceWorker.register(script, {scope: scope}),
+      'register should fail');
+}, 'Registering outside Service-Worker-Allowed path with parent reference');
+register_test(
+    build_script_url('/allowed-path'),
+    '/allowed-path',
+    'Registering within Service-Worker-Allowed path');
+promise_test(async t => {
+  const script = build_script_url(
+      host_info.HTTPS_REMOTE_ORIGIN + '/');
+  const scope = 'resources/this-scope-is-normally-allowed'
+  const registration = await service_worker_unregister_and_register(
+      t, script, scope);
+  assert_true(registration instanceof ServiceWorkerRegistration, 'registered');
+  assert_equals(registration.scope, normalizeURL(scope));
+  return registration.unregister();
+}, 'Service-Worker-Allowed is cross-origin to script, registering on a normally allowed scope');
+register_test(
+    build_script_url(new URL('/allowed-path', document.location)),
+    '/allowed-path',
+    'Registering within Service-Worker-Allowed path (absolute URL)');
+promise_test(async t => {
+  const script = build_script_url(
+      host_info.HTTPS_REMOTE_ORIGIN + '/');
+  const scope = '/this-scope-is-normally-disallowed'
+  const registration = await service_worker_unregister_and_register(
+      t, script, scope);
+  assert_true(registration instanceof ServiceWorkerRegistration, 'registered');
+  assert_equals(registration.scope, normalizeURL(scope));
+  return registration.unregister();
+}, 'Service-Worker-Allowed is cross-origin to script, registering on a normally disallowed scope');
+register_test(
+    build_script_url('../allowed-path-with-parent'),
+    'allowed-path-with-parent',
+    'Registering within Service-Worker-Allowed path with parent reference');
+promise_test(async t => {
+  const script = build_script_url(
+      host_info.HTTPS_REMOTE_ORIGIN + '/cross-origin/',
+      host_info.HTTPS_REMOTE_ORIGIN);
+  const scope = '/cross-origin/';
+  await service_worker_unregister(t, scope);
+  return promise_rejects(t,
+      'SecurityError',
+      navigator.serviceWorker.register(script, {scope: scope}),
+      'register should fail');
+}, 'Service-Worker-Allowed is cross-origin to page, same-origin to script');
+register_fail_test(
+    build_script_url('../allowed-path'),
+    '/disallowed-path',
+    'Registering outside Service-Worker-Allowed path'),
+register_fail_test(
+    build_script_url('../allowed-path-with-parent'),
+    '/allowed-path-with-parent',
+    'Registering outside Service-Worker-Allowed path with parent reference');
+register_fail_test(
+    build_script_url(host_info.HTTPS_REMOTE_ORIGIN + '/'),
+    'resources/this-scope-is-normally-allowed',
+    'Service-Worker-Allowed is cross-origin to script, registering on a normally allowed scope');
+register_fail_test(
+    build_script_url(host_info.HTTPS_REMOTE_ORIGIN + '/'),
+    '/this-scope-is-normally-disallowed',
+    'Service-Worker-Allowed is cross-origin to script, registering on a normally disallowed scope');
+register_fail_test(
+    build_script_url(host_info.HTTPS_REMOTE_ORIGIN + '/cross-origin/',
+                     host_info.HTTPS_REMOTE_ORIGIN),
+    '/cross-origin/',
+    'Service-Worker-Allowed is cross-origin to page, same-origin to script');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/ServiceWorkerGlobalScope/postmessage.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           registration = r;
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
       .then(function(result) {
           assert_equals(result, 'OK');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Post loopback messages');
 …
     return service_worker_unregister_and_register(t, script1, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           registration = r;
           return wait_for_state(t, registration.installing, 'activated');
 …
           assert_equals(result, 'OK');
           frame.remove();
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Post messages among service workers');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/ServiceWorkerGlobalScope/unregister.https.html

-                      r202471
+                      r246363
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'redundant');
         })
 …
             undefined,
             'After unregister(), the registration should not found');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Unregister on script evaluation');
 …
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'redundant');
         })
 …
             undefined,
             'After unregister(), the registration should not found');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Unregister on installing event');
 …
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'redundant');
         })
 …
             undefined,
             'After unregister(), the registration should not found');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Unregister on activate event');
 …
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
           frame.remove();
           new_frame.remove();
-          return service_worker_unregister_and_done(t, scope);
         })
   }, 'Unregister controlling service worker');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/ServiceWorkerGlobalScope/update.https.html

-                      r202471
+                      r246363
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           registration = r;
           return wait_for_state(t, registration.installing, 'activated');
 …
           frame1.remove();
           frame2.remove();
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Update a registration on ServiceWorkerGlobalScope');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/about-blank-replacement.https.html

-                      r238592
+                      r246363
 async function doAsyncTest(t, scope) {
   let reg = await service_worker_unregister_and_register(t, worker, scope);
+  t.add_cleanup(() => service_worker_unregister(t, scope));
   await wait_for_state(t, reg.installing, 'activated');
 …
   frame.remove();
-  await service_worker_unregister_and_done(t, scope);
+}
 …
   let reg = await service_worker_unregister_and_register(t, worker, scope);
+  t.add_cleanup(() => service_worker_unregister(t, scope));
   await wait_for_state(t, reg.installing, 'activated');
 …
   frame.remove();
-  await service_worker_unregister_and_done(t, scope);
 }, 'Initial about:blank is controlled, exposed to clients.matchAll(), and ' +
    'final Client is not controlled by a service worker.');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/activate-event-after-install-state-change.https.html

-                      r202471
+                      r246363
   return service_worker_unregister_and_register(t, script, scope)
     .then(function(registration) {
+        t.add_cleanup(function() {
+            return service_worker_unregister(t, scope);
+          });
         var sw = registration.installing;
 …
         }));
       })
-    .then(function() {
-        return service_worker_unregister_and_done(t, scope);
-      })
     .catch(unreached_rejection(t));
   }, 'installed event should be fired before activating service worker');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/appcache-ordering-main.https.html

-                      r238592
+                      r246363
 <script>
-var INSTALL_APPCACHE_URL = "resources/appcache-ordering.install.html";
 var IS_APPCACHED_URL = "resources/appcache-ordering.is-appcached.html";
 var SERVICE_WORKER_SCOPE = "resources/appcache-ordering";
 …
 var frames = [];
-// Called by the INSTALL_APPCACHE_URL child frame.
-function notify_appcache_installed(success) {
-  if (success)
-    resolve_install_appcache();
-  else
-    reject_install_appcache();
+}
-function install_appcache() {
-  return new Promise(function(resolve, reject) {
-      var frame = document.createElement('iframe');
-      frames.push(frame);
-      frame.src = INSTALL_APPCACHE_URL;
-      document.body.appendChild(frame);
-      resolve_install_appcache = function() {
-          document.body.removeChild(frame);
-          resolve();
-        };
-      reject_install_appcache = function() {
-          document.body.removeChild(frame);
-          reject();
-        };
-  });
+}
 var resolve_is_appcached = undefined;
 …
     return service_worker_unregister(t, SERVICE_WORKER_SCOPE)
       .then(function() {
           return install_appcache();
+          return install_appcache_ordering_manifest();
         })
       .then(function() {

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-fetch.https.html

-                      r220223
+                      r246363
 <script>
+promise_test(function(t) {
+  var frame;
+  var resource = 'simple.txt';
+async function try_fetch(fetch_func, path) {
+  let response;
+  try {
+   response = await fetch_func(path);
+  } catch (err) {
+    throw (`fetch() threw: ${err}`);
+  }
+  var worker;
+  var scope = 'resources/';
+  var script = 'resources/claim-worker.js';
+  let response_text;
+  try {
+   response_text = await response.text();
+  } catch (err) {
+   throw (`text() threw: ${err}`);
+  }
+  return Promise.resolve()
+    // Create the test iframe.
+    .then(() => with_iframe('resources/blank.html'))
+    .then(f => frame = f)
+  return response_text;
+}
+    // Check the controller and test with fetch.
     .then(() => assert_equals(frame.contentWindow.navigator.controller,
                               undefined,
                               'Should have no controller.'))
     .then(() => frame.contentWindow.fetch(resource))
     .then(response => response.text())
     .then(response_text => assert_equals(response_text,
                                          'a simple text file\n',
                                          'fetch() should not be intercepted.'))
+promise_test(async function(t) {
+  let frame;
+  const scope = 'resources/';
+  const script = 'resources/claim-worker.js';
+  t.add_cleanup(async () => {
+    if (frame)
+      frame.remove();
+    return service_worker_unregister(t, scope);
+  });
+    // Register a service worker.
+    .then(() => service_worker_unregister_and_register(t, script, scope))
+    .then(r => worker = r.installing)
+    .then(() => wait_for_state(t, worker, 'activated'))
+  const resource = 'simple.txt';
+    // Let the service worker claim the iframe.
+    .then(() => {
+      var channel = new MessageChannel();
+      var saw_message = new Promise(function(resolve) {
+        channel.port1.onmessage = t.step_func(function(e) {
+          assert_equals(e.data, 'PASS',
+                        'Worker call to claim() should fulfill.');
+          resolve();
+        });
+      });
+      worker.postMessage({port: channel.port2}, [channel.port2]);
+      return saw_message;
+    })
+  // Create the test frame.
+  await service_worker_unregister(t, scope);
+  frame = await with_iframe('resources/blank.html');
+    // Check the controller and test with fetch.
+    .then(() => frame.contentWindow.navigator.serviceWorker.getRegistration(scope))
+    .then(r => assert_equals(frame.contentWindow.navigator.serviceWorker.controller,
+                             r.active,
+                             'Test iframe should be claimed.'))
+    .then(() => frame.contentWindow.fetch(resource))
+    .then(response => response.text())
+    .then(response_text => assert_equals(response_text,
+                                         'Intercepted!',
+                                         'fetch() should be intercepted.'))
+  // Check the controller and test with fetch.
+  assert_equals(frame.contentWindow.navigator.controller, undefined,
+                'Should have no controller.');
+  let response;
+  try {
+    response = await try_fetch(frame.contentWindow.fetch, resource);
+  } catch (err) {
+    assert_unreached(`uncontrolled fetch failed: ${err}`);
+  }
+  assert_equals(response, 'a simple text file\n',
+                'fetch() should not be intercepted.');
+    // Cleanup this testcase.
+    .then(() => frame.remove())
+    .then(() => service_worker_unregister_and_done(t, scope));
+}, 'fetch() should be intercepted after the client is claimed.')
+  // Register a service worker.
+  const registration = await navigator.serviceWorker.register(script, {scope});
+  const worker = registration.installing;
+  await wait_for_state(t, worker, 'activated');
+  // Tell the service worker to claim the iframe.
+  const saw_message = new Promise((resolve) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = t.step_func((event) => {
+      resolve(event.data);
+    });
+    worker.postMessage({port: channel.port2}, [channel.port2]);
+  });
+  const data = await saw_message;
+  assert_equals(data, 'PASS', 'Worker call to claim() should fulfill.');
+  // Check the controller and test with fetch.
+  const controller = frame.contentWindow.navigator.serviceWorker.controller;
+  assert_true(controller instanceof frame.contentWindow.ServiceWorker,
+              'iframe should be controlled.');
+  try {
+    response = await try_fetch(frame.contentWindow.fetch, resource);
+  } catch (err) {
+    assert_unreached(`controlled fetch failed: ${err}`);
+  }
+  assert_equals(response, 'Intercepted!',
+                'fetch() should be intercepted.');
+}, 'fetch() should be intercepted after the client is claimed.');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-not-using-registration.https.html

-                      r220223
+                      r246363
         t, init_worker_url, init_scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, init_scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
         })
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, claim_scope);
+            });
           claim_worker = registration.installing;
           claim_registration = registration;
 …
           frame2.remove();
           return claim_registration.unregister();
-        })
-      .then(function() {
-          return service_worker_unregister_and_done(t, init_scope);
         });
   }, 'Test claim client which is not using registration');
 …
         })
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, claim_scope);
+            });
           claim_worker = registration.installing;
           return wait_for_state(t, registration.installing, 'activated');
 …
         })
       .then(function() {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           var channel = new MessageChannel();
           var saw_message = new Promise(function(resolve) {
 …
               'registration exists');
           frame.remove();
-          return service_worker_unregister(t, claim_scope);
-        })
-      .then(function() {
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Test claim client when there\'s a longer-matched registration not ' +

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-shared-worker-fetch.https.html

-                      r222307
+                      r246363
     // Register a service worker.
     .then(() => service_worker_unregister_and_register(t, script, scope))
     .then(r => worker = r.installing)
     .then(() => wait_for_state(t, worker, 'activated'))
+    .then(r => {
+        t.add_cleanup(() => service_worker_unregister(t, scope));
+        worker = r.installing;
+        return wait_for_state(t, worker, 'activated')
+      })
     // Let the service worker claim the iframe and the shared worker.
     .then(() => {
 …
     // Cleanup this testcase.
+    .then(() => frame.remove())
+    .then(() => service_worker_unregister_and_done(t, scope));
+    .then(() => frame.remove());
 }, 'fetch() in SharedWorker should be intercepted after the client is claimed.')

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-using-registration.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, url1, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
           frame.remove();
           return sw_registration.unregister();
-        })
-      .then(function() {
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Test worker claims client which is using another registration');
 …
     return service_worker_unregister_and_register(t, url1, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
       .then(function() {
           frame.remove();
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Test for the waiting worker claims a client which is using the the ' +

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/clients-matchall-client-types.https.html

-                      r222307
+                      r246363
         t, 'resources/clients-matchall-worker.js', scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
       .then(function() {
           frame.remove();
+          return service_worker_unregister_and_done(t, scope);
+        })
+      .catch(unreached_rejection(t));
+        });
   }, 'Verify matchAll() with window client type');
 …
         t, 'resources/clients-matchall-worker.js', scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
       .then(function() {
           frame.remove();
-          return service_worker_unregister_and_done(t, scope);
         });
 }, 'Verify matchAll() with {window, sharedworker, worker} client types');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/clients-matchall-order.https.html

-                      r238592
+                      r246363
   let extraWindowResult;
   return service_worker_unregister_and_register(t, script, opts.scope).then(swr => {
+    t.add_cleanup(() => service_worker_unregister(t, opts.scope));
     worker = swr.installing;
     return wait_for_state(t, worker, 'activated');
 …
     frameResultList.forEach(result => result.top.remove());
     extraWindowResult.top.remove();
-  }).then(_ => {
-    return service_worker_unregister_and_done(t, opts.scope);
   }).catch(e => {
     if (frameResultList) {

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/controller-on-reload.https.html

-                      r220223
+                      r246363
     return service_worker_unregister(t, scope)
       .then(function() {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return with_iframe(scope);
         })
 …
           assert_equals(frameRegistration.active, controller);
           frame.remove();
-          service_worker_unregister_and_done(t, scope);
         });
   }, 'controller is set upon reload after registration');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/extendable-event-async-waituntil.https-expected.txt

-                      r238592
+                      r246363
+PASS Test calling waitUntil in a different task without an existing extension throws
+FAIL Test calling waitUntil in a different microtask without an existing extension throws assert_equals: expected "InvalidStateError" but got "OK"
+PASS Test calling waitUntil in a different task with an existing extension succeeds
+PASS Test calling waitUntil with an existing extension promise handler succeeds
+FAIL Test calling waitUntil at the end of the microtask turn throws assert_equals: expected "InvalidStateError" but got "OK"
+PASS Test calling waitUntil in a task at the end of the event handler without an existing extension throws
+PASS Test calling waitUntil in a microtask at the end of the event handler without an existing extension suceeds
+PASS Test calling waitUntil in a different task an existing extension succeeds
+PASS Test calling waitUntil at the end of an existing extension promise handler succeeds (event is still being dispatched)
+PASS Test calling waitUntil in a microtask at the end of an existing extension promise handler succeeds (event is still being dispatched)
+PASS Test calling waitUntil in an existing extension promise handler succeeds (event is not being dispatched)
+PASS Test calling waitUntil in a microtask at the end of an existing extension promise handler throws (event is not being dispatched)
 PASS Test calling waitUntil after the current extension expired in a different task fails
 PASS Test calling waitUntil on a script constructed ExtendableEvent throws exception
 PASS Test calling waitUntil asynchronously with pending respondWith promise.
+PASS Test calling waitUntil synchronously inside microtask of respondWith promise.
+FAIL Test calling waitUntil asynchronously inside microtask of respondWith promise. assert_equals: expected "InvalidStateError" but got "OK"
+PASS Test calling waitUntil synchronously inside microtask of respondWith promise (event is being dispatched).
+PASS Test calling waitUntil asynchronously inside microtask of respondWith promise (event is being dispatched).
+PASS Test calling waitUntil synchronously inside microtask of respondWith promise (event is not being dispatched).
+PASS Test calling waitUntil asynchronously inside microtask of respondWith promise (event is not being dispatched).

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/extendable-event-async-waituntil.https.html

-                      r238592
+                      r246363
 <!DOCTYPE html>
+<meta name="timeout" content="long">
 <script src="/resources/testharness.js"></script>
 <script src="resources/testharness-helpers.js"></script>
 …
 promise_test(msg_event_test.bind(this, 'no-current-extension-different-task'),
   'Test calling waitUntil in a different task without an existing extension throws');
+  'Test calling waitUntil in a task at the end of the event handler without an existing extension throws');
 promise_test(msg_event_test.bind(this, 'no-current-extension-different-microtask'),
   'Test calling waitUntil in a different microtask without an existing extension throws');
+  'Test calling waitUntil in a microtask at the end of the event handler without an existing extension suceeds');
 promise_test(msg_event_test.bind(this, 'current-extension-different-task'),
   'Test calling waitUntil in a different task with an existing extension succeeds');
+  'Test calling waitUntil in a different task an existing extension succeeds');
 promise_test(msg_event_test.bind(this, 'current-extension-expired-same-microtask-turn'),
   'Test calling waitUntil with an existing extension promise handler succeeds');
+promise_test(msg_event_test.bind(this, 'during-event-dispatch-current-extension-expired-same-microtask-turn'),
+  'Test calling waitUntil at the end of an existing extension promise handler succeeds (event is still being dispatched)');
+// The promise handler will queue a new microtask after the check for new
+// extensions was performed.
+promise_test(msg_event_test.bind(this, 'current-extension-expired-same-microtask-turn-extra'),
+  'Test calling waitUntil at the end of the microtask turn throws');
+promise_test(msg_event_test.bind(this, 'during-event-dispatch-current-extension-expired-same-microtask-turn-extra'),
+  'Test calling waitUntil in a microtask at the end of an existing extension promise handler succeeds (event is still being dispatched)');
+promise_test(msg_event_test.bind(this, 'after-event-dispatch-current-extension-expired-same-microtask-turn'),
+  'Test calling waitUntil in an existing extension promise handler succeeds (event is not being dispatched)');
+promise_test(msg_event_test.bind(this, 'after-event-dispatch-current-extension-expired-same-microtask-turn-extra'),
+  'Test calling waitUntil in a microtask at the end of an existing extension promise handler throws (event is not being dispatched)');
 promise_test(msg_event_test.bind(this, 'current-extension-expired-different-task'),
 …
 promise_test(function(t) {
     var testBody = function(worker) {
       return with_iframe('./resources/pending-respondwith-async-waituntil/dummy.html');
+      return with_iframe('./resources/pending-respondwith-async-waituntil');
+    }
     return runTest(t, 'pending-respondwith-async-waituntil', testBody);
 …
 promise_test(function(t) {
     var testBody = function(worker) {
       return with_iframe('./resources/respondwith-microtask-sync-waituntil/dummy.html');
+      return with_iframe('./resources/during-event-dispatch-respondwith-microtask-sync-waituntil');
+    }
     return runTest(t, 'respondwith-microtask-sync-waituntil', testBody);
   }, 'Test calling waitUntil synchronously inside microtask of respondWith promise.');
+    return runTest(t, 'during-event-dispatch-respondwith-microtask-sync-waituntil', testBody);
+  }, 'Test calling waitUntil synchronously inside microtask of respondWith promise (event is being dispatched).');
 promise_test(function(t) {
     var testBody = function(worker) {
       return with_iframe('./resources/respondwith-microtask-async-waituntil/dummy.html');
+      return with_iframe('./resources/during-event-dispatch-respondwith-microtask-async-waituntil');
+    }
     return runTest(t, 'respondwith-microtask-async-waituntil', testBody);
   }, 'Test calling waitUntil asynchronously inside microtask of respondWith promise.');
+    return runTest(t, 'during-event-dispatch-respondwith-microtask-async-waituntil', testBody);
+  }, 'Test calling waitUntil asynchronously inside microtask of respondWith promise (event is being dispatched).');
+promise_test(function(t) {
+    var testBody = function(worker) {
+      return with_iframe('./resources/after-event-dispatch-respondwith-microtask-sync-waituntil');
+    }
+    return runTest(t, 'after-event-dispatch-respondwith-microtask-sync-waituntil', testBody);
+  }, 'Test calling waitUntil synchronously inside microtask of respondWith promise (event is not being dispatched).');
+promise_test(function(t) {
+    var testBody = function(worker) {
+      return with_iframe('./resources/after-event-dispatch-respondwith-microtask-async-waituntil');
+    }
+    return runTest(t, 'after-event-dispatch-respondwith-microtask-async-waituntil', testBody);
+  }, 'Test calling waitUntil asynchronously inside microtask of respondWith promise (event is not being dispatched).');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-canvas-tainting-video-cache.https.html

r238592	r246363
2	2	<meta charset="utf-8">
3	3	<title>Service Worker: canvas tainting of the fetched video using cache responses</title>
	4	<meta name="timeout" content="long">
4	5	<script src="/resources/testharness.js"></script>
5	6	<script src="/resources/testharnessreport.js"></script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-canvas-tainting-video.https.html

r238592	r246363
2	2	<meta charset="utf-8">
3	3	<title>Service Worker: canvas tainting of the fetched video</title>
	4	<meta name="timeout" content="long">
4	5	<script src="/resources/testharness.js"></script>
5	6	<script src="/resources/testharnessreport.js"></script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-csp.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, SCRIPT, SCOPE)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, SCOPE);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
       .then(function() {
           frame.remove();
-          service_worker_unregister_and_done(t, SCOPE);
         });
   }, 'Verify CSP control of fetch() in a Service Worker');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-after-navigation-within-page.https.html

-                      r202471
+                      r246363
     return service_worker_unregister_and_register(t, worker, scope)
       .then(function(reg) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, reg.installing, 'activated');
         })
 …
           assert_equals(response, 'intercepted by service worker');
           frame.remove();
-          return service_worker_unregister_and_done(t, scope);
         })
   }, 'Service Worker should respond to fetch event after the hash changes');
 …
     return service_worker_unregister_and_register(t, worker, scope)
       .then(function(reg) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, reg.installing, 'activated');
         })
 …
           assert_equals(response, 'intercepted by service worker');
           frame.remove();
-          return service_worker_unregister_and_done(t, scope);
         })
   }, 'Service Worker should respond to fetch event after the pushState');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-async-respond-with.https-expected.txt

-                      r227425
+                      r246363
+CONSOLE MESSAGE: Unhandled Promise Rejection: TypeError: cancelled
+PASS Calling respondWith asynchronously throws an exception
+Harness Error (FAIL), message = cancelled
+PASS global setup
+PASS respondWith in a task throws InvalidStateError
+PASS respondWith in a microtask does not throw
+PASS global cleanup

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-async-respond-with.https.html

-                      r220223
+                      r246363
 <!DOCTYPE html>
+<html>
+<title>respondWith cannot be called asynchronously</title>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="resources/test-helpers.sub.js"></script>
 <script>
+promise_test(function(t) {
+    var script = 'resources/fetch-event-async-respond-with-worker.js';
+    var scope = 'resources/simple.html';
+// This file has tests that call respondWith() asynchronously.
+    return service_worker_unregister_and_register(t, script, scope)
+      .then(function(registration) {
+          return wait_for_state(t, registration.installing, 'activated');
+        })
+      .then(function() {
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          add_completion_callback(function() { frame.remove(); });
+          var channel = new MessageChannel();
+          var saw_message = new Promise(function(resolve) {
+              channel.port1.onmessage = function(e) { resolve(e.data); }
+            });
+          var worker = frame.contentWindow.navigator.serviceWorker.controller;
+let frame;
+let worker;
+const script = 'resources/fetch-event-async-respond-with-worker.js';
+const scope = 'resources/simple.html';
+          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 respondWith asynchronously throws an exception');
+// Global setup: this must be the first promise_test.
+promise_test(async (t) => {
+  const registration =
+      await service_worker_unregister_and_register(t, script, scope);
+  worker = registration.installing;
+  await wait_for_state(t, worker, 'activated');
+  frame = await with_iframe(scope);
+}, 'global setup');
+// Waits for a single message from the service worker and then removes the
+// message handler. Not safe for concurrent use.
+function wait_for_message() {
+  return new Promise((resolve) => {
+    const handler = (event) => {
+      navigator.serviceWorker.removeEventListener('message', handler);
+      resolve(event.data);
+    };
+    navigator.serviceWorker.addEventListener('message', handler);
+  });
+}
+// Does one test case. It fetches |url|. The service worker gets a fetch event
+// for |url| and attempts to call respondWith() asynchronously. It reports back
+// to the test whether an exception was thrown.
+async function do_test(url) {
+  // Send a message to tell the worker a new test case is starting.
+  const message = wait_for_message();
+  worker.postMessage('initializeMessageHandler');
+  const response = await message;
+  assert_equals(response, 'messageHandlerInitialized');
+  // Start a fetch.
+  frame.contentWindow.fetch(url);
+  // Receive the test result from the service worker.
+  return wait_for_message();
+};
+promise_test(async (t) => {
+  const result = await do_test('respondWith-in-task');
+  assert_true(result.didThrow, 'should throw');
+  assert_equals(result.error, 'InvalidStateError');
+}, 'respondWith in a task throws InvalidStateError');
+promise_test(async (t) => {
+  const result = await do_test('respondWith-in-microtask');
+  assert_equals(result.didThrow, false, 'should not throw');
+}, 'respondWith in a microtask does not throw');
+// Global cleanup: the final promise_test.
+promise_test(async (t) => {
+  if (frame)
+    frame.remove();
+  await service_worker_unregister(t, scope);
+}, 'global cleanup');
 </script>
+</html>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-network-error.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
           frame.remove();
           assert_equals(result, 'PASS');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Rejecting the fetch event or using preventDefault() causes a network ' +

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-referrer-policy.https-expected.txt

-                      r226397
+                      r246363
 CONSOLE MESSAGE: line 32: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 29: [blocked] The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was not allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 54: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 76: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 98: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 120: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 132: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 197: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 231: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 32: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 54: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 76: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 98: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 120: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 132: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 197: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 231: The page at https://localhost:9443/service-workers/service-worker/fetch-event-referrer-policy.https.html was allowed to display insecure content from http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull.
+CONSOLE MESSAGE: line 29: Not allowed to request resource
+CONSOLE MESSAGE: line 29: Fetch API cannot load http://localhost:8800/service-workers/service-worker//resources/simple.html?referrerFull due to access control checks.
+PASS Service Worker responds to fetch event with the referrer policy
+FAIL Service Worker responds to fetch event with the referrer policy promise_test: Unhandled rejection with value: object "TypeError: Not allowed to request resource"
 PASS Service Worker should respond to fetch with the default referrer policy
 PASS Service Worker should respond to fetch with the referrer URL when a member of RequestInit is present - Default Referrer
-PASS Service Worker should respond to fetch with no referrer when a member of RequestInit is present with an HTTP request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer with "" - Default Referrer
-PASS Service Worker should respond to fetch with no referrer with "" - Default Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "origin" and a same origin request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "origin" and a cross origin request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer URL with "origin-when-cross-origin" and a same origin request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "origin-when-cross-origin" and a cross origin request - Default Referrer
-PASS Service Worker should respond to fetch with no referrer with "no-referrer-when-downgrade" and a same origin request - Default Referrer
-PASS Service Worker should respond to fetch with no referrer with "no-referrer-when-downgrade" and an HTTP request - Default Referrer
-PASS Service Worker should respond to fetch with no referrer with "unsafe-url" - Default Referrer
-PASS Service Worker should respond to fetch with no referrer URL with "no-referrer" - Default Referrer
-PASS Service Worker should respond to fetch with referrer URL with "same-origin" and a same origin request - Default Referrer
-PASS Service Worker should respond to fetch with no referrer with "same-origin" and cross origin request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer origin  with "strict-origin" and a HTTPS cross origin request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "strict-origin" and a same origin request - Default Referrer
-PASS Service Worker should respond to fetch with no referrer with "strict-origin" and a HTTP request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer URL with "strict-origin-when-cross-origin" and a same origin request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "strict-origin-when-cross-origin" and a HTTPS cross origin request - Default Referrer
-PASS Service Worker should respond to fetch with no referrer with "strict-origin-when-cross-origin" and a HTTP request - Default Referrer
-PASS Service Worker should respond to fetch with the referrer URL when a member of RequestInit is present - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer when a member of RequestInit is present with an HTTP request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer with "" - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer with "" - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "origin" and a same origin request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "origin" and a cross origin request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer URL with "origin-when-cross-origin" and a same origin request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "origin-when-cross-origin" and a cross origin request - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer with "no-referrer-when-downgrade" and a same origin request - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer with "no-referrer-when-downgrade" and an HTTP request - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer with "unsafe-url" - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer URL with "no-referrer" - Custom Referrer
-PASS Service Worker should respond to fetch with referrer URL with "same-origin" and a same origin request - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer with "same-origin" and cross origin request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer origin  with "strict-origin" and a HTTPS cross origin request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "strict-origin" and a same origin request - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer with "strict-origin" and a HTTP request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer URL with "strict-origin-when-cross-origin" and a same origin request - Custom Referrer
-PASS Service Worker should respond to fetch with the referrer origin with "strict-origin-when-cross-origin" and a HTTPS cross origin request - Custom Referrer
-PASS Service Worker should respond to fetch with no referrer with "strict-origin-when-cross-origin" and a HTTP request - Custom Referrer

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-referrer-policy.https.html

-                      r238592
+                      r246363
 <script>
 var worker = 'resources/fetch-event-test-worker.js';
-if (window.internals && window.internals.settings)
-    internals.settings.setAllowDisplayOfInsecureContent(true);
 function do_test(referrer, value, expected, name)

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-respond-with-argument.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
           frame.remove();
           assert_equals(result, 'PASS');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'respondWith() takes either a Response or a promise that resolves ' +

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-respond-with-body-loaded-in-chunk.https.html

r227870	r246363
2	2	<meta charset="utf-8">
3	3	<title>respondWith with a response whose body is being loaded from the network by chunks</title>
	4	<meta name="timeout" content="long">
4	5	<script src="/resources/testharness.js"></script>
5	6	<script src="/resources/testharnessreport.js"></script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-respond-with-stops-propagation.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, script, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, registration.installing, 'activated');
         })
 …
       .then(function(message) {
           assert_equals(message, 'PASS');
-          return service_worker_unregister_and_done(t, scope);
         })
   }, 'respondWith() invokes stopImmediatePropagation()');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-throws-after-respond-with.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, workerscript, scope)
       .then(function(reg) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, reg.installing, 'activated')
             .then(() => reg.active);
 …
       .then(function(frame) {
         assert_true(frame.contentDocument.body.innerHTML.includes("intercepted"));
-        service_worker_unregister_and_done(t, scope);
       })
   }, 'Fetch event handler throws after a successful respondWith()');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-request-css-base-url.https-expected.txt

-                      r227425
+                      r246363
+PASS global setup
+FAIL base URL when service worker does respondWith(fetch(responseUrl)). assert_equals: referrer expected "https://localhost:9443/service-workers/service-worker/resources/fetch-request-css-base-url-style.css?fetch" but got "https://localhost:9443/service-workers/service-worker/resources/fetch-request-css-base-url-iframe.html?fetch"
+FAIL base URL when service worker does respondWith(new Response()). assert_equals: referrer expected "https://localhost:9443/service-workers/service-worker/resources/request-url-path/fetch-request-css-base-url-style.css?newResponse" but got "https://localhost:9443/service-workers/service-worker/resources/fetch-request-css-base-url-iframe.html?newResponse"
+PASS cleanup global state
-FAIL CSS's base URL must be the request URL even when fetched from other URL. assert_equals: The base URL while loading the images referred from CSS must be the request URL of CSS. expected "https://localhost:9443/service-workers/service-worker/resources/dummy.png" but got "https://127.0.0.1:9443/service-workers/service-worker/resources/dummy.png"

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-request-css-base-url.https.html

-                      r238592
+                      r246363
 <!DOCTYPE html>
 <title>Service Worker: CSS's base URL must be the request URL even when fetched from other URL</title>
+<title>Service Worker: CSS's base URL must be the response URL</title>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
-<script src="/common/get-host-info.sub.js"></script>
 <script src="resources/test-helpers.sub.js?pipe=sub"></script>
 <script>
+promise_test(function(t) {
+    var SCOPE = 'resources/fetch-request-css-base-url-iframe.html';
+    var SCRIPT = 'resources/fetch-request-css-base-url-worker.js';
+    var worker;
+    var testDonePromise;
+const SCOPE = 'resources/fetch-request-css-base-url-iframe.html';
+const SCRIPT = 'resources/fetch-request-css-base-url-worker.js';
+let worker;
+    return service_worker_unregister_and_register(t, SCRIPT, SCOPE)
+      .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, SCOPE);
+            });
+var signalMessage;
+function getNextMessage() {
+  return new Promise(resolve => { signalMessage = resolve; });
+}
+          worker = registration.installing;
+          return wait_for_state(t, worker, 'activated');
+        })
+      .then(function() {
+          return new Promise(function(resolve) {
+              var channel = new MessageChannel();
+              testDonePromise = new Promise(function(resolveTestDone) {
+                channel.port1.onmessage = t.step_func(function(msg) {
+                  if (msg.data.ready) {
+                    resolve();
+                    return;
+                  }
+                  var result = msg.data;
+                  var base = get_host_info()['HTTPS_ORIGIN'] + base_path();
+                  assert_equals(
+                    result.url,
+                    base + 'resources/dummy.png',
+                    'The base URL while loading the images referred from CSS ' +
+                    'must be the request URL of CSS.');
+                  assert_equals(
+                    result.referrer,
+                    base + 'resources/fetch-request-css-base-url-style.css',
+                    'While loading the image defined in CSS the referrer must ' +
+                    'be the request URL of CSS.');
+                  resolveTestDone();
+                });
+              });
+              worker.postMessage(
+                {port: channel.port2}, [channel.port2]);
+            });
+        })
+      .then(function() { return with_iframe(SCOPE); })
+      .then(function(f) {
+          return testDonePromise.then(function() {
+            f.remove();
+          });
+        });
+  }, 'CSS\'s base URL must be the request URL even when fetched from other URL.');
+promise_test(async (t) => {
+  const registration = await service_worker_unregister_and_register(
+      t, SCRIPT, SCOPE);
+  worker = registration.installing;
+  await wait_for_state(t, worker, 'activated');
+}, 'global setup');
+// Creates a test concerning the base URL of a stylesheet. It loads a
+// stylesheet from a controlled page. The stylesheet makes a subresource
+// request for an image. The service worker messages back the details of the
+// image request in order to test the base URL.
+//
+// The request URL for the stylesheet is under "resources/request-url-path/".
+// The service worker may respond in a way such that the response URL is
+// different to the request URL.
+function base_url_test(params) {
+  promise_test(async (t) => {
+    let frame;
+    t.add_cleanup(() => {
+      if (frame)
+        frame.remove();
+    });
+    // Ask the service worker to message this page once it gets the request
+    // for the image.
+    let channel = new MessageChannel();
+    const sawPong = getNextMessage();
+    channel.port1.onmessage = (event) => {
+      signalMessage(event.data);
+    };
+    worker.postMessage({port:channel.port2},[channel.port2]);
+    // It sends a pong back immediately. This ping/pong protocol helps deflake
+    // the test for browsers where message/fetch ordering isn't guaranteed.
+    assert_equals('pong', await sawPong);
+    // Load the frame which will load the stylesheet that makes the image
+    // request.
+    const sawResult = getNextMessage();
+    frame = await with_iframe(params.framePath);
+    const result = await sawResult;
+    // Test the image request.
+    const base = new URL('.', document.location).href;
+    assert_equals(result.url,
+                  base + params.expectImageRequestPath,
+                  'request');
+    assert_equals(result.referrer,
+                  base + params.expectImageRequestReferrer,
+                  'referrer');
+  }, params.description);
+}
+const cssFile = 'fetch-request-css-base-url-style.css';
+base_url_test({
+  framePath: SCOPE + '?fetch',
+  expectImageRequestPath: 'resources/dummy.png',
+  expectImageRequestReferrer: `resources/${cssFile}?fetch`,
+  description: 'base URL when service worker does respondWith(fetch(responseUrl)).'});
+base_url_test({
+  framePath: SCOPE + '?newResponse',
+  expectImageRequestPath: 'resources/request-url-path/dummy.png',
+  expectImageRequestReferrer: `resources/request-url-path/${cssFile}?newResponse`,
+  description: 'base URL when service worker does respondWith(new Response()).'});
+// Cleanup step: this must be the last promise_test.
+promise_test(async (t) => {
+  return service_worker_unregister(t, SCOPE);
+}, 'cleanup global state');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-request-redirect.https.html

-                      r226792
+                      r246363
     return service_worker_unregister_and_register(t, SCRIPT, SCOPE)
       .then(function(registration) {
+          t.add_cleanup(() => service_worker_unregister(t, SCOPE));
           worker = registration.installing;
           return wait_for_state(t, worker, 'activated');
 …
       .then(function() {
           frame.remove();
-          service_worker_unregister_and_done(t, SCOPE);
         });
   }, 'Verify redirect mode of Fetch API and ServiceWorker FetchEvent.');
 …
     return service_worker_unregister_and_register(t, SCRIPT, SCOPE)
       .then(function(registration) {
+          t.add_cleanup(() => service_worker_unregister(t, SCOPE));
           worker = registration.installing;
           return wait_for_state(t, worker, 'activated');
 …
       .then(function() {
           frame.remove();
-          service_worker_unregister_and_done(t, SCOPE);
         });
   }, 'Verify redirected of Response(Fetch API) and ServiceWorker FetchEvent.');
 …
     return service_worker_unregister_and_register(t, SCRIPT, SCOPE)
       .then(function(registration) {
+          t.add_cleanup(() => service_worker_unregister(t, SCOPE));
           worker = registration.installing;
           return wait_for_state(t, worker, 'activated');
 …
       .then(function() {
           frame.remove();
-          service_worker_unregister_and_done(t, SCOPE);
         });
   }, 'Verify redirected of Response(Fetch API), Cache API and ServiceWorker ' +

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/getregistration.https-expected.txt

r224453	r246363
5	5	PASS getRegistration with a cross origin URL
6	6	PASS Register then Unregister then getRegistration
	7	PASS Register then Unregister then getRegistration in controlled iframe
7	8

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/getregistration.https.html

-                      r238592
+                      r246363
   }, 'Register then Unregister then getRegistration');
+promise_test(async function(t) {
+  const scope = 'resources/scope/getregistration/register-unregister';
+  const registration = await service_worker_unregister_and_register(
+    t, 'resources/empty-worker.js', scope
+  );
+  const frame = await with_iframe(scope);
+  t.add_cleanup(() => frame.remove());
+  const frameNav = frame.contentWindow.navigator;
+  await registration.unregister();
+  const value = await frameNav.serviceWorker.getRegistration(scope);
+  assert_equals(value, undefined, 'getRegistration should resolve with undefined');
+}, 'Register then Unregister then getRegistration in controlled iframe');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/import-scripts-resource-map.https-expected.txt

r224132	r246363
1	1
2	2	PASS import the same script URL multiple times
	3	PASS call importScripts() with multiple arguments
3	4

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/import-scripts-resource-map.https.html

-                      r220223
+                      r246363
 <!DOCTYPE html>
 <meta charset="utf-8">
+<meta charset="utf-8" />
 <title>Tests for importScripts: script resource map</title>
 <script src="/resources/testharness.js"></script>
 …
 <script src="resources/test-helpers.sub.js"></script>
 <body>
+<script>
+// This test registers a worker that imports a script multiple times. The
+// script should be stored on the first import and thereafter that stored
+// script should be loaded. The worker asserts that the stored script was
+// loaded; if the assert fails then registration fails.
+promise_test(t => {
+    const scope = 'resources/import-scripts-resource-map';
+    return service_worker_unregister(t, scope)
+      .then(() => {
+          return navigator.serviceWorker.register(
+              'resources/import-scripts-resource-map-worker.js', {scope: scope});
+        })
+      .then(r => r.unregister());
+  }, 'import the same script URL multiple times');
+</script>
+  <script>
+    // This test registers a worker that imports a script multiple times. The
+    // script should be stored on the first import and thereafter that stored
+    // script should be loaded. The worker asserts that the stored script was
+    // loaded; if the assert fails then registration fails.
+    promise_test(async t => {
+      const SCOPE = "resources/import-scripts-resource-map";
+      const SCRIPT = "resources/import-scripts-resource-map-worker.js";
+      await service_worker_unregister(t, SCOPE);
+      const registration = await navigator.serviceWorker.register(SCRIPT, {
+        scope: SCOPE
+      });
+      await registration.unregister();
+    }, "import the same script URL multiple times");
+    promise_test(async t => {
+      const SCOPE = "resources/import-scripts-diff-resource-map";
+      const SCRIPT = "resources/import-scripts-diff-resource-map-worker.js";
+      await service_worker_unregister(t, SCOPE);
+      const registration = await navigator.serviceWorker.register(SCRIPT, {
+        scope: SCOPE
+      });
+      await registration.unregister();
+    }, "call importScripts() with multiple arguments");
+  </script>
 </body>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/interfaces-window.https.html

r238592	r246363
1	1	<!DOCTYPE html>
2	2	<title>Service Worker: Interfaces</title>
	3	<meta name="timeout" content="long">
3	4	<script src="/resources/testharness.js"></script>
4	5	<script src="/resources/testharnessreport.js"></script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/multiple-update.https.html

-                      r223273
+                      r246363
     return service_worker_unregister_and_register(t, expected_url, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           registration = r;
           return wait_for_state(t, registration.installing, 'activated');
 …
           assert_equals(registration.active.scriptURL, expected_url,
                         'active should still exist after update found.');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Trigger multiple updates.');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/navigation-redirect.https.html

-                      r238592
+                      r246363
+// SW responds with a fetch from a different url.
+// SW: event.respondWith(fetch(params['url']));
+url2 = SCOPE1;
+url1 = SCOPE1 + 'sw=fetch-url&url=' + encodeURIComponent(url2);
+redirect_test(
+    url1,
+    url1,
+    [
+      [
+        {url: url1, resultingClientIdTag: 'x'}
+      ],
+      [],
+      []
+    ],
+    'x',
+    'SW-fetched response from different URL, same-origin same-scope.');
 // Opaque redirect.
 // SW: event.respondWith(fetch(

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/performance-timeline.https.html

-                      r220223
+                      r246363
   let frame;
   return service_worker_unregister_and_register(t, script, scope)
+    .then(reg => wait_for_state(t, reg.installing, 'activated'))
+    .then(reg => {
+        t.add_cleanup(() => service_worker_unregister(t, scope));
+        return wait_for_state(t, reg.installing, 'activated');
+      })
     .then(_ => with_iframe(scope))
     .then(f => {
 …
                   'Slow service worker request should measure increased delay.');
       frame.remove();
-      return service_worker_unregister_and_done(t, scope);
     })
 }, 'empty service worker fetch event included in performance timings');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/postmessage-to-client-message-queue.https.html

-                      r238592
+                      r246363
     description)
+{
     function later_state(state1, state2) {
+    function assert_state_less_than_equal(state1, state2, explanation) {
         const states = ['init', 'install', 'start', 'finish', 'loaded'];
         const index1 = states.indexOf(state1);
         const index2 = states.indexOf(state2);
         const max_index = Math.max(index1, index2);
         return states[max_index];
+        if (index1 > index2)
+          assert_unreached(explanation);
+    }
 …
         // Wait for all messages to get dispatched on the child's
         // ServiceWorkerContainer and then verify that each message
         // was dispatched while the child was in the correct state.
+        // was dispatched after |earliest_dispatch|.
         const report = await t.frame.report;
         ['init', 'install', 'start'].forEach(state => {
+            const dispatch = later_state(state, earliest_dispatch);
+            assert_equals(report[state], dispatch,
+                          `Message sent in state '${state}' dispatched in state '${dispatch}'`);
+            const explanation = `Message sent in state '${state}' was dispatched in '${report[state]}', should be dispatched no earlier than '${earliest_dispatch}'`;
+            assert_state_less_than_equal(earliest_dispatch,
+                                         report[state],
+                                         explanation);
         });
     }, description);

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/postmessage.https-expected.txt

r238592	r246363
4	4	PASS postMessage a transferable ArrayBuffer between ServiceWorker and Client over MessagePort
5	5	FAIL postMessage with dictionary a transferable ArrayBuffer between ServiceWorker and Client promise_test: Unhandled rejection with value: object "TypeError: Type error"
	6	FAIL postMessage to a redundant worker promise_test: Unhandled rejection with value: object "InvalidStateError: Service Worker state is redundant"
6	7

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/postmessage.https.html

-                      r238592
+                      r246363
           assert_equals(e.data, 'quit');
           return registration.unregister(scope);
-        })
-      .then(() => { return wait_for_state(t, worker, 'redundant'); })
-      .then(() => {
-          assert_equals(worker.state, 'redundant');
-          assert_throws(
-            {name:'InvalidStateError'},
-            function() { worker.postMessage(''); },
-            'Calling postMessage on a redundant ServiceWorker should ' +
-                'throw InvalidStateError.');
         });
   }, 'postMessage to a ServiceWorker (and back via MessagePort)');
 …
   }, 'postMessage with dictionary a transferable ArrayBuffer between ServiceWorker and Client');
+  promise_test(async t => {
+    const firstScript = 'resources/postmessage-echo-worker.js?one';
+    const secondScript = 'resources/postmessage-echo-worker.js?two';
+    const scope = 'resources/';
+    const registration = await service_worker_unregister_and_register(t, firstScript, scope);
+    t.add_cleanup(() => registration.unregister());
+    const firstWorker = registration.installing;
+    const messagePromise = new Promise(resolve => {
+      navigator.serviceWorker.addEventListener('message', (event) => {
+        resolve(event.data);
+      }, {once: true});
+    });
+    await wait_for_state(t, firstWorker, 'activated');
+    await navigator.serviceWorker.register(secondScript, {scope});
+    const secondWorker = registration.installing;
+    await wait_for_state(t, firstWorker, 'redundant');
+    // postMessage() to a redundant worker should be dropped silently.
+    // Historically, this threw an exception.
+    firstWorker.postMessage('firstWorker');
+    // To test somewhat that it was not received, send a message to another
+    // worker and check that we get a reply for that one.
+    secondWorker.postMessage('secondWorker');
+    const data = await messagePromise;
+    assert_equals(data, 'secondWorker');
+  }, 'postMessage to a redundant worker');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/ready.https-expected.txt

r225577	r246363
10	10	PASS ready after a longer matched registration registered
11	11	PASS access ready after it has been resolved
12		PASS access ready on uninstalling registration that is resurrected
	12	FAIL resolve ready after unregistering and reregistering assert_not_equals: Registrations should be different got disallowed value object "[object ServiceWorkerRegistration]"
	13	FAIL resolve ready before unregistering and reregistering assert_equals: Resolves with the first registration expected "https://localhost:9443/service-workers/service-worker/resources/empty-worker.js" but got "https://localhost:9443/service-workers/service-worker/resources/empty-worker.js?2"
13	14

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/ready.https.html

-                      r224156
+                      r246363
 promise_test(async function(t) {
+    var url = 'resources/empty-worker.js';
+    var matched_scope = 'resources/blank.html?ready-after-resurrect';
+    let reg1 = await service_worker_unregister_and_register(t, url, matched_scope);
+    add_completion_callback(function() {
+        reg1.unregister();
+      });
+    await wait_for_state(t, reg1.installing, 'activated');
+    // Hold the worker alive with a controlled worker
+    let frame = await with_iframe(matched_scope);
+    add_completion_callback(function() {
+        frame.remove();
+      });
+    // Doom the registration as uninstalling.
+    await reg1.unregister();
+    // Access the ready promise while the registration is doomed.
+    let readyPromise = frame.contentWindow.navigator.serviceWorker.ready;
+    // Resurrect the doomed registration;
+    let reg2 = await service_worker_unregister_and_register(t, url, matched_scope);
+    assert_equals(reg1, reg2, 'existing registration should be resurrected');
+    // We are trying to test if the ready promise ever resolves here.  Use
+    // an explicit timeout check here rather than forcing a full infrastructure
+    // level timeout.
+    let timeoutId;
+    let timeoutPromise = new Promise(resolve => {
+      timeoutId = setTimeout(_ => {
+        timeoutId = null;
+        resolve();
+      }, 500);
+    });
+    // This should resolve immediately since there is an alive registration
+    // with an active promise for the matching scope.
+    await Promise.race([readyPromise, timeoutPromise]);
+    assert_not_equals(timeoutId, null,
+                      'ready promise should resolve before timeout');
+    clearTimeout(timeoutId);
+    // We should get here and not time out.
+  }, 'access ready on uninstalling registration that is resurrected');
+  const url1 = 'resources/empty-worker.js';
+  const url2 = url1 + '?2';
+  const matched_scope = 'resources/blank.html?ready-after-unregister';
+  const reg1 = await service_worker_unregister_and_register(t, url1, matched_scope);
+  t.add_cleanup(() => reg1.unregister());
+  await wait_for_state(t, reg1.installing, 'activating');
+  // This registration will resolve all ready promises in clients that match the scope.
+  // But there are no clients.
+  const frame = await with_iframe(matched_scope);
+  t.add_cleanup(() => frame.remove());
+  await reg1.unregister();
+  // Access the ready promise while the registration is unregistering.
+  const readyPromise = frame.contentWindow.navigator.serviceWorker.ready;
+  // Create a new registration.
+  const reg2 = await navigator.serviceWorker.register(url2, { scope: matched_scope });
+  t.add_cleanup(() => reg2.unregister());
+  // This registration will resolve all ready promises in clients that match the scope.
+  // That includes frame's client.
+  const readyReg = await readyPromise;
+  assert_equals(readyReg.active.scriptURL, reg2.active.scriptURL, 'Resolves with the second registration');
+  assert_not_equals(reg1, reg2, 'Registrations should be different');
+}, 'resolve ready after unregistering and reregistering');
+promise_test(async function(t) {
+  const url1 = 'resources/empty-worker.js';
+  const url2 = url1 + '?2';
+  const matched_scope = 'resources/blank.html?ready-after-unregister';
+  const frame = await with_iframe(matched_scope);
+  t.add_cleanup(() => frame.remove());
+  const reg1 = await service_worker_unregister_and_register(t, url1, matched_scope);
+  t.add_cleanup(() => reg1.unregister());
+  await wait_for_state(t, reg1.installing, 'activated');
+  // This registration will resolve all ready promises in clients that match the scope.
+  // That includes frame's client.
+  const reg1Active = reg1.active;
+  await reg1.unregister();
+  // Access the ready promise while the registration is unregistering.
+  const readyPromise = frame.contentWindow.navigator.serviceWorker.ready;
+  // Create a new registration.
+  const reg2 = await navigator.serviceWorker.register(url2, { scope: matched_scope });
+  t.add_cleanup(() => reg2.unregister());
+  // This registration will resolve all ready promises in clients that match the scope.
+  // That includes frame's client, but its ready promise has already resolved.
+  const readyReg = await readyPromise;
+  assert_equals(readyReg.active.scriptURL, reg1Active.scriptURL, 'Resolves with the first registration');
+  assert_not_equals(reg1, reg2, 'Registrations should be different');
+}, 'resolve ready before unregistering and reregistering');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/register-default-scope.https.html

-                      r202471
+                      r246363
       .then(
         function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, registration.scope);
+            });
           assert_unreached('register should fail');
-          service_worker_unregister_and_done(t, registration.scope);
         },
         function(error) {

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/register-wait-forever-in-install-worker.https.html

-                      r202471
+                      r246363
     return navigator.serviceWorker.register(bad_script, {scope: scope})
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           registration = r;
           assert_equals(registration.installing.scriptURL,
 …
           return wait_for_state(t, registration.installing, 'activated');
         })
-      .then(function() {
-          return service_worker_unregister_and_done(t, scope);
-        })
   }, 'register worker that calls waitUntil with a promise that never ' +
      'resolves in oninstall');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-end-to-end.https.html

-                      r202471
+                      r246363
     var lastServiceWorkerState = '';
     var receivedMessageFromPort = '';
-    var currentChangeCount = 0;
     assert_true(navigator.serviceWorker instanceof ServiceWorkerContainer);
     assert_equals(typeof navigator.serviceWorker.register, 'function');
     assert_equals(typeof navigator.serviceWorker.getRegistration, 'function');
-    navigator.serviceWorker.oncurrentchange = function() {
-        ++currentChangeCount;
-    };
     service_worker_unregister_and_register(
 …
                                 'Service worker should pass through all states');
-            assert_equals(currentChangeCount, 0,
-                          'Should not see current changes since document is out of scope');
             assert_equals(receivedMessageFromPort, 'Ack for: registering doc');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-mime-types.https.html

r222307	r246363
1	1	<!DOCTYPE html>
2	2	<title>Service Worker: Registration (MIME types)</title>
	3	<meta name="timeout" content="long">
3	4	<script src="/resources/testharness.js"></script>
4	5	<script src="/resources/testharnessreport.js"></script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-updateviacache.https-expected.txt

r238592	r246363
24	24	PASS access-updateViaCache-after-unregister-all
25	25	PASS access-updateViaCache-after-unregister-none
	26	FAIL updateViaCache is not updated if register() rejects assert_equals: after update attempt expected "imports" but got "none"
26	27

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-updateviacache.https.html

-                      r238592
+                      r246363
+  }
+  promise_test(async t => {
+    await cleanup();
+    t.add_cleanup(cleanup);
+    const registration = await navigator.serviceWorker.register(
+        'resources/empty.js',
+        {scope: SCOPE});
+    assert_equals(registration.updateViaCache, 'imports',
+                  'before update attempt');
+    const fail = navigator.serviceWorker.register(
+        'resources/malformed-worker.py?parse-error',
+        {scope: SCOPE, updateViaCache: 'none'});
+    await promise_rejects(t, new TypeError(), fail);
+    assert_equals(registration.updateViaCache, 'imports',
+                  'after update attempt');
+  }, 'updateViaCache is not updated if register() rejects');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resource-timing.sub.https.html

-                      r244776
+                      r246363
     const url = options.mode === 'cross-origin' ? crossOriginUrl(options.resource)
                                       : resourceUrl(options.resource);
     const entryList = options.performance.getEntriesByName(url);
+    const entryList = options.performance.getEntriesByName(url, 'resource');
     if (options.should_no_performance_entry) {
         // The performance timeline may not have an entry for a resource
 …
 test(() => {
     const url = resourceUrl('resources/test-helpers.sub.js');
     const entry = window.performance.getEntriesByName(url)[0];
+    const entry = window.performance.getEntriesByName(url, 'resource')[0];
     assert_equals(entry.workerStart, 0, 'Non-controlled');
 }, 'Non-controlled resource loads');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/appcache-ordering.manifest

r202471	r246363
2	2
3	3	appcache-ordering.is-appcached.html
	4	blank.html
4	5
5	6	FALLBACK:

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/claim-worker.js

-                      r220223
+                      r246363
 self.addEventListener('fetch', function(event) {
+    event.respondWith(new Response('Intercepted!'));
+});
+    if (!/404/.test(event.request.url))
+      event.respondWith(new Response('Intercepted!'));
+  });

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/extendable-event-async-waituntil.js

-                      r222307
+                      r246363
+// controlled by 'init'/'done' messages.
+// 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;
 …
         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('InvalidStateError'));
+        break;
+        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;
+      case 'current-extension-expired-same-microtask-turn':
+      // 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);
 …
           .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.
+      // 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'));
 …
 self.addEventListener('fetch', function(event) {
+    if (event.request.url.indexOf('pending-respondwith-async-waituntil') != -1) {
+  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;
       let response = new Promise((res) => { resolveFetch = res; });
+      response = new Promise((res) => { resolveFetch = res; });
       event.respondWith(response);
       async_task_waituntil(event)
         .then(reportResultExpecting('OK'))
         .then(() => { resolveFetch(new Response('OK')); });
+    } else if (event.request.url.indexOf('respondwith-microtask-sync-waituntil') != -1) {
+      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'))
+    } else if (event.request.url.indexOf('respondwith-microtask-async-waituntil') != -1) {
+        .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) {
 …
   });
+}
+// Returns a promise that settles in a separate task.
+function makeNewTaskPromise() {
+  return new Promise(resolve => {
+    setTimeout(resolve, 0);
+  });
+}

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/fetch-event-async-respond-with-worker.js

-                      r220223
+                      r246363
+var result;
+// This worker attempts to call respondWith() asynchronously after the
+// fetch event handler finished. It reports back to the test whether
+// an exception was thrown.
+self.addEventListener('message', function(event) {
+    event.data.port.postMessage(result);
+// These get reset at the start of a test case.
+let reportResult;
+// The test page sends a message to tell us that a new test case is starting.
+// We expect a fetch event after this.
+self.addEventListener('message', (event) => {
+  // Ensure tests run mutually exclusive.
+  if (reportResult) {
+    event.source.postMessage('testAlreadyRunning');
+    return;
+  }
+  const resultPromise = new Promise((resolve) => {
+    reportResult = resolve;
+    // Tell the client that everything is initialized and that it's safe to
+    // proceed with the test without relying on the order of events (which some
+    // browsers like Chrome may not guarantee).
+    event.source.postMessage('messageHandlerInitialized');
   });
+  // Keep the worker alive until the test case finishes, and report
+  // back the result to the test page.
+  event.waitUntil(resultPromise.then(result => {
+    reportResult = null;
+    event.source.postMessage(result);
+  }));
+});
+// Calls respondWith() and reports back whether an exception occurred.
+function tryRespondWith(event) {
+  try {
+    event.respondWith(new Response());
+    reportResult({didThrow: false});
+  } catch (error) {
+    reportResult({didThrow: true, error: error.name});
+  }
+}
+function respondWithInTask(event) {
+  setTimeout(() => {
+    tryRespondWith(event);
+  }, 0);
+}
+function respondWithInMicrotask(event) {
+  Promise.resolve().then(() => {
+    tryRespondWith(event);
+  });
+}
 self.addEventListener('fetch', function(event) {
+    setTimeout(function() {
+        try {
+          event.respondWith(new Response());
+          result = 'FAIL: did not throw';
+        } catch (error) {
+          if (error.name == 'InvalidStateError')
+            result = 'PASS';
+          else
+            result = 'FAIL: Unexpected exception: ' + error;
+        }
+      }, 0);
+  });
+  const path = new URL(event.request.url).pathname;
+  const test = path.substring(path.lastIndexOf('/') + 1);
+  // If this is a test case, try respondWith() and report back to the test page
+  // the result.
+  if (test == 'respondWith-in-task') {
+    respondWithInTask(event);
+  } else if (test == 'respondWith-in-microtask') {
+    respondWithInMicrotask(event);
+  }
+});

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/fetch-event-network-fallback-worker.js

r238592	r246363
1	1	self.addEventListener('fetch', () => {
2		// Do nothing.
3		});
	2	// Do nothing.
	3	});

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/fetch-request-css-base-url-iframe.html

-                      r220223
+                      r246363
+<link href="./fetch-request-css-base-url-style.css" rel="stylesheet" type="text/css">
+<html>
+<head>
+<title>iframe for css base url test</title>
+</head>
+<body>
+<script>
+// Load a stylesheet. Create it dynamically so we can construct the href URL
+// dynamically.
+const link = document.createElement('link');
+link.rel = 'stylesheet';
+link.type = 'text/css';
+// Add "request-url-path" to the path to help distinguish the request URL from
+// the response URL. Add |document.location.search| (chosen by the test main
+// page) to tell the service worker how to respond to the request.
+link.href = 'request-url-path/fetch-request-css-base-url-style.css' +
+    document.location.search;
+document.head.appendChild(link);
+</script>
+</body>
+</html>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/fetch-request-css-base-url-worker.js

-                      r220223
+                      r246363
+importScripts('/common/get-host-info.sub.js');
+importScripts('test-helpers.sub.js');
+let source;
+let resolveDone;
+let done = new Promise(resolve => resolveDone = resolve);
+var port = undefined;
+// The page messages this worker to ask for the result. Keep the worker alive
+// via waitUntil() until the result is sent.
+self.addEventListener('message', event => {
+  source = event.data.port;
+  source.postMessage('pong');
+  event.waitUntil(done);
+});
+self.onmessage = function(e) {
+  var message = e.data;
+  if ('port' in message) {
+    port = message.port;
+    port.postMessage({ready: true});
+self.addEventListener('fetch', event => {
+  const url = new URL(event.request.url);
+  // For the CSS file, respond in a way that may change the response URL,
+  // depending on |url.search|.
+  const cssPath = 'request-url-path/fetch-request-css-base-url-style.css';
+  if (url.pathname.indexOf(cssPath) != -1) {
+    // Respond with a different URL, deleting "request-url-path/".
+    if (url.search == '?fetch') {
+      event.respondWith(fetch('fetch-request-css-base-url-style.css'));
+    }
+    // Respond with new Response().
+    else if (url.search == '?newResponse') {
+      const styleString = 'body { background-image: url("./dummy.png");}';
+      const headers = {'content-type': 'text/css'};
+      event.respondWith(new Response(styleString, headers));
+    }
+  }
-};
+self.addEventListener('fetch', function(event) {
     var url = event.request.url;
     if (url.indexOf('fetch-request-css-base-url-style.css') != -1) {
       event.respondWith(fetch(
         get_host_info()['HTTPS_REMOTE_ORIGIN'] + base_path() +
         'fetch-request-css-base-url-style.css',
         {mode: 'no-cors'}));
     } else if (url.indexOf('dummy.png') != -1) {
       port.postMessage({
           url: event.request.url,
           referrer: event.request.referrer
         });
+    }
   });
+  // The image request indicates what the base URL of the CSS was. Message the
+  // result back to the test page.
+  else if (url.pathname.indexOf('dummy.png') != -1) {
+    // For some reason |source| is undefined here when running the test manually
+    // in Firefox. The test author experimented with both using Client
+    // (event.source) and MessagePort to try to get the test to pass, but
+    // failed.
+    source.postMessage({
+      url: event.request.url,
+      referrer: event.request.referrer
+    });
+    resolveDone();
+  }
+});

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/service-worker-csp-worker.py

-                      r220223
+                      r246363
                 'Importing the other origins script should fail.');
   }, 'importScripts test for default-src');
+test(function() {
+    assert_throws(EvalError(),
+                  function() { eval('1 + 1'); },
+                  'eval() should throw EvalError.')
+    assert_throws(EvalError(),
+                  function() { new Function('1 + 1'); },
+                  'new Function() should throw EvalError.')
+  }, 'eval test for default-src');
 async_test(function(t) {
 …
   }, 'importScripts test for script-src');
+test(function() {
+    assert_throws(EvalError(),
+                  function() { eval('1 + 1'); },
+                  'eval() should throw EvalError.')
+    assert_throws(EvalError(),
+                  function() { new Function('1 + 1'); },
+                  'new Function() should throw EvalError.')
+  }, 'eval test for script-src');
 async_test(function(t) {
     fetch(host_info.HTTPS_REMOTE_ORIGIN +
 …
   }, 'importScripts test for connect-src');
+test(function() {
+    var eval_failed = false;
+    try {
+      eval('1 + 1');
+      new Function('1 + 1');
+    } catch(e) {
+      eval_failed = true;
+    }
+    assert_false(eval_failed,
+                 'connect-src without unsafe-eval should not block eval().');
+  }, 'eval test for connect-src');
 async_test(function(t) {
     fetch(host_info.HTTPS_REMOTE_ORIGIN +

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/test-helpers.sub.js

-                      r238592
+                      r246363
   return new Promise(test.step_func(function(resolve) {
+      registration.addEventListener('updatefound', test.step_func(function() {
+          resolve(registration.installing);
+        }));
+      var handler = test.step_func(function() {
+        registration.removeEventListener('updatefound', handler);
+        resolve(registration.installing);
+      });
+      registration.addEventListener('updatefound', handler);
     }));
+}
 …
   await registration.unregister();
+}
+// This installs resources/appcache-ordering.manifest.
+function install_appcache_ordering_manifest() {
+  let resolve_install_appcache;
+  let reject_install_appcache;
+  // This is notified by the child iframe, i.e. appcache-ordering.install.html,
+  // that's to be created below.
+  window.notify_appcache_installed = success => {
+    if (success)
+      resolve_install_appcache();
+    else
+      reject_install_appcache();
+  };
+  return new Promise((resolve, reject) => {
+      const frame = document.createElement('iframe');
+      frame.src = 'resources/appcache-ordering.install.html';
+      document.body.appendChild(frame);
+      resolve_install_appcache = function() {
+          document.body.removeChild(frame);
+          resolve();
+        };
+      reject_install_appcache = function() {
+          document.body.removeChild(frame);
+          reject();
+        };
+  });
+}

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/update-during-installation-worker.js

-                      r238592
+                      r246363
 'use strict';
 const installMayFinish = new Promise(resolve => {
     self.finishInstall = resolve;
+const installEventFired = new Promise(resolve => {
+  self.fireInstallEvent = resolve;
 });
+let report = { installEventFired: false };
+const installFinished = new Promise(resolve => {
+  self.finishInstall = resolve;
+});
 addEventListener('install', event => {
+    report.installEventFired = true;
+    let attemptUpdate = registration.update().catch(exception => {
+        report.exception = exception.name;
+    });
+    event.waitUntil(Promise.all([installMayFinish, attemptUpdate]));
+  fireInstallEvent();
+  event.waitUntil(installFinished);
 });
 addEventListener('message', event => {
+    if (event.data === 'finishInstall') {
+  // Use a dedicated MessageChannel for every request so senders can wait for
+  // individual requests to finish, and concurrent requests (to different
+  // workers) don't cause race conditions.
+  const port = event.data;
+  port.onmessage = (event) => {
+    switch (event.data) {
+      case 'awaitInstallEvent':
+        installEventFired.then(() => {
+            port.postMessage('installEventFired');
+        });
+        break;
+      case 'finishInstall':
+        installFinished.then(() => {
+            port.postMessage('installFinished');
+        });
         finishInstall();
+    } else {
+        event.source.postMessage(report);
+        break;
+      case 'callUpdate': {
+        const channel = new MessageChannel();
+        registration.update().then(() => {
+            channel.port2.postMessage({
+                success: true,
+            });
+        }).catch((exception) => {
+            channel.port2.postMessage({
+                success: false,
+                exception: exception.name,
+            });
+        });
+        port.postMessage(channel.port1, [channel.port1]);
+        break;
+      }
+      default:
+        port.postMessage('Unexpected command ' + event.data);
+        break;
+    }
+  };
 });

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/w3c-import.log

-                      r238592
+                      r246363
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/fetch-waits-for-activate-worker.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/frame-for-getregistrations.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/get-resultingClientId-worker.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/http-to-https-redirect-and-register-iframe.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/iframe-with-image.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/immutable-prototype-serviceworker.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/import-mime-type-worker.py
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/import-relative.xsl
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/import-scripts-diff-resource-map-worker.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/import-scripts-echo.py
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/import-scripts-get.py
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/import-scripts-mime-types-worker.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/import-scripts-redirect-import.js
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/postmessage-blob-url.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/postmessage-dictionary-transferables-worker.js
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/postmessage-echo-worker.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/postmessage-msgport-to-client-worker.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/postmessage-to-client-worker.js
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/success.py
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/test-helpers.sub.js
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/test-request-headers-worker.js
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/test-request-headers-worker.py
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/testharness-helpers.js
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/trickle.py
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/unregister-controller-page.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/update-claim-worker.py
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/update-during-installation-worker.js
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/update-during-installation-worker.py
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/update-fetch-worker.py
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/update-max-aged-worker-imported-script.py
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/update-max-aged-worker.py
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/worker-testharness.js
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/worker_interception_redirect_webworker.py
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/xhr-iframe.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/xhr-response-url-worker.js
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/xsl-base-url-iframe.xml
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/xsl-base-url-worker.js
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/xslt-pass.xsl

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/worker-interception-iframe.https.html

-                      r238592
+                      r246363
 <script src="/common/get-host-info.sub.js"></script>
+<script src="/resources/testharness.js"></script>
 <script src="test-helpers.sub.js?pipe=sub"></script>
 <script>
 …
         })
       .then(function(data) {
           window.parent.postMessage({results: data}, host_info['HTTPS_ORIGIN']);
+          assert_equals(data, "This load was successfully intercepted.");
         });
+}

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/worker-load-interceptor.js

-                      r220223
+                      r246363
         event.respondWith(new Response(response_text));
     } else if (url.indexOf("synthesized-response.js") != -1) {
+        event.respondWith(new Response(response_script));
+      event.respondWith(new Response(
+          response_script,
+          {headers: {'Content-Type': 'application/javascript'}}));
+    }
 };

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/service-worker-csp-connect.https-expected.txt

r226628	r246363
2	2	PASS CSP test for connect-src in ServiceWorkerGlobalScope
3	3	PASS importScripts test for connect-src
	4	PASS eval test for connect-src
4	5	PASS Fetch test for connect-src
5	6	PASS Redirected fetch test for connect-src

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/service-worker-csp-default.https-expected.txt

r226628	r246363
2	2	PASS CSP test for default-src in ServiceWorkerGlobalScope
3	3	PASS importScripts test for default-src
	4	PASS eval test for default-src
4	5	PASS Fetch test for default-src
5	6	PASS Redirected fetch test for default-src

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/service-worker-csp-script.https-expected.txt

r226628	r246363
2	2	PASS CSP test for script-src in ServiceWorkerGlobalScope
3	3	PASS importScripts test for script-src
	4	PASS eval test for script-src
4	5	PASS Fetch test for script-src
5	6	PASS Redirected fetch test for script-src

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/serviceworker-message-event-historical.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, url, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
               worker.postMessage('PING');
             });
-        })
-      .then(function() {
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Test MessageEvent supplants ServiceWorkerMessageEvent.');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/shared-worker-controlled.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, service_worker, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
       .then(function(data) {
           assert_equals(data, 'intercepted by service worker');
-          service_worker_unregister_and_done(t, scope);
         });
   }, 'Verify subresource loads in SharedWorker are controlled by a Service Worker');
 …
     return service_worker_unregister_and_register(t, service_worker, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
       .then(function(data) {
           assert_equals(data, 'worker loading intercepted by service worker');
-          service_worker_unregister_and_done(t, scope);
         });
   }, 'Verify SharedWorker construction is controlled by a Service Worker');
 …
     return service_worker_unregister_and_register(t, service_worker, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
       .then(function(data) {
           assert_equals(data, 'worker loading intercepted by service worker');
-          service_worker_unregister_and_done(t, scope);
         });
   }, 'Verify importScripts from SharedWorker is controlled by a Service Worker');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/skip-waiting-installed.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, url1, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
       .then(function() {
           frame.remove();
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Test skipWaiting when a installed worker is waiting');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/skip-waiting-using-registration.https.html

-                      r238592
+                      r246363
 <!DOCTYPE html>
 <title>Service Worker: Skip waiting using registration</title>
+<meta name="timeout" content="long">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 …
           assert_not_equals(sw_registration.active, null,
                             'Registration active worker should not be null');
           fetch_tests_from_worker(sw_registration.active);
+          return fetch_tests_from_worker(sw_registration.active);
         });
   }, 'Test skipWaiting while a client is using the registration');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/skip-waiting-without-using-registration.https.html

-                      r238592
+                      r246363
 <!DOCTYPE html>
 <title>Service Worker: Skip waiting without using registration</title>
+<meta name="timeout" content="long">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 …
           assert_not_equals(sw_registration.active, null,
                             'Registration active worker should not be null');
           fetch_tests_from_worker(sw_registration.active);
+          return fetch_tests_from_worker(sw_registration.active);
         });
   }, 'Test skipWaiting while a client is not being controlled');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/skip-waiting.https.html

-                      r220223
+                      r246363
     return service_worker_unregister_and_register(t, url1, scope)
       .then(function(registration) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           sw_registration = registration;
           return wait_for_state(t, registration.installing, 'activated');
 …
           assert_equals(sw_registration.active.scriptURL, normalizeURL(url3),
                         'Worker with url3 should be activated');
-          return service_worker_unregister_and_done(t, scope);
         });
   }, 'Test skipWaiting with both active and waiting workers');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/unregister-then-register-new-script.https-expected.txt

-                      r238592
+                      r246363
 PASS Registering a new script URL while an unregistered registration is in use
+PASS Registering a new script URL that 404s does resurrect an unregistered registration
+PASS Registering a new script URL that fails to install does resurrect an unregistered registration
+FAIL Registering a new script URL that 404s does not resurrect unregistered registration assert_equals: Document should not be controlled expected null but got object "[object ServiceWorker]"
+FAIL Registering a new script URL that fails to install does not resurrect unregistered registration assert_equals: registration.active expected null but got object "[object ServiceWorker]"

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/unregister-then-register-new-script.https.html

-                      r238592
+                      r246363
 var worker_url = 'resources/empty-worker.js';
+async_test(function(t) {
+    var scope = 'resources/scope/unregister-then-register-new-script-that-exists';
+    var new_worker_url = worker_url + '?new';
+    var iframe;
+    var registration;
+    var new_registration;
+promise_test(async function(t) {
+  const scope = 'resources/scope/unregister-then-register-new-script-that-exists';
+  const registration = await service_worker_unregister_and_register(t, worker_url, scope);
+  t.add_cleanup(() => registration.unregister());
+    service_worker_unregister_and_register(t, worker_url, scope)
+      .then(function(r) {
+          registration = r;
+          return wait_for_state(t, r.installing, 'activated');
+        })
+      .then(function() {
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          iframe = frame;
+          return registration.unregister();
+        })
+      .then(function() {
+          return navigator.serviceWorker.register(new_worker_url,
+                                                  { scope: scope });
+        })
+      .then(function(r) {
+          new_registration = r;
+          assert_equals(registration.installing.scriptURL,
+                        normalizeURL(new_worker_url),
+                        'before activated registration.installing');
+          assert_equals(registration.waiting, null,
+                        'before activated registration.waiting');
+          assert_equals(registration.active.scriptURL, normalizeURL(worker_url),
+                        'before activated registration.active');
+          assert_equals(new_registration.installing.scriptURL,
+                        normalizeURL(new_worker_url),
+                        'before activated new_registration.installing');
+          assert_equals(new_registration.waiting, null,
+                        'before activated new_registration.waiting');
+          assert_equals(new_registration.active.scriptURL,
+                        normalizeURL(worker_url),
+                        'before activated new_registration.active');
+          iframe.remove();
+          return wait_for_state(t, registration.installing, 'activated');
+        })
+      .then(function() {
+          assert_equals(new_registration.installing, null,
+                        'after activated new_registration.installing');
+          assert_equals(new_registration.waiting, null,
+                        'after activated new_registration.waiting');
+          assert_equals(new_registration.active.scriptURL,
+                        normalizeURL(new_worker_url),
+                        'after activated new_registration.active');
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          assert_equals(
+              frame.contentWindow.navigator.serviceWorker.controller.scriptURL,
+              normalizeURL(new_worker_url),
+              'the new worker should control a new document');
+          frame.remove();
+          return registration.unregister();
+        })
+      .then(function() {
+          t.done();
+        })
+      .catch(unreached_rejection(t));
+  const newWorkerURL = worker_url + '?new';
+  await wait_for_state(t, registration.installing, 'activated');
+  const iframe = await with_iframe(scope);
+  t.add_cleanup(() => iframe.remove());
+  await registration.unregister();
+  const newRegistration = await navigator.serviceWorker.register(newWorkerURL, { scope });
+  t.add_cleanup(() => newRegistration.unregister());
+  assert_equals(
+    registration.installing.scriptURL,
+    normalizeURL(newWorkerURL),
+    'before activated registration.installing'
+  );
+  assert_equals(
+    registration.waiting,
+    null,
+    'before activated registration.waiting'
+  );
+  assert_equals(
+    registration.active.scriptURL,
+    normalizeURL(worker_url),
+    'before activated registration.active'
+  );
+  assert_equals(
+    newRegistration.installing.scriptURL,
+    normalizeURL(newWorkerURL),
+    'before activated newRegistration.installing'
+  );
+  assert_equals(
+    newRegistration.waiting,
+    null,
+    'before activated newRegistration.waiting'
+  );
+  assert_equals(
+    newRegistration.active.scriptURL,
+    normalizeURL(worker_url),
+    'before activated newRegistration.active'
+  );
+  iframe.remove();
+  await wait_for_state(t, registration.installing, 'activated');
+  assert_equals(
+    newRegistration.installing,
+    null,
+    'after activated newRegistration.installing'
+  );
+  assert_equals(
+    newRegistration.waiting,
+    null,
+    'after activated newRegistration.waiting'
+  );
+  assert_equals(
+    newRegistration.active.scriptURL,
+    normalizeURL(newWorkerURL),
+    'after activated newRegistration.active'
+  );
+  const newIframe = await with_iframe(scope);
+  t.add_cleanup(() => newIframe.remove());
+  assert_equals(
+    newIframe.contentWindow.navigator.serviceWorker.controller.scriptURL,
+    normalizeURL(newWorkerURL),
+    'the new worker should control a new document'
+  );
 }, 'Registering a new script URL while an unregistered registration is in use');
 async_test(function(t) {
     var scope = 'resources/scope/unregister-then-register-new-script-that-404s';
     var iframe;
     var registration;
+promise_test(async function(t) {
+  const scope = 'resources/scope/unregister-then-register-new-script-that-404s';
+  const registration = await service_worker_unregister_and_register(t, worker_url, scope);
+  t.add_cleanup(() => registration.unregister());
+    service_worker_unregister_and_register(t, worker_url, scope)
+      .then(function(r) {
+          registration = r;
+          return wait_for_state(t, r.installing, 'activated');
+        })
+      .then(function() {
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          iframe = frame;
+          return registration.unregister();
+        })
+      .then(function() {
+          // Step 5.1 of Register clears the uninstall flag before fetching
+          // the script:
+          //
+          //  https://w3c.github.io/ServiceWorker/#register-algorithm
+          var promise = navigator.serviceWorker.register('this-will-404',
+                                                         { scope: scope });
+          return promise;
+        })
+      .then(
+        function() {
+          assert_unreached('register should reject the promise');
+        },
+        function() {
+          assert_equals(registration.installing, null,
+                        'registration.installing');
+          assert_equals(registration.waiting, null,
+                        'registration.waiting');
+          assert_equals(registration.active.scriptURL, normalizeURL(worker_url),
+                        'registration.active');
+          iframe.remove();
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          assert_equals(
+              frame.contentWindow.navigator.serviceWorker.controller.scriptURL,
+              normalizeURL(worker_url),
+              'the original worker should control a new document');
+          frame.remove();
+          return registration.unregister();
+        })
+      .then(function() {
+          t.done();
+        })
+      .catch(unreached_rejection(t));
+}, 'Registering a new script URL that 404s does resurrect an ' +
+       'unregistered registration');
+  await wait_for_state(t, registration.installing, 'activated');
+async_test(function(t) {
+    var scope = 'resources/scope/unregister-then-register-reject-install-worker';
+    var iframe;
+    var registration;
+  const iframe = await with_iframe(scope);
+  t.add_cleanup(() => iframe.remove());
+    service_worker_unregister_and_register(t, worker_url, scope)
+      .then(function(r) {
+          registration = r;
+          return wait_for_state(t, r.installing, 'activated');
+        })
+      .then(function() {
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          iframe = frame;
+          return registration.unregister();
+        })
+      .then(function() {
+          // Step 5.1 of Register clears the uninstall flag before firing
+          // the install event:
+          //
+          //  https://w3c.github.io/ServiceWorker/#register-algorithm
+          var promise = navigator.serviceWorker.register(
+              'resources/reject-install-worker.js', { scope: scope });
+          return promise;
+        })
+      .then(function(r) {
+          registration = r;
+          return wait_for_state(t, r.installing, 'redundant');
+        })
+      .then(function() {
+          assert_equals(registration.installing, null,
+                        'registration.installing');
+          assert_equals(registration.waiting, null,
+                        'registration.waiting');
+          assert_equals(registration.active.scriptURL, normalizeURL(worker_url),
+                        'registration.active');
+          iframe.remove();
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          assert_equals(
+              frame.contentWindow.navigator.serviceWorker.controller.scriptURL,
+              normalizeURL(worker_url),
+              'the original worker should control a new document');
+          frame.remove();
+          return registration.unregister();
+        })
+      .then(function() {
+          t.done();
+        })
+      .catch(unreached_rejection(t));
+  }, 'Registering a new script URL that fails to install does resurrect ' +
+       'an unregistered registration');
+  await registration.unregister();
+  await promise_rejects(
+    t, new TypeError(),
+    navigator.serviceWorker.register('this-will-404', { scope })
+  );
+  assert_equals(registration.installing, null, 'registration.installing');
+  assert_equals(registration.waiting, null, 'registration.waiting');
+  assert_equals(registration.active.scriptURL, normalizeURL(worker_url), 'registration.active');
+  const newIframe = await with_iframe(scope);
+  t.add_cleanup(() => newIframe.remove());
+  assert_equals(newIframe.contentWindow.navigator.serviceWorker.controller, null, 'Document should not be controlled');
+}, 'Registering a new script URL that 404s does not resurrect unregistered registration');
+promise_test(async function(t) {
+  const scope = 'resources/scope/unregister-then-register-reject-install-worker';
+  const registration = await service_worker_unregister_and_register(t, worker_url, scope);
+  t.add_cleanup(() => registration.unregister());
+  await wait_for_state(t, registration.installing, 'activated');
+  const iframe = await with_iframe(scope);
+  t.add_cleanup(() => iframe.remove());
+  await registration.unregister();
+  const newRegistration = await navigator.serviceWorker.register(
+    'resources/reject-install-worker.js', { scope }
+  );
+  t.add_cleanup(() => newRegistration.unregister());
+  await wait_for_state(t, newRegistration.installing, 'redundant');
+  assert_equals(registration.installing, null, 'registration.installing');
+  assert_equals(registration.waiting, null, 'registration.waiting');
+  assert_equals(registration.active, null, 'registration.active');
+  assert_not_equals(registration, newRegistration, 'New registration is different');
+}, 'Registering a new script URL that fails to install does not resurrect unregistered registration');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/unregister-then-register.https-expected.txt

-                      r224947
+                      r246363
 PASS Unregister then register resolves to a new value
+PASS Unregister then register resolves to the original value if the registration is in use.
+PASS Reloading the last controlled iframe after unregistration should ensure the deletion of the registration
+FAIL Unregister then register does not resolve to the original value even if the registration is in use. assert_not_equals: Unregister and register should always create a new registration got disallowed value object "[object ServiceWorkerRegistration]"
 PASS Unregister then register does not affect existing controllee
+PASS Unregister then register resurrects the registration
+FAIL Unregister then register does not resurrect the registration assert_equals: Registration is new expected null but got object "[object ServiceWorker]"

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/unregister-then-register.https.html

-                      r238592
+                      r246363
 var worker_url = 'resources/empty-worker.js';
+promise_test(function(t) {
+    var scope = 'resources/scope/re-register-resolves-to-new-value';
+    var registration;
+promise_test(async function(t) {
+    const scope = 'resources/scope/re-register-resolves-to-new-value';
+    const registration = await service_worker_unregister_and_register(t, worker_url, scope);
+    t.add_cleanup(() => registration.unregister());
+    return service_worker_unregister_and_register(t, worker_url, scope)
+      .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
+    await wait_for_state(t, registration.installing, 'activated');
+    await registration.unregister();
+    const newRegistration = await navigator.serviceWorker.register(worker_url, { scope });
+    t.add_cleanup(() => newRegistration.unregister());
+          registration = r;
+          return wait_for_state(t, r.installing, 'activated');
+        })
+      .then(function() {
+          return registration.unregister();
+        })
+      .then(function() {
+          return navigator.serviceWorker.register(worker_url, { scope: scope });
+        })
+      .then(function(new_registration) {
+          assert_not_equals(registration, new_registration,
+                            'register should resolve to a new value');
+        });
+    assert_not_equals(
+      registration, newRegistration,
+      'register should resolve to a new value'
+    );
   }, 'Unregister then register resolves to a new value');
+promise_test(function(t) {
+    var scope = 'resources/scope/re-register-while-old-registration-in-use';
+    var registration;
+promise_test(async function(t) {
+  const scope = 'resources/scope/re-register-while-old-registration-in-use';
+  const registration = await service_worker_unregister_and_register(t, worker_url, scope);
+  t.add_cleanup(() => registration.unregister());
+    return service_worker_unregister_and_register(t, worker_url, scope)
+      .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
+  await wait_for_state(t, registration.installing, 'activated');
+  const frame = await with_iframe(scope);
+  t.add_cleanup(() => frame.remove());
+          registration = r;
+          return wait_for_state(t, r.installing, 'activated');
+        })
+      .then(function() {
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          return registration.unregister();
+        })
+      .then(function() {
+          return navigator.serviceWorker.register(worker_url, { scope: scope });
+        })
+      .then(function(new_registration) {
+          assert_equals(registration, new_registration,
+                        'new registration should resolve to the same registration');
+        });
+  }, 'Unregister then register resolves to the original value if the ' +
+         'registration is in use.');
+  await registration.unregister();
+  const newRegistration = await navigator.serviceWorker.register(worker_url, { scope });
+  t.add_cleanup(() => newRegistration.unregister());
+promise_test(function(t) {
+    var scope = 'resources/scope/complete-unregistration-followed-by-' +
+                'reloading-controllee-iframe';
+    var registration;
+    var frame;
+    var service_worker;
+    return service_worker_unregister_and_register(t, worker_url, scope)
+      .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
+          registration = r;
+          return wait_for_state(t, r.installing, 'activated');
+        })
+      .then(function() {
+          return with_iframe(scope);
+        })
+      .then(function(f) {
+          frame = f;
+          return registration.unregister();
+        })
+      .then(function() {
+          return new Promise(function(resolve) {
+              frame.onload = resolve;
+              frame.contentWindow.location.reload();
+            });
+        })
+      .then(function() {
+          var c = frame.contentWindow.navigator.serviceWorker.controller;
+          assert_equals(c, null, 'a page after unregistration should not be ' +
+                                 'controlled by service worker');
+          return navigator.serviceWorker.getRegistration(scope);
+        })
+      .then(function(r) {
+          assert_equals(r, undefined, 'getRegistration should return ' +
+                                      'undefined after unregistration');
+        });
+}, 'Reloading the last controlled iframe after unregistration should ensure ' +
+   'the deletion of the registration');
+  assert_not_equals(
+    registration, newRegistration,
+    'Unregister and register should always create a new registration'
+  );
+}, 'Unregister then register does not resolve to the original value even if the registration is in use.');
 promise_test(function(t) {
 …
       .then(function(r) {
           t.add_cleanup(function() {
               return service_worker_unregister(t, scope);
             });
+            return service_worker_unregister(t, scope);
+          });
           registration = r;
 …
   }, 'Unregister then register does not affect existing controllee');
+promise_test(function(t) {
+    var scope = 'resources/scope/resurrection';
+    var iframe;
+    var registration;
+promise_test(async function(t) {
+  const scope = 'resources/scope/resurrection';
+  const altWorkerURL = worker_url + '?alt';
+  const registration = await service_worker_unregister_and_register(t, worker_url, scope);
+  t.add_cleanup(() => registration.unregister());
+    return service_worker_unregister_and_register(t, worker_url, scope)
+      .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
+  await wait_for_state(t, registration.installing, 'activating');
+  const iframe = await with_iframe(scope);
+  t.add_cleanup(() => iframe.remove());
+          registration = r;
+          return wait_for_state(t, r.installing, 'activated');
+        })
+      .then(function() {
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          iframe = frame;
+          return registration.unregister();
+        })
+      .then(function() {
+          return navigator.serviceWorker.register(worker_url, { scope: scope });
+        })
+      .then(function() {
+          iframe.remove();
+          return with_iframe(scope);
+        })
+      .then(function(frame) {
+          assert_not_equals(
+              frame.contentWindow.navigator.serviceWorker.controller, null,
+              'document should have a controller');
+          frame.remove();
+        });
+  }, 'Unregister then register resurrects the registration');
+  await registration.unregister();
+  const newRegistration = await navigator.serviceWorker.register(altWorkerURL, { scope });
+  t.add_cleanup(() => newRegistration.unregister());
+  assert_equals(newRegistration.active, null, 'Registration is new');
+  await wait_for_state(t, newRegistration.installing, 'activating');
+  const newIframe = await with_iframe(scope);
+  t.add_cleanup(() => newIframe.remove());
+  const iframeController = iframe.contentWindow.navigator.serviceWorker.controller;
+  const newIframeController = newIframe.contentWindow.navigator.serviceWorker.controller;
+  assert_not_equals(iframeController, newIframeController, 'iframes have different controllers');
+}, 'Unregister then register does not resurrect the registration');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-after-navigation-redirect.https.html

r238592	r246363
2	2	<meta charset="utf-8">
3	3	<title>Service Worker: Update should be triggered after redirects during navigation</title>
	4	<meta name="timeout" content="long">
4	5	<script src="/resources/testharness.js"></script>
5	6	<script src="/resources/testharnessreport.js"></script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-after-oneday.https.html

-                      r223273
+                      r246363
     return service_worker_unregister_and_register(t, expected_url, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           registration = r;
           return wait_for_state(t, registration.installing, 'activated');
 …
        .then(function() {
           frame.remove();
-          return service_worker_unregister_and_done(t, scope);
        })
   }, 'Update should be triggered after a functional event when last update time is over 24 hours');

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-bytecheck.https.html

-                      r228255
+                      r246363
 <meta charset=utf-8>
 <title></title>
+<meta name="timeout" content="long">
 <script src="/resources/testharness.js"></script>
 <script src="resources/testharness-helpers.js"></script>
 …
       // Register a service worker.
       .then(_ => service_worker_unregister_and_register(t, script, scope))
+      .then(r => swr = r)
+      .then(_ => wait_for_update(t, swr))
+      .then(r => {
+        t.add_cleanup(() => service_worker_unregister(t, scope));
+        swr = r;
+        return wait_for_update(t, swr);
+      })
       .then(w => sw = w)
       .then(_ => wait_for_state(t, sw, 'activated'))
 …
                               swr.installing],
                              [sw, null, null]);
+      })
+      // Unregister the service worker.
+      .then(_ => service_worker_unregister_and_done(t, scope));
+      });
   }, `Test(cors: ${s.cors}, main: ${s.main}, imported: ${s.imported})`));
 }, Promise.resolve());

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-not-allowed.https.html

-                      r238592
+                      r246363
 'use strict';
+function send_message_to_worker_and_wait_for_response(worker, message) {
+  return new Promise(resolve => {
+    // Use a dedicated channel for every request to avoid race conditions on
+    // concurrent requests.
+    const channel = new MessageChannel();
+    worker.postMessage(channel.port1, [channel.port1]);
+    let messageReceived = false;
+    channel.port2.onmessage = event => {
+      assert_false(messageReceived, 'Already received response for ' + message);
+      messageReceived = true;
+      resolve(event.data);
+    };
+    channel.port2.postMessage(message);
+  });
+}
+async function ensure_install_event_fired(worker) {
+  const response = await send_message_to_worker_and_wait_for_response(worker, 'awaitInstallEvent');
+  assert_equals('installEventFired', response);
+  assert_equals('installing', worker.state, 'Expected worker to be installing.');
+}
+async function finish_install(worker) {
+  await ensure_install_event_fired(worker);
+  const response = await send_message_to_worker_and_wait_for_response(worker, 'finishInstall');
+  assert_equals('installFinished', response);
+}
+async function activate_service_worker(t, worker) {
+  await finish_install(worker);
+  // By waiting for both states at the same time, the test fails
+  // quickly if the installation fails, avoiding a timeout.
+  await Promise.race([wait_for_state(t, worker, 'activated'),
+                      wait_for_state(t, worker, 'redundant')]);
+  assert_equals('activated', worker.state, 'Service worker should be activated.');
+}
+async function update_within_service_worker(worker) {
+  // This function returns a Promise that resolves when update()
+  // has been called but is not necessarily finished yet.
+  // Call finish() on the returned object to wait for update() settle.
+  const port = await send_message_to_worker_and_wait_for_response(worker, 'callUpdate');
+  let messageReceived = false;
+  return {
+    finish: () => {
+      return new Promise(resolve => {
+        port.onmessage = event => {
+          assert_false(messageReceived, 'Update already finished.');
+          messageReceived = true;
+          resolve(event.data);
+        };
+      });
+    },
+  };
+}
+async function update_from_client_and_await_installing_version(test, registration) {
+  const updatefound = wait_for_update(test, registration);
+  registration.update();
+  await updatefound;
+  return registration.installing;
+}
 async function spin_up_service_worker(test) {
     const script = 'resources/update-during-installation-worker.js';
     const scope = 'resources/blank.html';
+  const script = 'resources/update-during-installation-worker.py';
+  const scope = 'resources/blank.html';
+    let registration = await service_worker_unregister_and_register(test, script, scope);
+    test.add_cleanup(() => {
+        if (registration.installing) {
+            registration.installing.postMessage('finishInstall');
+        }
+        registration.unregister();
+    });
+  const registration = await service_worker_unregister_and_register(test, script, scope);
+  test.add_cleanup(async () => {
+    if (registration.installing) {
+      // If there is an installing worker, we need to finish installing it.
+      // Otherwise, the tests fails with an timeout because unregister() blocks
+      // until the install-event-handler finishes.
+      const worker = registration.installing;
+      await send_message_to_worker_and_wait_for_response(worker, 'awaitInstallEvent');
+      await send_message_to_worker_and_wait_for_response(worker, 'finishInstall');
+    }
+    return registration.unregister();
+  });
     return registration;
+  return registration;
+}
 promise_test(async t => {
+    const registration = await spin_up_service_worker(t);
+    const worker = registration.installing;
+  const registration = await spin_up_service_worker(t);
+  const worker = registration.installing;
+  await ensure_install_event_fired(worker);
+    // spin_up_service_worker installs a cleanup hook that ensures the
+    // worker finished its installation by sending it a
+    // 'finishInstall' message, thus making sure that the registration
+    // will be cleanly removed at the end of the test.
+    assert_equals(worker.state, 'installing');
+    promise_rejects(t, 'InvalidStateError', registration.update());
+}, 'ServiceWorkerRegistration.update() from client throws while installing service worker.')
+  const result = registration.update();
+  await activate_service_worker(t, worker);
+  return result;
+}, 'ServiceWorkerRegistration.update() from client succeeds while installing service worker.');
 promise_test(async t => {
     const registration = await spin_up_service_worker(t);
     const worker = registration.installing;
     worker.postMessage('finishInstall');
+  const registration = await spin_up_service_worker(t);
+  const worker = registration.installing;
+  await ensure_install_event_fired(worker);
+    // By waiting for both states at the same time, the test fails
+    // quickly if the installation fails, avoiding a timeout.
+    await Promise.race([wait_for_state(t, worker, 'activated'),
+                        wait_for_state(t, worker, 'redundant')]);
+    assert_equals(worker.state, 'activated', 'Service worker should be activated.');
+  // Add event listener to fail the test if update() succeeds.
+  const updatefound = t.step_func(async () => {
+    registration.removeEventListener('updatefound', updatefound);
+    // Activate new worker so non-compliant browsers don't fail with timeout.
+    await activate_service_worker(t, registration.installing);
+    assert_unreached("update() should have failed");
+  });
+  registration.addEventListener('updatefound', updatefound);
     const response = await new Promise(resolve => {
         navigator.serviceWorker.onmessage = event => { resolve(event.data); };
         worker.postMessage('PING');
     });
+  const update = await update_within_service_worker(worker);
+  // Activate worker to ensure update() finishes and the test doesn't timeout
+  // in non-compliant browsers.
+  await activate_service_worker(t, worker);
+    // We check that the service worker instance that replied to the
+    // message is the same one that received the 'install' event since
+    // it's possible for them to be two distinct execution
+    // environments.
+    assert_true(response.installEventFired, 'Service worker should have been installed.');
+    assert_equals(response.exception, 'InvalidStateError', 'update() should have thrown.');
+  const response = await update.finish();
+  assert_false(response.success, 'update() should have failed.');
+  assert_equals('InvalidStateError', response.exception, 'update() should have thrown InvalidStateError.');
 }, 'ServiceWorkerRegistration.update() from installing service worker throws.');
+promise_test(async t => {
+  const registration = await spin_up_service_worker(t);
+  const worker1 = registration.installing;
+  await activate_service_worker(t, worker1);
+  const worker2 = await update_from_client_and_await_installing_version(t, registration);
+  await ensure_install_event_fired(worker2);
+  const update = await update_within_service_worker(worker1);
+  // Activate the new version so that update() finishes and the test doesn't timeout.
+  await activate_service_worker(t, worker2);
+  const response = await update.finish();
+  assert_true(response.success, 'update() from active service worker should have succeeded.');
+}, 'ServiceWorkerRegistration.update() from active service worker succeeds while installing service worker.');
 </script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-registration-with-type.https-expected.txt

-                      r238592
+                      r246363
 FAIL Update the registration with a different script type (classic => module). promise_test: Unhandled rejection with value: object "ReferenceError: Can't find variable: guid"
 FAIL Update the registration with a different script type (module => classic). promise_test: Unhandled rejection with value: object "ReferenceError: Can't find variable: guid"
+FAIL Update the registration with a different script type (classic => module). promise_test: Unhandled rejection with value: object "TypeError: null is not an object (evaluating 'secondWorker.postMessage')"
+FAIL Update the registration with a different script type (module => classic). promise_test: Unhandled rejection with value: object "TypeError: SyntaxError: Unexpected token '*'. import call expects exactly one argument."
 PASS Update the registration with a different script type (classic => module) and with a same main script.
 PASS Update the registration with a different script type (module => classic) and with a same main script.

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-registration-with-type.https.html

r238592	r246363
3	3	<title>Service Worker: Update the registration with a different script type.</title>
4	4	<!-- common.js is for guid() -->
5		<script src="/~~mixed-content/generic~~/common.js"></script>
	5	<script src="/common/security-features/resources/common.js"></script>
6	6	<script src="/resources/testharness.js"></script>
7	7	<script src="/resources/testharnessreport.js"></script>

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/w3c-import.log

-                      r238592
+                      r246363
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/appcache-ordering-main.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-affect-other-registration.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-fetch-with-appcache.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-fetch.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-not-using-registration.https.html
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/clients-get-client-types.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/clients-get-cross-origin.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/clients-get-resultingClientId.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/clients-get.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/clients-matchall-client-types.https.html
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/controller-on-reload.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/controller-with-no-fetch-event-handler.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/data-transfer-files.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/dedicated-worker-service-worker-interception.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/detached-context.https.html
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-iframe.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-mime-types.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-schedule-job.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-scope.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/registration-script-url.https.html
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/request-end-to-end.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resource-timing-cross-origin.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resource-timing.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resource-timing.sub.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/respond-with-body-accessed-response.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/sandboxed-iframe-fetch-event.https.html
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-bytecheck.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-missing-import-scripts.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-no-cache-request-headers.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-not-allowed.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-on-navigation.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-recovery.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/update-registration-with-type.https.html
 …
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/worker-interception-redirect.https.html
 /LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/worker-interception.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/xhr-response-url.https.html
+/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/xsl-base-url.https.html

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/websocket.https-expected.txt

r224218	r246363
3	3
4	4
5		FAIL Verify WebSocket handshake channel does not get intercepted ~~assert_unreached: unexpected rejection: [object Event] Reached unreachable code~~
	5	FAIL Verify WebSocket handshake channel does not get intercepted promise_test: Unhandled rejection with value: object "[object Event]"
6	6

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/windowclient-navigate.https.html

-                      r238592
+                      r246363
+    }
     var cleanup = function() {
+    test.add_cleanup(function() {
       if (client_frame && client_frame) {
         client_frame.remove();
 …
         return registration.unregister();
+      }
     };
+    });
     var test_body = with_iframe(parameters.src_url)
+    return with_iframe(parameters.src_url)
       .then(function(frame) {
           client_frame = frame;
 …
           assert_equals(response.data, parameters.expected);
         });
-    // Ensure that test "clean up" is deferred until after the test body
-    // executes. `Test#add_cleanup` cannot be used for this purpose because the
-    // operation is asynchronous, and `add_cleanup` does not support
-    // asynchronous operations at the time of this writing. See
-    // https://github.com/web-platform-tests/wpt/issues/6075
-    // Ensure also that test failure is not hidden by successful cleanup
-    // operation.
-    return test_body
-      .then(cleanup, cleanup)
-      .then(function() { return test_body; });
   }, parameters.description);
+}

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/worker-interception.https-expected.txt

-                      r238592
+                      r246363
+CONSOLE MESSAGE: line 1: ReferenceError: Can't find variable: Worker
 FAIL Verify worker script from uncontrolled document is intercepted by Service Worker promise_test: Unhandled rejection with value: undefined
 …
 PASS Verify worker script intercepted by cors response fails
 PASS Verify worker script intercepted by no-cors cross-origin response fails
+PASS Verify worker loads from controlled document are intercepted by Service Worker
+FAIL Verify worker loads from controlled document are intercepted by Service Worker assert_equals: expected "finish" but got "failure:[object ErrorEvent]"

trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/worker-interception.https.html

-                      r238592
+                      r246363
     return service_worker_unregister_and_register(t, service_worker, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
       .then(function(data) {
           assert_equals(data, 'worker loading intercepted by service worker');
-          service_worker_unregister_and_done(t, scope);
         });
   }, 'Verify worker script from uncontrolled document is intercepted by Service Worker');
 …
     return service_worker_unregister_and_register(t, service_worker, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
       .then(function(data) {
           assert_equals(data, 'dummy-worker-script loaded');
-          service_worker_unregister_and_done(t, scope);
         });
   }, 'Verify worker script intercepted by same-origin response succeeds');
 …
           var watcher = new EventWatcher(t, w, ['message', 'error']);
           return watcher.wait_for('error');
+        })
+      .then(function() {
+          service_worker_unregister_and_done(t, scope);
+       });
+        });
   }, 'Verify worker script intercepted by cors response fails');
 …
     return service_worker_unregister_and_register(t, service_worker, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
           var watcher = new EventWatcher(t, w, ['message', 'error']);
           return watcher.wait_for('error');
+        })
+      .then(function() {
+          service_worker_unregister_and_done(t, scope);
+       });
+        });
   }, 'Verify worker script intercepted by no-cors cross-origin response fails');
 …
     var scope = 'resources/';
-    window.addEventListener('message', t.step_func(on_message), false);
-    function on_message(e) {
-      assert_equals(e.data.results, "This load was successfully intercepted.");
-      t.done();
+    }
     return service_worker_unregister_and_register(t, service_worker, scope)
       .then(function(r) {
+          t.add_cleanup(function() {
+              return service_worker_unregister(t, scope);
+            });
           return wait_for_state(t, r.installing, 'activated');
         })
 …
       .then(function(data) {
           assert_equals(data.results, 'finish');
-          service_worker_unregister_and_done(t, scope);
         });
   }, 'Verify worker loads from controlled document are intercepted by Service Worker');

trunk/LayoutTests/tests-options.json

-                      r246330
+                      r246363
         "slow"
     ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/extendable-event-async-waituntil.https.html": [
+        "slow"
+    ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/fetch-canvas-tainting-video-cache.https.html": [
+        "slow"
+    ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/fetch-canvas-tainting-video.https.html": [
+        "slow"
+    ],
     "imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-redirect.https.html": [
         "slow"
     ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-respond-with-body-loaded-in-chunk.https.html": [
+        "slow"
+    ],
     "imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event.https.html": [
         "slow"
 …
         "slow"
     ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/interfaces-window.https.html": [
+        "slow"
+    ],
     "imported/w3c/web-platform-tests/service-workers/service-worker/local-url-inherit-controller.https.html": [
         "slow"
 …
         "slow"
     ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/registration-mime-types.https.html": [
+        "slow"
+    ],
     "imported/w3c/web-platform-tests/service-workers/service-worker/registration-updateviacache.https.html": [
         "slow"
     ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/skip-waiting-using-registration.https.html": [
+        "slow"
+    ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/skip-waiting-without-using-registration.https.html": [
+        "slow"
+    ],
     "imported/w3c/web-platform-tests/service-workers/service-worker/update-after-navigation-fetch-event.https.html": [
+        "slow"
+    ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/update-after-navigation-redirect.https.html": [
+        "slow"
+    ],
+    "imported/w3c/web-platform-tests/service-workers/service-worker/update-bytecheck.https.html": [
         "slow"
     ],

Context Navigation

Changeset 246363 in webkit

Legend:

Download in other formats: