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 1726 matching lines @@
   // 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.google.izzle"),
                   "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.google.izzle"),
                   "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.google.izzle"),
                   "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.google.izzle"),
                   "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.google.izzle"),
                   "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.google.izzle"),
                   "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.google.izzle"),
                   "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.google.izzle/")));
 
   // 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.google.izzle/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.google.izzle"), "X=1; path=/", now,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "X=2; path=/", now,
+  AddCookieToList(GURL("http://www.google.izzle"), "X=2; path=/", now,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "X=3; path=/", now,
+  AddCookieToList(GURL("http://www.google.izzle"), "X=3; path=/", now,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "X=4; path=/", now,
+  AddCookieToList(GURL("http://www.google.izzle"), "X=4; path=/", now,
                   &initial_cookies);
 
-  AddCookieToList(GURL("http://www.google.com"), "Y=1; path=/", earlier,
+  AddCookieToList(GURL("http://www.google.izzle"), "Y=1; path=/", earlier,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "Y=2; path=/", earlier,
+  AddCookieToList(GURL("http://www.google.izzle"), "Y=2; path=/", earlier,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "Y=3; path=/", earlier,
+  AddCookieToList(GURL("http://www.google.izzle"), "Y=3; path=/", earlier,
                   &initial_cookies);
-  AddCookieToList(GURL("http://www.google.com"), "Y=4; path=/", earlier,
+  AddCookieToList(GURL("http://www.google.izzle"), "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.
@@ skipping 168 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("google.izzle", cm->GetKey("www.google.izzle"));
   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,
-       false, false, CookieSameSite::DEFAULT_MODE, COOKIE_PRIORITY_DEFAULT},
-      {GURL("https://www.google.com"), "b", "2", ".google.com",
+      {GURL("http://a.b.google.izzle"), "a", "1", "", "/path/to/cookie",
+       expires, false, false, CookieSameSite::DEFAULT_MODE,
+       COOKIE_PRIORITY_DEFAULT},
+      {GURL("https://www.google.izzle"), "b", "2", ".google.izzle",
        "/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://google.izzle"), "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 35 matching lines @@
       EXPECT_EQ(input->expiration_time.ToInternalValue(),
                 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://d.c.b.a.google.izzle/aa/x.html"),
+                        "c=1"));
   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"));
+                        GURL("http://b.a.google.izzle/aa/bb/cc/x.html"),
+                        "d=1; domain=b.a.google.izzle"));
   EXPECT_TRUE(SetCookie(cm.get(),
-                        GURL("http://d.c.b.a.google.com/aa/bb/x.html"), "b=1"));
+                        GURL("http://b.a.google.izzle/aa/bb/cc/x.html"),
+                        "a=4; domain=b.a.google.izzle"));
+  EXPECT_TRUE(SetCookie(cm.get(),
+                        GURL("http://c.b.a.google.izzle/aa/bb/cc/x.html"),
+                        "e=1; domain=c.b.a.google.izzle"));
+  EXPECT_TRUE(SetCookie(
+      cm.get(), GURL("http://d.c.b.a.google.izzle/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.google.izzle/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 904 matching lines @@
   EXPECT_TRUE(SetCookie(cm.get(), https_www_google_.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.google.izzle");
+  GURL http_superdomain_url("http://google.izzle");
+  GURL https_url("https://www.google.izzle");
 
   // 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=google.izzle"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=C; domain=www.google.izzle"));
 
   // 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=google.izzle"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_url, "B=D; domain=google.izzle"));
   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.google.izzle");
+  GURL http_superdomain_url("http://google.izzle");
+  GURL https_url("https://www.google.izzle");
 
   // 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=google.izzle"));
+  EXPECT_FALSE(SetCookie(cm.get(), http_url, "A=D; domain=google.izzle"));
 }
 
 class CookieMonsterNotificationTest : public CookieMonsterTest {
  public:
   CookieMonsterNotificationTest()
-      : test_url_("http://www.google.com/foo"),
+      : test_url_("http://www.google.izzle/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