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/+/2220556Reviewed-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}

android_webview/javatests/src/org/chromium/android_webview/test/CookieManagerTest.java

@@ -1269,8 +1269,9 @@ public class CookieManagerTest {
     private String makeCookieStoreSetFragment(String name, String value, String finallyAction) {
         return "try {"
                 + "  await window.cookieStore.set("
-                + "      " + name + ", " + value + ", "
-                + "      { expires: Date.now() + 3600*1000,"
+                + "      { name: " + name + ","
+                + "        value: " + value + ","
+                + "        expires: Date.now() + 3600*1000,"
                 + "        sameSite: 'none' });"
                 + "} finally {"
                 + "  " + finallyAction + "}\n";

chrome/browser/content_settings/content_settings_browsertest.cc

@@ -317,8 +317,9 @@ class CookieSettingsTest
         browser->tab_strip_model()->GetActiveWebContents(),
         "async function doSet() {"
         "  await window.cookieStore.set("
-        "      'name', 'Good', "
-        "       { expires: Date.now() + 3600*1000,"
+        "       { name: 'name',"
+        "         value: 'Good',"
+        "         expires: Date.now() + 3600*1000,"
         "         sameSite: 'none' });"
         "  window.domAutomationController.send(true);"
         "}"
@@ -954,8 +955,9 @@ IN_PROC_BROWSER_TEST_F(ContentSettingsWorkerModulesBrowserTest, CookieStore) {
       async function cookieHandler(e) {
         try {
           await cookieStore.set(
-              e.data, 'value',
-              { expires: Date.now() + 3600*1000,
+              { name: e.data,
+                value: 'value',
+                expires: Date.now() + 3600*1000,
                 sameSite: 'none' });
         } finally {
           e.source.postMessage('set executed for ' + e.data);

content/test/data/browsing_data/site_data.html

@@ -34,8 +34,9 @@
   }
 
   function setCookieStore() {
-    cookieStore.set('cookie-name', 'cookie-value', {sameSite: 'none'})
-      .then(success_).catch(failure_);
+    cookieStore.set({
+      name: 'cookie-name', value: 'cookie-value', sameSite: 'none'
+    }).then(success_).catch(failure_);
   }
 
   function hasCookieStore() {

third_party/blink/renderer/bindings/idl_in_modules.gni

@@ -100,13 +100,12 @@ static_idl_files_in_modules = get_path_info(
           "//third_party/blink/renderer/modules/content_index/service_worker_registration_content_index.idl",
           "//third_party/blink/renderer/modules/cookie_store/cookie_change_event.idl",
           "//third_party/blink/renderer/modules/cookie_store/cookie_change_event_init.idl",
+          "//third_party/blink/renderer/modules/cookie_store/cookie_init.idl",
           "//third_party/blink/renderer/modules/cookie_store/cookie_list_item.idl",
           "//third_party/blink/renderer/modules/cookie_store/cookie_store.idl",
           "//third_party/blink/renderer/modules/cookie_store/cookie_store_delete_options.idl",
           "//third_party/blink/renderer/modules/cookie_store/cookie_store_get_options.idl",
           "//third_party/blink/renderer/modules/cookie_store/cookie_store_manager.idl",
-          "//third_party/blink/renderer/modules/cookie_store/cookie_store_set_extra_options.idl",
-          "//third_party/blink/renderer/modules/cookie_store/cookie_store_set_options.idl",
           "//third_party/blink/renderer/modules/cookie_store/extendable_cookie_change_event.idl",
           "//third_party/blink/renderer/modules/cookie_store/extendable_cookie_change_event_init.idl",
           "//third_party/blink/renderer/modules/cookie_store/service_worker_global_scope_cookie_store.idl",

third_party/blink/renderer/modules/cookie_store/cookie_store_set_options.idl → third_party/blink/renderer/modules/cookie_store/cookie_init.idl

-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2020 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://github.com/WICG/async-cookies-api/blob/gh-pages/explainer.md
+// https://wicg.github.io/cookie-store/explainer.html
 
 enum CookieSameSite {
   "strict",
@@ -10,9 +10,11 @@ enum CookieSameSite {
   "none"
 };
 
-dictionary CookieStoreSetOptions {
-  DOMTimeStamp? expires = null;
+dictionary CookieInit {
+  required USVString name;
+  required USVString value;
   USVString? domain = null;
   USVString path = "/";
+  DOMTimeStamp? expires = null;
   CookieSameSite sameSite = "strict";
 };

third_party/blink/renderer/modules/cookie_store/cookie_list_item.idl

@@ -5,13 +5,13 @@
 // https://github.com/WICG/async-cookies-api/blob/gh-pages/explainer.md
 
 dictionary CookieListItem {
-  required USVString name;
+  USVString name;
   USVString value;
-  USVString? domain = null;
-  USVString path = "/";
-  DOMTimeStamp? expires = null;
-  boolean secure = true;
-  CookieSameSite sameSite = "strict";
+  USVString? domain;
+  USVString path;
+  DOMTimeStamp? expires;
+  boolean secure;
+  CookieSameSite sameSite;
 };
 
 typedef sequence<CookieListItem> CookieList;

third_party/blink/renderer/modules/cookie_store/cookie_store.cc

@@ -10,11 +10,10 @@
 #include "services/network/public/mojom/restricted_cookie_manager.mojom-blink.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_throw_dom_exception.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_cookie_init.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_cookie_list_item.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_cookie_store_delete_options.h"
 #include "third_party/blink/renderer/bindings/modules/v8/v8_cookie_store_get_options.h"
-#include "third_party/blink/renderer/bindings/modules/v8/v8_cookie_store_set_extra_options.h"
-#include "third_party/blink/renderer/bindings/modules/v8/v8_cookie_store_set_options.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
@@ -69,7 +68,7 @@ network::mojom::blink::CookieManagerGetOptionsPtr ToBackendOptions(
 // Returns no value if and only if an exception is thrown.
 base::Optional<CanonicalCookie> ToCanonicalCookie(
     const KURL& cookie_url,
-    const CookieStoreSetExtraOptions* options,
+    const CookieInit* options,
     ExceptionState& exception_state) {
   const String& name = options->name();
   const String& value = options->value();
@@ -284,22 +283,15 @@ ScriptPromise CookieStore::get(ScriptState* script_state,
 ScriptPromise CookieStore::set(ScriptState* script_state,
                                const String& name,
                                const String& value,
-                               const CookieStoreSetOptions* options,
                                ExceptionState& exception_state) {
-  CookieStoreSetExtraOptions* set_options =
-      CookieStoreSetExtraOptions::Create();
+  CookieInit* set_options = CookieInit::Create();
   set_options->setName(name);
   set_options->setValue(value);
-  if (options->hasExpires())
-    set_options->setExpires(options->expires());
-  set_options->setDomain(options->domain());
-  set_options->setPath(options->path());
-  set_options->setSameSite(options->sameSite());
   return set(script_state, set_options, exception_state);
 }
 
 ScriptPromise CookieStore::set(ScriptState* script_state,
-                               const CookieStoreSetExtraOptions* options,
+                               const CookieInit* options,
                                ExceptionState& exception_state) {
   UseCounter::Count(CurrentExecutionContext(script_state->GetIsolate()),
                     WebFeature::kCookieStoreAPI);
@@ -313,8 +305,7 @@ ScriptPromise CookieStore::Delete(ScriptState* script_state,
   UseCounter::Count(CurrentExecutionContext(script_state->GetIsolate()),
                     WebFeature::kCookieStoreAPI);
 
-  CookieStoreSetExtraOptions* set_options =
-      CookieStoreSetExtraOptions::Create();
+  CookieInit* set_options = CookieInit::Create();
   set_options->setName(name);
   set_options->setValue(g_empty_string);
   set_options->setExpires(0);
@@ -324,8 +315,7 @@ ScriptPromise CookieStore::Delete(ScriptState* script_state,
 ScriptPromise CookieStore::Delete(ScriptState* script_state,
                                   const CookieStoreDeleteOptions* options,
                                   ExceptionState& exception_state) {
-  CookieStoreSetExtraOptions* set_options =
-      CookieStoreSetExtraOptions::Create();
+  CookieInit* set_options = CookieInit::Create();
   set_options->setName(options->name());
   set_options->setValue(g_empty_string);
   set_options->setExpires(0);
@@ -466,7 +456,7 @@ void CookieStore::GetAllForUrlToGetResult(
 }
 
 ScriptPromise CookieStore::DoWrite(ScriptState* script_state,
-                                   const CookieStoreSetExtraOptions* options,
+                                   const CookieInit* options,
                                    ExceptionState& exception_state) {
   ExecutionContext* context = ExecutionContext::From(script_state);
   if (!context->GetSecurityOrigin()->CanAccessCookies()) {

third_party/blink/renderer/modules/cookie_store/cookie_store.h

@@ -22,10 +22,9 @@
 
 namespace blink {
 
+class CookieInit;
 class CookieStoreDeleteOptions;
 class CookieStoreGetOptions;
-class CookieStoreSetOptions;
-class CookieStoreSetExtraOptions;
 class ExceptionState;
 class ScriptPromiseResolver;
 class ScriptState;
@@ -53,14 +52,11 @@ class CookieStore final : public EventTargetWithInlineData,
                     const CookieStoreGetOptions*,
                     ExceptionState&);
 
-  ScriptPromise set(ScriptState*,
-                    const CookieStoreSetExtraOptions*,
-                    ExceptionState&);
   ScriptPromise set(ScriptState*,
                     const String& name,
                     const String& value,
-                    const CookieStoreSetOptions*,
                     ExceptionState&);
+  ScriptPromise set(ScriptState*, const CookieInit*, ExceptionState&);
   ScriptPromise Delete(ScriptState*, const String& name, ExceptionState&);
   ScriptPromise Delete(ScriptState*,
                        const CookieStoreDeleteOptions*,
@@ -120,9 +116,7 @@ class CookieStore final : public EventTargetWithInlineData,
           backend_result);
 
   // Common code in CookieStore::delete and CookieStore::set.
-  ScriptPromise DoWrite(ScriptState*,
-                        const CookieStoreSetExtraOptions*,
-                        ExceptionState&);
+  ScriptPromise DoWrite(ScriptState*, const CookieInit*, ExceptionState&);
 
   static void OnSetCanonicalCookieResult(ScriptPromiseResolver*,
                                          bool backend_result);

third_party/blink/renderer/modules/cookie_store/cookie_store.idl

@@ -21,9 +21,9 @@
 
   // https://wicg.github.io/cookie-store/explainer.html#the-modifications-api
   [CallWith=ScriptState, Measure, RaisesException] Promise<void> set(
-      USVString name, USVString value, optional CookieStoreSetOptions options = {});
+      USVString name, USVString value);
   [CallWith=ScriptState, Measure, RaisesException] Promise<void> set(
-      CookieStoreSetExtraOptions options);
+      CookieInit cookieInit);
   [CallWith=ScriptState, ImplementedAs=Delete, Measure, RaisesException]
   Promise<void> delete(USVString name);
   [CallWith=ScriptState, ImplementedAs=Delete, Measure, RaisesException]

third_party/blink/renderer/modules/cookie_store/cookie_store_set_extra_options.idl

-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://github.com/WICG/async-cookies-api/blob/gh-pages/explainer.md
-
-dictionary CookieStoreSetExtraOptions : CookieStoreSetOptions {
-  required USVString name;
-  required USVString value;
-};

third_party/blink/renderer/modules/cookie_store/idls.gni

@@ -11,11 +11,10 @@ modules_idl_files = [
 
 modules_dictionary_idl_files = [
   "cookie_change_event_init.idl",
+  "cookie_init.idl",
   "cookie_list_item.idl",
   "cookie_store_delete_options.idl",
   "cookie_store_get_options.idl",
-  "cookie_store_set_extra_options.idl",
-  "cookie_store_set_options.idl",
   "extendable_cookie_change_event_init.idl",
 ]
 

third_party/blink/web_tests/external/wpt/cookie-store/cookieListItem_attributes.tentative.https.any.js

@@ -49,26 +49,6 @@ promise_test(async testCase => {
   assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
 }, '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 });
-  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 expires set to a timestamp 10 ' +
-   'years in the future');
-
 promise_test(async testCase => {
   await cookieStore.delete('cookie-name');
 
@@ -86,25 +66,7 @@ promise_test(async testCase => {
   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) });
-  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);
-}, 'CookieListItem - cookieStore.set with expires set to a Date 10 ' +
+}, 'CookieListItem - cookieStore.set with expires set to a timestamp 10 ' +
    'years in the future');
 
 promise_test(async testCase => {
@@ -122,16 +84,14 @@ promise_test(async testCase => {
   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');
+}, 'CookieListItem - cookieStore.set with expires set to a Date 10 ' +
+   'years in the future');
 
 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 @@ promise_test(async testCase => {
       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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
     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}`);
 });

third_party/blink/web_tests/external/wpt/cookie-store/cookieStore_delete_arguments.tentative.https.any.js

@@ -22,35 +22,25 @@ promise_test(async testCase => {
   assert_equals(cookie, null);
 }, '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 });
   });
@@ -81,50 +71,13 @@ promise_test(async testCase => {
 }, 'cookieStore.delete with domain set to a non-domain-matching suffix of ' +
    'the current hostname');
 
-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 @@ promise_test(async testCase => {
       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 @@ promise_test(async testCase => {
   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 });
   });

third_party/blink/web_tests/external/wpt/cookie-store/cookieStore_set_arguments.tentative.https.any.js

@@ -28,18 +28,6 @@ promise_test(async testCase => {
   assert_equals(cookie.value, 'cookie-value');
 }, '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'));
@@ -56,55 +44,15 @@ promise_test(async testCase => {
   assert_equals(cookie.value, 'suspicious-value=resembles-name-and-value');
 }, "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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   });
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 @@ promise_test(async testCase => {
   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 => {

third_party/blink/web_tests/external/wpt/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 @@ promise_test(async testCase => {
   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');

third_party/blink/web_tests/http/tests/cookie-store/set-on-localhost.html

@@ -17,6 +17,6 @@ promise_test(async t => {
 promise_test(async t => {
   await promise_rejects_js(t, TypeError,
       cookieStore.set('cookie-name', 'cookie-value'));
-}, `cookieStore.set(name, value, options) throws an exception`);
+}, `cookieStore.set(name, value) throws an exception`);
 
 </script>