Remove dangerous CanonicalCookie::Create method.

net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <memory>
 #include <set>
 
@@ skipping 149 matching lines @@
     CanonicalCookieVector cookies;
     CreateAndLoad(crypt, restore_old_session_cookies, &cookies);
     EXPECT_EQ(0U, cookies.size());
   }
 
   // We have to create this method to wrap WaitableEvent::Wait, since we cannot
   // bind a non-void returning method as a Closure.
   void WaitOnDBEvent() { db_thread_event_.Wait(); }
 
   // Adds a persistent cookie to store_.
-  void AddCookie(const GURL& url,
-                 const std::string& name,
+  void AddCookie(const std::string& name,
                  const std::string& value,
                  const std::string& domain,
                  const std::string& path,
                  const base::Time& creation) {
     store_->AddCookie(*CanonicalCookie::Create(
-        url, name, value, domain, path, creation, creation, false, false,
-        CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
+        name, value, domain, path, creation, creation, base::Time(), false,
+        false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   }
 
-  void AddCookieWithExpiration(const GURL& url,
-                               const std::string& name,
+  void AddCookieWithExpiration(const std::string& name,
                                const std::string& value,
                                const std::string& domain,
                                const std::string& path,
                                const base::Time& creation,
                                const base::Time& expiration) {
     store_->AddCookie(*CanonicalCookie::Create(
-        url, name, value, domain, path, creation, expiration, false, false,
-        CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
+        name, value, domain, path, creation, expiration, base::Time(), false,
+        false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   }
 
   std::string ReadRawDBContents() {
     std::string contents;
     if (!base::ReadFileToString(temp_dir_.GetPath().Append(kCookieFilename),
                                 &contents))
       return std::string();
     return contents;
   }
 
   void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }
 
   void TearDown() override {
     DestroyStore();
   }
 
  protected:
   std::unique_ptr<base::SequencedWorkerPoolOwner> pool_owner_;
   base::WaitableEvent loaded_event_;
   base::WaitableEvent key_loaded_event_;
   base::WaitableEvent db_thread_event_;
   CanonicalCookieVector cookies_;
   base::ScopedTempDir temp_dir_;
   scoped_refptr<SQLitePersistentCookieStore> store_;
   std::unique_ptr<CookieCryptor> cookie_crypto_delegate_;
 };
 
 TEST_F(SQLitePersistentCookieStoreTest, TestInvalidMetaTableRecovery) {
   InitializeStore(false, false);
-  AddCookie(GURL("http://foo.bar"), "A", "B", std::string(), "/",
-            base::Time::Now());
+  AddCookie("A", "B", "foo.bar", "/", base::Time::Now());
   DestroyStore();
 
   // Load up the store and verify that it has good data in it.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("A", cookies[0]->Name().c_str());
   ASSERT_STREQ("B", cookies[0]->Value().c_str());
   DestroyStore();
   cookies.clear();
 
   // Now corrupt the meta table.
   {
     sql::Connection db;
     ASSERT_TRUE(db.Open(temp_dir_.GetPath().Append(kCookieFilename)));
     sql::MetaTable meta_table_;
     meta_table_.Init(&db, 1, 1);
     ASSERT_TRUE(db.Execute("DELETE FROM meta"));
     db.Close();
   }
 
   // Upon loading, the database should be reset to a good, blank state.
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 
   // Verify that, after, recovery, the database persists properly.
-  AddCookie(GURL("http://foo.bar"), "X", "Y", std::string(), "/",
-            base::Time::Now());
+  AddCookie("X", "Y", "foo.bar", "/", base::Time::Now());
   DestroyStore();
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("X", cookies[0]->Name().c_str());
   ASSERT_STREQ("Y", cookies[0]->Value().c_str());
   cookies.clear();
 }
 
 // Test if data is stored as expected in the SQLite database.
 TEST_F(SQLitePersistentCookieStoreTest, TestPersistance) {
   InitializeStore(false, false);
-  AddCookie(GURL("http://foo.bar"), "A", "B", std::string(), "/",
-            base::Time::Now());
+  AddCookie("A", "B", "foo.bar", "/", base::Time::Now());
   // Replace the store effectively destroying the current one and forcing it
   // to write its data to disk. Then we can see if after loading it again it
   // is still there.
   DestroyStore();
   // Reload and test for persistence
   CanonicalCookieVector cookies;
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("A", cookies[0]->Name().c_str());
   ASSERT_STREQ("B", cookies[0]->Value().c_str());
 
   // Now delete the cookie and check persistence again.
   store_->DeleteCookie(*cookies[0]);
   DestroyStore();
   cookies.clear();
 
   // Reload and check if the cookie has been removed.
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, TestSessionCookiesDeletedOnStartup) {
   // Initialize the cookie store with 3 persistent cookies, 5 transient
   // cookies.
   InitializeStore(false, false);
 
   // Add persistent cookies.
   base::Time t = base::Time::Now();
-  AddCookie(GURL("http://a1.com"), "A", "B", std::string(), "/", t);
+  AddCookie("A", "B", "a1.com", "/", t);
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookie(GURL("http://a2.com"), "A", "B", std::string(), "/", t);
+  AddCookie("A", "B", "a2.com", "/", t);
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookie(GURL("http://a3.com"), "A", "B", std::string(), "/", t);
+  AddCookie("A", "B", "a3.com", "/", t);
 
   // Add transient cookies.
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookieWithExpiration(GURL("http://b1.com"), "A", "B", std::string(), "/",
-                          t, base::Time());
+  AddCookieWithExpiration("A", "B", "b1.com", "/", t, base::Time());
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookieWithExpiration(GURL("http://b2.com"), "A", "B", std::string(), "/",
-                          t, base::Time());
+  AddCookieWithExpiration("A", "B", "b2.com", "/", t, base::Time());
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookieWithExpiration(GURL("http://b3.com"), "A", "B", std::string(), "/",
-                          t, base::Time());
+  AddCookieWithExpiration("A", "B", "b3.com", "/", t, base::Time());
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookieWithExpiration(GURL("http://b4.com"), "A", "B", std::string(), "/",
-                          t, base::Time());
+  AddCookieWithExpiration("A", "B", "b4.com", "/", t, base::Time());
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookieWithExpiration(GURL("http://b5.com"), "A", "B", std::string(), "/",
-                          t, base::Time());
+  AddCookieWithExpiration("A", "B", "b5.com", "/", t, base::Time());
   DestroyStore();
 
   // Load the store a second time. Before the store finishes loading, add a
   // transient cookie and flush it to disk.
   store_ = new SQLitePersistentCookieStore(
       temp_dir_.GetPath().Append(kCookieFilename), client_task_runner(),
       background_task_runner(), false, nullptr);
 
   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
   // until both Load and Flush have been posted to its task queue.
   background_task_runner()->PostTask(
       FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
                             base::Unretained(this)));
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookieWithExpiration(GURL("http://c.com"), "A", "B", std::string(), "/", t,
-                          base::Time());
+  AddCookieWithExpiration("A", "B", "c.com", "/", t, base::Time());
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
   store_->Flush(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
 
   // Now the DB-thread queue contains:
   // (active:)
   // 1. Wait (on db_event)
   // (pending:)
   // 2. "Init And Chain-Load First Domain"
@@ skipping 16 matching lines @@
   loaded_event_.Wait();
   ASSERT_EQ(4u, cookies_.size());
   cookies_.clear();
 }
 
 // Test that priority load of cookies for a specfic domain key could be
 // completed before the entire store is loaded
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadCookiesForKey) {
   InitializeStore(false, false);
   base::Time t = base::Time::Now();
-  AddCookie(GURL("http://foo.bar"), "A", "B", std::string(), "/", t);
+  AddCookie("A", "B", "foo.bar", "/", t);
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookie(GURL("http://www.aaa.com"), "A", "B", std::string(), "/", t);
+  AddCookie("A", "B", "www.aaa.com", "/", t);
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookie(GURL("http://travel.aaa.com"), "A", "B", std::string(), "/", t);
+  AddCookie("A", "B", "travel.aaa.com", "/", t);
   t += base::TimeDelta::FromInternalValue(10);
-  AddCookie(GURL("http://www.bbb.com"), "A", "B", std::string(), "/", t);
+  AddCookie("A", "B", "www.bbb.com", "/", t);
   DestroyStore();
 
   store_ = new SQLitePersistentCookieStore(
       temp_dir_.GetPath().Append(kCookieFilename), client_task_runner(),
       background_task_runner(), false, nullptr);
 
   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
   // until both Load and LoadCookiesForKey have been posted to its task queue.
   background_task_runner()->PostTask(
       FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
@@ skipping 49 matching lines @@
   base::File::Info info;
   ASSERT_TRUE(base::GetFileInfo(path, &info));
   int64_t base_size = info.size;
 
   // Write some large cookies, so the DB will have to expand by several KB.
   for (char c = 'a'; c < 'z'; ++c) {
     // Each cookie needs a unique timestamp for creation_utc (see DB schema).
     base::Time t = base::Time::Now() + base::TimeDelta::FromMicroseconds(c);
     std::string name(1, c);
     std::string value(1000, c);
-    AddCookie(GURL("http://foo.bar"), name, value, std::string(), "/", t);
+    AddCookie(name, value, "foo.bar", "/", t);
   }
 
   Flush();
 
   // We forced a write, so now the file will be bigger.
   ASSERT_TRUE(base::GetFileInfo(path, &info));
   ASSERT_GT(info.size, base_size);
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadOldSessionCookies) {
   InitializeStore(false, true);
 
   // Add a session cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL("http://sessioncookie.com"), "C", "D", std::string(), "/",
-      base::Time::Now(), base::Time(), false, false,
-      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
+      "C", "D", "sessioncookie.com", "/", base::Time::Now(), base::Time(),
+      base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
+      COOKIE_PRIORITY_DEFAULT));
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store that loads session cookies and test that the session cookie
   // was loaded.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, true, &cookies);
 
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("sessioncookie.com", cookies[0]->Domain().c_str());
   ASSERT_STREQ("C", cookies[0]->Name().c_str());
   ASSERT_STREQ("D", cookies[0]->Value().c_str());
   ASSERT_EQ(COOKIE_PRIORITY_DEFAULT, cookies[0]->Priority());
 
   cookies.clear();
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestDontLoadOldSessionCookies) {
   InitializeStore(false, true);
 
   // Add a session cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL("http://sessioncookie.com"), "C", "D", std::string(), "/",
-      base::Time::Now(), base::Time(), false, false,
-      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
+      "C", "D", "sessioncookie.com", "/", base::Time::Now(), base::Time(),
+      base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
+      COOKIE_PRIORITY_DEFAULT));
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store that doesn't load old session cookies and test that the
   // session cookie was not loaded.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 
   // The store should also delete the session cookie. Wait until that has been
   // done.
   DestroyStore();
 
   // Create a store that loads old session cookies and test that the session
   // cookie is gone.
   CreateAndLoad(false, true, &cookies);
   ASSERT_EQ(0U, cookies.size());
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, PersistIsPersistent) {
   InitializeStore(false, true);
   static const char kSessionName[] = "session";
   static const char kPersistentName[] = "persistent";
 
   // Add a session cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL("http://sessioncookie.com"), kSessionName, "val", std::string(), "/",
-      base::Time::Now(), base::Time(), false, false,
-      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
+      kSessionName, "val", "sessioncookie.com", "/", base::Time::Now(),
+      base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
+      COOKIE_PRIORITY_DEFAULT));
   // Add a persistent cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL("http://sessioncookie.com"), kPersistentName, "val", std::string(),
-      "/", base::Time::Now() - base::TimeDelta::FromDays(1),
-      base::Time::Now() + base::TimeDelta::FromDays(1), false, false,
-      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
+      kPersistentName, "val", "sessioncookie.com", "/",
+      base::Time::Now() - base::TimeDelta::FromDays(1),
+      base::Time::Now() + base::TimeDelta::FromDays(1), base::Time(), false,
+      false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store that loads session cookie and test that the IsPersistent
   // attribute is restored.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, true, &cookies);
   ASSERT_EQ(2U, cookies.size());
 
   std::map<std::string, CanonicalCookie*> cookie_map;
   for (const auto& cookie : cookies)
     cookie_map[cookie->Name()] = cookie.get();
 
   auto it = cookie_map.find(kSessionName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_FALSE(cookie_map[kSessionName]->IsPersistent());
 
   it = cookie_map.find(kPersistentName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_TRUE(cookie_map[kPersistentName]->IsPersistent());
 
   cookies.clear();
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, PriorityIsPersistent) {
-  static const char kURL[] = "http://sessioncookie.com";
+  static const char kDomain[] = "sessioncookie.com";
   static const char kLowName[] = "low";
   static const char kMediumName[] = "medium";
   static const char kHighName[] = "high";
   static const char kCookieValue[] = "value";
   static const char kCookiePath[] = "/";
 
   InitializeStore(false, true);
 
   // Add a low-priority persistent cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL(kURL), kLowName, kCookieValue, std::string(), kCookiePath,
+      kLowName, kCookieValue, kDomain, kCookiePath,
       base::Time::Now() - base::TimeDelta::FromMinutes(1),
-      base::Time::Now() + base::TimeDelta::FromDays(1), false, false,
-      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_LOW));
+      base::Time::Now() + base::TimeDelta::FromDays(1), base::Time(), false,
+      false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_LOW));
 
   // Add a medium-priority persistent cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL(kURL), kMediumName, kCookieValue, std::string(), kCookiePath,
+      kMediumName, kCookieValue, kDomain, kCookiePath,
       base::Time::Now() - base::TimeDelta::FromMinutes(2),
-      base::Time::Now() + base::TimeDelta::FromDays(1), false, false,
-      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_MEDIUM));
+      base::Time::Now() + base::TimeDelta::FromDays(1), base::Time(), false,
+      false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_MEDIUM));
 
   // Add a high-priority peristent cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL(kURL), kHighName, kCookieValue, std::string(), kCookiePath,
+      kHighName, kCookieValue, kDomain, kCookiePath,
       base::Time::Now() - base::TimeDelta::FromMinutes(3),
-      base::Time::Now() + base::TimeDelta::FromDays(1), false, false,
-      CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_HIGH));
+      base::Time::Now() + base::TimeDelta::FromDays(1), base::Time(), false,
+      false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_HIGH));
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store that loads session cookie and test that the priority
   // attribute values are restored.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, true, &cookies);
   ASSERT_EQ(3U, cookies.size());
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(COOKIE_PRIORITY_MEDIUM, cookie_map[kMediumName]->Priority());
 
   it = cookie_map.find(kHighName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_EQ(COOKIE_PRIORITY_HIGH, cookie_map[kHighName]->Priority());
 
   cookies.clear();
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, SameSiteIsPersistent) {
-  const char kURL[] = "http://sessioncookie.com";
+  const char kDomain[] = "sessioncookie.com";
   const char kNoneName[] = "none";
   const char kLaxName[] = "lax";
   const char kStrictName[] = "strict";
   const char kCookieValue[] = "value";
   const char kCookiePath[] = "/";
 
   InitializeStore(false, true);
 
   // Add a non-samesite cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL(kURL), kNoneName, kCookieValue, std::string(), kCookiePath,
+      kNoneName, kCookieValue, kDomain, kCookiePath,
       base::Time::Now() - base::TimeDelta::FromMinutes(1),
-      base::Time::Now() + base::TimeDelta::FromDays(1), false, false,
-      CookieSameSite::NO_RESTRICTION, COOKIE_PRIORITY_DEFAULT));
+      base::Time::Now() + base::TimeDelta::FromDays(1), base::Time(), false,
+      false, CookieSameSite::NO_RESTRICTION, COOKIE_PRIORITY_DEFAULT));
 
   // Add a lax-samesite persistent cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL(kURL), kLaxName, kCookieValue, std::string(), kCookiePath,
+      kLaxName, kCookieValue, kDomain, kCookiePath,
       base::Time::Now() - base::TimeDelta::FromMinutes(2),
-      base::Time::Now() + base::TimeDelta::FromDays(1), false, false,
-      CookieSameSite::LAX_MODE, COOKIE_PRIORITY_DEFAULT));
+      base::Time::Now() + base::TimeDelta::FromDays(1), base::Time(), false,
+      false, CookieSameSite::LAX_MODE, COOKIE_PRIORITY_DEFAULT));
 
   // Add a strict-samesite persistent cookie.
   store_->AddCookie(*CanonicalCookie::Create(
-      GURL(kURL), kStrictName, kCookieValue, std::string(), kCookiePath,
+      kStrictName, kCookieValue, kDomain, kCookiePath,
       base::Time::Now() - base::TimeDelta::FromMinutes(3),
-      base::Time::Now() + base::TimeDelta::FromDays(1), false, false,
-      CookieSameSite::STRICT_MODE, COOKIE_PRIORITY_DEFAULT));
+      base::Time::Now() + base::TimeDelta::FromDays(1), base::Time(), false,
+      false, CookieSameSite::STRICT_MODE, COOKIE_PRIORITY_DEFAULT));
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store that loads session cookie and test that the priority
   // attribute values are restored.
   CanonicalCookieVector cookies;
   CreateAndLoad(false, true, &cookies);
   ASSERT_EQ(3U, cookies.size());
 
@@ skipping 13 matching lines @@
   EXPECT_EQ(CookieSameSite::STRICT_MODE, cookie_map[kStrictName]->SameSite());
 
   cookies.clear();
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, UpdateToEncryption) {
   CanonicalCookieVector cookies;
 
   // Create unencrypted cookie store and write something to it.
   InitializeStore(false, false);
-  AddCookie(GURL("http://foo.bar"), "name", "value123XYZ", std::string(), "/",
-            base::Time::Now());
+  AddCookie("name", "value123XYZ", "foo.bar", "/", base::Time::Now());
   DestroyStore();
 
   // Verify that "value" is visible in the file.  This is necessary in order to
   // have confidence in a later test that "encrypted_value" is not visible.
   std::string contents = ReadRawDBContents();
   EXPECT_NE(0U, contents.length());
   EXPECT_NE(contents.find("value123XYZ"), std::string::npos);
 
   // Create encrypted cookie store and ensure old cookie still reads.
   cookies.clear();
   EXPECT_EQ(0U, cookies.size());
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ("name", cookies[0]->Name());
   EXPECT_EQ("value123XYZ", cookies[0]->Value());
 
   // Make sure we can update existing cookie and add new cookie as encrypted.
   store_->DeleteCookie(*(cookies[0]));
-  AddCookie(GURL("http://foo.bar"), "name", "encrypted_value123XYZ",
-            std::string(), "/", base::Time::Now());
-  AddCookie(GURL("http://foo.bar"), "other", "something456ABC", std::string(),
-            "/", base::Time::Now() + base::TimeDelta::FromInternalValue(10));
+  AddCookie("name", "encrypted_value123XYZ", "foo.bar", "/", base::Time::Now());
+  AddCookie("other", "something456ABC", "foo.bar", "/",
+            base::Time::Now() + base::TimeDelta::FromInternalValue(10));
   DestroyStore();
   cookies.clear();
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(2U, cookies.size());
   CanonicalCookie* cookie_name = nullptr;
   CanonicalCookie* cookie_other = nullptr;
   if (cookies[0]->Name() == "name") {
     cookie_name = cookies[0].get();
     cookie_other = cookies[1].get();
   } else {
@@ skipping 28 matching lines @@
   EXPECT_NE(0U, contents.length());
   EXPECT_EQ(contents.find("encrypted_value123XYZ"), std::string::npos);
   EXPECT_EQ(contents.find("something456ABC"), std::string::npos);
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, UpdateFromEncryption) {
   CanonicalCookieVector cookies;
 
   // Create unencrypted cookie store and write something to it.
   InitializeStore(true, false);
-  AddCookie(GURL("http://foo.bar"), "name", "value123XYZ", std::string(), "/",
-            base::Time::Now());
+  AddCookie("name", "value123XYZ", "foo.bar", "/", base::Time::Now());
   DestroyStore();
 
   // Verify that "value" is not visible in the file.
   std::string contents = ReadRawDBContents();
   EXPECT_NE(0U, contents.length());
   EXPECT_EQ(contents.find("value123XYZ"), std::string::npos);
 
   // Create encrypted cookie store and ensure old cookie still reads.
   cookies.clear();
   EXPECT_EQ(0U, cookies.size());
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(1U, cookies.size());
   EXPECT_EQ("name", cookies[0]->Name());
   EXPECT_EQ("value123XYZ", cookies[0]->Value());
 
   // Make sure we can update existing cookie and it writes unencrypted.
   cookie_crypto_delegate_->should_encrypt_ = false;
   store_->DeleteCookie(*(cookies[0]));
-  AddCookie(GURL("http://foo.bar"), "name", "plaintext_value123XYZ",
-            std::string(), "/", base::Time::Now());
-  AddCookie(GURL("http://foo.bar"), "other", "something456ABC", std::string(),
-            "/", base::Time::Now() + base::TimeDelta::FromInternalValue(10));
+  AddCookie("name", "plaintext_value123XYZ", "foo.bar", "/", base::Time::Now());
+  AddCookie("other", "something456ABC", "foo.bar", "/",
+            base::Time::Now() + base::TimeDelta::FromInternalValue(10));
   DestroyStore();
   cookies.clear();
   CreateAndLoad(true, false, &cookies);
   EXPECT_EQ(2U, cookies.size());
   CanonicalCookie* cookie_name = nullptr;
   CanonicalCookie* cookie_other = nullptr;
   if (cookies[0]->Name() == "name") {
     cookie_name = cookies[0].get();
     cookie_other = cookies[1].get();
   } else {
@@ skipping 15 matching lines @@
 void WasCalledWithNoCookies(
     bool* was_called_with_no_cookies,
     std::vector<std::unique_ptr<CanonicalCookie>> cookies) {
   *was_called_with_no_cookies = cookies.empty();
 }
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, EmptyLoadAfterClose) {
   // Create unencrypted cookie store and write something to it.
   InitializeStore(false, false);
-  AddCookie(GURL("http://foo.bar"), "name", "value123XYZ", std::string(), "/",
-            base::Time::Now());
+  AddCookie("name", "value123XYZ", "foo.bar", "/", base::Time::Now());
   DestroyStore();
 
   // Create the cookie store, but immediately close it.
   Create(false, false);
   store_->Close(base::Closure());
 
   // Expect any attempt to call Load() to synchronously respond with an empty
   // vector of cookies after we've Close()d the database.
   bool was_called_with_no_cookies = false;
   store_->Load(base::Bind(WasCalledWithNoCookies, &was_called_with_no_cookies));
   EXPECT_TRUE(was_called_with_no_cookies);
 
   // Same with trying to load a specific cookie.
   was_called_with_no_cookies = false;
   store_->LoadCookiesForKey("foo.bar", base::Bind(WasCalledWithNoCookies,
                                                   &was_called_with_no_cookies));
   EXPECT_TRUE(was_called_with_no_cookies);
 }
 
 }  // namespace net