Update web-platform-tests to revision 60220357131c65146444da1f54624d5b54d0975d

tests/wpt/web-platform-tests/cookie-store/META.yml

@@ -1,3 +1,4 @@
+spec: https://wicg.github.io/cookie-store/
 suggested_reviewers:
   - inexorabletash
   - pwnall

tests/wpt/web-platform-tests/cookie-store/cookieListItem_attributes.tentative.https.window.js

@@ -129,7 +129,7 @@ promise_test(async testCase => {
    'expires set to a future Date');
 
 promise_test(async testCase => {
-  await cookieStore.delete('cookie-name', { domain: kCurrentHostname });
+  await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
 
   await cookieStore.set('cookie-name', 'cookie-value',
                         { domain: kCurrentHostname });
@@ -144,7 +144,7 @@ promise_test(async testCase => {
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { domain: kCurrentHostname });
+    await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
   });
 }, 'CookieListItem - cookieStore.set with domain set to the current hostname');
 
@@ -153,7 +153,7 @@ promise_test(async testCase => {
   const currentPath = currentUrl.pathname;
   const currentDirectory =
       currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
-  await cookieStore.delete('cookie-name', { path: currentDirectory });
+  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
 
   await cookieStore.set('cookie-name', 'cookie-value',
                         { path: currentDirectory });
@@ -168,12 +168,12 @@ promise_test(async testCase => {
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { path: currentDirectory });
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
 }, 'CookieListItem - cookieStore.set with path set to the current directory');
 
 promise_test(async testCase => {
-  await cookieStore.delete('cookie-name', { secure: false });
+  await cookieStore.delete('cookie-name');
 
   await cookieStore.set('cookie-name', 'cookie-value', { secure: false });
   const cookie = await cookieStore.get('cookie-name');
@@ -186,14 +186,12 @@ promise_test(async testCase => {
   assert_equals(cookie.sameSite, 'strict');
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
 
-  await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { secure: false });
-  });
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'CookieListItem - cookieStore.set with secure set to false');
 
 ['strict', 'lax', 'unrestricted'].forEach(sameSiteValue => {
   promise_test(async testCase => {
-    await cookieStore.delete('cookie-name', { sameSite: sameSiteValue });
+    await cookieStore.delete('cookie-name');
 
     await cookieStore.set({
         name: 'cookie-name', value: 'cookie-value', sameSite: sameSiteValue });
@@ -207,13 +205,11 @@ promise_test(async testCase => {
     assert_equals(cookie.sameSite, sameSiteValue);
     assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
 
-    await async_cleanup(async () => {
-      await cookieStore.delete('cookie-name', { secure: sameSiteValue });
-    });
+    await async_cleanup(() => cookieStore.delete('cookie-name'));
   }, `CookieListItem - cookieStore.set with sameSite set to ${sameSiteValue}`);
 
   promise_test(async testCase => {
-    await cookieStore.delete('cookie-name', { sameSite: sameSiteValue });
+    await cookieStore.delete('cookie-name');
 
     await cookieStore.set('cookie-name', 'cookie-value',
                           { sameSite: sameSiteValue });
@@ -227,9 +223,7 @@ promise_test(async testCase => {
     assert_equals(cookie.sameSite, sameSiteValue);
     assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
 
-    await async_cleanup(async () => {
-      await cookieStore.delete('cookie-name', { secure: sameSiteValue });
-    });
+    await async_cleanup(() => cookieStore.delete('cookie-name'));
   }, 'CookieListItem - cookieStore.set with positional name and value and ' +
      `sameSite set to ${sameSiteValue}`);
 });

tests/wpt/web-platform-tests/cookie-store/cookieStore_delete_arguments.tentative.https.window.js

@@ -31,54 +31,25 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
-  await promise_rejects(testCase, new TypeError(), cookieStore.delete(
-      'cookie-name', { name: 'cookie-name' }));
+  await cookieStore.delete('cookie-name', { name: 'wrong-cookie-name' });
   const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie, null);
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.delete with name in both positional arguments and options');
 
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  await promise_rejects(testCase, new TypeError(), cookieStore.delete(
-      'cookie-name', { value: 'cookie-value' }));
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.delete with value in options');
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  const tenYears = 10 * 365 * 24 * 60 * 60 * 1000;
-  const tenYearsAgo = Date.now() - tenYears;
-
-  await promise_rejects(testCase, new TypeError(), cookieStore.delete(
-      'cookie-name', { expires: tenYearsAgo }));
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.delete with expires in options');
-
 promise_test(async testCase => {
   const currentUrl = new URL(self.location.href);
   const currentDomain = currentUrl.hostname;
   await cookieStore.set(
       'cookie-name', 'cookie-value', { domain: currentDomain });
 
-  await cookieStore.delete('cookie-name', { domain: currentDomain });
+  await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { domain: currentDomain })
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   });
 }, 'cookieStore.delete with domain set to the current hostname');
 
@@ -88,7 +59,7 @@ promise_test(async testCase => {
   const subDomain = `sub.${currentDomain}`;
 
   await promise_rejects(testCase, new TypeError(), cookieStore.delete(
-      'cookie-name', 'cookie-value', { domain: subDomain }));
+      { name: 'cookie-name', domain: subDomain }));
 }, 'cookieStore.delete with domain set to a subdomain of the current hostname');
 
 promise_test(async testCase => {
@@ -99,7 +70,7 @@ promise_test(async testCase => {
   const domainSuffix = currentDomain.substr(1);
 
   await promise_rejects(testCase, new TypeError(), cookieStore.delete(
-      'cookie-name', { domain: domainSuffix }));
+      { name: 'cookie-name', domain: domainSuffix }));
 }, 'cookieStore.delete with domain set to a non-domain-matching suffix of ' +
    'the current hostname');
 
@@ -114,7 +85,7 @@ promise_test(async testCase => {
   assert_equals(cookie, null);
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { domain: currentDomain })
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   });
 }, 'cookieStore.delete with name in options and domain set to the current ' +
    'hostname');
@@ -149,12 +120,12 @@ promise_test(async testCase => {
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: currentDirectory });
 
-  await cookieStore.delete('cookie-name', { path: currentDirectory });
+  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
 
   async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { path: currentDirectory })
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
 }, 'cookieStore.delete with path set to the current directory');
 
@@ -167,12 +138,26 @@ promise_test(async testCase => {
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: currentDirectory });
 
-  await cookieStore.delete('cookie-name', { path: subDirectory });
+  await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { path: currentDirectory })
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
 }, 'cookieStore.delete with path set to subdirectory of the current directory');
+
+promise_test(async testCase => {
+  await cookieStore.set('cookie-name', 'cookie-value');
+
+  const cookie_attributes = await cookieStore.get('cookie-name');
+  assert_equals(cookie_attributes.name, 'cookie-name');
+  assert_equals(cookie_attributes.value, 'cookie-value');
+
+  await cookieStore.delete(cookie_attributes);
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie, null);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookieStore.delete with get result');

tests/wpt/web-platform-tests/cookie-store/cookieStore_getAll_arguments.tentative.https.window.js

@@ -56,8 +56,11 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
 
-  await promise_rejects(testCase, new TypeError(), cookieStore.get(
-      'cookie-name', { name: 'cookie-name' }));
+  const cookies = await cookieStore.getAll('cookie-name',
+                                           { name: 'wrong-cookie-name' });
+  assert_equals(cookies.length, 1);
+  assert_equals(cookies[0].name, 'cookie-name');
+  assert_equals(cookies[0].value, 'cookie-value');
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
   await async_cleanup(() => cookieStore.delete('cookie-name-2'));
@@ -66,8 +69,8 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
-  const cookies = await cookieStore.getAll(
-      'cookie-name', { matchType: 'equals' });
+  const cookies = await cookieStore.getAll({ name: 'cookie-name',
+                                             matchType: 'equals' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-value');
@@ -83,8 +86,8 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
 
-  const cookies = await cookieStore.getAll(
-      'cookie-name-', { matchType: 'starts-with' });
+  const cookies = await cookieStore.getAll({ name: 'cookie-name-',
+                                             matchType: 'starts-with' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name-2');
   assert_equals(cookies[0].value, 'cookie-value-2');
@@ -98,7 +101,7 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
 
   await promise_rejects(testCase, new TypeError(), cookieStore.getAll(
-      'cookie-name', { matchType: 'invalid' }));
+      { name: 'cookie-name', matchType: 'invalid' }));
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
   await async_cleanup(() => cookieStore.delete('cookie-name-2'));
@@ -106,14 +109,22 @@ promise_test(async testCase => {
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
-  await cookieStore.set('cookie-name-2', 'cookie-value-2');
 
-  const cookies = await cookieStore.getAll(
-      { matchType: 'starts-with', name: 'cookie-name-' });
+  const cookies = await cookieStore.getAll({ matchType: 'equals' });
   assert_equals(cookies.length, 1);
-  assert_equals(cookies[0].name, 'cookie-name-2');
-  assert_equals(cookies[0].value, 'cookie-value-2');
+  assert_equals(cookies[0].name, 'cookie-name');
+  assert_equals(cookies[0].value, 'cookie-value');
 
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name-2'));
-}, 'cookieStore.getAll with matchType set to starts-with and name in options');
+  async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookieStore.getAll with matchType set to equals and missing name');
+
+promise_test(async testCase => {
+  await cookieStore.set('cookie-name', 'cookie-value');
+
+  const cookies = await cookieStore.getAll({ matchType: 'starts-with' });
+  assert_equals(cookies.length, 1);
+  assert_equals(cookies[0].name, 'cookie-name');
+  assert_equals(cookies[0].value, 'cookie-value');
+
+  async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookieStore.getAll with matchType set to starts-with and missing name');

tests/wpt/web-platform-tests/cookie-store/cookieStore_get_arguments.tentative.https.window.js

@@ -10,6 +10,16 @@ async function async_cleanup(cleanup_function) {
   }
 }
 
+promise_test(async testCase => {
+  await cookieStore.set('cookie-name', 'cookie-value');
+
+  const cookie = await cookieStore.get();
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookieStore.get with no arguments');
+
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
@@ -33,8 +43,8 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
-  await promise_rejects(testCase, new TypeError(), cookieStore.get(
-      'cookie-name', { name: 'cookie-name' }));
+  const cookie = await cookieStore.get('cookie-name',
+                                       { name: 'wrong-cookie-name' });
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with name in both positional arguments and options');
@@ -47,8 +57,8 @@ promise_test(async testCase => {
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
 
-  const no_cookie = await cookieStore.get(
-      'cookie-na', { matchType: 'equals' });
+  const no_cookie = await cookieStore.get({ name: 'cookie-na',
+                                            matchType: 'equals' });
   assert_equals(no_cookie, null);
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
@@ -57,8 +67,8 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
-  const cookie = await cookieStore.get(
-      'cookie-na', { matchType: 'starts-with' });
+  const cookie = await cookieStore.get({ name: 'cookie-na',
+                                         matchType: 'starts-with' });
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
 
@@ -69,7 +79,7 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
   await promise_rejects(testCase, new TypeError(), cookieStore.get(
-      'cookie-name', { matchType: 'invalid' }));
+      { name: 'cookie-name', matchType: 'invalid' }));
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.get with invalid matchType');
@@ -77,10 +87,19 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
-  const cookie = await cookieStore.get(
-      { matchType: 'starts-with', name: 'cookie-na' });
+  const cookie = await cookieStore.get({ matchType: 'equals' });
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
 
   async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.get with matchType set to starts-with and name in options');
+}, 'cookieStore.get with matchType set to equals and missing name');
+
+promise_test(async testCase => {
+  await cookieStore.set('cookie-name', 'cookie-value');
+
+  const cookie = await cookieStore.get({ matchType: 'starts-with' });
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+
+  async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookieStore.get with matchType set to starts-with and missing name');

tests/wpt/web-platform-tests/cookie-store/cookieStore_set_arguments.tentative.https.window.js

@@ -36,10 +36,10 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
-  await promise_rejects(testCase, new TypeError(), cookieStore.set(
-      'cookie-name', 'cookie-value', { name: 'cookie-name' }));
+  cookieStore.set('cookie-name', 'cookie-value', { name: 'wrong-cookie-name' });
   const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie, null);
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with name in both positional arguments and options');
@@ -47,10 +47,11 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
-  await promise_rejects(testCase, new TypeError(), cookieStore.set(
-      'cookie-name', 'cookie-value', { value: 'cookie-value' }));
+  cookieStore.set('cookie-name', 'cookie-value',
+                  { value: 'wrong-cookie-value' });
   const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie, null);
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
 }, 'cookieStore.set with value in both positional arguments and options');
@@ -139,7 +140,7 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   const currentUrl = new URL(self.location.href);
   const currentDomain = currentUrl.hostname;
-  await cookieStore.delete('cookie-name', { domain: currentDomain });
+  await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { domain: currentDomain });
@@ -148,7 +149,7 @@ promise_test(async testCase => {
   assert_equals(cookie.value, 'cookie-value');
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { domain: currentDomain });
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   });
 }, 'cookieStore.set with domain set to the current hostname');
 
@@ -198,7 +199,7 @@ promise_test(async testCase => {
 
   await async_cleanup(async () => {
     await cookieStore.delete('cookie-name');
-    await cookieStore.delete('cookie-name', { domain: currentDomain });
+    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   });
 }, 'cookieStore.set default domain is null and differs from current hostname');
 
@@ -207,7 +208,7 @@ promise_test(async testCase => {
   const currentPath = currentUrl.pathname;
   const currentDirectory =
       currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
-  await cookieStore.delete('cookie-name', { path: currentDirectory });
+  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: currentDirectory });
@@ -216,7 +217,7 @@ promise_test(async testCase => {
   assert_equals(cookie.value, 'cookie-value');
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { path: currentDirectory });
+    await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
 }, 'cookieStore.set with path set to the current directory');
 
@@ -226,8 +227,8 @@ promise_test(async testCase => {
   const currentDirectory =
       currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
   const subDirectory = currentDirectory + "subdir/";
-  await cookieStore.delete('cookie-name', { path: currentDirectory });
-  await cookieStore.delete('cookie-name', { path: subDirectory });
+  await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
+  await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
 
   await cookieStore.set(
       'cookie-name', 'cookie-value', { path: subDirectory });
@@ -235,7 +236,7 @@ promise_test(async testCase => {
   assert_equals(cookie, null);
 
   await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { path: subDirectory });
+    await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
   });
 }, 'cookieStore.set with path set to a subdirectory of the current directory');
 
@@ -250,6 +251,24 @@ promise_test(async testCase => {
   assert_equals(cookies[0].name, 'cookie-name');
   assert_equals(cookies[0].value, 'cookie-new-value');
 
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-  await async_cleanup(() => cookieStore.delete('cookie-name', { path: '/' }));
+  await async_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
+    await cookieStore.delete({ name: 'cookie-name',  path: '/' });
+  });
 }, 'cookieStore.set default path is /');
+
+promise_test(async testCase => {
+  await cookieStore.set('cookie-name', 'old-cookie-value');
+
+  const cookie_attributes = await cookieStore.get('cookie-name');
+  assert_equals(cookie_attributes.name, 'cookie-name');
+  assert_equals(cookie_attributes.value, 'old-cookie-value');
+
+  cookie_attributes.value = 'new-cookie-value';
+  await cookieStore.set(cookie_attributes);
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'new-cookie-value');
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookieStore.set with get result');

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions.js

@@ -103,8 +103,8 @@ promise_test(async testCase => {
   assert_true(event instanceof ExtendableCookieChangeEvent);
   assert_true(event instanceof ExtendableEvent);
 
-  await async_cleanup(() => {
-    cookieStore.delete('cookie-name');
+  await async_cleanup(async () => {
+    await cookieStore.delete('cookie-name');
     g_cookie_changes = [];
     RearmCookieChangeReceivedPromise();
   });

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_basic.js

@@ -6,7 +6,7 @@ importScripts("/resources/testharness.js");
 
 self.addEventListener('install', (event) => {
   event.waitUntil((async () => {
-    cookieStore.subscribeToChanges([
+    await cookieStore.subscribeToChanges([
       { name: 'cookie-name', matchType: 'equals', url: '/scope/path' }]);
   })());
 });
@@ -57,7 +57,8 @@ promise_test(async testCase => {
   assert_true(event instanceof ExtendableCookieChangeEvent);
   assert_true(event instanceof ExtendableEvent);
 
-  await async_cleanup(() => { cookieStore.delete('cookie-name'); });
-}, 'cookiechange dispatched with cookie change that matches subscription');
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookiechange dispatched with cookie change that matches subscription ' +
+   'to event handler registered with addEventListener');
 
 done();

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_empty.js

@@ -6,7 +6,7 @@ importScripts("/resources/testharness.js");
 
 self.addEventListener('install', (event) => {
   event.waitUntil((async () => {
-    cookieStore.subscribeToChanges([]);
+    await cookieStore.subscribeToChanges([]);
   })());
 });
 

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_eventhandler_attribute.js

@@ -0,0 +1,51 @@
+self.GLOBAL = {
+  isWindow: function() { return false; },
+  isWorker: function() { return true; },
+};
+importScripts("/resources/testharness.js");
+
+self.addEventListener('install', (event) => {
+  event.waitUntil((async () => {
+    await cookieStore.subscribeToChanges([
+      { name: 'cookie-name', matchType: 'equals', url: '/scope/path' }]);
+  })());
+});
+
+// Workaround because add_cleanup doesn't support async functions yet.
+// See https://github.com/web-platform-tests/wpt/issues/6075
+async function async_cleanup(cleanup_function) {
+  try {
+    await cleanup_function();
+  } catch (e) {
+    // Errors in cleanup functions shouldn't result in test failures.
+  }
+}
+
+// Resolves when the service worker receives the 'activate' event.
+const kServiceWorkerActivatedPromise = new Promise(resolve => {
+  self.addEventListener('activate', event => { resolve(); });
+});
+
+promise_test(async testCase => {
+  await kServiceWorkerActivatedPromise;
+
+  const cookie_change_received_promise = new Promise((resolve) => {
+    self.oncookiechange = (event) => { resolve(event); };
+  });
+
+  await cookieStore.set('cookie-name', 'cookie-value');
+
+  const event = await cookie_change_received_promise;
+  assert_equals(event.type, 'cookiechange');
+  assert_equals(event.changed.length, 1);
+  assert_equals(event.changed[0].name, 'cookie-name');
+  assert_equals(event.changed[0].value, 'cookie-value');
+  assert_equals(event.deleted.length, 0);
+  assert_true(event instanceof ExtendableCookieChangeEvent);
+  assert_true(event instanceof ExtendableEvent);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookiechange dispatched with cookie change that matches subscription ' +
+   'to event handler registered with oncookiechange');
+
+done();

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_eventhandler_attribute.tentative.https.html

@@ -0,0 +1,22 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Async Cookies: oncookiechange event handler attribute in ServiceWorker</title>
+<link rel="help" href="https://github.com/WICG/cookie-store">
+<link rel="author" href="pwnall@chromium.org" title="Victor Costan">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+'use strict';
+
+(async () => {
+  const scope = 'scope';
+
+  let registration = await navigator.serviceWorker.getRegistration(scope);
+  if (registration)
+    await registration.unregister();
+  registration = await navigator.serviceWorker.register(
+      'serviceworker_cookieStore_subscriptions_eventhandler_attribute.js', {scope});
+
+  fetch_tests_from_worker(registration.installing);
+})();
+</script>

tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_mismatch.js

@@ -6,7 +6,7 @@ importScripts("/resources/testharness.js");
 
 self.addEventListener('install', (event) => {
   event.waitUntil((async () => {
-    cookieStore.subscribeToChanges([
+    await cookieStore.subscribeToChanges([
       { name: 'cookie-name', matchType: 'equals', url: '/scope/path' }]);
   })());
 });
@@ -44,9 +44,9 @@ promise_test(async testCase => {
   assert_equals(event.changed[0].name, 'cookie-name');
   assert_equals(event.changed[0].value, 'cookie-value');
 
-  await async_cleanup(() => {
-    cookieStore.delete('another-cookie-name');
-    cookieStore.delete('cookie-name');
+  await async_cleanup(async () => {
+    await cookieStore.delete('another-cookie-name');
+    await cookieStore.delete('cookie-name');
   });
 }, 'cookiechange not dispatched for change that does not match subscription');