Change all "google.com" references in net/cookies to "foo.com" to avoid repeatedly tripping ov…

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_monster.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 104 matching lines @@
 INSTANTIATE_TYPED_TEST_CASE_P(CookieMonster,
                               CookieStoreTest,
                               CookieMonsterTestTraits);
 
 template <typename T>
 class CookieMonsterTestBase : public CookieStoreTest<T> {
  public:
   using CookieStoreTest<T>::SetCookie;
 
  protected:
-  using CookieStoreTest<T>::http_www_google_;
-  using CookieStoreTest<T>::https_www_google_;
+  using CookieStoreTest<T>::http_www_foo_;
+  using CookieStoreTest<T>::https_www_foo_;
 
   CookieList GetAllCookiesForURLWithOptions(CookieMonster* cm,
                                             const GURL& url,
                                             const CookieOptions& options) {
     DCHECK(cm);
     GetCookieListCallback callback;
     cm->GetCookieListWithOptionsAsync(
         url, options,
         base::Bind(&GetCookieListCallback::Run, base::Unretained(&callback)));
     callback.WaitUntilDone();
@@ skipping 153 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.
     {
       std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
       for (int i = 0; i < more_than_enough_cookies; ++i) {
         std::string cookie = base::StringPrintf("a%03d=b", i);
-        EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), cookie));
-        std::string cookies =
-            this->GetCookies(cm.get(), http_www_google_.url());
+        EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), cookie));
+        std::string cookies = this->GetCookies(cm.get(), http_www_foo_.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(http_www_google_.Format("http://www.gmail.%D"));
+    GURL url_google_specific(http_www_foo_.Format("http://www.gmail.%D"));
     {
       std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
       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(), http_www_google_.url(), cookie_general));
+        EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.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(), http_www_google_.url());
+            this->GetCookies(cm.get(), http_www_foo_.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(), http_www_google_.url());
+          this->GetCookies(cm.get(), http_www_foo_.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 http_www_google_)
+  // Instantiates a CookieMonster, adds multiple cookies (to http_www_foo_)
   // with priorities specified by |coded_priority_str|, and tests priority-aware
   // domain cookie eviction.
   //
   // Example: |coded_priority_string| of "2MN 3LS MN 4HN" specifies sequential
   // (i.e., from least- to most-recently accessed) insertion of 2
   // medium-priority non-secure cookies, 3 low-priority secure cookies, 1
   // medium-priority non-secure cookie, and 4 high-priority non-secure cookies.
   //
   // Within each priority, only the least-accessed cookies should be evicted.
   // Thus, to describe expected suriving cookies, it suffices to specify the
@@ skipping 31 matching lines @@
       if (!token.empty()) {
         bool result = base::StringToInt(
             base::StringPiece(token.begin(), token.end() - 2), &rep);
         DCHECK(result);
       }
       for (; rep > 0; --rep, ++next_cookie_id) {
         std::string cookie =
             base::StringPrintf("a%d=b;priority=%s;%s", next_cookie_id,
                                CookiePriorityToString(priority).c_str(),
                                is_secure ? "secure" : "");
-        EXPECT_TRUE(SetCookie(cm, https_www_google_.url(), cookie));
+        EXPECT_TRUE(SetCookie(cm, https_www_foo_.url(), cookie));
         cookie_data.push_back(std::make_pair(is_secure, priority));
         id_list[is_secure][priority].push_back(next_cookie_id);
       }
     }
 
     int num_cookies = static_cast<int>(cookie_data.size());
     // A list of cookie IDs, indexed by secure status, then by priority.
     std::vector<int> surviving_id_list[2][3];
 
     // Parse the list of cookies
-    std::string cookie_str = this->GetCookies(cm, https_www_google_.url());
+    std::string cookie_str = this->GetCookies(cm, https_www_foo_.url());
     size_t num_nonsecure = 0;
     size_t num_secure = 0;
     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);
@@ skipping 70 matching lines @@
     }
 
     int next_cookie_id = 0;
     for (size_t i = 0; i < num_cookie_entries; i++) {
       for (size_t j = 0; j < cookie_entries[i].num_cookies; j++) {
         std::string cookie;
         if (cookie_entries[i].is_secure)
           cookie = base::StringPrintf("a%d=b; Secure", next_cookie_id);
         else
           cookie = base::StringPrintf("a%d=b", next_cookie_id);
-        EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(), cookie));
+        EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.url(), cookie));
         ++next_cookie_id;
       }
     }
 
     CookieList cookies = this->GetAllCookies(cm.get());
     EXPECT_EQ(expected_secure_cookies + expected_non_secure_cookies,
               cookies.size());
     size_t total_secure_cookies = 0;
     size_t total_non_secure_cookies = 0;
     for (const auto& cookie : cookies) {
@@ skipping 465 matching lines @@
   base::RunLoop load_run_loop_;
   // Indicates whether ExpectLoadCall() has been called.
   bool expect_load_called_;
   // Stores the CookieMonster under test.
   std::unique_ptr<CookieMonster> cookie_monster_;
   // Stores the mock PersistentCookieStore.
   scoped_refptr<NewMockPersistentCookieStore> persistent_store_;
 };
 
 TEST_F(DeferredCookieTaskTest, DeferredGetCookies) {
-  DeclareLoadedCookie(http_www_google_.url(),
+  DeclareLoadedCookie(http_www_foo_.url(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookiesCallback get_cookies_callback;
 
-  BeginWithForDomainKey(
-      http_www_google_.domain(),
-      GetCookiesAction(&cookie_monster(), http_www_google_.url(),
-                       &get_cookies_callback));
+  BeginWithForDomainKey(http_www_foo_.domain(),
+                        GetCookiesAction(&cookie_monster(), http_www_foo_.url(),
+                                         &get_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookies_callback, Run("X=1"))
-      .WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
+      .WillOnce(GetCookiesAction(&cookie_monster(), http_www_foo_.url(),
                                  &get_cookies_callback));
   base::RunLoop loop;
   EXPECT_CALL(get_cookies_callback, Run("X=1")).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
   MockSetCookiesCallback set_cookies_callback;
 
-  BeginWithForDomainKey(
-      http_www_google_.domain(),
-      SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
-                      &set_cookies_callback));
+  BeginWithForDomainKey(http_www_foo_.domain(),
+                        SetCookieAction(&cookie_monster(), http_www_foo_.url(),
+                                        "A=B", &set_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(set_cookies_callback, Run(true))
-      .WillOnce(SetCookieAction(&cookie_monster(), http_www_google_.url(),
-                                "X=Y", &set_cookies_callback));
+      .WillOnce(SetCookieAction(&cookie_monster(), http_www_foo_.url(), "X=Y",
+                                &set_cookies_callback));
   base::RunLoop loop;
   EXPECT_CALL(set_cookies_callback, Run(true)).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetAllCookies) {
   MockSetCookiesCallback set_cookies_callback;
   CookieList list;
-  list.push_back(CanonicalCookie("A", "B", "." + http_www_google_.domain(), "/",
+  list.push_back(CanonicalCookie("A", "B", "." + http_www_foo_.domain(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, true, CookieSameSite::DEFAULT_MODE,
                                  COOKIE_PRIORITY_DEFAULT));
-  list.push_back(CanonicalCookie("C", "D", "." + http_www_google_.domain(), "/",
+  list.push_back(CanonicalCookie("C", "D", "." + http_www_foo_.domain(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, true, CookieSameSite::DEFAULT_MODE,
                                  COOKIE_PRIORITY_DEFAULT));
 
   BeginWith(
       SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(set_cookies_callback, Run(true))
       .WillOnce(
           SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
   base::RunLoop loop;
   EXPECT_CALL(set_cookies_callback, Run(true)).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) {
   MockClosure delete_cookie_callback;
 
   BeginWithForDomainKey(
-      http_www_google_.domain(),
-      DeleteCookieAction(&cookie_monster(), http_www_google_.url(), "A",
+      http_www_foo_.domain(),
+      DeleteCookieAction(&cookie_monster(), http_www_foo_.url(), "A",
                          &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Run())
-      .WillOnce(DeleteCookieAction(&cookie_monster(), http_www_google_.url(),
-                                   "X", &delete_cookie_callback));
+      .WillOnce(DeleteCookieAction(&cookie_monster(), http_www_foo_.url(), "X",
+                                   &delete_cookie_callback));
   base::RunLoop loop;
   EXPECT_CALL(delete_cookie_callback, Run()).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) {
   MockSetCookiesCallback set_cookies_callback;
 
-  CookiesInputInfo cookie_info = {www_google_foo_.url(),
+  CookiesInputInfo cookie_info = {www_foo_foo_.url(),
                                   "A",
                                   "B",
                                   std::string(),
                                   "/foo",
                                   base::Time(),
                                   false,
                                   false,
                                   CookieSameSite::DEFAULT_MODE,
                                   COOKIE_PRIORITY_DEFAULT};
   BeginWithForDomainKey(
-      http_www_google_.domain(),
+      http_www_foo_.domain(),
       SetCookieWithDetailsAction(&cookie_monster(), cookie_info,
                                  &set_cookies_callback));
 
   WaitForLoadCall();
 
-  CookiesInputInfo cookie_info_exp = {www_google_foo_.url(),
+  CookiesInputInfo cookie_info_exp = {www_foo_foo_.url(),
                                       "A",
                                       "B",
                                       std::string(),
                                       "/foo",
                                       base::Time(),
                                       false,
                                       false,
                                       CookieSameSite::DEFAULT_MODE,
                                       COOKIE_PRIORITY_DEFAULT};
   EXPECT_CALL(set_cookies_callback, Run(true))
       .WillOnce(SetCookieWithDetailsAction(&cookie_monster(), cookie_info_exp,
                                            &set_cookies_callback));
   base::RunLoop loop;
   EXPECT_CALL(set_cookies_callback, Run(true)).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) {
-  DeclareLoadedCookie(http_www_google_.url(),
+  DeclareLoadedCookie(http_www_foo_.url(),
                       "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, Run(testing::_))
       .WillOnce(
           GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback));
   base::RunLoop loop;
   EXPECT_CALL(get_cookie_list_callback, Run(testing::_))
       .WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlCookies) {
-  DeclareLoadedCookie(http_www_google_.url(),
+  DeclareLoadedCookie(http_www_foo_.url(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
   BeginWithForDomainKey(
-      http_www_google_.domain(),
-      GetAllCookiesForUrlAction(&cookie_monster(), http_www_google_.url(),
+      http_www_foo_.domain(),
+      GetAllCookiesForUrlAction(&cookie_monster(), http_www_foo_.url(),
                                 &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Run(testing::_))
-      .WillOnce(GetAllCookiesForUrlAction(&cookie_monster(),
-                                          http_www_google_.url(),
-                                          &get_cookie_list_callback));
+      .WillOnce(GetAllCookiesForUrlAction(
+          &cookie_monster(), http_www_foo_.url(), &get_cookie_list_callback));
   base::RunLoop loop;
   EXPECT_CALL(get_cookie_list_callback, Run(testing::_))
       .WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlWithOptionsCookies) {
-  DeclareLoadedCookie(http_www_google_.url(),
+  DeclareLoadedCookie(http_www_foo_.url(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
-  BeginWithForDomainKey(http_www_google_.domain(),
-                        GetCookieListForUrlWithOptionsAction(
-                            &cookie_monster(), http_www_google_.url(),
-                            &get_cookie_list_callback));
+  BeginWithForDomainKey(
+      http_www_foo_.domain(),
+      GetCookieListForUrlWithOptionsAction(
+          &cookie_monster(), http_www_foo_.url(), &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Run(testing::_))
       .WillOnce(GetCookieListForUrlWithOptionsAction(
-          &cookie_monster(), http_www_google_.url(),
-          &get_cookie_list_callback));
+          &cookie_monster(), http_www_foo_.url(), &get_cookie_list_callback));
   base::RunLoop loop;
   EXPECT_CALL(get_cookie_list_callback, Run(testing::_))
       .WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCookies) {
   MockDeleteCallback delete_callback;
@@ skipping 50 matching lines @@
   base::RunLoop loop;
   EXPECT_CALL(delete_callback, Run(false)).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
   std::vector<std::unique_ptr<CanonicalCookie>> cookies;
   std::unique_ptr<CanonicalCookie> cookie = BuildCanonicalCookie(
-      http_www_google_.url(), "X=1; path=/", base::Time::Now());
+      http_www_foo_.url(), "X=1; path=/", base::Time::Now());
 
   MockDeleteCallback delete_cookie_callback;
 
   BeginWith(DeleteCanonicalCookieAction(&cookie_monster(), *cookie,
                                         &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Run(0))
       .WillOnce(DeleteCanonicalCookieAction(&cookie_monster(), *cookie,
@@ skipping 19 matching lines @@
   EXPECT_CALL(delete_callback, Run(false)).WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 // 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(http_www_google_.url(),
+  DeclareLoadedCookie(http_www_foo_.url(),
                       "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(), http_www_google_.url(),
+          GetCookiesAction(&cookie_monster(), http_www_foo_.url(),
                            &get_cookies_callback),
-          SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
+          SetCookieAction(&cookie_monster(), http_www_foo_.url(), "A=B",
                           &set_cookies_callback)));
   ExpectLoadCall();
-  ExpectLoadForKeyCall(http_www_google_.domain());
+  ExpectLoadForKeyCall(http_www_foo_.domain());
   Begin();
 
   WaitForLoadCall();
   EXPECT_CALL(get_cookies_callback, Run("X=1"))
-      .WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
+      .WillOnce(GetCookiesAction(&cookie_monster(), http_www_foo_.url(),
                                  &get_cookies_callback_deferred));
   EXPECT_CALL(set_cookies_callback, Run(true));
   base::RunLoop loop;
   EXPECT_CALL(get_cookies_callback_deferred, Run("A=B; X=1"))
       .WillOnce(QuitRunLoop(&loop));
 
   CompleteLoading();
   loop.Run();
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), kValidCookieLine));
-  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), kValidCookieLine));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_foo_.url()));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_foo_.url(),
                                    "C=D; httponly", options));
   EXPECT_EQ("A=B; C=D",
-            GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
+            GetCookiesWithOptions(cm.get(), http_www_foo_.url(), options));
 
   EXPECT_EQ(2, DeleteAll(cm.get()));
-  EXPECT_EQ("",
-            GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
+  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), http_www_foo_.url(), options));
   EXPECT_EQ(0u, store->commands().size());
 
   // Create a persistent cookie.
   EXPECT_TRUE(SetCookie(
-      cm.get(), http_www_google_.url(),
+      cm.get(), http_www_foo_.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(), http_www_google_.url(), options));
+  EXPECT_EQ("", GetCookiesWithOptions(cm.get(), http_www_foo_.url(), options));
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   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 5 cookies with different creation dates.
   EXPECT_TRUE(
-      cm->SetCookieWithCreationTime(http_www_google_.url(), "T-0=Now", now));
+      cm->SetCookieWithCreationTime(http_www_foo_.url(), "T-0=Now", now));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
-      http_www_google_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
+      http_www_foo_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
-      http_www_google_.url(), "T-2=DayBefore", now - TimeDelta::FromDays(2)));
+      http_www_foo_.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)));
+      http_www_foo_.url(), "T-3=ThreeDays", now - TimeDelta::FromDays(3)));
+  EXPECT_TRUE(cm->SetCookieWithCreationTime(http_www_foo_.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));
 
@@ skipping 20 matching lines @@
   CookiePredicate false_predicate =
       base::Bind(&AlwaysFalseCookiePredicate, &test_cookie);
 
   // Nothing has been added so nothing should be deleted.
   EXPECT_EQ(
       0, DeleteAllCreatedBetweenWithPredicate(
              cm.get(), now - TimeDelta::FromDays(99), Time(), true_predicate));
 
   // Create 5 cookies with different creation dates.
   EXPECT_TRUE(
-      cm->SetCookieWithCreationTime(http_www_google_.url(), "T-0=Now", now));
+      cm->SetCookieWithCreationTime(http_www_foo_.url(), "T-0=Now", now));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
-      http_www_google_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
+      http_www_foo_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
-      http_www_google_.url(), "T-2=DayBefore", now - TimeDelta::FromDays(2)));
+      http_www_foo_.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)));
+      http_www_foo_.url(), "T-3=ThreeDays", now - TimeDelta::FromDays(3)));
+  EXPECT_TRUE(cm->SetCookieWithCreationTime(http_www_foo_.url(), "T-7=LastWeek",
+                                            now - TimeDelta::FromDays(7)));
 
   // Try to delete threedays and the daybefore, but we should do nothing due
   // to the predicate.
   EXPECT_EQ(0, DeleteAllCreatedBetweenWithPredicate(
                    cm.get(), now - TimeDelta::FromDays(3),
                    now - TimeDelta::FromDays(1), false_predicate));
   // Same as above with a null predicate, so it shouldn't delete anything.
   EXPECT_EQ(0, DeleteAllCreatedBetweenWithPredicate(
                    cm.get(), now - TimeDelta::FromDays(3),
                    now - TimeDelta::FromDays(1), CookiePredicate()));
   // Same as above, but we use the true_predicate, so it works.
   EXPECT_EQ(2, DeleteAllCreatedBetweenWithPredicate(
                    cm.get(), now - TimeDelta::FromDays(3),
                    now - TimeDelta::FromDays(1), true_predicate));
 
   // Try to delete yesterday, also make sure that delete_end is not
   // inclusive.
   EXPECT_EQ(0,
             DeleteAllCreatedBetweenWithPredicate(
                 cm.get(), now - TimeDelta::FromDays(2), now, false_predicate));
   EXPECT_EQ(1,
             DeleteAllCreatedBetweenWithPredicate(
                 cm.get(), now - TimeDelta::FromDays(2), now, true_predicate));
   // Check our cookie values.
   std::unique_ptr<CanonicalCookie> expected_cookie =
-      CanonicalCookie::Create(http_www_google_.url(), "T-1=Yesterday",
+      CanonicalCookie::Create(http_www_foo_.url(), "T-1=Yesterday",
                               now - TimeDelta::FromDays(1), CookieOptions());
   EXPECT_THAT(test_cookie, CookieEquals(*expected_cookie))
       << "Actual:\n"
       << test_cookie.DebugString() << "\nExpected:\n"
       << expected_cookie->DebugString();
 
   // Make sure the delete_begin is inclusive.
   EXPECT_EQ(0,
             DeleteAllCreatedBetweenWithPredicate(
                 cm.get(), now - TimeDelta::FromDays(7), now, false_predicate));
   EXPECT_EQ(1,
             DeleteAllCreatedBetweenWithPredicate(
                 cm.get(), now - TimeDelta::FromDays(7), now, true_predicate));
 
   // Delete the last (now) item.
   EXPECT_EQ(0, DeleteAllCreatedBetweenWithPredicate(cm.get(), Time(), Time(),
                                                     false_predicate));
   EXPECT_EQ(1, DeleteAllCreatedBetweenWithPredicate(cm.get(), Time(), Time(),
                                                     true_predicate));
-  expected_cookie = CanonicalCookie::Create(http_www_google_.url(), "T-0=Now",
-                                            now, CookieOptions());
+  expected_cookie = CanonicalCookie::Create(http_www_foo_.url(), "T-0=Now", now,
+                                            CookieOptions());
   EXPECT_THAT(test_cookie, CookieEquals(*expected_cookie))
       << "Actual:\n"
       << test_cookie.DebugString() << "\nExpected:\n"
       << expected_cookie->DebugString();
 
   // Really make sure everything is gone.
   EXPECT_EQ(0, DeleteAll(cm.get()));
 }
 
 static const base::TimeDelta kLastAccessThreshold =
     base::TimeDelta::FromMilliseconds(200);
 static const base::TimeDelta kAccessDelay =
     kLastAccessThreshold + base::TimeDelta::FromMilliseconds(20);
 
 TEST_F(CookieMonsterTest, TestLastAccess) {
   std::unique_ptr<CookieMonster> cm(
       new CookieMonster(nullptr, nullptr, kLastAccessThreshold));
 
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.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(), http_www_google_.url()));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_foo_.url()));
   EXPECT_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
 
   // Reading after a short wait will update the access date, if the cookie
   // is requested with options that would update the access date. First, test
   // that the flag's behavior is respected.
   base::PlatformThread::Sleep(kAccessDelay);
   CookieOptions options;
   options.set_do_not_update_access_time();
   EXPECT_EQ("A=B",
-            GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
+            GetCookiesWithOptions(cm.get(), http_www_foo_.url(), options));
   EXPECT_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
 
   // Getting all cookies for a URL doesn't update the accessed time either.
-  CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_google_.url());
+  CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_foo_.url());
   CookieList::iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ(http_www_google_.host(), it->Domain());
+  EXPECT_EQ(http_www_foo_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   EXPECT_EQ("B", it->Value());
   EXPECT_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
   EXPECT_TRUE(++it == cookies.end());
 
   // If the flag isn't set, the last accessed time should be updated.
   options = CookieOptions();
   EXPECT_EQ("A=B",
-            GetCookiesWithOptions(cm.get(), http_www_google_.url(), options));
+            GetCookiesWithOptions(cm.get(), http_www_foo_.url(), options));
   EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm.get()));
 }
 
 TEST_F(CookieMonsterTest, TestHostGarbageCollection) {
   TestHostGarbageCollectHelper();
 }
 
 TEST_F(CookieMonsterTest, TestPriorityAwareGarbageCollectionNonSecure) {
   TestPriorityAwareGarbageCollectHelperNonSecure();
 }
@@ skipping 25 matching lines @@
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
   std::unique_ptr<CookieMonster> cm(
       new CookieMonster(nullptr, nullptr, kLastAccessThreshold));
 
   // Create an httponly cookie.
   CookieOptions options;
   options.set_include_httponly();
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_foo_.url(),
                                    "A=B; httponly", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
-                                   http_www_google_.Format("C=D; domain=.%D"),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_foo_.url(),
+                                   http_www_foo_.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));
+      cm.get(), https_www_foo_.url(),
+      http_www_foo_.Format("E=F; domain=.%D; secure"), options));
 
   const Time last_access_date(GetFirstCookieAccessDate(cm.get()));
 
   base::PlatformThread::Sleep(kAccessDelay);
 
   // Check cookies for url.
-  CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_google_.url());
+  CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_foo_.url());
   CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ(http_www_google_.host(), it->Domain());
+  EXPECT_EQ(http_www_foo_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
 
   ASSERT_TRUE(++it != cookies.end());
-  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
+  EXPECT_EQ(http_www_foo_.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(), http_www_google_.url(),
+  cookies = GetAllCookiesForURLWithOptions(cm.get(), http_www_foo_.url(),
                                            CookieOptions());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
+  EXPECT_EQ(http_www_foo_.Format(".%D"), it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it == cookies.end());
 
   // Test secure cookies.
-  cookies = GetAllCookiesForURL(cm.get(), https_www_google_.url());
+  cookies = GetAllCookiesForURL(cm.get(), https_www_foo_.url());
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
-  EXPECT_EQ(http_www_google_.host(), it->Domain());
+  EXPECT_EQ(http_www_foo_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
 
   ASSERT_TRUE(++it != cookies.end());
-  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
+  EXPECT_EQ(http_www_foo_.Format(".%D"), it->Domain());
   EXPECT_EQ("C", it->Name());
 
   ASSERT_TRUE(++it != cookies.end());
-  EXPECT_EQ(http_www_google_.Format(".%D"), it->Domain());
+  EXPECT_EQ(http_www_foo_.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_EQ(last_access_date, GetFirstCookieAccessDate(cm.get()));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURLPathMatching) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   CookieOptions options;
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_google_foo_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_foo_foo_.url(),
                                    "A=B; path=/foo;", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_google_bar_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), www_foo_bar_.url(),
                                    "C=D; path=/bar;", options));
   EXPECT_TRUE(
-      SetCookieWithOptions(cm.get(), http_www_google_.url(), "E=F;", options));
+      SetCookieWithOptions(cm.get(), http_www_foo_.url(), "E=F;", options));
 
-  CookieList cookies = GetAllCookiesForURL(cm.get(), www_google_foo_.url());
+  CookieList cookies = GetAllCookiesForURL(cm.get(), www_foo_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(), www_google_bar_.url());
+  cookies = GetAllCookiesForURL(cm.get(), www_foo_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) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
 
-  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"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B3; path=/foo/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A3; path=/foo/bar"));
 
   // Re-set cookie which should not change sort order.
-  EXPECT_TRUE(
-      SetCookie(cm.get(), http_www_google_.url(), "B=B3; path=/foo/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.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) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
 
-  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"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=A3; path=/bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B1; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B2; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=B3; path=/bar"));
 
-  DeleteCookie(cm.get(), http_www_google_.AppendPath("foo/bar"), "A");
+  DeleteCookie(cm.get(), http_www_foo_.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());
   }
 }
 
 // Tests importing from a persistent cookie store that contains duplicate
 // equivalent cookies. This situation should be handled by removing the
 // duplicate cookie (both from the in-memory cache, and from the backing store).
 //
 // This is a regression test for: http://crbug.com/17855.
 TEST_F(CookieMonsterTest, DontImportDuplicateCookies) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
 
   // We will fill some initial cookies into the PersistentCookieStore,
   // to simulate a database with 4 duplicates.  Note that we need to
   // be careful not to have any duplicate creation times at all (as it's a
   // violation of a CookieMonster invariant) even if Time::Now() doesn't
   // move between calls.
   std::vector<std::unique_ptr<CanonicalCookie>> initial_cookies;
 
   // Insert 4 cookies with name "X" on path "/", with varying creation
   // dates. We expect only the most recent one to be preserved following
   // the import.
 
-  AddCookieToList(GURL("http://www.google.com"),
+  AddCookieToList(GURL("http://www.foo.com"),
                   "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(3), &initial_cookies);
 
-  AddCookieToList(GURL("http://www.google.com"),
+  AddCookieToList(GURL("http://www.foo.com"),
                   "X=2; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(1), &initial_cookies);
 
   // ===> This one is the WINNER (biggest creation time).  <====
-  AddCookieToList(GURL("http://www.google.com"),
+  AddCookieToList(GURL("http://www.foo.com"),
                   "X=3; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(4), &initial_cookies);
 
-  AddCookieToList(GURL("http://www.google.com"),
+  AddCookieToList(GURL("http://www.foo.com"),
                   "X=4; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now(), &initial_cookies);
 
   // Insert 2 cookies with name "X" on path "/2", with varying creation
   // dates. We expect only the most recent one to be preserved the import.
 
   // ===> This one is the WINNER (biggest creation time).  <====
-  AddCookieToList(GURL("http://www.google.com"),
+  AddCookieToList(GURL("http://www.foo.com"),
                   "X=a1; path=/2; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(9), &initial_cookies);
 
-  AddCookieToList(GURL("http://www.google.com"),
+  AddCookieToList(GURL("http://www.foo.com"),
                   "X=a2; path=/2; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(2), &initial_cookies);
 
   // Insert 1 cookie with name "Y" on path "/".
-  AddCookieToList(GURL("http://www.google.com"),
+  AddCookieToList(GURL("http://www.foo.com"),
                   "Y=a; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(10), &initial_cookies);
 
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, std::move(initial_cookies));
 
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   // Verify that duplicates were not imported for path "/".
   // (If this had failed, GetCookies() would have also returned X=1, X=2, X=4).
-  EXPECT_EQ("X=3; Y=a", GetCookies(cm.get(), GURL("http://www.google.com/")));
+  EXPECT_EQ("X=3; Y=a", GetCookies(cm.get(), GURL("http://www.foo.com/")));
 
   // Verify that same-named cookie on a different path ("/x2") didn't get
   // messed up.
   EXPECT_EQ("X=a1; X=3; Y=a",
-            GetCookies(cm.get(), GURL("http://www.google.com/2/x")));
+            GetCookies(cm.get(), GURL("http://www.foo.com/2/x")));
 
   // Verify that the PersistentCookieStore was told to kill its 4 duplicates.
   ASSERT_EQ(4u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[0].type);
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[2].type);
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[3].type);
 }
 
 // Tests importing from a persistent cookie store that contains cookies
 // with duplicate creation times.  This situation should be handled by
 // dropping the cookies before insertion/visibility to user.
 //
 // This is a regression test for: http://crbug.com/43188.
 TEST_F(CookieMonsterTest, DontImportDuplicateCreationTimes) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
 
   Time now(Time::Now());
   Time earlier(now - TimeDelta::FromDays(1));
 
   // Insert 8 cookies, four with the current time as creation times, and
   // four with the earlier time as creation times.  We should only get
   // two cookies remaining, but which two (other than that there should
   // be one from each set) will be random.
   std::vector<std::unique_ptr<CanonicalCookie>> initial_cookies;
-  AddCookieToList(GURL("http://www.google.com"), "X=1; path=/", now,
+  AddCookieToList(GURL("http://www.foo.com"), "X=1; path=/", now,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "X=2; path=/", now,
+  AddCookieToList(GURL("http://www.foo.com"), "X=2; path=/", now,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "X=3; path=/", now,
+  AddCookieToList(GURL("http://www.foo.com"), "X=3; path=/", now,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "X=4; path=/", now,
+  AddCookieToList(GURL("http://www.foo.com"), "X=4; path=/", now,
                   &initial_cookies);
 
-  AddCookieToList(GURL("http://www.google.com"), "Y=1; path=/", earlier,
+  AddCookieToList(GURL("http://www.foo.com"), "Y=1; path=/", earlier,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "Y=2; path=/", earlier,
+  AddCookieToList(GURL("http://www.foo.com"), "Y=2; path=/", earlier,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "Y=3; path=/", earlier,
+  AddCookieToList(GURL("http://www.foo.com"), "Y=3; path=/", earlier,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "Y=4; path=/", earlier,
+  AddCookieToList(GURL("http://www.foo.com"), "Y=4; path=/", earlier,
                   &initial_cookies);
 
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, std::move(initial_cookies));
 
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   CookieList list(GetAllCookies(cm.get()));
   EXPECT_EQ(2U, list.size());
   // Confirm that we have one of each.
   std::string name1(list[0].Name());
   std::string name2(list[1].Name());
   EXPECT_TRUE(name1 == "X" || name2 == "X");
   EXPECT_TRUE(name1 == "Y" || name2 == "Y");
   EXPECT_NE(name1, name2);
 }
 
 TEST_F(CookieMonsterTest, CookieMonsterDelegate) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   scoped_refptr<MockCookieMonsterDelegate> delegate(
       new MockCookieMonsterDelegate);
   std::unique_ptr<CookieMonster> cm(
       new CookieMonster(store.get(), delegate.get()));
 
-  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(SetCookie(cm.get(), http_www_foo_.url(), "A=B"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "C=D"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "E=F"));
+  EXPECT_EQ("A=B; C=D; E=F", GetCookies(cm.get(), http_www_foo_.url()));
   ASSERT_EQ(3u, delegate->changes().size());
   EXPECT_FALSE(delegate->changes()[0].second);
-  EXPECT_EQ(http_www_google_.url().host(),
-            delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_foo_.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(http_www_google_.url().host(),
-            delegate->changes()[1].first.Domain());
+  EXPECT_EQ(http_www_foo_.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(http_www_google_.url().host(),
-            delegate->changes()[2].first.Domain());
+  EXPECT_EQ(http_www_foo_.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(), http_www_google_.url().host(), "C"));
-  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_google_.url()));
+  EXPECT_TRUE(FindAndDeleteCookie(cm.get(), http_www_foo_.url().host(), "C"));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_foo_.url()));
   ASSERT_EQ(1u, delegate->changes().size());
-  EXPECT_EQ(http_www_google_.url().host(),
-            delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_foo_.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(), http_www_google_.url()));
+  EXPECT_EQ("A=B; E=F", GetCookies(cm.get(), http_www_foo_.url()));
   EXPECT_EQ(0u, delegate->changes().size());
 
   // Insert a cookie "a" for path "/path1"
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.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(http_www_google_.url().host(),
-            delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_foo_.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(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_foo_.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(http_www_google_.url().host(),
-            delegate->changes()[0].first.Domain());
+  EXPECT_EQ(http_www_foo_.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(http_www_google_.url().host(),
-            delegate->changes()[1].first.Domain());
+  EXPECT_EQ(http_www_foo_.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, PredicateSeesAllCookies) {
   const std::string kTrueValue = "A";
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   // We test that we can see all cookies with our predicated. This includes
@@ skipping 21 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(), 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(SetCookie(cm.get(), http_www_foo_.url(), "SetCookie1=A"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "SetCookie2=A"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "SetCookie3=A"));
 
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_foo_.url(),
                                    "setCookieWithOptions1=A", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_foo_.url(),
                                    "setCookieWithOptions2=A", options));
-  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookieWithOptions(cm.get(), http_www_foo_.url(),
                                    "setCookieWithOptions3=A", options));
 
   EXPECT_TRUE(SetCookieWithDetails(
-      cm.get(), http_www_google_.url(), "setCookieWithDetails1", "A",
-      http_www_google_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
+      cm.get(), http_www_foo_.url(), "setCookieWithDetails1", "A",
+      http_www_foo_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
       CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(SetCookieWithDetails(
-      cm.get(), http_www_google_.url(), "setCookieWithDetails2", "A",
-      http_www_google_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
+      cm.get(), http_www_foo_.url(), "setCookieWithDetails2", "A",
+      http_www_foo_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
       CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   EXPECT_TRUE(SetCookieWithDetails(
-      cm.get(), http_www_google_.url(), "setCookieWithDetails3", "A",
-      http_www_google_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
+      cm.get(), http_www_foo_.url(), "setCookieWithDetails3", "A",
+      http_www_foo_.Format(".%D"), "/", Time(), Time(), Time(), false, false,
       CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
 
   // Now we check
   CookieList cookie_list(GetAllCookies(cm.get()));
   EXPECT_EQ(9u, cookie_list.size());
   typedef std::map<int64_t, CanonicalCookie> TimeCookieMap;
   TimeCookieMap check_map;
   for (CookieList::const_iterator it = cookie_list.begin();
        it != cookie_list.end(); it++) {
     const int64_t creation_date = it->CreationDate().ToInternalValue();
@@ skipping 11 matching lines @@
     }
   }
 }
 
 // Mainly a test of GetEffectiveDomain, or more specifically, of the
 // expected behavior of GetEffectiveDomain within the CookieMonster.
 TEST_F(CookieMonsterTest, GetKey) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
 
   // This test is really only interesting if GetKey() actually does something.
-  EXPECT_EQ("google.com", cm->GetKey("www.google.com"));
+  EXPECT_EQ("foo.com", cm->GetKey("www.foo.com"));
   EXPECT_EQ("google.izzie", cm->GetKey("www.google.izzie"));
   EXPECT_EQ("google.izzie", cm->GetKey(".google.izzie"));
   EXPECT_EQ("bbc.co.uk", cm->GetKey("bbc.co.uk"));
   EXPECT_EQ("bbc.co.uk", cm->GetKey("a.b.c.d.bbc.co.uk"));
   EXPECT_EQ("apple.com", cm->GetKey("a.b.c.d.apple.com"));
   EXPECT_EQ("apple.izzie", cm->GetKey("a.b.c.d.apple.izzie"));
 
   // Cases where the effective domain is null, so we use the host
   // as the key.
   EXPECT_EQ("co.uk", cm->GetKey("co.uk"));
   const std::string extension_name("iehocdgbbocmkdidlbnnfbmbinnahbae");
   EXPECT_EQ(extension_name, cm->GetKey(extension_name));
   EXPECT_EQ("com", cm->GetKey("com"));
   EXPECT_EQ("hostalias", cm->GetKey("hostalias"));
   EXPECT_EQ("localhost", cm->GetKey("localhost"));
 }
 
 // Test that cookies transfer from/to the backing store correctly.
 TEST_F(CookieMonsterTest, BackingStoreCommunication) {
   // Store details for cookies transforming through the backing store interface.
 
   base::Time current(base::Time::Now());
   scoped_refptr<MockSimplePersistentCookieStore> store(
       new MockSimplePersistentCookieStore);
   base::Time new_access_time;
   base::Time expires(base::Time::Now() + base::TimeDelta::FromSeconds(100));
 
   const CookiesInputInfo input_info[] = {
-      {GURL("http://a.b.google.com"), "a", "1", "", "/path/to/cookie", expires,
+      {GURL("http://a.b.foo.com"), "a", "1", "", "/path/to/cookie", expires,
        false, false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT},
-      {GURL("https://www.google.com"), "b", "2", ".google.com",
-       "/path/from/cookie", expires + TimeDelta::FromSeconds(10), true, true,
+      {GURL("https://www.foo.com"), "b", "2", ".foo.com", "/path/from/cookie",
+       expires + TimeDelta::FromSeconds(10), true, true,
        CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT},
-      {GURL("https://google.com"), "c", "3", "", "/another/path/to/cookie",
+      {GURL("https://foo.com"), "c", "3", "", "/another/path/to/cookie",
        base::Time::Now() + base::TimeDelta::FromSeconds(100), true, false,
        CookieSameSite::STRICT_MODE, COOKIE_PRIORITY_DEFAULT}};
   const int INPUT_DELETE = 1;
 
   // Create new cookies and flush them to the store.
   {
     std::unique_ptr<CookieMonster> cmout(
         new CookieMonster(store.get(), nullptr));
     for (const CookiesInputInfo* p = input_info;
          p < &input_info[arraysize(input_info)]; p++) {
@@ skipping 36 matching lines @@
                 output->ExpiryDate().ToInternalValue());
     }
   }
 }
 
 TEST_F(CookieMonsterTest, CookieListOrdering) {
   // Put a random set of cookies into a monster and make sure
   // they're returned in the right order.
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   EXPECT_TRUE(
-      SetCookie(cm.get(), GURL("http://d.c.b.a.google.com/aa/x.html"), "c=1"));
-  EXPECT_TRUE(SetCookie(cm.get(), GURL("http://b.a.google.com/aa/bb/cc/x.html"),
-                        "d=1; domain=b.a.google.com"));
-  EXPECT_TRUE(SetCookie(cm.get(), GURL("http://b.a.google.com/aa/bb/cc/x.html"),
-                        "a=4; domain=b.a.google.com"));
-  EXPECT_TRUE(SetCookie(cm.get(),
-                        GURL("http://c.b.a.google.com/aa/bb/cc/x.html"),
-                        "e=1; domain=c.b.a.google.com"));
-  EXPECT_TRUE(SetCookie(cm.get(),
-                        GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1"));
+      SetCookie(cm.get(), GURL("http://d.c.b.a.foo.com/aa/x.html"), "c=1"));
+  EXPECT_TRUE(SetCookie(cm.get(), GURL("http://b.a.foo.com/aa/bb/cc/x.html"),
+                        "d=1; domain=b.a.foo.com"));
+  EXPECT_TRUE(SetCookie(cm.get(), GURL("http://b.a.foo.com/aa/bb/cc/x.html"),
+                        "a=4; domain=b.a.foo.com"));
+  EXPECT_TRUE(SetCookie(cm.get(), GURL("http://c.b.a.foo.com/aa/bb/cc/x.html"),
+                        "e=1; domain=c.b.a.foo.com"));
+  EXPECT_TRUE(
+      SetCookie(cm.get(), GURL("http://d.c.b.a.foo.com/aa/bb/x.html"), "b=1"));
   EXPECT_TRUE(SetCookie(cm.get(), GURL("http://news.bbc.co.uk/midpath/x.html"),
                         "g=10"));
   {
     unsigned int i = 0;
     CookieList cookies(GetAllCookiesForURL(
-        cm.get(), GURL("http://d.c.b.a.google.com/aa/bb/cc/dd")));
+        cm.get(), GURL("http://d.c.b.a.foo.com/aa/bb/cc/dd")));
     ASSERT_EQ(5u, cookies.size());
     EXPECT_EQ("d", cookies[i++].Name());
     EXPECT_EQ("a", cookies[i++].Name());
     EXPECT_EQ("e", cookies[i++].Name());
     EXPECT_EQ("b", cookies[i++].Name());
     EXPECT_EQ("c", cookies[i++].Name());
   }
 
   {
     unsigned int i = 0;
@@ skipping 431 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, channel_id_store->flush_count());
 }
 
 TEST_F(CookieMonsterTest, SetAllCookies) {
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
   cm->SetPersistSessionCookies(true);
 
-  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=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "U=V; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "W=X; path=/foo"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "Y=Z; path=/"));
 
   CookieList list;
   list.push_back(CanonicalCookie(
-      "A", "B", "." + http_www_google_.url().host(), "/", base::Time::Now(),
+      "A", "B", "." + http_www_foo_.url().host(), "/", base::Time::Now(),
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   list.push_back(CanonicalCookie(
-      "W", "X", "." + http_www_google_.url().host(), "/bar", base::Time::Now(),
+      "W", "X", "." + http_www_foo_.url().host(), "/bar", base::Time::Now(),
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   list.push_back(CanonicalCookie(
-      "Y", "Z", "." + http_www_google_.url().host(), "/", base::Time::Now(),
+      "Y", "Z", "." + http_www_foo_.url().host(), "/", base::Time::Now(),
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       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 14 matching lines @@
   EXPECT_EQ("Z", it->Value());
 }
 
 TEST_F(CookieMonsterTest, ComputeCookieDiff) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
 
   base::Time now = base::Time::Now();
   base::Time creation_time = now - base::TimeDelta::FromSeconds(1);
 
   std::unique_ptr<CanonicalCookie> cookie1(base::MakeUnique<CanonicalCookie>(
-      "A", "B", "." + http_www_google_.url().host(), "/", creation_time,
+      "A", "B", "." + http_www_foo_.url().host(), "/", creation_time,
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie2(base::MakeUnique<CanonicalCookie>(
-      "C", "D", "." + http_www_google_.url().host(), "/", creation_time,
+      "C", "D", "." + http_www_foo_.url().host(), "/", creation_time,
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie3(base::MakeUnique<CanonicalCookie>(
-      "E", "F", "." + http_www_google_.url().host(), "/", creation_time,
+      "E", "F", "." + http_www_foo_.url().host(), "/", creation_time,
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie4(base::MakeUnique<CanonicalCookie>(
-      "G", "H", "." + http_www_google_.url().host(), "/", creation_time,
+      "G", "H", "." + http_www_foo_.url().host(), "/", creation_time,
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie4_with_new_value(
       base::MakeUnique<CanonicalCookie>(
-          "G", "iamnew", "." + http_www_google_.url().host(), "/",
-          creation_time, base::Time(), base::Time(), false, false,
+          "G", "iamnew", "." + http_www_foo_.url().host(), "/", creation_time,
+          base::Time(), base::Time(), false, false,
           CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie5(base::MakeUnique<CanonicalCookie>(
-      "I", "J", "." + http_www_google_.url().host(), "/", creation_time,
+      "I", "J", "." + http_www_foo_.url().host(), "/", creation_time,
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie5_with_new_creation_time(
       base::MakeUnique<CanonicalCookie>(
-          "I", "J", "." + http_www_google_.url().host(), "/", now, base::Time(),
+          "I", "J", "." + http_www_foo_.url().host(), "/", now, base::Time(),
           base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
           COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie6(base::MakeUnique<CanonicalCookie>(
-      "K", "L", "." + http_www_google_.url().host(), "/foo", creation_time,
+      "K", "L", "." + http_www_foo_.url().host(), "/foo", creation_time,
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie6_with_new_path(
       base::MakeUnique<CanonicalCookie>(
-          "K", "L", "." + http_www_google_.url().host(), "/bar", creation_time,
+          "K", "L", "." + http_www_foo_.url().host(), "/bar", creation_time,
           base::Time(), base::Time(), false, false,
           CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie7(base::MakeUnique<CanonicalCookie>(
-      "M", "N", "." + http_www_google_.url().host(), "/foo", creation_time,
+      "M", "N", "." + http_www_foo_.url().host(), "/foo", creation_time,
       base::Time(), base::Time(), false, false, CookieSameSite::DEFAULT_MODE,
       COOKIE_PRIORITY_DEFAULT));
   std::unique_ptr<CanonicalCookie> cookie7_with_new_path(
       base::MakeUnique<CanonicalCookie>(
-          "M", "N", "." + http_www_google_.url().host(), "/bar", creation_time,
+          "M", "N", "." + http_www_foo_.url().host(), "/bar", creation_time,
           base::Time(), base::Time(), false, false,
           CookieSameSite::DEFAULT_MODE, 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);
@@ skipping 54 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());
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
   cm->SetPersistSessionCookies(true);
 
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "X=Y; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.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) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   // 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);
 
   std::unique_ptr<base::HistogramSamples> samples1(
       expired_histogram->SnapshotSamples());
   ASSERT_TRUE(SetCookieWithDetails(
       cm.get(), GURL("http://fake.a.url"), "a", "b", "a.url", "/", base::Time(),
       base::Time::Now() + base::TimeDelta::FromMinutes(59), base::Time(), false,
       false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT));
 
   std::unique_ptr<base::HistogramSamples> samples2(
       expired_histogram->SnapshotSamples());
   EXPECT_EQ(samples1->TotalCount() + 1, samples2->TotalCount());
 
   // kValidCookieLine creates a session cookie.
-  ASSERT_TRUE(SetCookie(cm.get(), http_www_google_.url(), kValidCookieLine));
+  ASSERT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), kValidCookieLine));
 
   std::unique_ptr<base::HistogramSamples> samples3(
       expired_histogram->SnapshotSamples());
   EXPECT_EQ(samples2->TotalCount(), samples3->TotalCount());
 }
 
 TEST_F(CookieMonsterTest, InvalidExpiryTime) {
   std::string cookie_line =
       std::string(kValidCookieLine) + "; expires=Blarg arg arg";
   std::unique_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(
-      http_www_google_.url(), cookie_line, Time::Now(), CookieOptions()));
+      http_www_foo_.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);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
   cm->SetPersistSessionCookies(true);
 
   // All cookies set with SetCookie are session cookies.
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
-  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=B"));
+  EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_foo_.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(), http_www_google_.url(), "A=C"));
-  EXPECT_EQ("A=C", GetCookies(cm.get(), http_www_google_.url()));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=C"));
+  EXPECT_EQ("A=C", GetCookies(cm.get(), http_www_foo_.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(), http_www_google_.url(), "A");
-  EXPECT_EQ("", GetCookies(cm.get(), http_www_google_.url()));
+  DeleteCookie(cm.get(), http_www_foo_.url(), "A");
+  EXPECT_EQ("", GetCookies(cm.get(), http_www_foo_.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);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(),
                         "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm.get(), http_www_google_.url()));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), http_www_foo_.url()));
   ASSERT_EQ(1u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type);
   // Remove it.
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B; max-age=0"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "A=B; max-age=0"));
   this->MatchCookieLines(std::string(),
-                         GetCookies(cm.get(), http_www_google_.url()));
+                         GetCookies(cm.get(), http_www_foo_.url()));
   ASSERT_EQ(2u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type);
 
   // Add a cookie.
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(),
                         "A=B; expires=Mon, 18-Apr-22 22:50:13 GMT"));
-  this->MatchCookieLines("A=B", GetCookies(cm.get(), http_www_google_.url()));
+  this->MatchCookieLines("A=B", GetCookies(cm.get(), http_www_foo_.url()));
   ASSERT_EQ(3u, store->commands().size());
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[2].type);
   // Overwrite it.
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(),
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(),
                         "A=Foo; expires=Mon, 18-Apr-22 22:50:14 GMT"));
-  this->MatchCookieLines("A=Foo", GetCookies(cm.get(), http_www_google_.url()));
+  this->MatchCookieLines("A=Foo", GetCookies(cm.get(), http_www_foo_.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(), http_www_google_.url(), "B=Bar"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "B=Bar"));
   this->MatchCookieLines("A=Foo; B=Bar",
-                         GetCookies(cm.get(), http_www_google_.url()));
+                         GetCookies(cm.get(), http_www_foo_.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);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   histograms.ExpectTotalCount(cookie_source_histogram, 0);
 
   // Set a secure cookie on a cryptographic scheme.
-  EXPECT_TRUE(
-      SetCookie(cm.get(), https_www_google_.url(), "A=B; path=/; Secure"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.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(), https_www_google_.url(), "C=D; path=/;"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.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_FALSE(
-      SetCookie(cm.get(), http_www_google_.url(), "D=E; path=/; Secure"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_www_foo_.url(), "D=E; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 2);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_SECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME, 0);
 
   // Overwrite a secure cookie (set by a cryptographic scheme) on a
   // non-cryptographic scheme.
-  EXPECT_FALSE(
-      SetCookie(cm.get(), http_www_google_.url(), "A=B; path=/; Secure"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_www_foo_.url(), "A=B; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 2);
   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, 0);
 
   // Test that attempting to clear a secure cookie on a http:// URL does
   // nothing.
-  EXPECT_TRUE(
-      SetCookie(cm.get(), https_www_google_.url(), "F=G; path=/; Secure"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.url(), "F=G; path=/; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 3);
-  std::string cookies1 = GetCookies(cm.get(), https_www_google_.url());
+  std::string cookies1 = GetCookies(cm.get(), https_www_foo_.url());
   EXPECT_NE(std::string::npos, cookies1.find("F=G"));
-  EXPECT_FALSE(SetCookie(cm.get(), http_www_google_.url(),
+  EXPECT_FALSE(SetCookie(cm.get(), http_www_foo_.url(),
                          "F=G; path=/; Expires=Thu, 01-Jan-1970 00:00:01 GMT"));
-  std::string cookies2 = GetCookies(cm.get(), https_www_google_.url());
+  std::string cookies2 = GetCookies(cm.get(), https_www_foo_.url());
   EXPECT_NE(std::string::npos, cookies2.find("F=G"));
   histograms.ExpectTotalCount(cookie_source_histogram, 3);
 
   // Set a non-secure cookie on a non-cryptographic scheme.
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "H=I; path=/"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "H=I; path=/"));
   histograms.ExpectTotalCount(cookie_source_histogram, 4);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_SOURCE_NONSECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME, 1);
 }
 
 // Test that cookie delete equivalent histograms are recorded correctly.
 TEST_F(CookieMonsterTest, CookieDeleteEquivalentHistogramTest) {
   base::HistogramTester histograms;
   const std::string cookie_source_histogram = "Cookie.CookieDeleteEquivalent";
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
   // Set a secure cookie from a secure origin
-  EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(), "A=B; Secure"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.url(), "A=B; Secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 1);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                1);
 
   // Set a new cookie with a different name from a variety of origins (including
   // the same one).
-  EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(), "B=A;"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.url(), "B=A;"));
   histograms.ExpectTotalCount(cookie_source_histogram, 2);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                2);
-  EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "C=A;"));
+  EXPECT_TRUE(SetCookie(cm.get(), http_www_foo_.url(), "C=A;"));
   histograms.ExpectTotalCount(cookie_source_histogram, 3);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                3);
 
   // Set a non-secure cookie from an insecure origin that matches the name of an
   // already existing cookie and additionally is equivalent to the existing
   // cookie. This should fail since it's trying to overwrite a secure cookie.
-  EXPECT_FALSE(SetCookie(cm.get(), http_www_google_.url(), "A=B;"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_www_foo_.url(), "A=B;"));
   histograms.ExpectTotalCount(cookie_source_histogram, 6);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                4);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_FOUND,
                                0);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_DELETE_EQUIVALENT_SKIPPING_SECURE, 1);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_DELETE_EQUIVALENT_WOULD_HAVE_DELETED, 1);
 
   // Set a non-secure cookie from an insecure origin that matches the name of an
   // already existing cookie but is not equivalent. This should fail since it's
   // trying to shadow a secure cookie.
   EXPECT_FALSE(
-      SetCookie(cm.get(), http_www_google_.url(), "A=C; path=/some/path"));
+      SetCookie(cm.get(), http_www_foo_.url(), "A=C; path=/some/path"));
   histograms.ExpectTotalCount(cookie_source_histogram, 8);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                5);
   histograms.ExpectBucketCount(
       cookie_source_histogram,
       CookieMonster::COOKIE_DELETE_EQUIVALENT_SKIPPING_SECURE, 2);
 
   // Set a secure cookie from a secure origin that matches the name of an
   // already existing cookies and is equivalent.
-  EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(), "A=D; secure"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.url(), "A=D; secure"));
   histograms.ExpectTotalCount(cookie_source_histogram, 10);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                6);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_FOUND,
                                1);
 
   // Set a secure cookie from a secure origin that matches the name of an
   // already existing cookie and is not equivalent.
-  EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.url(),
+  EXPECT_TRUE(SetCookie(cm.get(), https_www_foo_.url(),
                         "A=E; secure; path=/some/other/path"));
   histograms.ExpectTotalCount(cookie_source_histogram, 11);
   histograms.ExpectBucketCount(cookie_source_histogram,
                                CookieMonster::COOKIE_DELETE_EQUIVALENT_ATTEMPT,
                                7);
 }
 
 TEST_F(CookieMonsterTest, SetSecureCookies) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
-  GURL http_url("http://www.google.com");
-  GURL http_superdomain_url("http://google.com");
-  GURL https_url("https://www.google.com");
+  GURL http_url("http://www.foo.com");
+  GURL http_superdomain_url("http://foo.com");
+  GURL https_url("https://www.foo.com");
 
   // A non-secure cookie can be created from either a URL with a secure or
   // insecure scheme.
   EXPECT_TRUE(SetCookie(cm.get(), http_url, "A=C;"));
   EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=B;"));
 
   // A secure cookie cannot be created from a URL with an insecure scheme.
   EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=B; Secure"));
 
   // A secure cookie can be created from a URL with a secure scheme.
@@ skipping 27 matching lines @@
   EXPECT_TRUE(SetCookie(cm.get(), http_url, "WITH_PATH=C"));
   EXPECT_TRUE(SetCookie(cm.get(), http_url, "WITH_PATH=C; path=/"));
   EXPECT_TRUE(SetCookie(cm.get(), http_url, "WITH_PATH=C; path=/your/path"));
   EXPECT_FALSE(SetCookie(cm.get(), http_url, "WITH_PATH=C; path=/my/path"));
   EXPECT_FALSE(SetCookie(cm.get(), http_url, "WITH_PATH=C; path=/my/path/sub"));
 
   // If a non-secure cookie is created from a URL with an insecure scheme, and
   // a secure cookie with the same name already exists, if the domain strings
   // domain-match, do not update the cookie.
   EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=B; Secure"));
-  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=C; domain=google.com"));
-  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=C; domain=www.google.com"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=C; domain=foo.com"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=C; domain=www.foo.com"));
 
   // Since A=B was set above with no domain string, set a different cookie here
   // so the insecure examples aren't trying to overwrite the one above.
-  EXPECT_TRUE(SetCookie(cm.get(), https_url, "B=C; Secure; domain=google.com"));
-  EXPECT_FALSE(SetCookie(cm.get(), http_url, "B=D; domain=google.com"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_url, "B=C; Secure; domain=foo.com"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_url, "B=D; domain=foo.com"));
   EXPECT_FALSE(SetCookie(cm.get(), http_url, "B=D"));
   EXPECT_FALSE(SetCookie(cm.get(), http_superdomain_url, "B=D"));
 
   // Verify that if an httponly version of the cookie exists, adding a Secure
   // version of the cookie still does not overwrite it.
   CookieOptions include_httponly;
   include_httponly.set_include_httponly();
   EXPECT_TRUE(SetCookieWithOptions(cm.get(), https_url, "C=D; httponly",
                                    include_httponly));
   // Note that the lack of an explicit options object below uses the default,
@@ skipping 126 matching lines @@
   const CookiesEntry test14[] = {{1U, true}};
   const AltHosts test14_alt_hosts(1500, 1800);
   TestSecureCookieEviction(test14, arraysize(test14), 1501U, 1499,
                            &test14_alt_hosts);
 }
 
 // Tests that strict secure cookies doesn't trip equivalent cookie checks
 // accidentally. Regression test for https://crbug.com/569943.
 TEST_F(CookieMonsterTest, EquivalentCookies) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
-  GURL http_url("http://www.google.com");
-  GURL http_superdomain_url("http://google.com");
-  GURL https_url("https://www.google.com");
+  GURL http_url("http://www.foo.com");
+  GURL http_superdomain_url("http://foo.com");
+  GURL https_url("https://www.foo.com");
 
   // Tests that non-equivalent cookies because of the path attribute can be set
   // successfully.
   EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=B; Secure"));
   EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=C; path=/some/other/path"));
   EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=D; path=/some/other/path"));
 
   // Tests that non-equivalent cookies because of the domain attribute can be
   // set successfully.
   EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=B; Secure"));
-  EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=C; domain=google.com"));
-  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=D; domain=google.com"));
+  EXPECT_TRUE(SetCookie(cm.get(), https_url, "A=C; domain=foo.com"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=D; domain=foo.com"));
 }
 
 class CookieMonsterNotificationTest : public CookieMonsterTest {
  public:
   CookieMonsterNotificationTest()
-      : test_url_("http://www.google.com/foo"),
+      : test_url_("http://www.foo.com/foo"),
         store_(new MockPersistentCookieStore),
         monster_(new CookieMonster(store_.get(), nullptr)) {}
 
   ~CookieMonsterNotificationTest() override {}
 
   CookieMonster* monster() { return monster_.get(); }
 
  protected:
   const GURL test_url_;
 
@@ skipping 133 matching lines @@
       monster()->AddCallbackForCookie(
           test_url_, "abc",
           base::Bind(&RecordCookieChanges, &cookies1, nullptr)));
   SetCookie(monster(), test_url_, "abc=def");
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1U, cookies0.size());
   EXPECT_EQ(1U, cookies0.size());
 }
 
 }  // namespace net