Decouple CookieMonsterTest from CookieStoreTest.

net/cookies/cookie_monster_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/cookies/cookie_store_unittest.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 52 matching lines @@
 
  private:
   virtual ~NewMockPersistentCookieStore() {}
 };
 
 const char kTopLevelDomainPlus1[] = "http://www.harvard.edu";
 const char kTopLevelDomainPlus2[] = "http://www.math.harvard.edu";
 const char kTopLevelDomainPlus2Secure[] = "https://www.math.harvard.edu";
 const char kTopLevelDomainPlus3[] = "http://www.bourbaki.math.harvard.edu";
 const char kOtherDomain[] = "http://www.mit.edu";
-const char kUrlGoogleSpecific[] = "http://www.gmail.google.izzle";
 
 class GetCookieListCallback : public CookieCallback {
  public:
   GetCookieListCallback() {}
   explicit GetCookieListCallback(Thread* run_in_thread)
       : CookieCallback(run_in_thread) {}
 
   void Run(const CookieList& cookies) {
     cookies_ = cookies;
     CallbackEpilogue();
@@ skipping 268 matching lines @@
   void TestHostGarbageCollectHelper() {
     int domain_max_cookies = CookieMonster::kDomainMaxCookies;
     int domain_purge_cookies = CookieMonster::kDomainPurgeCookies;
     const int more_than_enough_cookies =
         (domain_max_cookies + domain_purge_cookies) * 2;
     // Add a bunch of cookies on a single host, should purge them.
     {
       scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie = base::StringPrintf("a%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm.get(), url_google_, cookie));
-        std::string cookies = this->GetCookies(cm.get(), url_google_);
+        EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), cookie));
+        std::string cookies =
+            this->GetCookies(cm.get(), http_www_google_.url());
         // Make sure we find it in the cookies.
         EXPECT_NE(cookies.find(cookie), std::string::npos);
         // Count the number of cookies.
         EXPECT_LE(CountInString(cookies, '='), domain_max_cookies);
       }
     }
 
     // Add a bunch of cookies on multiple hosts within a single eTLD.
     // Should keep at least kDomainMaxCookies - kDomainPurgeCookies
     // between them.  We shouldn't go above kDomainMaxCookies for both together.
-    GURL url_google_specific(kUrlGoogleSpecific);
+    GURL url_google_specific(http_www_google_.Format("http://www.gmail.%D"));
     {
       scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie_general = base::StringPrintf("a%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm.get(), url_google_, cookie_general));
+        EXPECT_TRUE(
+            SetCookie(cm.get(), http_www_google_.url(), cookie_general));
         std::string cookie_specific = base::StringPrintf("c%03d=b", i);
         EXPECT_TRUE(SetCookie(cm.get(), url_google_specific, cookie_specific));
-        std::string cookies_general = this->GetCookies(cm.get(), url_google_);
+        std::string cookies_general =
+            this->GetCookies(cm.get(), http_www_google_.url());
         EXPECT_NE(cookies_general.find(cookie_general), std::string::npos);
         std::string cookies_specific =
             this->GetCookies(cm.get(), url_google_specific);
         EXPECT_NE(cookies_specific.find(cookie_specific), std::string::npos);
         EXPECT_LE((CountInString(cookies_general, '=') +
                    CountInString(cookies_specific, '=')),
                   domain_max_cookies);
       }
       // After all this, there should be at least
       // kDomainMaxCookies - kDomainPurgeCookies for both URLs.
-      std::string cookies_general = this->GetCookies(cm.get(), url_google_);
+      std::string cookies_general =
+          this->GetCookies(cm.get(), http_www_google_.url());
       std::string cookies_specific =
           this->GetCookies(cm.get(), url_google_specific);
       int total_cookies = (CountInString(cookies_general, '=') +
                            CountInString(cookies_specific, '='));
       EXPECT_GE(total_cookies, domain_max_cookies - domain_purge_cookies);
       EXPECT_LE(total_cookies, domain_max_cookies);
     }
   }
 
   CookiePriority CharToPriority(char ch) {
     switch (ch) {
       case 'L':
         return COOKIE_PRIORITY_LOW;
       case 'M':
         return COOKIE_PRIORITY_MEDIUM;
       case 'H':
         return COOKIE_PRIORITY_HIGH;
     }
     NOTREACHED();
     return COOKIE_PRIORITY_DEFAULT;
   }
 
-  // Instantiates a CookieMonster, adds multiple cookies (to url_google_) with
-  // priorities specified by |coded_priority_str|, and tests priority-aware
+  // Instantiates a CookieMonster, adds multiple cookies (to http_www_google_)
+  // with priorities specified by |coded_priority_str|, and tests priority-aware
   // domain cookie eviction.
   // |coded_priority_str| specifies a run-length-encoded string of priorities.
   // Example: "2M 3L M 4H" means "MMLLLMHHHH", and speicifies sequential (i.e.,
   // from least- to most-recently accessed) insertion of 2 medium-priority
   // cookies, 3 low-priority cookies, 1 medium-priority cookie, and 4
   // high-priority cookies.
   // Within each priority, only the least-accessed cookies should be evicted.
   // Thus, to describe expected suriving cookies, it suffices to specify the
   // expected population of surviving cookies per priority, i.e.,
   // |expected_low_count|, |expected_medium_count|, and |expected_high_count|.
@@ skipping 18 matching lines @@
       // The rest of the string (possibly empty) specifies repetition.
       int rep = 1;
       if (!token.empty()) {
         bool result = base::StringToInt(
             base::StringPiece(token.begin(), token.end() - 1), &rep);
         DCHECK(result);
       }
       for (; rep > 0; --rep, ++next_cookie_id) {
         std::string cookie = base::StringPrintf(
             "a%d=b;priority=%s", next_cookie_id, priority_str.c_str());
-        EXPECT_TRUE(SetCookie(cm, url_google_, cookie));
+        EXPECT_TRUE(SetCookie(cm, http_www_google_.url(), cookie));
         priority_list.push_back(priority);
         id_list[priority].push_back(next_cookie_id);
       }
     }
 
     int num_cookies = static_cast<int>(priority_list.size());
     std::vector<int> surviving_id_list[3];  // Indexed by CookiePriority.
 
     // Parse the list of cookies
-    std::string cookie_str = this->GetCookies(cm, url_google_);
+    std::string cookie_str = this->GetCookies(cm, http_www_google_.url());
     for (const std::string& token : base::SplitString(
              cookie_str, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
       // Assuming *it is "a#=b", so extract and parse "#" portion.
       int id = -1;
       bool result = base::StringToInt(
           base::StringPiece(token.begin() + 1, token.end() - 2), &id);
       DCHECK(result);
       DCHECK_GE(id, 0);
       DCHECK_LT(id, num_cookies);
       surviving_id_list[priority_list[id]].push_back(id);
@@ skipping 332 matching lines @@
   std::queue<CookieMonster::PersistentCookieStore::LoadedCallback>
       loaded_for_key_callbacks_;
 
   // Stores the CookieMonster under test.
   scoped_refptr<CookieMonster> cookie_monster_;
   // Stores the mock PersistentCookieStore.
   scoped_refptr<NewMockPersistentCookieStore> persistent_store_;
 };
 
 TEST_F(DeferredCookieTaskTest, DeferredGetCookies) {
-  DeclareLoadedCookie("www.google.izzle",
+  DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookiesCallback get_cookies_callback;
 
   BeginWithForDomainKey(
-      "google.izzle",
-      GetCookiesAction(&cookie_monster(), url_google_, &get_cookies_callback));
+      http_www_google_.domain(),
+      GetCookiesAction(&cookie_monster(), http_www_google_.url(),
+                       &get_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
-      .WillOnce(GetCookiesAction(&cookie_monster(), url_google_,
+      .WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
                                  &get_cookies_callback));
   EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
   MockSetCookiesCallback set_cookies_callback;
 
-  BeginWithForDomainKey("google.izzle",
-                        SetCookieAction(&cookie_monster(), url_google_, "A=B",
-                                        &set_cookies_callback));
+  BeginWithForDomainKey(
+      http_www_google_.domain(),
+      SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
+                      &set_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(set_cookies_callback, Invoke(true))
-      .WillOnce(SetCookieAction(&cookie_monster(), url_google_, "X=Y",
-                                &set_cookies_callback));
+      .WillOnce(SetCookieAction(&cookie_monster(), http_www_google_.url(),
+                                "X=Y", &set_cookies_callback));
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetAllCookies) {
   MockSetCookiesCallback set_cookies_callback;
   CookieList list;
-  list.push_back(CanonicalCookie(url_google_, "A", "B", "google.izzle", "/",
+  list.push_back(CanonicalCookie(http_www_google_.url(), "A", "B",
+                                 http_www_google_.domain(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, true, false, COOKIE_PRIORITY_DEFAULT));
-  list.push_back(CanonicalCookie(url_google_, "C", "D", "google.izzle", "/",
+  list.push_back(CanonicalCookie(http_www_google_.url(), "C", "D",
+                                 http_www_google_.domain(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, true, false, COOKIE_PRIORITY_DEFAULT));
 
   BeginWith(
       SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(
           SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) {
   MockClosure delete_cookie_callback;
 
-  BeginWithForDomainKey("google.izzle",
-                        DeleteCookieAction(&cookie_monster(), url_google_, "A",
-                                           &delete_cookie_callback));
+  BeginWithForDomainKey(
+      http_www_google_.domain(),
+      DeleteCookieAction(&cookie_monster(), http_www_google_.url(), "A",
+                         &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Invoke())
-      .WillOnce(DeleteCookieAction(&cookie_monster(), url_google_, "X",
-                                   &delete_cookie_callback));
+      .WillOnce(DeleteCookieAction(&cookie_monster(), http_www_google_.url(),
+                                   "X", &delete_cookie_callback));
   EXPECT_CALL(delete_cookie_callback, Invoke())
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) {
   MockSetCookiesCallback set_cookies_callback;
 
-  CookiesInputInfo cookie_info = {url_google_foo_,
+  CookiesInputInfo cookie_info = {www_google_foo_.url(),
                                   "A",
                                   "B",
                                   std::string(),
                                   "/foo",
                                   base::Time(),
                                   false,
                                   false,
                                   false,
                                   COOKIE_PRIORITY_DEFAULT};
   BeginWithForDomainKey(
-      "google.izzle", SetCookieWithDetailsAction(&cookie_monster(), cookie_info,
-                                                 &set_cookies_callback));
+      http_www_google_.domain(),
+      SetCookieWithDetailsAction(&cookie_monster(), cookie_info,
+                                 &set_cookies_callback));
 
   WaitForLoadCall();
 
-  CookiesInputInfo cookie_info_exp = {url_google_foo_,
+  CookiesInputInfo cookie_info_exp = {www_google_foo_.url(),
                                       "A",
                                       "B",
                                       std::string(),
                                       "/foo",
                                       base::Time(),
                                       false,
                                       false,
                                       false,
                                       COOKIE_PRIORITY_DEFAULT};
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(SetCookieWithDetailsAction(&cookie_monster(), cookie_info_exp,
                                            &set_cookies_callback));
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) {
-  DeclareLoadedCookie("www.google.izzle",
+  DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
   BeginWith(GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(
           GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback));
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlCookies) {
-  DeclareLoadedCookie("www.google.izzle",
+  DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
   BeginWithForDomainKey(
-      "google.izzle", GetAllCookiesForUrlAction(&cookie_monster(), url_google_,
-                                                &get_cookie_list_callback));
+      http_www_google_.domain(),
+      GetAllCookiesForUrlAction(&cookie_monster(), http_www_google_.url(),
+                                &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
-      .WillOnce(GetAllCookiesForUrlAction(&cookie_monster(), url_google_,
+      .WillOnce(GetAllCookiesForUrlAction(&cookie_monster(),
+                                          http_www_google_.url(),
                                           &get_cookie_list_callback));
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlWithOptionsCookies) {
-  DeclareLoadedCookie("www.google.izzle",
+  DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
-  BeginWithForDomainKey("google.izzle", GetAllCookiesForUrlWithOptionsAction(
-                                            &cookie_monster(), url_google_,
-                                            &get_cookie_list_callback));
+  BeginWithForDomainKey(http_www_google_.domain(),
+                        GetAllCookiesForUrlWithOptionsAction(
+                            &cookie_monster(), http_www_google_.url(),
+                            &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(GetAllCookiesForUrlWithOptionsAction(
-          &cookie_monster(), url_google_, &get_cookie_list_callback));
+          &cookie_monster(), http_www_google_.url(),
+          &get_cookie_list_callback));
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCookies) {
   MockDeleteCallback delete_callback;
 
   BeginWith(DeleteAllAction(&cookie_monster(), &delete_callback));
@@ skipping 23 matching lines @@
   EXPECT_CALL(delete_callback, Invoke(false))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllForHostCookies) {
   MockDeleteCallback delete_callback;
 
   BeginWithForDomainKey(
-      "google.izzle",
-      DeleteAllForHostAction(&cookie_monster(), url_google_, &delete_callback));
+      http_www_google_.domain(),
+      DeleteAllForHostAction(&cookie_monster(), http_www_google_.url(),
+                             &delete_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_callback, Invoke(false))
-      .WillOnce(DeleteAllForHostAction(&cookie_monster(), url_google_,
-                                       &delete_callback));
+      .WillOnce(DeleteAllForHostAction(
+          &cookie_monster(), http_www_google_.url(), &delete_callback));
   EXPECT_CALL(delete_callback, Invoke(false))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
   std::vector<CanonicalCookie*> cookies;
-  CanonicalCookie cookie =
-      BuildCanonicalCookie("www.google.com", "X=1; path=/", base::Time::Now());
+  CanonicalCookie cookie = BuildCanonicalCookie(
+      http_www_google_.host(), "X=1; path=/", base::Time::Now());
 
   MockDeleteCookieCallback delete_cookie_callback;
 
   BeginWith(DeleteCanonicalCookieAction(&cookie_monster(), cookie,
                                         &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Invoke(false))
       .WillOnce(DeleteCanonicalCookieAction(&cookie_monster(), cookie,
@@ skipping 17 matching lines @@
   EXPECT_CALL(delete_callback, Invoke(false))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 // Verify that a series of queued tasks are executed in order upon loading of
 // the backing store and that new tasks received while the queued tasks are
 // being dispatched go to the end of the queue.
 TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
-  DeclareLoadedCookie("www.google.izzle",
+  DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookiesCallback get_cookies_callback;
   MockSetCookiesCallback set_cookies_callback;
   MockGetCookiesCallback get_cookies_callback_deferred;
 
   EXPECT_CALL(*this, Begin())
-      .WillOnce(testing::DoAll(GetCookiesAction(&cookie_monster(), url_google_,
-                                                &get_cookies_callback),
-                               SetCookieAction(&cookie_monster(), url_google_,
-                                               "A=B", &set_cookies_callback)));
+      .WillOnce(testing::DoAll(
+          GetCookiesAction(&cookie_monster(), http_www_google_.url(),
+                           &get_cookies_callback),
+          SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
+                          &set_cookies_callback)));
   ExpectLoadCall();
-  ExpectLoadForKeyCall("google.izzle", false);
+  ExpectLoadForKeyCall(http_www_google_.domain(), false);
   Begin();
 
   WaitForLoadCall();
   EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
-      .WillOnce(GetCookiesAction(&cookie_monster(), url_google_,
+      .WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
                                  &get_cookies_callback_deferred));
   EXPECT_CALL(set_cookies_callback, Invoke(true));
   EXPECT_CALL(get_cookies_callback_deferred, Invoke("A=B; X=1"))
       .WillOnce(QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
-  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), kValidCookieLine));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
 
-  EXPECT_TRUE(
-      SetCookieWithOptions(cm.get(), url_google_, "C=D; httponly", options));
-  EXPECT_EQ("A=B; C=D", GetCookiesWithOptions(cm.get(), url_google_, options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+                                   "C=D; httponly", options));
+  EXPECT_EQ("A=B; C=D",
+            GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
 
   EXPECT_EQ(2, DeleteAll(cm.get()));
-  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), url_google_, options));
+  EXPECT_EQ("",
+            GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
   EXPECT_EQ(0u, store->commands().size());
 
   // Create a persistent cookie.
   EXPECT_TRUE(SetCookie(
-      cm.get(), url_google_,
+      cm.get(), http_www_google_.url(),
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
 
   EXPECT_EQ(1, DeleteAll(cm.get()));  // sync_to_store = true.
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
-  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), url_google_, options));
+  EXPECT_EQ("",
+            GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   Time now = Time::Now();
 
   // Nothing has been added so nothing should be deleted.
   EXPECT_EQ(0, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99),
                                        Time()));
 
   // Create 3 cookies with creation date of today, yesterday and the day before.
-  EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-0=Now", now));
-  EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-1=Yesterday",
-                                            now - TimeDelta::FromDays(1)));
-  EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-2=DayBefore",
-                                            now - TimeDelta::FromDays(2)));
-  EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-3=ThreeDays",
-                                            now - TimeDelta::FromDays(3)));
-  EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "T-7=LastWeek",
-                                            now - TimeDelta::FromDays(7)));
+  EXPECT_TRUE(
+      cm->SetCookieWithCreationTime(http_www_google_.url(), "T-0=Now", now));
+  EXPECT_TRUE(cm->SetCookieWithCreationTime(
+      http_www_google_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
+  EXPECT_TRUE(cm->SetCookieWithCreationTime(
+      http_www_google_.url(), "T-2=DayBefore", now - TimeDelta::FromDays(2)));
+  EXPECT_TRUE(cm->SetCookieWithCreationTime(
+      http_www_google_.url(), "T-3=ThreeDays", now - TimeDelta::FromDays(3)));
+  EXPECT_TRUE(cm->SetCookieWithCreationTime(
+      http_www_google_.url(), "T-7=LastWeek", now - TimeDelta::FromDays(7)));
 
   // Try to delete threedays and the daybefore.
   EXPECT_EQ(2, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(3),
                                        now - TimeDelta::FromDays(1)));
 
   // Try to delete yesterday, also make sure that delete_end is not
   // inclusive.
   EXPECT_EQ(
       1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(2), now));
 
   // Make sure the delete_begin is inclusive.
   EXPECT_EQ(
       1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(7), now));
 
   // Delete the last (now) item.
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), Time(), Time()));
 
   // Really make sure everything is gone.
   EXPECT_EQ(0, DeleteAll(cm.get()));
 }
 
 static const int kAccessDelayMs = kLastAccessThresholdMilliseconds + 20;
 
 TEST_F(CookieMonsterTest, TestLastAccess) {
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
   const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
 
   // Reading the cookie again immediately shouldn't update the access date,
   // since we're inside the threshold.
-  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
   EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 
   // Reading after a short wait should update the access date.
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kAccessDelayMs));
-  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
   EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 }
 
 TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
   TestHostGarbageCollectHelper();
 }
 
 TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollection) {
   TestPriorityAwareGarbageCollectHelper();
 }
 
 TEST_F(CookieMonsterTest, TestDeleteSingleCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
-  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "C=D"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "E=F"));
+  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), http_www_google_.url()));
 
-  EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(
+      FindAndDeleteCookie(cm.get(), http_www_google_.url().host(), "C"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
 
   EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
 }
 
 TEST_F(CookieMonsterTest, SetCookieableSchemes) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   scoped_refptr<CookieMonster> cm_foo(new CookieMonster(NULL, NULL));
 
   // Only cm_foo should allow foo:// cookies.
   const char* const kSchemes[] = {"foo"};
   cm_foo->SetCookieableSchemes(kSchemes, 1);
 
   GURL foo_url("foo://host/path");
   GURL http_url("http://host/path");
 
   EXPECT_TRUE(SetCookie(cm.get(), http_url, "x=1"));
   EXPECT_FALSE(SetCookie(cm.get(), foo_url, "x=1"));
   EXPECT_TRUE(SetCookie(cm_foo.get(), foo_url, "x=1"));
   EXPECT_FALSE(SetCookie(cm_foo.get(), http_url, "x=1"));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
   // Create an httponly cookie.
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(
-      SetCookieWithOptions(cm.get(), url_google_, "A=B; httponly", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_,
-                                   "C=D; domain=.google.izzle", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_secure_,
-                                   "E=F; domain=.google.izzle; secure",
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+                                   "A=B; httponly", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+                                   http_www_google_.Format("C=D; domain=.%D"),
                                    options));
+  EXPECT_TRUE(SetCookieWithOptions(
+      cm.get(), https_www_google_.url(),
+      http_www_google_.Format("E=F; domain=.%D; secure"), options));
 
   const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
 
   base::PlatformThread::Sleep(
       base::TimeDelta::FromMilliseconds(kAccessDelayMs));
 
   // Check cookies for url.
-  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_google_.url());
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
 
   ASSERT_TRUE(++it != cookies.end());
-  EXPECT_EQ(".google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it == cookies.end());
 
   // Check cookies for url excluding http-only cookies.
-  cookies =
-      GetAllCookiesForURLWithOptions(cm.get(), url_google_, CookieOptions());
+  cookies = GetAllCookiesForURLWithOptions(cm.get(), http_www_google_.url(),
+                                           CookieOptions());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ(".google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it == cookies.end());
 
   // Test secure cookies.
-  cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
+  cookies = GetAllCookiesForURL(cm.get(), https_www_google_.url());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
 
   ASSERT_TRUE(++it != cookies.end());
-  EXPECT_EQ(".google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it != cookies.end());
-  EXPECT_EQ(".google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
   EXPECT_EQ("E", it->Name());
 
   ASSERT_TRUE(++it == cookies.end());
 
   // Reading after a short wait should not update the access date.
   EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_foo_, "A=B; path=/foo;",
-                                   options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_bar_, "C=D; path=/bar;",
-                                   options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "E=F;", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_google_foo_.url(),
+                                   "A=B; path=/foo;", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_google_bar_.url(),
+                                   "C=D; path=/bar;", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "E=F;", options));
 
-  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_foo_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), www_google_foo_.url());
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("A", it->Name());
   EXPECT_EQ("/foo", it->Path());
 
   ASSERT_TRUE(++it != cookies.end());
   EXPECT_EQ("E", it->Name());
   EXPECT_EQ("/", it->Path());
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
+  cookies = GetAllCookiesForURL(cm.get(), www_google_bar_.url());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("C", it->Name());
   EXPECT_EQ("/bar", it->Path());
 
   ASSERT_TRUE(++it != cookies.end());
   EXPECT_EQ("E", it->Name());
   EXPECT_EQ("/", it->Path());
 
   ASSERT_TRUE(++it == cookies.end());
 }
 
 TEST_F(CookieMonsterTest, CookieSorting) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B1; path=/"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B2; path=/foo"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B3; path=/foo/bar"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A1; path=/"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A2; path=/foo"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A3; path=/foo/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B2; path=/foo"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), http_www_google_.url(), "B=B3; path=/foo/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A2; path=/foo"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), http_www_google_.url(), "A=A3; path=/foo/bar"));
 
   // Re-set cookie which should not change sort order.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B3; path=/foo/bar"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), http_www_google_.url(), "B=B3; path=/foo/bar"));
 
   CookieList cookies = GetAllCookies(cm.get());
   ASSERT_EQ(6u, cookies.size());
   // According to RFC 6265 5.3 (11) re-setting this cookie should retain the
   // initial creation-time from above, and the sort order should not change.
   // Chrome's current implementation deviates from the spec so capturing this to
   // avoid any inadvertent changes to this behavior.
   EXPECT_EQ("A3", cookies[0].Value());
   EXPECT_EQ("B3", cookies[1].Value());
   EXPECT_EQ("B2", cookies[2].Value());
   EXPECT_EQ("A2", cookies[3].Value());
   EXPECT_EQ("B1", cookies[4].Value());
   EXPECT_EQ("A1", cookies[5].Value());
 }
 
 TEST_F(CookieMonsterTest, DeleteCookieByName) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A1; path=/"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A2; path=/foo"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=A3; path=/bar"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B1; path=/"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B2; path=/foo"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=B3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=A3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=B3; path=/bar"));
 
-  DeleteCookie(cm.get(), GURL(std::string(kUrlGoogle) + "/foo/bar"), "A");
+  DeleteCookie(cm.get(), http_www_google_.AppendPath("foo/bar"), "A");
 
   CookieList cookies = GetAllCookies(cm.get());
   size_t expected_size = 4;
   EXPECT_EQ(expected_size, cookies.size());
   for (CookieList::iterator it = cookies.begin(); it != cookies.end(); ++it) {
     EXPECT_NE("A1", it->Value());
     EXPECT_NE("A2", it->Value());
   }
 }
 
 TEST_F(CookieMonsterTest, ImportCookiesFromCookieMonster) {
   scoped_refptr<CookieMonster> cm_1(new CookieMonster(NULL, NULL));
   CookieOptions options;
 
-  EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_foo_,
+  EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), www_google_foo_.url(),
                                    "A1=B; path=/foo;", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_bar_,
+  EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), www_google_bar_.url(),
                                    "A2=D; path=/bar;", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), url_google_, "A3=F;", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm_1.get(), http_www_google_.url(), "A3=F;",
+                                   options));
 
   CookieList cookies_1 = GetAllCookies(cm_1.get());
   scoped_refptr<CookieMonster> cm_2(new CookieMonster(NULL, NULL));
   ASSERT_TRUE(cm_2->ImportCookies(cookies_1));
   CookieList cookies_2 = GetAllCookies(cm_2.get());
 
   size_t expected_size = 3;
   EXPECT_EQ(expected_size, cookies_2.size());
 
   CookieList::iterator it = cookies_2.begin();
@@ skipping 127 matching lines @@
   EXPECT_NE(name1, name2);
 }
 
 TEST_F(CookieMonsterTest, CookieMonsterDelegate) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   scoped_refptr<MockCookieMonsterDelegate> delegate(
       new MockCookieMonsterDelegate);
   scoped_refptr<CookieMonster> cm(
       new CookieMonster(store.get(), delegate.get()));
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "C=D"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "E=F"));
-  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "C=D"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "E=F"));
+  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), http_www_google_.url()));
   ASSERT_EQ(3u, delegate->changes().size());
   EXPECT_FALSE(delegate->changes()[0].second);
-  EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_google_.url().host(),
+            delegate->changes()[0].first.Domain());
   EXPECT_EQ("A", delegate->changes()[0].first.Name());
   EXPECT_EQ("B", delegate->changes()[0].first.Value());
-  EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain());
+  EXPECT_EQ(http_www_google_.url().host(),
+            delegate->changes()[1].first.Domain());
   EXPECT_FALSE(delegate->changes()[1].second);
   EXPECT_EQ("C", delegate->changes()[1].first.Name());
   EXPECT_EQ("D", delegate->changes()[1].first.Value());
-  EXPECT_EQ(url_google_.host(), delegate->changes()[2].first.Domain());
+  EXPECT_EQ(http_www_google_.url().host(),
+            delegate->changes()[2].first.Domain());
   EXPECT_FALSE(delegate->changes()[2].second);
   EXPECT_EQ("E", delegate->changes()[2].first.Name());
   EXPECT_EQ("F", delegate->changes()[2].first.Value());
   delegate->reset();
 
-  EXPECT_TRUE(FindAndDeleteCookie(cm.get(), url_google_.host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(
+      FindAndDeleteCookie(cm.get(), http_www_google_.url().host(), "C"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
   ASSERT_EQ(1u, delegate->changes().size());
-  EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_google_.url().host(),
+            delegate->changes()[0].first.Domain());
   EXPECT_TRUE(delegate->changes()[0].second);
   EXPECT_EQ("C", delegate->changes()[0].first.Name());
   EXPECT_EQ("D", delegate->changes()[0].first.Value());
   delegate->reset();
 
   EXPECT_FALSE(FindAndDeleteCookie(cm.get(), "random.host", "E"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), url_google_));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
   EXPECT_EQ(0u, delegate->changes().size());
 
   // Insert a cookie "a" for path "/path1"
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
                         "a=val1; path=/path1; "
                         "expires=Mon, 18-Apr-22 22:50:13 GMT"));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   ASSERT_EQ(1u, delegate->changes().size());
   EXPECT_FALSE(delegate->changes()[0].second);
-  EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_google_.url().host(),
+            delegate->changes()[0].first.Domain());
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
   delegate->reset();
 
   // Insert a cookie "a" for path "/path1", that is httponly. This should
   // overwrite the non-http-only version.
   CookieOptions allow_httponly;
   allow_httponly.set_include_httponly();
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
                                    "a=val2; path=/path1; httponly; "
                                    "expires=Mon, 18-Apr-22 22:50:14 GMT",
                                    allow_httponly));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   ASSERT_EQ(2u, delegate->changes().size());
-  EXPECT_EQ(url_google_.host(), delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_google_.url().host(),
+            delegate->changes()[0].first.Domain());
   EXPECT_TRUE(delegate->changes()[0].second);
   EXPECT_EQ("a", delegate->changes()[0].first.Name());
   EXPECT_EQ("val1", delegate->changes()[0].first.Value());
-  EXPECT_EQ(url_google_.host(), delegate->changes()[1].first.Domain());
+  EXPECT_EQ(http_www_google_.url().host(),
+            delegate->changes()[1].first.Domain());
   EXPECT_FALSE(delegate->changes()[1].second);
   EXPECT_EQ("a", delegate->changes()[1].first.Name());
   EXPECT_EQ("val2", delegate->changes()[1].first.Value());
   delegate->reset();
 }
 
 TEST_F(CookieMonsterTest, SetCookieWithDetails) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
-  EXPECT_TRUE(SetCookieWithDetails(cm.get(), url_google_foo_, "A", "B",
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(), www_google_foo_.url(), "A", "B",
                                    std::string(), "/foo", base::Time(), false,
                                    false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_TRUE(SetCookieWithDetails(cm.get(), url_google_bar_, "C", "D",
-                                   "google.izzle", "/bar", base::Time(), false,
-                                   true, false, COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(SetCookieWithDetails(
-      cm.get(), url_google_, "E", "F", std::string(), std::string(),
+      cm.get(), www_google_bar_.url(), "C", "D", www_google_bar_.domain(),
+      "/bar", base::Time(), false, true, false, COOKIE_PRIORITY_DEFAULT));
+  EXPECT_TRUE(SetCookieWithDetails(
+      cm.get(), http_www_google_.url(), "E", "F", std::string(), std::string(),
       base::Time(), true, false, false, COOKIE_PRIORITY_DEFAULT));
 
   // Test that malformed attributes fail to set the cookie.
-  EXPECT_FALSE(SetCookieWithDetails(cm.get(), url_google_foo_, " A", "B",
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(), www_google_foo_.url(), " A", "B",
                                     std::string(), "/foo", base::Time(), false,
                                     false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(cm.get(), url_google_foo_, "A;", "B",
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(), www_google_foo_.url(), "A;", "B",
                                     std::string(), "/foo", base::Time(), false,
                                     false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(cm.get(), url_google_foo_, "A=", "B",
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(), www_google_foo_.url(), "A=", "B",
                                     std::string(), "/foo", base::Time(), false,
                                     false, false, COOKIE_PRIORITY_DEFAULT));
   EXPECT_FALSE(SetCookieWithDetails(
-      cm.get(), url_google_foo_, "A", "B", "google.ozzzzzzle", "foo",
+      cm.get(), www_google_foo_.url(), "A", "B", "google.ozzzzzzle", "foo",
       base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
-  EXPECT_FALSE(SetCookieWithDetails(cm.get(), url_google_foo_, "A=", "B",
+  EXPECT_FALSE(SetCookieWithDetails(cm.get(), www_google_foo_.url(), "A=", "B",
                                     std::string(), "foo", base::Time(), false,
                                     false, false, COOKIE_PRIORITY_DEFAULT));
 
-  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_foo_);
+  CookieList cookies = GetAllCookiesForURL(cm.get(), www_google_foo_.url());
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("A", it->Name());
   EXPECT_EQ("B", it->Value());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(www_google_foo_.host(), it->Domain());
   EXPECT_EQ("/foo", it->Path());
   EXPECT_FALSE(it->IsPersistent());
   EXPECT_FALSE(it->IsSecure());
   EXPECT_FALSE(it->IsHttpOnly());
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm.get(), url_google_bar_);
+  cookies = GetAllCookiesForURL(cm.get(), www_google_bar_.url());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("C", it->Name());
   EXPECT_EQ("D", it->Value());
-  EXPECT_EQ(".google.izzle", it->Domain());
+  EXPECT_EQ(www_google_bar_.Format(".%D"), it->Domain());
   EXPECT_EQ("/bar", it->Path());
   EXPECT_FALSE(it->IsSecure());
   EXPECT_TRUE(it->IsHttpOnly());
 
   ASSERT_TRUE(++it == cookies.end());
 
-  cookies = GetAllCookiesForURL(cm.get(), url_google_secure_);
+  cookies = GetAllCookiesForURL(cm.get(), https_www_google_.url());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("E", it->Name());
   EXPECT_EQ("F", it->Value());
   EXPECT_EQ("/", it->Path());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(https_www_google_.host(), it->Domain());
   EXPECT_TRUE(it->IsSecure());
   EXPECT_FALSE(it->IsHttpOnly());
 
   ASSERT_TRUE(++it == cookies.end());
 }
 
 TEST_F(CookieMonsterTest, DeleteAllForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
   // Test probes:
@@ skipping 67 matching lines @@
   // Add in three cookies through every public interface to the
   // CookieMonster and confirm that none of them have duplicate
   // creation times.
 
   // SetCookieWithCreationTime and SetCookieWithCreationTimeAndOptions
   // are not included as they aren't going to be public for very much
   // longer.
 
   // SetCookie, SetCookieWithOptions, SetCookieWithDetails
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "SetCookie1=A"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "SetCookie2=A"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "SetCookie3=A"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "SetCookie1=A"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "SetCookie2=A"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "SetCookie3=A"));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
                                    "setCookieWithOptions1=A", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
                                    "setCookieWithOptions2=A", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
                                    "setCookieWithOptions3=A", options));
 
   EXPECT_TRUE(SetCookieWithDetails(
-      cm.get(), url_google_, "setCookieWithDetails1", "A", ".google.izzle", "/",
-      Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
+      cm.get(), http_www_google_.url(), "setCookieWithDetails1", "A",
+      http_www_google_.Format(".%D"), "/", Time(), false, false, false,
+      COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(SetCookieWithDetails(
-      cm.get(), url_google_, "setCookieWithDetails2", "A", ".google.izzle", "/",
-      Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
+      cm.get(), http_www_google_.url(), "setCookieWithDetails2", "A",
+      http_www_google_.Format(".%D"), "/", Time(), false, false, false,
+      COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(SetCookieWithDetails(
-      cm.get(), url_google_, "setCookieWithDetails3", "A", ".google.izzle", "/",
-      Time(), false, false, false, COOKIE_PRIORITY_DEFAULT));
+      cm.get(), http_www_google_.url(), "setCookieWithDetails3", "A",
+      http_www_google_.Format(".%D"), "/", Time(), false, false, false,
+      COOKIE_PRIORITY_DEFAULT));
 
   // Now we check
   CookieList cookie_list(GetAllCookies(cm.get()));
   EXPECT_EQ(9u, cookie_list.size());
   typedef std::map<int64, CanonicalCookie> TimeCookieMap;
   TimeCookieMap check_map;
   for (CookieList::const_iterator it = cookie_list.begin();
        it != cookie_list.end(); it++) {
     const int64 creation_date = it->CreationDate().ToInternalValue();
     TimeCookieMap::const_iterator existing_cookie_it(
@@ skipping 240 matching lines @@
 }
 
 // This test checks that keep expired cookies flag is working.
 TEST_F(CookieMonsterTest, KeepExpiredCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   cm->SetKeepExpiredCookies();
   CookieOptions options;
 
   // Set a persistent cookie.
   ASSERT_TRUE(SetCookieWithOptions(
-      cm.get(), url_google_,
+      cm.get(), http_www_google_.url(),
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT",
       options));
 
   // Get the canonical cookie.
   CookieList cookie_list = GetAllCookies(cm.get());
   ASSERT_EQ(1U, cookie_list.size());
 
   // Use a past expiry date to delete the cookie.
   ASSERT_TRUE(SetCookieWithOptions(
-      cm.get(), url_google_,
+      cm.get(), http_www_google_.url(),
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
       options));
 
   // Check that the cookie with the past expiry date is still there.
   // GetAllCookies() also triggers garbage collection.
   cookie_list = GetAllCookies(cm.get());
   ASSERT_EQ(1U, cookie_list.size());
   ASSERT_TRUE(cookie_list[0].IsExpired(Time::Now()));
 }
 
@@ skipping 104 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(3, counter->callback_count());
 }
 
 TEST_F(CookieMonsterTest, SetAllCookies) {
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   cm->SetPersistSessionCookies(true);
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "U=V; path=/"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "W=X; path=/foo"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "Y=Z; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "U=V; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "W=X; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "Y=Z; path=/"));
 
   CookieList list;
-  list.push_back(CanonicalCookie(url_google_, "A", "B", url_google_.host(), "/",
+  list.push_back(CanonicalCookie(http_www_google_.url(), "A", "B",
+                                 http_www_google_.url().host(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, false, false, COOKIE_PRIORITY_DEFAULT));
-  list.push_back(CanonicalCookie(url_google_, "W", "X", url_google_.host(),
-                                 "/bar", base::Time::Now(), base::Time(),
-                                 base::Time(), false, false, false,
-                                 COOKIE_PRIORITY_DEFAULT));
-  list.push_back(CanonicalCookie(url_google_, "Y", "Z", url_google_.host(), "/",
+  list.push_back(CanonicalCookie(http_www_google_.url(), "W", "X",
+                                 http_www_google_.url().host(), "/bar",
+                                 base::Time::Now(), base::Time(), base::Time(),
+                                 false, false, false, COOKIE_PRIORITY_DEFAULT));
+  list.push_back(CanonicalCookie(http_www_google_.url(), "Y", "Z",
+                                 http_www_google_.url().host(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, false, false, COOKIE_PRIORITY_DEFAULT));
 
   // SetAllCookies must not flush.
   ASSERT_EQ(0, store->flush_count());
   EXPECT_TRUE(SetAllCookies(cm.get(), list));
   EXPECT_EQ(0, store->flush_count());
 
   CookieList cookies = GetAllCookies(cm.get());
   size_t expected_size = 3;  // "A", "W" and "Y". "U" is gone.
@@ skipping 13 matching lines @@
   EXPECT_EQ("Y", it->Name());
   EXPECT_EQ("Z", it->Value());
 }
 
 TEST_F(CookieMonsterTest, ComputeCookieDiff) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
 
   base::Time now = base::Time::Now();
   base::Time creation_time = now - base::TimeDelta::FromSeconds(1);
 
-  CanonicalCookie cookie1(url_google_, "A", "B", url_google_.host(), "/",
-                          creation_time, base::Time(), base::Time(), false,
-                          false, false, COOKIE_PRIORITY_DEFAULT);
-  CanonicalCookie cookie2(url_google_, "C", "D", url_google_.host(), "/",
-                          creation_time, base::Time(), base::Time(), false,
-                          false, false, COOKIE_PRIORITY_DEFAULT);
-  CanonicalCookie cookie3(url_google_, "E", "F", url_google_.host(), "/",
-                          creation_time, base::Time(), base::Time(), false,
-                          false, false, COOKIE_PRIORITY_DEFAULT);
-  CanonicalCookie cookie4(url_google_, "G", "H", url_google_.host(), "/",
-                          creation_time, base::Time(), base::Time(), false,
-                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie1(http_www_google_.url(), "A", "B",
+                          http_www_google_.url().host(), "/", creation_time,
+                          base::Time(), base::Time(), false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie2(http_www_google_.url(), "C", "D",
+                          http_www_google_.url().host(), "/", creation_time,
+                          base::Time(), base::Time(), false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie3(http_www_google_.url(), "E", "F",
+                          http_www_google_.url().host(), "/", creation_time,
+                          base::Time(), base::Time(), false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie4(http_www_google_.url(), "G", "H",
+                          http_www_google_.url().host(), "/", creation_time,
+                          base::Time(), base::Time(), false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
   CanonicalCookie cookie4_with_new_value(
-      url_google_, "G", "iamnew", url_google_.host(), "/", creation_time,
+      http_www_google_.url(), "G", "iamnew", http_www_google_.url().host(), "/",
+      creation_time, base::Time(), base::Time(), false, false, false,
+      COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie5(http_www_google_.url(), "I", "J",
+                          http_www_google_.url().host(), "/", creation_time,
+                          base::Time(), base::Time(), false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie5_with_new_creation_time(
+      http_www_google_.url(), "I", "J", http_www_google_.url().host(), "/", now,
       base::Time(), base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
-  CanonicalCookie cookie5(url_google_, "I", "J", url_google_.host(), "/",
-                          creation_time, base::Time(), base::Time(), false,
-                          false, false, COOKIE_PRIORITY_DEFAULT);
-  CanonicalCookie cookie5_with_new_creation_time(
-      url_google_, "I", "J", url_google_.host(), "/", now, base::Time(),
-      base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
-  CanonicalCookie cookie6(url_google_, "K", "L", url_google_.host(), "/foo",
-                          creation_time, base::Time(), base::Time(), false,
-                          false, false, COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie6(http_www_google_.url(), "K", "L",
+                          http_www_google_.url().host(), "/foo", creation_time,
+                          base::Time(), base::Time(), false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
   CanonicalCookie cookie6_with_new_path(
-      url_google_, "K", "L", url_google_.host(), "/bar", creation_time,
-      base::Time(), base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
-  CanonicalCookie cookie7(url_google_, "M", "N", url_google_.host(), "/foo",
-                          creation_time, base::Time(), base::Time(), false,
-                          false, false, COOKIE_PRIORITY_DEFAULT);
+      http_www_google_.url(), "K", "L", http_www_google_.url().host(), "/bar",
+      creation_time, base::Time(), base::Time(), false, false, false,
+      COOKIE_PRIORITY_DEFAULT);
+  CanonicalCookie cookie7(http_www_google_.url(), "M", "N",
+                          http_www_google_.url().host(), "/foo", creation_time,
+                          base::Time(), base::Time(), false, false, false,
+                          COOKIE_PRIORITY_DEFAULT);
   CanonicalCookie cookie7_with_new_path(
-      url_google_, "M", "N", url_google_.host(), "/bar", creation_time,
-      base::Time(), base::Time(), false, false, false, COOKIE_PRIORITY_DEFAULT);
+      http_www_google_.url(), "M", "N", http_www_google_.url().host(), "/bar",
+      creation_time, base::Time(), base::Time(), false, false, false,
+      COOKIE_PRIORITY_DEFAULT);
 
   CookieList old_cookies;
   old_cookies.push_back(cookie1);
   old_cookies.push_back(cookie2);
   old_cookies.push_back(cookie4);
   old_cookies.push_back(cookie5);
   old_cookies.push_back(cookie6);
   old_cookies.push_back(cookie7);
 
   CookieList new_cookies;
@@ skipping 52 matching lines @@
   EXPECT_FALSE(IsCookieInList(cookie7_with_new_path, cookies_to_delete));
 }
 
 // Check that DeleteAll does flush (as a sanity check that flush_count()
 // works).
 TEST_F(CookieMonsterTest, DeleteAll) {
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   cm->SetPersistSessionCookies(true);
 
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "X=Y; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "X=Y; path=/"));
 
   ASSERT_EQ(0, store->flush_count());
   EXPECT_EQ(1, DeleteAll(cm.get()));
   EXPECT_EQ(1, store->flush_count());
 }
 
 TEST_F(CookieMonsterTest, HistogramCheck) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   // Should match call in InitializeHistograms, but doesn't really matter
   // since the histogram should have been initialized by the CM construction
   // above.
   base::HistogramBase* expired_histogram = base::Histogram::FactoryGet(
       "Cookie.ExpirationDurationMinutes", 1, 10 * 365 * 24 * 60, 50,
       base::Histogram::kUmaTargetedHistogramFlag);
 
   scoped_ptr<base::HistogramSamples> samples1(
       expired_histogram->SnapshotSamples());
   ASSERT_TRUE(SetCookieWithDetails(
       cm.get(), GURL("http://fake.a.url"), "a", "b", "a.url", "/",
       base::Time::Now() + base::TimeDelta::FromMinutes(59), false, false, false,
       COOKIE_PRIORITY_DEFAULT));
 
   scoped_ptr<base::HistogramSamples> samples2(
       expired_histogram->SnapshotSamples());
   EXPECT_EQ(samples1->TotalCount() + 1, samples2->TotalCount());
 
   // kValidCookieLine creates a session cookie.
-  ASSERT_TRUE(SetCookie(cm.get(), url_google_, kValidCookieLine));
+  ASSERT_TRUE(SetCookie(cm.get(), http_www_google_.url(), kValidCookieLine));
 
   scoped_ptr<base::HistogramSamples> samples3(
       expired_histogram->SnapshotSamples());
   EXPECT_EQ(samples2->TotalCount(), samples3->TotalCount());
 }
 
 namespace {
 
 class MultiThreadedCookieMonsterTest : public CookieMonsterTest {
  public:
@@ skipping 90 matching lines @@
     other_thread_.Stop();
   }
 
   Thread other_thread_;
 };
 
 }  // namespace
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
   CookieList cookies = GetAllCookies(cm.get());
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::GetAllCookiesTask,
                  base::Unretained(this), cm, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
-  CookieList cookies = GetAllCookiesForURL(cm.get(), url_google_);
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
+  CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_google_.url());
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::GetAllCookiesForURLTask,
-                 base::Unretained(this), cm, url_google_, &callback);
+                 base::Unretained(this), cm, http_www_google_.url(), &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
   CookieOptions options;
   CookieList cookies =
-      GetAllCookiesForURLWithOptions(cm.get(), url_google_, options);
+      GetAllCookiesForURLWithOptions(cm.get(), http_www_google_.url(), options);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &MultiThreadedCookieMonsterTest::GetAllCookiesForURLWithOptionsTask,
-      base::Unretained(this), cm, url_google_, options, &callback);
+      base::Unretained(this), cm, http_www_google_.url(), options, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
-  EXPECT_EQ("www.google.izzle", it->Domain());
+  EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckSetCookieWithDetails) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
-  EXPECT_TRUE(SetCookieWithDetails(cm.get(), url_google_foo_, "A", "B",
+  EXPECT_TRUE(SetCookieWithDetails(cm.get(), www_google_foo_.url(), "A", "B",
                                    std::string(), "/foo", base::Time(), false,
                                    false, false, COOKIE_PRIORITY_DEFAULT));
   ResultSavingCookieCallback<bool> callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask,
-                 base::Unretained(this), cm, url_google_foo_, &callback);
+                 base::Unretained(this), cm, www_google_foo_.url(), &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   Time now = Time::Now();
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99),
                                        Time()));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<int> callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
                  base::Unretained(this), cm, now - TimeDelta::FromDays(99),
                  Time(), &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
-  EXPECT_EQ(1, DeleteAllForHost(cm.get(), url_google_));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
+  EXPECT_EQ(1, DeleteAllForHost(cm.get(), http_www_google_.url()));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<int> callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::DeleteAllForHostTask,
-                 base::Unretained(this), cm, url_google_, &callback);
+                 base::Unretained(this), cm, http_www_google_.url(), &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest,
        ThreadCheckDeleteAllCreatedBetweenForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   GURL url_not_google("http://www.notgoogle.com");
 
   CookieOptions options;
   Time now = Time::Now();
   // ago1 < ago2 < ago3 < now.
   Time ago1 = now - TimeDelta::FromDays(101);
   Time ago2 = now - TimeDelta::FromDays(100);
   Time ago3 = now - TimeDelta::FromDays(99);
 
   // These 3 cookies match the first deletion.
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "C=D", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "Y=Z", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "C=D", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "Y=Z", options));
 
   // This cookie does not match host.
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_not_google, "E=F", options));
 
   // This cookie does not match time range: [ago3, inf], for first deletion, but
   // matches for the second deletion.
-  EXPECT_TRUE(cm->SetCookieWithCreationTime(url_google_, "G=H", ago2));
+  EXPECT_TRUE(
+      cm->SetCookieWithCreationTime(http_www_google_.url(), "G=H", ago2));
 
   // 1. First set of deletions.
-  EXPECT_EQ(
-      3,  // Deletes A=B, C=D, Y=Z
-      DeleteAllCreatedBetweenForHost(cm.get(), ago3, Time::Max(), url_google_));
+  EXPECT_EQ(3,  // Deletes A=B, C=D, Y=Z
+            DeleteAllCreatedBetweenForHost(cm.get(), ago3, Time::Max(),
+                                           http_www_google_.url()));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<int> callback(&other_thread_);
 
   // 2. Second set of deletions.
   base::Closure task = base::Bind(
       &MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenForHostTask,
-      base::Unretained(this), cm, ago1, Time(), url_google_, &callback);
+      base::Unretained(this), cm, ago1, Time(), http_www_google_.url(),
+      &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(2, callback.result());  // Deletes A=B, G=H.
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   CookieList cookies = GetAllCookies(cm.get());
   CookieList::iterator it = cookies.begin();
   EXPECT_TRUE(DeleteCanonicalCookie(cm.get(), *it));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), url_google_, "A=B", options));
+  EXPECT_TRUE(
+      SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<bool> callback(&other_thread_);
   cookies = GetAllCookies(cm.get());
   it = cookies.begin();
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
                  base::Unretained(this), cm, *it, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 // Ensure that cookies for http, https, ws, and wss all share the same storage
 // and policies when GetAllCookiesForURLAsync is used. This test is part of
 // MultiThreadedCookieMonsterTest in order to test and use
 // GetAllCookiesForURLAsync, but it does not use any additional threads.
 TEST_F(MultiThreadedCookieMonsterTest, GetAllCookiesForURLEffectiveDomain) {
   std::vector<CanonicalCookie*> cookies;
   // This cookie will be freed by the CookieMonster.
-  cookies.push_back(CanonicalCookie::Create(url_google_, kValidCookieLine,
-                                            Time::Now(), CookieOptions()));
+  cookies.push_back(CanonicalCookie::Create(
+      http_www_google_.url(), kValidCookieLine, Time::Now(), CookieOptions()));
   CanonicalCookie cookie = *cookies[0];
   scoped_refptr<NewMockPersistentCookieStore> store(
       new NewMockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback;
   ::testing::StrictMock<::testing::MockFunction<void(int)>> checkpoint;
-  const std::string key =
-      cookie_util::GetEffectiveDomain(url_google_.scheme(), url_google_.host());
+  const std::string key = cookie_util::GetEffectiveDomain(
+      http_www_google_.url().scheme(), http_www_google_.url().host());
 
   ::testing::InSequence s;
   EXPECT_CALL(checkpoint, Call(0));
   EXPECT_CALL(*store, Load(::testing::_));
   EXPECT_CALL(*store, LoadCookiesForKey(key, ::testing::_))
       .WillOnce(::testing::SaveArg<1>(&loaded_callback));
   EXPECT_CALL(checkpoint, Call(1));
   // LoadCookiesForKey will never be called after checkpoint.Call(1) although
   // we will call GetAllCookiesForURLAsync again, because all URLs below share
   // the same key.
   EXPECT_CALL(*store, LoadCookiesForKey(::testing::_, ::testing::_)).Times(0);
 
   GetCookieListCallback callback;
   checkpoint.Call(0);
-  GetAllCookiesForURLTask(cm.get(), url_google_, &callback);
+  GetAllCookiesForURLTask(cm.get(), http_www_google_.url(), &callback);
   checkpoint.Call(1);
   ASSERT_FALSE(callback.did_run());
   // Pass the cookies to the CookieMonster.
   loaded_callback.Run(cookies);
   // Now GetAllCookiesForURLTask is done.
   ASSERT_TRUE(callback.did_run());
   // See that the callback was called with the cookies.
   ASSERT_EQ(1u, callback.cookies().size());
   EXPECT_TRUE(cookie.IsEquivalent(callback.cookies()[0]));
 
   // All urls in |urls| should share the same cookie domain.
   const GURL kUrls[] = {
-      url_google_,
-      url_google_secure_,
-      GURL(kUrlGoogleWebSocket),
-      GURL(kUrlGoogleWebSocketSecure),
+      http_www_google_.url(), https_www_google_.url(), ws_www_google_.url(),
+      wss_www_google_.url(),
   };
   for (const GURL& url : kUrls) {
     // Call the function with |url| and verify it is done synchronously without
     // calling LoadCookiesForKey.
     GetCookieListCallback callback;
     GetAllCookiesForURLTask(cm.get(), url, &callback);
     ASSERT_TRUE(callback.did_run());
     ASSERT_EQ(1u, callback.cookies().size());
     EXPECT_TRUE(cookie.IsEquivalent(callback.cookies()[0]));
   }
 }
 
 TEST_F(CookieMonsterTest, InvalidExpiryTime) {
   std::string cookie_line =
       std::string(kValidCookieLine) + "; expires=Blarg arg arg";
   scoped_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(
-      url_google_, cookie_line, Time::Now(), CookieOptions()));
+      http_www_google_.url(), cookie_line, Time::Now(), CookieOptions()));
   ASSERT_FALSE(cookie->IsPersistent());
 }
 
 // Test that CookieMonster writes session cookies into the underlying
 // CookieStore if the "persist session cookies" option is on.
 TEST_F(CookieMonsterTest, PersistSessionCookies) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   cm->SetPersistSessionCookies(true);
 
   // All cookies set with SetCookie are session cookies.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B"));
-  EXPECT_EQ("A=B", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
 
   // The cookie was written to the backing store.
   EXPECT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   EXPECT_EQ("A", store->commands()[0].cookie.Name());
   EXPECT_EQ("B", store->commands()[0].cookie.Value());
 
   // Modify the cookie.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=C"));
-  EXPECT_EQ("A=C", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=C"));
+  EXPECT_EQ("A=C", GetCookies(cm.get(), http_www_google_.url()));
   EXPECT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ("A", store->commands()[1].cookie.Name());
   EXPECT_EQ("B", store->commands()[1].cookie.Value());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   EXPECT_EQ("A", store->commands()[2].cookie.Name());
   EXPECT_EQ("C", store->commands()[2].cookie.Value());
 
   // Delete the cookie.
-  DeleteCookie(cm.get(), url_google_, "A");
-  EXPECT_EQ("", GetCookies(cm.get(), url_google_));
+  DeleteCookie(cm.get(), http_www_google_.url(), "A");
+  EXPECT_EQ("", GetCookies(cm.get(), http_www_google_.url()));
   EXPECT_EQ(4u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ("A", store->commands()[3].cookie.Name());
   EXPECT_EQ("C", store->commands()[3].cookie.Value());
 }
 
 // Test the commands sent to the persistent cookie store.
 TEST_F(CookieMonsterTest, PersisentCookieStorageTest) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
                         "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), http_www_google_.url()));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   // Remove it.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B; max-age=0"));
-  this->MatchCookieLines(std::string(), GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B; max-age=0"));
+  this->MatchCookieLines(std::string(),
+                         GetCookies(cm.get(), http_www_google_.url()));
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
                         "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm.get(), url_google_));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), http_www_google_.url()));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   // Overwrite it.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
                         "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
-  this->MatchCookieLines("A=Foo", GetCookies(cm.get(), url_google_));
+  this->MatchCookieLines("A=Foo", GetCookies(cm.get(), http_www_google_.url()));
   ASSERT_EQ(5u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
 
   // Create some non-persistent cookies and check that they don't go to the
   // persistent storage.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "B=Bar"));
-  this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm.get(), url_google_));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "B=Bar"));
+  this->MatchCookieLines("A=Foo; B=Bar",
+                         GetCookies(cm.get(), http_www_google_.url()));
   EXPECT_EQ(5u, store->commands().size());
 }
 
 // Test to assure that cookies with control characters are purged appropriately.
 // See http://crbug.com/238041 for background.
 TEST_F(CookieMonsterTest, ControlCharacterPurge) {
   const Time now1(Time::Now());
   const Time now2(Time::Now() + TimeDelta::FromSeconds(1));
   const Time now3(Time::Now() + TimeDelta::FromSeconds(2));
   const Time later(now1 + TimeDelta::FromDays(1));
@@ skipping 31 matching lines @@
 TEST_F(CookieMonsterTest, CookieSourceHistogram) {
   base::HistogramTester histograms;
   const std::string cookie_source_histogram = "Cookie.CookieSourceScheme";
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   histograms.ExpectTotalCount(cookie_source_histogram, 0);
 
   // Set a Secure cookie on a cryptographic scheme.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_secure_, "A=B; path=/; Secure"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), https_www_google_.url(), "A=B; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 1);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_SECURE_COOKIE_CRYPTOGRAPHIC_SCHEME, 1);
 
   // Set a non-Secure cookie on a cryptographic scheme.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_secure_, "C=D; path=/;"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(), "C=D; path=/;"));
   histograms.ExpectTotalCount(cookie_source_histogram, 2);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_NONSECURE_COOKIE_CRYPTOGRAPHIC_SCHEME, 1);
 
   // Set a Secure cookie on a non-cryptographic scheme.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "D=E; path=/; Secure"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), http_www_google_.url(), "D=E; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 3);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_SECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME, 1);
 
   // Overwrite a Secure cookie (set by a cryptographic scheme) on a
   // non-cryptographic scheme.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "A=B; path=/; Secure"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), http_www_google_.url(), "A=B; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 4);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_SECURE_COOKIE_CRYPTOGRAPHIC_SCHEME, 1);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_SECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME, 2);
 
   // Test that clearing a Secure cookie on a http:// URL does not get
   // counted.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_secure_, "F=G; path=/; Secure"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), https_www_google_.url(), "F=G; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 5);
-  std::string cookies1 = GetCookies(cm.get(), url_google_secure_);
+  std::string cookies1 = GetCookies(cm.get(), https_www_google_.url());
   EXPECT_NE(std::string::npos, cookies1.find("F=G"));
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_,
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
                         "F=G; path=/; Expires=Thu, 01-Jan-1970 00:00:01 GMT"));
-  std::string cookies2 = GetCookies(cm.get(), url_google_secure_);
+  std::string cookies2 = GetCookies(cm.get(), https_www_google_.url());
   EXPECT_EQ(std::string::npos, cookies2.find("F=G"));
   histograms.ExpectTotalCount(cookie_source_histogram, 5);
 
   // Set a non-Secure cookie on a non-cryptographic scheme.
-  EXPECT_TRUE(SetCookie(cm.get(), url_google_, "H=I; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "H=I; path=/"));
   histograms.ExpectTotalCount(cookie_source_histogram, 6);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_NONSECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME, 1);
 }
 
 class CookieMonsterNotificationTest : public CookieMonsterTest {
  public:
   CookieMonsterNotificationTest()
       : test_url_("http://www.google.com/foo"),
@@ skipping 143 matching lines @@
       monster()->AddCallbackForCookie(
           test_url_, "abc",
           base::Bind(&RecordCookieChanges, &cookies1, nullptr)));
   SetCookie(monster(), test_url_, "abc=def");
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, cookies0.size());
   EXPECT_EQ(1U, cookies0.size());
 }
 
 }  // namespace net