CookieStore: change set() to use CookieInit

Per TAG review discussion [1], this change updates the set()
method as follows:

Promise<void> set(USVString name, USVString value);
Promise<void> set(CookieInit cookieInit);

dictionary CookieInit {
  required USVString name;
  required USVString value;
  USVString? domain = null;
  USVString path = "/";
  DOMTimeStamp? expires = null;
  CookieSameSite sameSite = "strict";
};

[1] https://github.com/WICG/cookie-store/pull/141

Bug: 1087580
Change-Id: Ic22ae0bc7dfc3df71ac849b9acd894316fe01377
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2220556
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Commit-Queue: Ayu Ishii <ayui@chromium.org>
Cr-Commit-Position: refs/heads/master@{#779365}
diff --git a/cookie-store/cookieListItem_attributes.tentative.https.any.js b/cookie-store/cookieListItem_attributes.tentative.https.any.js
index 3442773..e46d6b6 100644
--- a/cookie-store/cookieListItem_attributes.tentative.https.any.js
+++ b/cookie-store/cookieListItem_attributes.tentative.https.any.js
@@ -52,8 +52,8 @@
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
-  await cookieStore.set('cookie-name', 'cookie-value',
-                        { expires: kTenYearsFromNow });
+  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
+                          expires: kTenYearsFromNow });
   testCase.add_cleanup(async () => {
     await cookieStore.delete('cookie-name');
   });
@@ -73,27 +73,7 @@
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
-                          expires: kTenYearsFromNow });
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-  });
-  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);
-}, '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) });
+                          expires: new Date(kTenYearsFromNow) });
   testCase.add_cleanup(async () => {
     await cookieStore.delete('cookie-name');
   });
@@ -108,30 +88,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) });
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-  });
-  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);
-}, 'CookieListItem - cookieStore.set with name and value in options and ' +
-   'expires set to a future Date');
-
-promise_test(async testCase => {
   await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
 
-  await cookieStore.set('cookie-name', 'cookie-value',
-                        { domain: kCurrentHostname });
+  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
+                          domain: kCurrentHostname });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
   });
@@ -153,8 +113,8 @@
       currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
   await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
 
-  await cookieStore.set('cookie-name', 'cookie-value',
-                        { path: currentDirectory });
+  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
+                          path: currentDirectory });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
@@ -175,8 +135,8 @@
   const currentDirectory = currentPath.substr(0, currentPath.lastIndexOf('/'));
   await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
 
-  await cookieStore.set('cookie-name', 'cookie-value',
-                        { path: currentDirectory });
+  await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
+                          path: currentDirectory });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
@@ -211,23 +171,4 @@
     assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
   }, `CookieListItem - cookieStore.set with sameSite set to ${sameSiteValue}`);
 
-  promise_test(async testCase => {
-    await cookieStore.delete('cookie-name');
-
-    await cookieStore.set('cookie-name', 'cookie-value',
-                          { sameSite: sameSiteValue });
-    testCase.add_cleanup(async () => {
-      await cookieStore.delete('cookie-name');
-    });
-    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);
-  }, 'CookieListItem - cookieStore.set with positional name and value and ' +
-     `sameSite set to ${sameSiteValue}`);
 });
diff --git a/cookie-store/cookieStore_delete_arguments.tentative.https.any.js b/cookie-store/cookieStore_delete_arguments.tentative.https.any.js
index f1763ad..5989dcb 100644
--- a/cookie-store/cookieStore_delete_arguments.tentative.https.any.js
+++ b/cookie-store/cookieStore_delete_arguments.tentative.https.any.js
@@ -23,34 +23,24 @@
 }, 'cookieStore.delete with name in options');
 
 promise_test(async testCase => {
-  await cookieStore.set('cookie-name', 'cookie-value');
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-  });
-
-  await cookieStore.delete('cookie-name', { name: 'wrong-cookie-name' });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie, null);
-}, 'cookieStore.delete with name in both positional arguments and options');
-
-promise_test(async testCase => {
   const currentUrl = new URL(self.location.href);
   const currentDomain = currentUrl.hostname;
 
   await promise_rejects_js(testCase, TypeError, cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: `.${currentDomain}` }));
+      { name: 'cookie-name', value: 'cookie-value',
+        domain: `.${currentDomain}` }));
 }, 'cookieStore.delete domain starts with "."');
 
 promise_test(async testCase => {
   await promise_rejects_js(testCase, TypeError, cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: 'example.com' }));
+      { name: 'cookie-name', value: 'cookie-value', domain: 'example.com' }));
 }, 'cookieStore.delete with domain that is not equal current host');
 
 promise_test(async testCase => {
   const currentUrl = new URL(self.location.href);
   const currentDomain = currentUrl.hostname;
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: currentDomain });
+      { name: 'cookie-name', value: 'cookie-value', domain: currentDomain });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   });
@@ -83,48 +73,11 @@
 
 promise_test(async testCase => {
   const currentUrl = new URL(self.location.href);
-  const currentDomain = currentUrl.hostname;
-  await cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: currentDomain });
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
-  });
-
-  await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie, null);
-}, 'cookieStore.delete with name in options and domain set to the current ' +
-   'hostname');
-
-promise_test(async testCase => {
-  const currentUrl = new URL(self.location.href);
-  const currentDomain = currentUrl.hostname;
-  const subDomain = `sub.${currentDomain}`;
-
-  await promise_rejects_js(testCase, TypeError, cookieStore.delete(
-      { name: 'cookie-name', domain: subDomain }));
-}, 'cookieStore.delete with name in options and domain set to a subdomain of ' +
-   'the current hostname');
-
-promise_test(async testCase => {
-  const currentUrl = new URL(self.location.href);
-  const currentDomain = currentUrl.hostname;
-  assert_not_equals(currentDomain[0] === '.',
-      'this test assumes that the current hostname does not start with .');
-  const domainSuffix = currentDomain.substr(1);
-
-  await promise_rejects_js(testCase, TypeError, cookieStore.delete(
-      { name: 'cookie-name', domain: domainSuffix }));
-}, 'cookieStore.delete with name in options and domain set to a ' +
-   'non-domain-matching suffix of 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.set(
-      'cookie-name', 'cookie-value', { path: currentDirectory });
+      { name: 'cookie-name', value: 'cookie-value', path: currentDirectory });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
@@ -141,7 +94,7 @@
       currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
   const subDirectory = currentDirectory + "subdir/";
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { path: currentDirectory });
+      { name: 'cookie-name', value: 'cookie-value', path: currentDirectory });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
@@ -157,7 +110,9 @@
   const currentPath = currentUrl.pathname;
   const currentDirectory = currentPath.substr(0, currentPath.lastIndexOf('/'));
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { path: currentDirectory + '/' });
+      { name: 'cookie-name',
+        value: 'cookie-value',
+        path: currentDirectory + '/' });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
diff --git a/cookie-store/cookieStore_set_arguments.tentative.https.any.js b/cookie-store/cookieStore_set_arguments.tentative.https.any.js
index 528bc9d..aab964d 100644
--- a/cookie-store/cookieStore_set_arguments.tentative.https.any.js
+++ b/cookie-store/cookieStore_set_arguments.tentative.https.any.js
@@ -29,18 +29,6 @@
 }, 'cookieStore.set with name and value in options');
 
 promise_test(async testCase => {
-  await cookieStore.delete('cookie-name');
-
-  cookieStore.set('cookie-name', 'cookie-value', { name: 'wrong-cookie-name' });
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-  });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-}, 'cookieStore.set with name in both positional arguments and options');
-
-promise_test(async testCase => {
   await promise_rejects_js(testCase, TypeError,
       cookieStore.set('', 'suspicious-value=resembles-name-and-value'));
 }, "cookieStore.set with empty name and an '=' in value");
@@ -57,54 +45,14 @@
 }, "cookieStore.set with normal name and an '=' in value");
 
 promise_test(async testCase => {
-  await cookieStore.delete('cookie-name');
-
-  cookieStore.set('cookie-name', 'cookie-value',
-                  { value: 'wrong-cookie-value' });
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-  });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-}, 'cookieStore.set with value in both positional arguments and options');
-
-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: tenYearsFromNow });
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-  });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie.name, 'cookie-name');
-  assert_equals(cookie.value, 'cookie-value');
-}, 'cookieStore.set with expires set to a future timestamp');
-
-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: tenYearsAgo });
-  testCase.add_cleanup(async () => {
-    await cookieStore.delete('cookie-name');
-  });
-  const cookie = await cookieStore.get('cookie-name');
-  assert_equals(cookie, null);
-}, '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) });
+      { name: 'cookie-name',
+        value: 'cookie-value',
+        expires: new Date(tenYearsFromNow) });
   testCase.add_cleanup(async () => {
     await cookieStore.delete('cookie-name');
   });
@@ -119,7 +67,9 @@
   await cookieStore.delete('cookie-name');
 
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { expires: new Date(tenYearsAgo) });
+      { name :'cookie-name',
+        value: 'cookie-value',
+        expires: new Date(tenYearsAgo) });
   testCase.add_cleanup(async () => {
     await cookieStore.delete('cookie-name');
   });
@@ -140,7 +90,7 @@
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie.name, 'cookie-name');
   assert_equals(cookie.value, 'cookie-value');
-}, 'cookieStore.set with name and value in options and 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;
@@ -154,19 +104,21 @@
   });
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
-}, 'cookieStore.set with name and value in options and expires in the past');
+}, 'cookieStore.set with expires set to a past timestamp');
 
 promise_test(async testCase => {
   const currentUrl = new URL(self.location.href);
   const currentDomain = currentUrl.hostname;
 
   await promise_rejects_js(testCase, TypeError, cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: `.${currentDomain}` }));
+      { name: 'cookie-name',
+        value: 'cookie-value',
+        domain: `.${currentDomain}` }));
 }, 'cookieStore.set domain starts with "."');
 
 promise_test(async testCase => {
   await promise_rejects_js(testCase, TypeError, cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: 'example.com' }));
+      { name: 'cookie-name', value: 'cookie-value', domain: 'example.com' }));
 }, 'cookieStore.set with domain that is not equal current host');
 
 promise_test(async testCase => {
@@ -175,7 +127,7 @@
   await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
 
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: currentDomain });
+      { name: 'cookie-name', value: 'cookie-value', domain: currentDomain });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   });
@@ -190,7 +142,7 @@
   const subDomain = `sub.${currentDomain}`;
 
   await promise_rejects_js(testCase, TypeError, cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: subDomain }));
+      { name: 'cookie-name', value: 'cookie-value', domain: subDomain }));
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
 }, 'cookieStore.set with domain set to a subdomain of the current hostname');
@@ -203,7 +155,7 @@
   const domainSuffix = currentDomain.substr(1);
 
   await promise_rejects_js(testCase, TypeError, cookieStore.set(
-      'cookie-name', 'cookie-value', { domain: domainSuffix }));
+      { name: 'cookie-name', value: 'cookie-value', domain: domainSuffix }));
   const cookie = await cookieStore.get('cookie-name');
   assert_equals(cookie, null);
 }, 'cookieStore.set with domain set to a non-domain-matching suffix of the ' +
@@ -218,8 +170,8 @@
   testCase.add_cleanup(async () => {
     await cookieStore.delete('cookie-name');
   });
-  await cookieStore.set('cookie-name', 'cookie-value2',
-                        { domain: currentDomain });
+  await cookieStore.set(
+      { name: 'cookie-name', value: 'cookie-value2', domain: currentDomain });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
   });
@@ -243,7 +195,7 @@
   await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
 
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { path: currentDirectory });
+      { name: 'cookie-name', value: 'cookie-value', path: currentDirectory });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
@@ -262,7 +214,7 @@
   await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
 
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { path: subDirectory });
+      { name: 'cookie-name', value: 'cookie-value', path: subDirectory });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
   });
@@ -277,7 +229,8 @@
   testCase.add_cleanup(async () => {
     await cookieStore.delete('cookie-name');
   });
-  await cookieStore.set('cookie-name', 'cookie-new-value', { path: '/' });
+  await cookieStore.set(
+      { name: 'cookie-name', value: 'cookie-new-value', path: '/' });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name',  path: '/' });
   });
@@ -295,7 +248,7 @@
   await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
 
   await cookieStore.set(
-      'cookie-name', 'cookie-value', { path: currentDirectory });
+      { name: 'cookie-name', value: 'cookie-value', path: currentDirectory });
   testCase.add_cleanup(async () => {
     await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
   });
@@ -313,7 +266,7 @@
   const invalidPath = currentDirectory.substr(1);
 
   await promise_rejects_js(testCase, TypeError, cookieStore.set(
-      'cookie-name', 'cookie-value', { path: invalidPath }));
+      { name: 'cookie-name', value: 'cookie-value', path: invalidPath }));
 }, 'cookieStore.set with path that does not start with /');
 
 promise_test(async testCase => {
diff --git a/cookie-store/cookieStore_special_names.tentative.https.any.js b/cookie-store/cookieStore_special_names.tentative.https.any.js
index 0cf4edc..db07747 100644
--- a/cookie-store/cookieStore_special_names.tentative.https.any.js
+++ b/cookie-store/cookieStore_special_names.tentative.https.any.js
@@ -19,9 +19,8 @@
     // contexts, the set() should fail even if the expiration date makes
     // the operation a no-op.
     await cookieStore.set(
-      `${prefix}cookie-name`, `secure-cookie-value`, {
-        expires: Date.now() - (24 * 60 * 60 * 1000)
-      });
+        { name: `${prefix}cookie-name`, value: `secure-cookie-value`,
+          expires: Date.now() - (24 * 60 * 60 * 1000)});
     assert_equals(await cookieStore.get(`${prefix}cookie-name`), null);
     try { await cookieStore.delete(`${prefix}cookie-name`); } catch (e) {}
   }, `cookieStore.set of expired ${prefix} cookie name on secure origin`);
@@ -37,19 +36,18 @@
   const currentUrl = new URL(self.location.href);
   const currentDomain = currentUrl.hostname;
   await promise_rejects_js(testCase, TypeError,
-      cookieStore.set('__Host-cookie-name', 'cookie-value', {
-        domain: currentDomain
-      }));
+      cookieStore.set({ name: '__Host-cookie-name', value: 'cookie-value',
+                        domain: currentDomain }));
 }, 'cookieStore.set with __Host- prefix and a domain option');
 
 promise_test(async testCase => {
-  await cookieStore.set('__Host-cookie-name', 'cookie-value', { path: "/" });
+  await cookieStore.set({ name: '__Host-cookie-name', value: 'cookie-value',
+                          path: "/" });
 
   assert_equals(
       (await cookieStore.get(`__Host-cookie-name`)).value, "cookie-value");
 
   await promise_rejects_js(testCase, TypeError,
-      cookieStore.set('__Host-cookie-name', 'cookie-value', {
-        path: "/path"
-      }));
+      cookieStore.set( { name: '__Host-cookie-name', value: 'cookie-value',
+                         path: "/path" }));
 }, 'cookieStore.set with __Host- prefix a path option');