Update web-platform-tests to revision 7a6f5673ff5d146ca5c09c6a1b42b7706cfee328

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

@@ -0,0 +1,235 @@
+'use strict';
+
+// 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.
+  }
+}
+
+const kCurrentHostname = (new URL(self.location.href)).hostname;
+
+const kOneDay = 24 * 60 * 60 * 1000;
+const kTenYears = 10 * 365 * kOneDay;
+const kTenYearsFromNow = Date.now() + kTenYears;
+
+const kCookieListItemKeys =
+    ['domain', 'expires', 'name', 'path', 'sameSite', 'secure', 'value'].sort();
+
+promise_test(async testCase => {
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set('cookie-name', 'cookie-value');
+
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, '/');
+  assert_equals(cookie.expires, null);
+  assert_equals(cookie.secure, true);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'CookieListItem - cookieStore.set defaults with positional name and value');
+
+promise_test(async testCase => {
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value' });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, '/');
+  assert_equals(cookie.expires, null);
+  assert_equals(cookie.secure, true);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'CookieListItem - cookieStore.set defaults with name and value in options');
+
+promise_test(async testCase => {
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set('cookie-name', 'cookie-value',
+                        { expires: kTenYearsFromNow });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, '/');
+  assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
+  assert_equals(cookie.secure, true);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'CookieListItem - cookieStore.set with expires set to a timestamp 10 ' +
+   'years in the future');
+
+promise_test(async testCase => {
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
+                          expires: kTenYearsFromNow });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, '/');
+  assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
+  assert_equals(cookie.secure, true);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'CookieListItem - cookieStore.set with name and value in options and ' +
+   'expires set to a future timestamp');
+
+promise_test(async testCase => {
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set('cookie-name', 'cookie-value',
+                        { expires: new Date(kTenYearsFromNow) });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, '/');
+  assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
+  assert_equals(cookie.secure, true);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'CookieListItem - cookieStore.set with expires set to a Date 10 ' +
+   'years in the future');
+
+promise_test(async testCase => {
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
+                          expires: new Date(kTenYearsFromNow) });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, '/');
+  assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
+  assert_equals(cookie.secure, true);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'CookieListItem - cookieStore.set with name and value in options and ' +
+   'expires set to a future Date');
+
+promise_test(async testCase => {
+  await cookieStore.delete('cookie-name', { domain: kCurrentHostname });
+
+  await cookieStore.set('cookie-name', 'cookie-value',
+                        { domain: kCurrentHostname });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, kCurrentHostname);
+  assert_equals(cookie.path, '/');
+  assert_equals(cookie.expires, null);
+  assert_equals(cookie.secure, true);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(async () => {
+    await cookieStore.delete('cookie-name', { domain: kCurrentHostname });
+  });
+}, 'CookieListItem - cookieStore.set with domain set to the current hostname');
+
+promise_test(async testCase => {
+  const currentUrl = new URL(self.location.href);
+  const currentPath = currentUrl.pathname;
+  const currentDirectory =
+      currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
+  await cookieStore.delete('cookie-name', { path: currentDirectory });
+
+  await cookieStore.set('cookie-name', 'cookie-value',
+                        { path: currentDirectory });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, currentDirectory);
+  assert_equals(cookie.expires, null);
+  assert_equals(cookie.secure, true);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(async () => {
+    await cookieStore.delete('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.set('cookie-name', 'cookie-value', { secure: false });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie.name, 'cookie-name');
+  assert_equals(cookie.value, 'cookie-value');
+  assert_equals(cookie.domain, null);
+  assert_equals(cookie.path, '/');
+  assert_equals(cookie.expires, null);
+  assert_equals(cookie.secure, false);
+  assert_equals(cookie.sameSite, 'strict');
+  assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+  await async_cleanup(async () => {
+    await cookieStore.delete('cookie-name', { secure: false });
+  });
+}, '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.set({
+        name: 'cookie-name', value: 'cookie-value', sameSite: sameSiteValue });
+    const cookie = await cookieStore.get('cookie-name');
+    assert_equals(cookie.name, 'cookie-name');
+    assert_equals(cookie.value, 'cookie-value');
+    assert_equals(cookie.domain, null);
+    assert_equals(cookie.path, '/');
+    assert_equals(cookie.expires, null);
+    assert_equals(cookie.secure, true);
+    assert_equals(cookie.sameSite, sameSiteValue);
+    assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+    await async_cleanup(async () => {
+      await cookieStore.delete('cookie-name', { secure: sameSiteValue });
+    });
+  }, `CookieListItem - cookieStore.set with sameSite set to ${sameSiteValue}`);
+
+  promise_test(async testCase => {
+    await cookieStore.delete('cookie-name', { sameSite: sameSiteValue });
+
+    await cookieStore.set('cookie-name', 'cookie-value',
+                          { sameSite: sameSiteValue });
+    const cookie = await cookieStore.get('cookie-name');
+    assert_equals(cookie.name, 'cookie-name');
+    assert_equals(cookie.value, 'cookie-value');
+    assert_equals(cookie.domain, null);
+    assert_equals(cookie.path, '/');
+    assert_equals(cookie.expires, null);
+    assert_equals(cookie.secure, true);
+    assert_equals(cookie.sameSite, sameSiteValue);
+    assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
+
+    await async_cleanup(async () => {
+      await cookieStore.delete('cookie-name', { secure: sameSiteValue });
+    });
+  }, 'CookieListItem - cookieStore.set with positional name and value and ' +
+     `sameSite set to ${sameSiteValue}`);
+});

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

@@ -1,121 +0,0 @@
-'use strict';
-
-// 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.
-  }
-}
-
-const kCurrentHostname = (new URL(self.location.href)).hostname;
-const kIsSecureTransport = (new URL(self.location.href)).protocol === 'https:';
-
-const kOneDay = 24 * 60 * 60 * 1000;
-const kTenYears = 10 * 365 * kOneDay;
-const kTenYearsFromNow = Date.now() + kTenYears;
-
-promise_test(async testCase => {
-  await cookieStore.delete('cookie-name');
-
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-  assert_equals(cookie.domain, null);
-  assert_equals(cookie.path, '/');
-  assert_equals(cookie.expires, null);
-  assert_equals(cookie.secure, kIsSecureTransport);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.set defaults with positional name and value');
-
-promise_test(async testCase => {
-  await cookieStore.delete('cookie-name');
-
-  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value' });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-  assert_equals(cookie.domain, null);
-  assert_equals(cookie.path, '/');
-  assert_equals(cookie.expires, null);
-  assert_equals(cookie.secure, kIsSecureTransport);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.set defaults with name and value in options');
-
-promise_test(async testCase => {
-  await cookieStore.delete('cookie-name');
-
-  await cookieStore.set('cookie-name', 'cookie-value',
-                        { expires: kTenYearsFromNow });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-  assert_equals(cookie.domain, null);
-  assert_equals(cookie.path, '/');
-  assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
-  assert_equals(cookie.secure, kIsSecureTransport);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.set with expires set to 10 years in the future');
-
-promise_test(async testCase => {
-  await cookieStore.delete('cookie-name');
-
-  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
-                          expires: kTenYearsFromNow });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-  assert_equals(cookie.domain, null);
-  assert_equals(cookie.path, '/');
-  assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
-  assert_equals(cookie.secure, kIsSecureTransport);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.set with name and value in options and expires in the future');
-
-promise_test(async testCase => {
-  await cookieStore.delete('cookie-name', { domain: kCurrentHostname });
-
-  await cookieStore.set('cookie-name', 'cookie-value',
-                        { domain: kCurrentHostname });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-  assert_equals(cookie.domain, kCurrentHostname);
-  assert_equals(cookie.path, '/');
-  assert_equals(cookie.expires, null);
-  assert_equals(cookie.secure, kIsSecureTransport);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { domain: kCurrentHostname });
-  });
-}, 'cookieStore.set with domain set to the current hostname');
-
-promise_test(async testCase => {
-  const currentUrl = new URL(self.location.href);
-  const currentPath = currentUrl.pathname;
-  const currentDirectory =
-      currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
-  await cookieStore.delete('cookie-name', { path: currentDirectory });
-
-  await cookieStore.set('cookie-name', 'cookie-value',
-                        { path: currentDirectory });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-  assert_equals(cookie.domain, null);
-  assert_equals(cookie.path, currentDirectory);
-  assert_equals(cookie.expires, null);
-  assert_equals(cookie.secure, kIsSecureTransport);
-
-  await async_cleanup(async () => {
-    await cookieStore.delete('cookie-name', { path: currentDirectory });
-  });
-}, 'cookieStore.set with path set to the current directory');

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

@@ -84,14 +84,14 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
 
   const cookies = await cookieStore.getAll(
-      'cookie-name-', { matchType: 'startsWith' });
+      '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');
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
   await async_cleanup(() => cookieStore.delete('cookie-name-2'));
-}, 'cookieStore.getAll with matchType set to startsWith');
+}, 'cookieStore.getAll with matchType set to starts-with');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
@@ -109,11 +109,11 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name-2', 'cookie-value-2');
 
   const cookies = await cookieStore.getAll(
-      { matchType: 'startsWith', name: 'cookie-name-' });
+      { matchType: 'starts-with', name: 'cookie-name-' });
   assert_equals(cookies.length, 1);
   assert_equals(cookies[0].name, 'cookie-name-2');
   assert_equals(cookies[0].value, 'cookie-value-2');
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
   await async_cleanup(() => cookieStore.delete('cookie-name-2'));
-}, 'cookieStore.getAll with matchType set to startsWith and name in options');
+}, 'cookieStore.getAll with matchType set to starts-with and name in options');

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

@@ -1,11 +1,3 @@
-<!doctype html>
-<meta charset="utf-8">
-<title>Async Cookies: cookieStore.getAll() sees cookieStore.set() cookie</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';
 
 // Workaround because add_cleanup doesn't support async functions yet.
@@ -37,5 +29,3 @@ promise_test(async testCase => {
   await async_cleanup(() => cookieStore.delete('cookie-name-2'));
   await async_cleanup(() => cookieStore.delete('cookie-name-3'));
 }, 'cookieStore.getAll returns multiple cookies written by cookieStore.set');
-
-</script>

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

@@ -58,12 +58,12 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
   const cookie = await cookieStore.get(
-      'cookie-na', { matchType: 'startsWith' });
+      'cookie-na', { 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 startsWith');
+}, 'cookieStore.get with matchType set to starts-with');
 
 promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
@@ -78,9 +78,9 @@ promise_test(async testCase => {
   await cookieStore.set('cookie-name', 'cookie-value');
 
   const cookie = await cookieStore.get(
-      { matchType: 'startsWith', name: 'cookie-na' });
+      { matchType: 'starts-with', name: 'cookie-na' });
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
 
   async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.get with matchType set to startsWith and name in options');
+}, 'cookieStore.get with matchType set to starts-with and name in options');

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

@@ -1,92 +0,0 @@
-'use strict';
-
-// 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.
-  }
-}
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-  await cookieStore.delete('cookie-name-2');
-
-  const has_cookie = await cookieStore.has('cookie-name');
-  assert_equals(has_cookie, true);
-  const has_cookie2 = await cookieStore.has('cookie-name-2');
-  assert_equals(has_cookie2, false);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has with positional name');
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-  await cookieStore.delete('cookie-name-2');
-
-  const has_cookie = await cookieStore.has({ name: 'cookie-name' });
-  assert_equals(has_cookie, true);
-  const has_cookie2 = await cookieStore.has({ name: 'cookie-name-2' });
-  assert_equals(has_cookie2, false);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has with name in options');
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  await promise_rejects(testCase, new TypeError(), cookieStore.has(
-      'cookie-name', { name: 'cookie-name' }));
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has with name in both positional arguments and options');
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  const has_cookie = await cookieStore.has(
-      'cookie-na', { matchType: 'equals' });
-  assert_equals(has_cookie, false);
-  const has_cookie2 = await cookieStore.has(
-      'cookie-name', { matchType: 'equals' });
-  assert_equals(has_cookie2, true);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has with matchType explicitly set to equals');
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  const has_cookie = await cookieStore.has(
-      'cookie-na', { matchType: 'startsWith' });
-  assert_equals(has_cookie, true);
-  const has_cookie2 = await cookieStore.has(
-      'cookie-name-', { matchType: 'startsWith' });
-  assert_equals(has_cookie2, false);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has with matchType set to startsWith');
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  await promise_rejects(testCase, new TypeError(), cookieStore.has(
-      'cookie-name', { matchType: 'invalid' }));
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has with invalid matchType');
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-
-  const has_cookie = await cookieStore.has(
-      { matchType: 'startsWith', name: 'cookie-na' });
-  assert_equals(has_cookie, true);
-  const has_cookie2 = await cookieStore.has(
-      { matchType: 'startsWith', name: 'cookie-name-' });
-  assert_equals(has_cookie2, false);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has with matchType set to startsWith and name in options');

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

@@ -1,25 +0,0 @@
-'use strict';
-
-// 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.
-  }
-}
-
-promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-  assert_equals(await cookieStore.has('cookie-name'), true);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has returns true for cookie set by cookieStore.set()');
-
-promise_test(async testCase => {
-  await cookieStore.delete('cookie-name');
-  assert_equals(await cookieStore.has('cookie-name'), false);
-
-  await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.has returns false for cookie deleted by cookieStore.delete()');

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

@@ -67,7 +67,7 @@ promise_test(async testCase => {
   assert_equals(cookie.value, 'cookie-value');
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.set with expires in the future');
+}, 'cookieStore.set with expires set to a future timestamp');
 
 promise_test(async testCase => {
   const tenYears = 10 * 365 * 24 * 60 * 60 * 1000;
@@ -80,7 +80,34 @@ promise_test(async testCase => {
   assert_equals(cookie, null);
 
   await async_cleanup(() => cookieStore.delete('cookie-name'));
-}, 'cookieStore.set with expires in the past');
+}, 'cookieStore.set with expires set to a past timestamp');
+
+promise_test(async testCase => {
+  const tenYears = 10 * 365 * 24 * 60 * 60 * 1000;
+  const tenYearsFromNow = Date.now() + tenYears;
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set(
+      'cookie-name', 'cookie-value', { expires: new Date(tenYearsFromNow) });
+  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.set with expires set to a future Date');
+
+promise_test(async testCase => {
+  const tenYears = 10 * 365 * 24 * 60 * 60 * 1000;
+  const tenYearsAgo = Date.now() - tenYears;
+  await cookieStore.delete('cookie-name');
+
+  await cookieStore.set(
+      'cookie-name', 'cookie-value', { expires: new Date(tenYearsAgo) });
+  const cookie = await cookieStore.get('cookie-name');
+  assert_equals(cookie, null);
+
+  await async_cleanup(() => cookieStore.delete('cookie-name'));
+}, 'cookieStore.set with expires set to a past Date');
 
 promise_test(async testCase => {
   const tenYears = 10 * 365 * 24 * 60 * 60 * 1000;

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

@@ -1,59 +0,0 @@
-'use strict';
-
-// 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.
-  }
-}
-
-promise_test(async testCase => {
-  const inTwentyFourHours = new Date(Date.now() + 24 * 60 * 60 * 1000);
-
-  assert_equals(
-    await cookieStore.set(
-      'cookie-name', 'cookie-value', { expires: inTwentyFourHours }),
-    undefined);
-
-  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.set with expires option: Date object');
-
-promise_test(async testCase => {
-  const inTwentyFourHours = Date.now() + 24 * 60 * 60 * 1000;
-
-  assert_equals(
-    await cookieStore.set(
-      'cookie-name', 'cookie-value', { expires: inTwentyFourHours }),
-    undefined);
-
-  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.set with expires option: milliseconds since epoch object');
-
-promise_test(async testCase => {
-  const year = (new Date()).getUTCFullYear() + 1;
-  const date = new Date('07 Jun ' + year + ' 07:07:07 UTC');
-  const day = ('Sun Mon Tue Wed Thu Fri Sat'.split(' '))[date.getUTCDay()];
-  const nextJune = `${day}, 07 Jun ${year} + ' 07:07:07 GMT`;
-
-  assert_equals(
-    await cookieStore.set(
-      'cookie-name', 'cookie-value', { expires: nextJune }),
-    undefined);
-
-  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.set with expires option: HTTP date string');

tests/wpt/web-platform-tests/cookie-store/cookieStore_special_names.tentative.html

@@ -1,71 +0,0 @@
-<!doctype html>
-<meta charset="utf-8">
-<title>Cookie Store: cookieStore handles special cookie names correctly</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';
-
-['__Secure-', '__Host-'].forEach(prefix => {
-  promise_test(async testCase => {
-    await promise_rejects(
-      testCase, new TypeError(),
-      cookieStore.set(`${prefix}cookie-name`, `secure-cookie-value`),
-      `Setting ${prefix} cookies should fail in non-secure contexts`);
-
-    try { await cookieStore.delete(`${prefix}cookie-name`); } catch (e) {}
-  }, `cookieStore.set with ${prefix} name on non-secure origin`);
-
-  promise_test(async testCase => {
-    await promise_rejects(
-      testCase, new TypeError(),
-      cookieStore.set(
-        `${prefix}cookie-name`, `secure-cookie-value`, {
-          expires: Date.now() - (24 * 60 * 60 * 1000)
-        }),
-      `Setting expired ${prefix} cookies should fail in non-secure contexts`);
-
-    try { await cookieStore.delete(`${prefix}cookie-name`); } catch (e) {}
-  }, `cookieStore.set of expired ${prefix} cookie on non-secure origin`);
-
-  promise_test(async testCase => {
-    assert_equals(
-      await cookieStore.get(`${prefix}cookie-name`),
-      null,
-      'get with ${prefix} prefix should not reject');
-    assert_equals(
-      await cookieStore.get({name: `${prefix}cookie-name`}),
-      null,
-      'get with ${prefix} prefix name option should not reject');
-    assert_equals(
-      await cookieStore.get({name: prefix, matchType: 'startsWith'}),
-      null,
-      'get with ${prefix} name and startsWith options should not reject');
-  }, `cookieStore.get with ${prefix} name on non-secure origin`);
-
-  promise_test(async testCase => {
-    assert_array_equals(
-      await cookieStore.getAll(`${prefix}cookie-name`),
-      [],
-      'getAll with ${prefix} prefix should not reject');
-    assert_array_equals(
-      await cookieStore.getAll({name: `${prefix}cookie-name`}),
-      [],
-      'getAll with ${prefix} prefix name option should not reject');
-    assert_array_equals(
-      await cookieStore.getAll({name: prefix, matchType: 'startsWith'}),
-      [],
-      'getAll with ${prefix} name and startsWith options should not reject');
-  }, `cookieStore.getAll with ${prefix} name on non-secure origin`);
-
-  promise_test(async testCase => {
-    await promise_rejects(
-      testCase, new TypeError(),
-      cookieStore.delete(`${prefix}cookie-name`, `host-cookie-value`),
-      `Deleting ${prefix} cookies should fail in non-secure contexts`);
-  }, `cookieStore.delete with ${prefix} name on non-secure origin`);
-});
-
-</script>

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

@@ -1,11 +1,3 @@
-<!doctype html>
-<meta charset="utf-8">
-<title>Cookie Store: cookieStore handles special cookie names correctly (secure context)</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';
 
 ['__Secure-', '__Host-'].forEach(prefix => {
@@ -37,5 +29,3 @@
       `Deleting ${prefix} cookies should not fail in secure context`);
   }, `cookieStore.delete with ${prefix} name on secure origin`);
 });
-
-</script>

tests/wpt/web-platform-tests/cookie-store/document_cookie.tentative.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8">
-<title>Async Cookies: document.cookie</title>
-<meta name="help" href="https://github.com/WICG/cookie-store/">
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="resources/cookie-test-helpers.js"></script>
-<script src="resources/document_cookie.js"></script>

tests/wpt/web-platform-tests/cookie-store/http_cookie_and_set_cookie_headers.tentative.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8">
-<title>Async Cookies: HTTP Cookie and Set-Cookie headers</title>
-<meta name="help" href="https://github.com/WICG/cookie-store/">
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="resources/cookie-test-helpers.js"></script>
-<script src="resources/http_cookie_and_set_cookie_headers.js"></script>

tests/wpt/web-platform-tests/cookie-store/no_name_and_no_value.tentative.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8">
-<title>Async Cookies: Test No Name and No Value</title>
-<meta name="help" href="https://github.com/WICG/cookie-store/">
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="resources/cookie-test-helpers.js"></script>
-<script src="resources/no_name_and_no_value.js"></script>

tests/wpt/web-platform-tests/cookie-store/no_name_equals_in_value.tentative.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8">
-<title>Async Cookies: Test No Name, '=' in Value</title>
-<meta name="help" href="https://github.com/WICG/cookie-store/">
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="resources/cookie-test-helpers.js"></script>
-<script src="resources/no_name_equals_in_value.js"></script>

tests/wpt/web-platform-tests/cookie-store/no_name_multiple_values.tentative.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8">
-<title>Async Cookies: Test No Name, Multiple Values</title>
-<meta name="help" href="https://github.com/WICG/cookie-store/">
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="resources/cookie-test-helpers.js"></script>
-<script src="resources/no_name_multiple_values.js"></script>

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

@@ -5,10 +5,12 @@ self.GLOBAL = {
 importScripts("/resources/testharness.js");
 
 importScripts(
-    "cookieStore_delete_arguments.tentative.window.js",
-    "cookieStore_get_arguments.tentative.window.js",
-    "cookieStore_getAll_arguments.tentative.window.js",
-    "cookieStore_has_arguments.tentative.window.js",
-    "cookieStore_set_arguments.tentative.window.js");
+    "cookieListItem_attributes.tentative.https.window.js",
+    "cookieStore_delete_arguments.tentative.https.window.js",
+    "cookieStore_get_arguments.tentative.https.window.js",
+    "cookieStore_getAll_arguments.tentative.https.window.js",
+    "cookieStore_getAll_multiple.tentative.https.window.js",
+    "cookieStore_set_arguments.tentative.https.window.js",
+    "cookieStore_special_names.tentative.https.window.js");
 
 done();

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

@@ -5,9 +5,9 @@ self.GLOBAL = {
 importScripts("/resources/testharness.js");
 
 importScripts(
-    "cookieStore_get_delete_basic.tentative.window.js",
-    "cookieStore_get_set_basic.tentative.window.js",
-    "cookieStore_getAll_set_basic.tentative.window.js",
-    "cookieStore_has_basic.tentative.window.js");
+    "cookieStore_delete_basic.tentative.https.window.js",
+    "cookieStore_get_delete_basic.tentative.https.window.js",
+    "cookieStore_get_set_basic.tentative.https.window.js",
+    "cookieStore_getAll_set_basic.tentative.https.window.js");
 
 done();

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

@@ -13,7 +13,7 @@ self.addEventListener('install', (event) => {
       { name: 'cookie-name1', matchType: 'equals', url: '/scope/path1' }]);
     await cookieStore.subscribeToChanges([
       { },  // Test the default values for subscription properties.
-      { name: 'cookie-prefix', matchType: 'startsWith' },
+      { name: 'cookie-prefix', matchType: 'starts-with' },
     ]);
   })());
 });
@@ -54,10 +54,10 @@ promise_test(async testCase => {
   assert_equals('equals', subscriptions[0].matchType);
 
   assert_equals(subscriptions[1].name, 'cookie-prefix');
-  assert_equals('startsWith', subscriptions[1].matchType);
+  assert_equals('starts-with', subscriptions[1].matchType);
 
   assert_false('name' in subscriptions[2]);
-  assert_equals('startsWith', subscriptions[2].matchType);
+  assert_equals('starts-with', subscriptions[2].matchType);
 }, 'getChangeSubscriptions returns subscriptions passed to subscribeToChanges');
 
 promise_test(async testCase => {

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

@@ -40,7 +40,7 @@ promise_test(async testCase => {
 promise_test(async testCase => {
   await kServiceWorkerActivatedPromise;
 
-  cookie_change_received_promise = new Promise((resolve) => {
+  const cookie_change_received_promise = new Promise((resolve) => {
     self.addEventListener('cookiechange', (event) => {
       resolve(event);
     });

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

@@ -0,0 +1,36 @@
+self.GLOBAL = {
+  isWindow: function() { return false; },
+  isWorker: function() { return true; },
+};
+importScripts("/resources/testharness.js");
+
+self.addEventListener('install', (event) => {
+  event.waitUntil((async () => {
+    cookieStore.subscribeToChanges([]);
+  })());
+});
+
+// Workaround because add_cleanup doesn't support async functions yet.
+// See https://github.com/w3c/web-platform-tests/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 subscriptions = await cookieStore.getChangeSubscriptions();
+  assert_equals(subscriptions.length, 0);
+
+}, 'getChangeSubscriptions returns an empty array when there are no subscriptions');
+
+done();

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

@@ -0,0 +1,21 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Async Cookies: ServiceWorker without cookie change subscriptions</title>
+<link rel="help" href="https://github.com/WICG/cookie-store">
+<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_empty.js', {scope});
+
+  fetch_tests_from_worker(registration.installing);
+})();
+</script>

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

@@ -0,0 +1,53 @@
+self.GLOBAL = {
+  isWindow: function() { return false; },
+  isWorker: function() { return true; },
+};
+importScripts("/resources/testharness.js");
+
+self.addEventListener('install', (event) => {
+  event.waitUntil((async () => {
+    cookieStore.subscribeToChanges([
+      { name: 'cookie-name', matchType: 'equals', url: '/scope/path' }]);
+  })());
+});
+
+// Workaround because add_cleanup doesn't support async functions yet.
+// See https://github.com/w3c/web-platform-tests/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.addEventListener('cookiechange', (event) => {
+      resolve(event);
+    });
+  });
+
+  await cookieStore.set('another-cookie-name', 'cookie-value');
+  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');
+
+  await async_cleanup(() => {
+    cookieStore.delete('another-cookie-name');
+    cookieStore.delete('cookie-name');
+  });
+}, 'cookiechange not dispatched for change that does not match subscription');
+
+done();

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

@@ -0,0 +1,21 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Async Cookies: ServiceWorker cookiechange event filtering</title>
+<link rel="help" href="https://github.com/WICG/cookie-store">
+<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_mismatch.js', {scope});
+
+  fetch_tests_from_worker(registration.installing);
+})();
+</script>