BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

1 files changed, 269 insertions, 180 deletions

diff --git a/chromium/net/cookies/cookie_monster_unittest.cc b/chromium/net/cookies/cookie_monster_unittest.cc
index 82877bcb54b..fc83d6a6211 100644
--- a/chromium/net/cookies/cookie_monster_unittest.cc
+++ b/chromium/net/cookies/cookie_monster_unittest.cc
@@ -135,7 +135,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
     return callback.cookies();
   }
 
-  CookieStatusList GetExcludedCookiesForURLWithOptions(
+  CookieAccessResultList GetExcludedCookiesForURLWithOptions(
       CookieMonster* cm,
       const GURL& url,
       const CookieOptions& options) {
@@ -148,7 +148,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
 
   bool SetAllCookies(CookieMonster* cm, const CookieList& list) {
     DCHECK(cm);
-    ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> callback;
+    ResultSavingCookieCallback<CookieInclusionStatus> callback;
     cm->SetAllCookiesAsync(list, callback.MakeCallback());
     callback.WaitUntilDone();
     return callback.result().IsInclude();
@@ -160,7 +160,7 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
                                  base::Time creation_time) {
     DCHECK(cm);
     DCHECK(!creation_time.is_null());
-    ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> callback;
+    ResultSavingCookieCallback<CookieInclusionStatus> callback;
     cm->SetCanonicalCookieAsync(
         CanonicalCookie::Create(url, cookie_line, creation_time,
                                 base::nullopt /* server_time */),
@@ -310,10 +310,10 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
   }
 
   void TestHostGarbageCollectHelper() {
+    const char kHistogramName[] = "Cookie.NumDomainPurgedKeys";
     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;
+    const int more_than_enough_cookies = domain_max_cookies + 10;
     // Add a bunch of cookies on a single host, should purge them.
     {
       auto cm = std::make_unique<CookieMonster>(nullptr, &net_log_);
@@ -326,6 +326,10 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
         // Count the number of cookies.
         EXPECT_LE(CountInString(cookies, '='), domain_max_cookies);
       }
+      base::HistogramTester histogram_tester;
+      EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+      histogram_tester.ExpectUniqueSample(kHistogramName, 1 /* sample */,
+                                          1 /* count */);
     }
 
     // Add a bunch of cookies on multiple hosts within a single eTLD.
@@ -359,6 +363,51 @@ class CookieMonsterTestBase : public CookieStoreTest<T> {
                            CountInString(cookies_specific, '='));
       EXPECT_GE(total_cookies, domain_max_cookies - domain_purge_cookies);
       EXPECT_LE(total_cookies, domain_max_cookies);
+
+      base::HistogramTester histogram_tester;
+      EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+      histogram_tester.ExpectUniqueSample(kHistogramName, 1 /* sample */,
+                                          1 /* count */);
+    }
+
+    // Test histogram for the number of registrable domains affected by domain
+    // purge.
+    {
+      auto cm = std::make_unique<CookieMonster>(nullptr, &net_log_);
+      GURL url;
+      for (int domain_num = 0; domain_num < 3; ++domain_num) {
+        url = GURL(base::StringPrintf("http://domain%d.test", domain_num));
+        for (int i = 0; i < more_than_enough_cookies; ++i) {
+          std::string cookie = base::StringPrintf("a%03d=b", i);
+          EXPECT_TRUE(SetCookie(cm.get(), url, cookie));
+          std::string cookies = this->GetCookies(cm.get(), 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);
+        }
+        base::HistogramTester histogram_tester;
+        EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+        histogram_tester.ExpectUniqueSample(
+            kHistogramName, domain_num + 1 /* sample */, 1 /* count */);
+      }
+
+      // Triggering eviction again for a previously affected registrable domain
+      // does not increment the histogram.
+      for (int i = 0; i < domain_purge_cookies * 2; ++i) {
+        // Add some extra cookies (different names than before).
+        std::string cookie = base::StringPrintf("b%03d=b", i);
+        EXPECT_TRUE(SetCookie(cm.get(), url, cookie));
+        std::string cookies = this->GetCookies(cm.get(), 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);
+      }
+      base::HistogramTester histogram_tester;
+      EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+      histogram_tester.ExpectUniqueSample(kHistogramName, 3 /* sample */,
+                                          1 /* count */);
     }
   }
 
@@ -932,7 +981,7 @@ TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
   // Generate puts to store w/o needing a proper expiration.
   cookie_monster_->SetPersistSessionCookies(true);
 
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> call1;
+  ResultSavingCookieCallback<CookieInclusionStatus> call1;
   cookie_monster_->SetCanonicalCookieAsync(
       CanonicalCookie::Create(http_www_foo_.url(), "A=B", base::Time::Now(),
                               base::nullopt /* server_time */),
@@ -946,7 +995,7 @@ TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
   EXPECT_TRUE(call1.result().IsInclude());
   EXPECT_EQ("LOAD; LOAD_FOR_KEY:foo.com; ADD; ", TakeCommandSummary());
 
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> call2;
+  ResultSavingCookieCallback<CookieInclusionStatus> call2;
   cookie_monster_->SetCanonicalCookieAsync(
       CanonicalCookie::Create(http_www_foo_.url(), "X=Y", base::Time::Now(),
                               base::nullopt /* server_time */),
@@ -971,7 +1020,7 @@ TEST_F(DeferredCookieTaskTest, DeferredSetAllCookies) {
                                  false, true, CookieSameSite::NO_RESTRICTION,
                                  COOKIE_PRIORITY_DEFAULT));
 
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> call1;
+  ResultSavingCookieCallback<CookieInclusionStatus> call1;
   cookie_monster_->SetAllCookiesAsync(list, call1.MakeCallback());
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(call1.was_run());
@@ -982,7 +1031,7 @@ TEST_F(DeferredCookieTaskTest, DeferredSetAllCookies) {
   EXPECT_EQ("LOAD; ADD; ADD; ", TakeCommandSummary());
 
   // 2nd set doesn't need to read from store. It erases the old cookies, though.
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> call2;
+  ResultSavingCookieCallback<CookieInclusionStatus> call2;
   cookie_monster_->SetAllCookiesAsync(list, call2.MakeCallback());
   ASSERT_TRUE(call2.was_run());
   EXPECT_TRUE(call2.result().IsInclude());
@@ -1183,30 +1232,30 @@ TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
 
   bool get_cookie_list_callback_was_run = false;
   GetCookieListCallback get_cookie_list_callback_deferred;
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus>
-      set_cookies_callback;
+  ResultSavingCookieCallback<CookieInclusionStatus> set_cookies_callback;
   base::RunLoop run_loop;
   cookie_monster_->GetCookieListWithOptionsAsync(
       http_www_foo_.url(), CookieOptions::MakeAllInclusive(),
-      base::BindLambdaForTesting([&](const CookieStatusList& cookies,
-                                     const CookieStatusList& excluded_list) {
-        // This should complete before the set.
-        get_cookie_list_callback_was_run = true;
-        EXPECT_FALSE(set_cookies_callback.was_run());
-        EXPECT_THAT(cookies, MatchesCookieLine("X=1"));
-        // Can't use TakeCommandSummary here since ExecuteLoads is walking
-        // through the data it takes.
-        EXPECT_EQ("LOAD; LOAD_FOR_KEY:foo.com; ",
-                  CommandSummary(persistent_store_->commands()));
-
-        // Queue up a second get. It should see the result of the set queued
-        // before it.
-        cookie_monster_->GetCookieListWithOptionsAsync(
-            http_www_foo_.url(), CookieOptions::MakeAllInclusive(),
-            get_cookie_list_callback_deferred.MakeCallback());
-
-        run_loop.Quit();
-      }));
+      base::BindLambdaForTesting(
+          [&](const CookieAccessResultList& cookies,
+              const CookieAccessResultList& excluded_list) {
+            // This should complete before the set.
+            get_cookie_list_callback_was_run = true;
+            EXPECT_FALSE(set_cookies_callback.was_run());
+            EXPECT_THAT(cookies, MatchesCookieLine("X=1"));
+            // Can't use TakeCommandSummary here since ExecuteLoads is walking
+            // through the data it takes.
+            EXPECT_EQ("LOAD; LOAD_FOR_KEY:foo.com; ",
+                      CommandSummary(persistent_store_->commands()));
+
+            // Queue up a second get. It should see the result of the set queued
+            // before it.
+            cookie_monster_->GetCookieListWithOptionsAsync(
+                http_www_foo_.url(), CookieOptions::MakeAllInclusive(),
+                get_cookie_list_callback_deferred.MakeCallback());
+
+            run_loop.Quit();
+          }));
 
   cookie_monster_->SetCanonicalCookieAsync(
       CanonicalCookie::Create(http_www_foo_.url(), "A=B", base::Time::Now(),
@@ -1446,15 +1495,13 @@ TEST_F(CookieMonsterTest, SetCookieableSchemes) {
 
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), foo_url, "x=1")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_NONCOOKIEABLE_SCHEME}));
+                      {CookieInclusionStatus::EXCLUDE_NONCOOKIEABLE_SCHEME}));
   EXPECT_TRUE(SetCanonicalCookieReturnStatus(
                   cm.get(),
                   CanonicalCookie::Create(foo_url, "y=1", now, server_time),
                   foo_url, false /*modify_httponly*/)
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_NONCOOKIEABLE_SCHEME}));
+                      {CookieInclusionStatus::EXCLUDE_NONCOOKIEABLE_SCHEME}));
 
   EXPECT_TRUE(
       CreateAndSetCookieReturnStatus(cm_foo.get(), foo_url, "x=1").IsInclude());
@@ -1466,15 +1513,13 @@ TEST_F(CookieMonsterTest, SetCookieableSchemes) {
 
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm_foo.get(), http_url, "x=1")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_NONCOOKIEABLE_SCHEME}));
+                      {CookieInclusionStatus::EXCLUDE_NONCOOKIEABLE_SCHEME}));
   EXPECT_TRUE(SetCanonicalCookieReturnStatus(
                   cm_foo.get(),
                   CanonicalCookie::Create(http_url, "y=1", now, server_time),
                   http_url, false /*modify_httponly*/)
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_NONCOOKIEABLE_SCHEME}));
+                      {CookieInclusionStatus::EXCLUDE_NONCOOKIEABLE_SCHEME}));
 }
 
 TEST_F(CookieMonsterTest, GetAllCookiesForURL) {
@@ -1573,7 +1618,7 @@ TEST_F(CookieMonsterTest, GetExcludedCookiesForURL) {
   CookieOptions do_not_return_excluded;
   do_not_return_excluded.unset_return_excluded_cookies();
 
-  CookieStatusList excluded_cookies = GetExcludedCookiesForURLWithOptions(
+  CookieAccessResultList excluded_cookies = GetExcludedCookiesForURLWithOptions(
       cm.get(), http_www_foo_.url(), do_not_return_excluded);
   auto iter = excluded_cookies.begin();
 
@@ -1587,8 +1632,8 @@ TEST_F(CookieMonsterTest, GetExcludedCookiesForURL) {
   ASSERT_TRUE(iter != excluded_cookies.end());
   EXPECT_EQ(http_www_foo_.Format(".%D"), iter->cookie.Domain());
   EXPECT_EQ("E", iter->cookie.Name());
-  EXPECT_TRUE(iter->status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
+  EXPECT_TRUE(iter->access_result.status.HasExactlyExclusionReasonsForTesting(
+      {CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
 
   ASSERT_TRUE(++iter == excluded_cookies.end());
 
@@ -1607,14 +1652,14 @@ TEST_F(CookieMonsterTest, GetExcludedCookiesForURL) {
   ASSERT_TRUE(iter != excluded_cookies.end());
   EXPECT_EQ(http_www_foo_.host(), iter->cookie.Domain());
   EXPECT_EQ("A", iter->cookie.Name());
-  EXPECT_TRUE(iter->status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_HTTP_ONLY}));
+  EXPECT_TRUE(iter->access_result.status.HasExactlyExclusionReasonsForTesting(
+      {CookieInclusionStatus::EXCLUDE_HTTP_ONLY}));
 
   ASSERT_TRUE(++iter != excluded_cookies.end());
   EXPECT_EQ(http_www_foo_.Format(".%D"), iter->cookie.Domain());
   EXPECT_EQ("E", iter->cookie.Name());
-  EXPECT_TRUE(iter->status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
+  EXPECT_TRUE(iter->access_result.status.HasExactlyExclusionReasonsForTesting(
+      {CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
 
   ASSERT_TRUE(++iter == excluded_cookies.end());
 
@@ -1674,15 +1719,15 @@ TEST_F(CookieMonsterTest, GetExcludedCookiesForURLPathMatching) {
   EXPECT_TRUE(
       CreateAndSetCookie(cm.get(), http_www_foo_.url(), "E=F;", options));
 
-  CookieStatusList excluded_cookies =
+  CookieAccessResultList excluded_cookies =
       GetExcludedCookiesForURL(cm.get(), www_foo_foo_.url());
   auto it = excluded_cookies.begin();
 
   ASSERT_TRUE(it != excluded_cookies.end());
   EXPECT_EQ("C", it->cookie.Name());
   EXPECT_EQ("/bar", it->cookie.Path());
-  EXPECT_TRUE(it->status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_NOT_ON_PATH}));
+  EXPECT_TRUE(it->access_result.status.HasExactlyExclusionReasonsForTesting(
+      {CookieInclusionStatus::EXCLUDE_NOT_ON_PATH}));
 
   ASSERT_TRUE(++it == excluded_cookies.end());
 
@@ -1692,8 +1737,8 @@ TEST_F(CookieMonsterTest, GetExcludedCookiesForURLPathMatching) {
   ASSERT_TRUE(it != excluded_cookies.end());
   EXPECT_EQ("A", it->cookie.Name());
   EXPECT_EQ("/foo", it->cookie.Path());
-  EXPECT_TRUE(it->status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_NOT_ON_PATH}));
+  EXPECT_TRUE(it->access_result.status.HasExactlyExclusionReasonsForTesting(
+      {CookieInclusionStatus::EXCLUDE_NOT_ON_PATH}));
 
   ASSERT_TRUE(++it == excluded_cookies.end());
 }
@@ -2189,8 +2234,7 @@ TEST_F(CookieMonsterTest, WhileLoadingLoadCompletesBeforeKeyLoadCompletes) {
 
   auto cookie = CanonicalCookie::Create(kUrl, "a=b", base::Time::Now(),
                                         base::nullopt /* server_time */);
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus>
-      set_cookie_callback;
+  ResultSavingCookieCallback<CookieInclusionStatus> set_cookie_callback;
   cm->SetCanonicalCookieAsync(std::move(cookie), kUrl,
                               CookieOptions::MakeAllInclusive(),
                               set_cookie_callback.MakeCallback());
@@ -2278,8 +2322,7 @@ TEST_F(CookieMonsterTest, WhileLoadingGetAllSetGetAll) {
 
   auto cookie = CanonicalCookie::Create(kUrl, "a=b", base::Time::Now(),
                                         base::nullopt /* server_time */);
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus>
-      set_cookie_callback;
+  ResultSavingCookieCallback<CookieInclusionStatus> set_cookie_callback;
   cm->SetCanonicalCookieAsync(std::move(cookie), kUrl,
                               CookieOptions::MakeAllInclusive(),
                               set_cookie_callback.MakeCallback());
@@ -2326,8 +2369,7 @@ TEST_F(CookieMonsterTest, CheckOrderOfCookieTaskQueueWhenLoadingCompletes) {
   // Get all cookies task that queues a task to set a cookie when executed.
   auto cookie = CanonicalCookie::Create(kUrl, "a=b", base::Time::Now(),
                                         base::nullopt /* server_time */);
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus>
-      set_cookie_callback;
+  ResultSavingCookieCallback<CookieInclusionStatus> set_cookie_callback;
   cm->GetAllCookiesAsync(base::BindOnce(
       &RunClosureOnAllCookiesReceived,
       base::BindOnce(&CookieStore::SetCanonicalCookieAsync,
@@ -2720,6 +2762,95 @@ TEST_F(CookieMonsterTest, CookieSourceHistogram) {
       CookieMonster::COOKIE_SOURCE_NONSECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME, 1);
 }
 
+// Test that inserting the first cookie for a key and deleting the last cookie
+// for a key correctly reflected in the Cookie.NumKeys histogram.
+TEST_F(CookieMonsterTest, NumKeysHistogram) {
+  const char kHistogramName[] = "Cookie.NumKeys";
+
+  // Test loading cookies from store.
+  scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
+  std::vector<std::unique_ptr<CanonicalCookie>> initial_cookies;
+  initial_cookies.push_back(CanonicalCookie::Create(
+      GURL("http://domain1.test"), "A=1", base::Time::Now(), base::nullopt));
+  initial_cookies.push_back(CanonicalCookie::Create(
+      GURL("http://domain2.test"), "A=1", base::Time::Now(), base::nullopt));
+  initial_cookies.push_back(
+      CanonicalCookie::Create(GURL("http://sub.domain2.test"), "A=1",
+                              base::Time::Now(), base::nullopt));
+  initial_cookies.push_back(CanonicalCookie::Create(
+      GURL("http://domain3.test"), "A=1", base::Time::Now(), base::nullopt));
+  initial_cookies.push_back(CanonicalCookie::Create(
+      GURL("http://domain3.test"), "B=1", base::Time::Now(), base::nullopt));
+  store->SetLoadExpectation(true /* return_value */,
+                            std::move(initial_cookies));
+  auto cm = std::make_unique<CookieMonster>(store.get(), &net_log_);
+  {
+    base::HistogramTester histogram_tester;
+    // Access the cookies to trigger loading from the persistent store.
+    EXPECT_EQ(5u, this->GetAllCookies(cm.get()).size());
+    EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+    // There should be 3 keys: "domain1.test", "domain2.test", and
+    // "domain3.test".
+    histogram_tester.ExpectUniqueSample(kHistogramName, 3 /* sample */,
+                                        1 /* count */);
+  }
+
+  // Test adding cookies for already existing key.
+  {
+    base::HistogramTester histogram_tester;
+    EXPECT_TRUE(CreateAndSetCookie(cm.get(), GURL("https://domain1.test"),
+                                   "B=1", CookieOptions::MakeAllInclusive()));
+    EXPECT_TRUE(CreateAndSetCookie(cm.get(), GURL("http://sub.domain1.test"),
+                                   "B=1", CookieOptions::MakeAllInclusive()));
+    EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+    histogram_tester.ExpectUniqueSample(kHistogramName, 3 /* sample */,
+                                        1 /* count */);
+  }
+
+  // Test adding a cookie for a new key.
+  {
+    base::HistogramTester histogram_tester;
+    EXPECT_TRUE(CreateAndSetCookie(cm.get(), GURL("https://domain4.test"),
+                                   "A=1", CookieOptions::MakeAllInclusive()));
+    EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+    histogram_tester.ExpectUniqueSample(kHistogramName, 4 /* sample */,
+                                        1 /* count */);
+  }
+
+  // Test overwriting the only cookie for a key. (Deletes and inserts, so the
+  // total doesn't change.)
+  {
+    base::HistogramTester histogram_tester;
+    EXPECT_TRUE(CreateAndSetCookie(cm.get(), GURL("https://domain4.test"),
+                                   "A=2", CookieOptions::MakeAllInclusive()));
+    EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+    histogram_tester.ExpectUniqueSample(kHistogramName, 4 /* sample */,
+                                        1 /* count */);
+  }
+
+  // Test deleting cookie for a key with more than one cookie.
+  {
+    base::HistogramTester histogram_tester;
+    EXPECT_TRUE(CreateAndSetCookie(cm.get(), GURL("https://domain2.test"),
+                                   "A=1; Max-Age=0",
+                                   CookieOptions::MakeAllInclusive()));
+    EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+    histogram_tester.ExpectUniqueSample(kHistogramName, 4 /* sample */,
+                                        1 /* count */);
+  }
+
+  // Test deleting cookie for a key with only one cookie.
+  {
+    base::HistogramTester histogram_tester;
+    EXPECT_TRUE(CreateAndSetCookie(cm.get(), GURL("https://domain4.test"),
+                                   "A=1; Max-Age=0",
+                                   CookieOptions::MakeAllInclusive()));
+    EXPECT_TRUE(cm->DoRecordPeriodicStatsForTesting());
+    histogram_tester.ExpectUniqueSample(kHistogramName, 3 /* sample */,
+                                        1 /* count */);
+  }
+}
+
 TEST_F(CookieMonsterTest, MaybeDeleteEquivalentCookieAndUpdateStatus) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), &net_log_));
@@ -2728,10 +2859,9 @@ TEST_F(CookieMonsterTest, MaybeDeleteEquivalentCookieAndUpdateStatus) {
   auto preexisting_cookie = CanonicalCookie::Create(
       https_www_foo_.url(), "A=B;Secure;HttpOnly", base::Time::Now(),
       base::nullopt /* server_time */);
-  CanonicalCookie::CookieInclusionStatus status =
-      SetCanonicalCookieReturnStatus(cm.get(), std::move(preexisting_cookie),
-                                     https_www_foo_.url(),
-                                     true /* can_modify_httponly */);
+  CookieInclusionStatus status = SetCanonicalCookieReturnStatus(
+      cm.get(), std::move(preexisting_cookie), https_www_foo_.url(),
+      true /* can_modify_httponly */);
   ASSERT_TRUE(status.IsInclude());
 
   // Set a new cookie with a different name. Should work because cookies with
@@ -2753,7 +2883,7 @@ TEST_F(CookieMonsterTest, MaybeDeleteEquivalentCookieAndUpdateStatus) {
                                           http_www_foo_.url(),
                                           true /* can_modify_httponly */);
   EXPECT_TRUE(status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
+      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   // The preexisting cookie should still be there.
   EXPECT_THAT(GetCookiesWithOptions(cm.get(), https_www_foo_.url(),
                                     CookieOptions::MakeAllInclusive()),
@@ -2784,7 +2914,7 @@ TEST_F(CookieMonsterTest, MaybeDeleteEquivalentCookieAndUpdateStatus) {
                                           http_www_foo_.url(),
                                           true /* can_modify_httponly */);
   EXPECT_TRUE(status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
+      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   // The preexisting cookie should still be there.
   EXPECT_THAT(GetCookiesWithOptions(cm.get(), https_www_foo_.url(),
                                     CookieOptions::MakeAllInclusive()),
@@ -2812,7 +2942,7 @@ TEST_F(CookieMonsterTest, MaybeDeleteEquivalentCookieAndUpdateStatus) {
                                           https_www_foo_.url(),
                                           false /* can_modify_httponly */);
   EXPECT_TRUE(status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_OVERWRITE_HTTP_ONLY}));
+      {CookieInclusionStatus::EXCLUDE_OVERWRITE_HTTP_ONLY}));
 
   entries = net_log_.GetEntries();
   ExpectLogContainsSomewhere(
@@ -2832,10 +2962,9 @@ TEST_F(CookieMonsterTest, SkipDontOverwriteForMultipleReasons) {
   auto preexisting_cookie = CanonicalCookie::Create(
       https_www_foo_.url(), "A=B;Secure;HttpOnly", base::Time::Now(),
       base::nullopt /* server_time */);
-  CanonicalCookie::CookieInclusionStatus status =
-      SetCanonicalCookieReturnStatus(cm.get(), std::move(preexisting_cookie),
-                                     https_www_foo_.url(),
-                                     true /* can_modify_httponly */);
+  CookieInclusionStatus status = SetCanonicalCookieReturnStatus(
+      cm.get(), std::move(preexisting_cookie), https_www_foo_.url(),
+      true /* can_modify_httponly */);
   ASSERT_TRUE(status.IsInclude());
 
   // Attempt to set a new cookie with the same name that is not Secure or
@@ -2847,8 +2976,8 @@ TEST_F(CookieMonsterTest, SkipDontOverwriteForMultipleReasons) {
                                           http_www_foo_.url(),
                                           false /* can_modify_httponly */);
   EXPECT_TRUE(status.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE,
-       CanonicalCookie::CookieInclusionStatus::EXCLUDE_OVERWRITE_HTTP_ONLY}));
+      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE,
+       CookieInclusionStatus::EXCLUDE_OVERWRITE_HTTP_ONLY}));
 
   auto entries = net_log_.GetEntries();
   ExpectLogContainsSomewhere(
@@ -2868,21 +2997,19 @@ TEST_F(CookieMonsterTest, DontDeleteEquivalentCookieIfSetIsRejected) {
   auto preexisting_cookie = CanonicalCookie::Create(
       http_www_foo_.url(), "cookie=foo", base::Time::Now(),
       base::nullopt /* server_time */);
-  CanonicalCookie::CookieInclusionStatus status =
-      SetCanonicalCookieReturnStatus(cm.get(), std::move(preexisting_cookie),
-                                     http_www_foo_.url(),
-                                     false /* can_modify_httponly */);
+  CookieInclusionStatus status = SetCanonicalCookieReturnStatus(
+      cm.get(), std::move(preexisting_cookie), http_www_foo_.url(),
+      false /* can_modify_httponly */);
   ASSERT_TRUE(status.IsInclude());
 
   auto bad_cookie = CanonicalCookie::Create(
       http_www_foo_.url(), "cookie=bar;secure", base::Time::Now(),
       base::nullopt /* server_time */);
-  CanonicalCookie::CookieInclusionStatus status2 =
-      SetCanonicalCookieReturnStatus(cm.get(), std::move(bad_cookie),
-                                     http_www_foo_.url(),
-                                     false /* can_modify_httponly */);
+  CookieInclusionStatus status2 = SetCanonicalCookieReturnStatus(
+      cm.get(), std::move(bad_cookie), http_www_foo_.url(),
+      false /* can_modify_httponly */);
   EXPECT_TRUE(status2.HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
+      {CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
 
   // Check that the original cookie is still there.
   EXPECT_EQ("cookie=foo", GetCookies(cm.get(), https_www_foo_.url()));
@@ -2904,10 +3031,9 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
       CreateAndSetCookieReturnStatus(cm.get(), https_url, "A=B;").IsInclude());
 
   // A secure cookie cannot be set from a URL with an insecure scheme.
-  EXPECT_TRUE(
-      CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=B; Secure")
-          .HasExactlyExclusionReasonsForTesting(
-              {CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
+  EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=B; Secure")
+                  .HasExactlyExclusionReasonsForTesting(
+                      {CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
 
   // A secure cookie can be set from a URL with a secure scheme.
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), https_url, "A=B; Secure")
@@ -2919,8 +3045,7 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
                   .IsInclude());
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=C;")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_SECURE}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
 
   // If a non-secure cookie is created from a URL with an secure scheme, and a
   // secure cookie with the same name already exists, update the cookie.
@@ -2939,13 +3064,11 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
                   .IsInclude());
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=C; path=/")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_SECURE}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   EXPECT_TRUE(
       CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=C; path=/my/path")
           .HasExactlyExclusionReasonsForTesting(
-              {CanonicalCookie::CookieInclusionStatus::
-                   EXCLUDE_OVERWRITE_SECURE}));
+              {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
 
   // But if the existing cookie has a path somewhere under the root, cookies
   // with the same name may be set for paths which don't overlap the existing
@@ -2963,13 +3086,11 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url,
                                              "WITH_PATH=C; path=/my/path")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_SECURE}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url,
                                              "WITH_PATH=C; path=/my/path/sub")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_SECURE}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
 
   DeleteAll(cm.get());
 
@@ -2994,12 +3115,10 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
   EXPECT_TRUE(
       CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=D; path=/foo")
           .HasExactlyExclusionReasonsForTesting(
-              {CanonicalCookie::CookieInclusionStatus::
-                   EXCLUDE_OVERWRITE_SECURE}));
+              {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=D; path=/")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_SECURE}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   EXPECT_THAT(GetCookies(cm.get(), https_foo_url), testing::HasSubstr("A=C"));
 
   // ...but the original insecure cookie is still retained.
@@ -3022,13 +3141,11 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
   EXPECT_TRUE(
       CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=C; domain=foo.com")
           .HasExactlyExclusionReasonsForTesting(
-              {CanonicalCookie::CookieInclusionStatus::
-                   EXCLUDE_OVERWRITE_SECURE}));
+              {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url,
                                              "A=C; domain=www.foo.com")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_SECURE}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
 
   // 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.
@@ -3038,17 +3155,14 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
   EXPECT_TRUE(
       CreateAndSetCookieReturnStatus(cm.get(), http_url, "B=D; domain=foo.com")
           .HasExactlyExclusionReasonsForTesting(
-              {CanonicalCookie::CookieInclusionStatus::
-                   EXCLUDE_OVERWRITE_SECURE}));
+              {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url, "B=D")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_SECURE}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
   EXPECT_TRUE(
       CreateAndSetCookieReturnStatus(cm.get(), http_superdomain_url, "B=D")
           .HasExactlyExclusionReasonsForTesting(
-              {CanonicalCookie::CookieInclusionStatus::
-                   EXCLUDE_OVERWRITE_SECURE}));
+              {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}));
 
   // Verify that if an httponly version of the cookie exists, adding a Secure
   // version of the cookie still does not overwrite it.
@@ -3059,8 +3173,7 @@ TEST_F(CookieMonsterTest, SetSecureCookies) {
   // which in this case includes "exclude_httponly = true".
   EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), https_url, "C=E; Secure")
                   .HasExactlyExclusionReasonsForTesting(
-                      {CanonicalCookie::CookieInclusionStatus::
-                           EXCLUDE_OVERWRITE_HTTP_ONLY}));
+                      {CookieInclusionStatus::EXCLUDE_OVERWRITE_HTTP_ONLY}));
 
   auto entries = net_log_.GetEntries();
   ExpectLogContainsSomewhere(
@@ -3109,8 +3222,7 @@ TEST_F(CookieMonsterTest, LeaveSecureCookiesAlone_DomainMatch) {
       // cookie exists.
       EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url, "A=1")
                       .HasExactlyExclusionReasonsForTesting(
-                          {CanonicalCookie::CookieInclusionStatus::
-                               EXCLUDE_OVERWRITE_SECURE}))
+                          {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}))
           << "Insecure host cookie from " << http_url
           << " should not be set if equivalent secure host cookie from "
           << preexisting_cookie_url << " exists.";
@@ -3118,15 +3230,13 @@ TEST_F(CookieMonsterTest, LeaveSecureCookiesAlone_DomainMatch) {
                       cm.get(), http_url,
                       base::StrCat({"A=2; Domain=", new_cookie_host}))
                       .HasExactlyExclusionReasonsForTesting(
-                          {CanonicalCookie::CookieInclusionStatus::
-                               EXCLUDE_OVERWRITE_SECURE}))
+                          {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}))
           << "Insecure domain cookie from " << http_url
           << " should not be set if equivalent secure host cookie from "
           << preexisting_cookie_url << " exists.";
       EXPECT_TRUE(CreateAndSetCookieReturnStatus(cm.get(), http_url, "B=1")
                       .HasExactlyExclusionReasonsForTesting(
-                          {CanonicalCookie::CookieInclusionStatus::
-                               EXCLUDE_OVERWRITE_SECURE}))
+                          {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}))
           << "Insecure host cookie from " << http_url
           << " should not be set if equivalent secure domain cookie from "
           << preexisting_cookie_url << " exists.";
@@ -3134,8 +3244,7 @@ TEST_F(CookieMonsterTest, LeaveSecureCookiesAlone_DomainMatch) {
                       cm.get(), http_url,
                       base::StrCat({"B=2; Domain=", new_cookie_host}))
                       .HasExactlyExclusionReasonsForTesting(
-                          {CanonicalCookie::CookieInclusionStatus::
-                               EXCLUDE_OVERWRITE_SECURE}))
+                          {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE}))
           << "Insecure domain cookie from " << http_url
           << " should not be set if equivalent secure domain cookie from "
           << preexisting_cookie_url << " exists.";
@@ -3282,14 +3391,11 @@ TEST_F(CookieMonsterTest, LeaveSecureCookiesAlone_PathMatch) {
 
       // Don't set insecure cookie from an insecure URL if equivalent secure
       // cookie exists.
-      CanonicalCookie::CookieInclusionStatus set =
-          CreateAndSetCookieReturnStatus(
-              cm.get(), http_url,
-              base::StrCat({"A=1; Path=", new_cookie_path}));
+      CookieInclusionStatus set = CreateAndSetCookieReturnStatus(
+          cm.get(), http_url, base::StrCat({"A=1; Path=", new_cookie_path}));
       EXPECT_TRUE(should_path_match
                       ? set.HasExactlyExclusionReasonsForTesting(
-                            {CanonicalCookie::CookieInclusionStatus::
-                                 EXCLUDE_OVERWRITE_SECURE})
+                            {CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE})
                       : set.IsInclude())
           << "Insecure cookie from " << http_url << " should "
           << (should_path_match ? "not " : "")
@@ -3507,8 +3613,7 @@ TEST_F(CookieMonsterTest, SetCanonicalCookieDoesNotBlockForLoadAll) {
   CookieMonster cm(persistent_store.get(), nullptr);
 
   // Start of a canonical cookie set.
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus>
-      callback_set;
+  ResultSavingCookieCallback<CookieInclusionStatus> callback_set;
   GURL cookie_url("http://a.com/");
   cm.SetCanonicalCookieAsync(
       CanonicalCookie::Create(cookie_url, "A=B", base::Time::Now(),
@@ -3594,16 +3699,14 @@ TEST_F(CookieMonsterTest, DeleteCookieWithInheritedTimestamps) {
 
   // Write a cookie created at |t1|.
   auto cookie = CanonicalCookie::Create(url, cookie_line, t1, server_time);
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus>
-      set_callback_1;
+  ResultSavingCookieCallback<CookieInclusionStatus> set_callback_1;
   cm.SetCanonicalCookieAsync(std::move(cookie), url, options,
                              set_callback_1.MakeCallback());
   set_callback_1.WaitUntilDone();
 
   // Overwrite the cookie at |t2|.
   cookie = CanonicalCookie::Create(url, cookie_line, t2, server_time);
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus>
-      set_callback_2;
+  ResultSavingCookieCallback<CookieInclusionStatus> set_callback_2;
   cm.SetCanonicalCookieAsync(std::move(cookie), url, options,
                              set_callback_2.MakeCallback());
   set_callback_2.WaitUntilDone();
@@ -3627,7 +3730,7 @@ TEST_F(CookieMonsterTest, RejectCreatedSameSiteCookieOnSet) {
       CookieOptions::SameSiteCookieContext(
           CookieOptions::SameSiteCookieContext::ContextType::CROSS_SITE));
 
-  CanonicalCookie::CookieInclusionStatus status;
+  CookieInclusionStatus status;
   // Cookie can be created successfully; SameSite is not checked on Creation.
   auto cookie =
       CanonicalCookie::Create(url, cookie_line, base::Time::Now(),
@@ -3636,12 +3739,12 @@ TEST_F(CookieMonsterTest, RejectCreatedSameSiteCookieOnSet) {
   ASSERT_TRUE(status.IsInclude());
 
   // ... but the environment is checked on set, so this may be rejected then.
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> callback;
+  ResultSavingCookieCallback<CookieInclusionStatus> callback;
   cm.SetCanonicalCookieAsync(std::move(cookie), url, env_cross_site,
                              callback.MakeCallback());
   callback.WaitUntilDone();
   EXPECT_TRUE(callback.result().HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_SAMESITE_LAX}));
+      {CookieInclusionStatus::EXCLUDE_SAMESITE_LAX}));
 }
 
 TEST_F(CookieMonsterTest, RejectCreatedSecureCookieOnSet) {
@@ -3649,7 +3752,7 @@ TEST_F(CookieMonsterTest, RejectCreatedSecureCookieOnSet) {
   std::string cookie_line = "foo=bar; Secure";
 
   CookieMonster cm(nullptr, nullptr);
-  CanonicalCookie::CookieInclusionStatus status;
+  CookieInclusionStatus status;
   // Cookie can be created successfully from an any url. Secure is not checked
   // on Create.
   auto cookie =
@@ -3660,13 +3763,13 @@ TEST_F(CookieMonsterTest, RejectCreatedSecureCookieOnSet) {
   ASSERT_TRUE(status.IsInclude());
 
   // Cookie is rejected when attempting to set from a non-secure scheme.
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> callback;
+  ResultSavingCookieCallback<CookieInclusionStatus> callback;
   cm.SetCanonicalCookieAsync(std::move(cookie), http_url,
                              CookieOptions::MakeAllInclusive(),
                              callback.MakeCallback());
   callback.WaitUntilDone();
   EXPECT_TRUE(callback.result().HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
+      {CookieInclusionStatus::EXCLUDE_SECURE_ONLY}));
 }
 
 TEST_F(CookieMonsterTest, RejectCreatedHttpOnlyCookieOnSet) {
@@ -3674,7 +3777,7 @@ TEST_F(CookieMonsterTest, RejectCreatedHttpOnlyCookieOnSet) {
   std::string cookie_line = "foo=bar; HttpOnly";
 
   CookieMonster cm(nullptr, nullptr);
-  CanonicalCookie::CookieInclusionStatus status;
+  CookieInclusionStatus status;
   // Cookie can be created successfully; HttpOnly is not checked on Create.
   auto cookie =
       CanonicalCookie::Create(url, cookie_line, base::Time::Now(),
@@ -3690,12 +3793,12 @@ TEST_F(CookieMonsterTest, RejectCreatedHttpOnlyCookieOnSet) {
       CookieOptions::SameSiteCookieContext(
           CookieOptions::SameSiteCookieContext::ContextType::SAME_SITE_STRICT));
   options_no_httponly.set_exclude_httponly();  // Default, but make it explicit.
-  ResultSavingCookieCallback<CanonicalCookie::CookieInclusionStatus> callback;
+  ResultSavingCookieCallback<CookieInclusionStatus> callback;
   cm.SetCanonicalCookieAsync(std::move(cookie), url, options_no_httponly,
                              callback.MakeCallback());
   callback.WaitUntilDone();
   EXPECT_TRUE(callback.result().HasExactlyExclusionReasonsForTesting(
-      {CanonicalCookie::CookieInclusionStatus::EXCLUDE_HTTP_ONLY}));
+      {CookieInclusionStatus::EXCLUDE_HTTP_ONLY}));
 }
 
 // Test the CookiesWithoutSameSiteMustBeSecure experimental option (in
@@ -3708,7 +3811,7 @@ TEST_F(CookieMonsterTest, CookiesWithoutSameSiteMustBeSecure) {
     bool is_cookies_without_samesite_must_be_secure_enabled;
     bool is_url_secure;
     std::string cookie_line;
-    CanonicalCookie::CookieInclusionStatus expected_set_cookie_result;
+    CookieInclusionStatus expected_set_cookie_result;
     // Only makes sense to check if result is INCLUDE:
     CookieEffectiveSameSite expected_effective_samesite =
         CookieEffectiveSameSite::NO_RESTRICTION;
@@ -3716,80 +3819,67 @@ TEST_F(CookieMonsterTest, CookiesWithoutSameSiteMustBeSecure) {
   } test_cases[] = {
       // Feature enabled:
       // Cookie set from a secure URL with SameSite enabled is not rejected.
-      {true, true, "A=B; SameSite=Lax",
-       CanonicalCookie::CookieInclusionStatus(),
+      {true, true, "A=B; SameSite=Lax", CookieInclusionStatus(),
        CookieEffectiveSameSite::LAX_MODE},
       // Cookie set from a secure URL which is defaulted into Lax is not
       // rejected.
       {true, true, "A=B",  // recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE, kShortAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE,
+       kShortAge},
       {true, true, "A=B",  // not-recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE, kLongAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE, kLongAge},
       // Cookie set from a secure URL with SameSite=None and Secure is set.
-      {true, true, "A=B; SameSite=None; Secure",
-       CanonicalCookie::CookieInclusionStatus(),
+      {true, true, "A=B; SameSite=None; Secure", CookieInclusionStatus(),
        CookieEffectiveSameSite::NO_RESTRICTION},
       // Cookie set from a secure URL with SameSite=None but not specifying
       // Secure is rejected.
       {true, true, "A=B; SameSite=None",
-       CanonicalCookie::CookieInclusionStatus(
-           CanonicalCookie::CookieInclusionStatus::
-               EXCLUDE_SAMESITE_NONE_INSECURE,
-           CanonicalCookie::CookieInclusionStatus::
-               WARN_SAMESITE_NONE_INSECURE)},
+       CookieInclusionStatus(
+           CookieInclusionStatus::EXCLUDE_SAMESITE_NONE_INSECURE,
+           CookieInclusionStatus::WARN_SAMESITE_NONE_INSECURE)},
       // Cookie set from an insecure URL which defaults into LAX_MODE is not
       // rejected.
       {true, false, "A=B",  // recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE, kShortAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE,
+       kShortAge},
       {true, false, "A=B",  // not-recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE, kLongAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE, kLongAge},
       {true, false, "A=B; Max-Age=1000000",  // recently-set persistent cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE, kShortAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE,
+       kShortAge},
       {true, false,
        "A=B; Max-Age=1000000",  // not-recently-set persistent cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE, kLongAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE, kLongAge},
 
       // Feature not enabled (but SameSiteByDefaultCookies is still enabled):
       // Cookie set from a secure URL with SameSite enabled is not rejected.
-      {false, true, "A=B; SameSite=Lax",
-       CanonicalCookie::CookieInclusionStatus(),
+      {false, true, "A=B; SameSite=Lax", CookieInclusionStatus(),
        CookieEffectiveSameSite::LAX_MODE},
       // Cookie set from a secure URL which is defaulted into Lax is not
       // rejected.
       {false, true, "A=B",  // recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE, kShortAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE,
+       kShortAge},
       {false, true, "A=B",  // not-recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE, kLongAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE, kLongAge},
       // Cookie set from a secure URL with SameSite=None and Secure is set.
-      {false, true, "A=B; SameSite=None; Secure",
-       CanonicalCookie::CookieInclusionStatus(),
+      {false, true, "A=B; SameSite=None; Secure", CookieInclusionStatus(),
        CookieEffectiveSameSite::NO_RESTRICTION},
       // Cookie set from an insecure URL with SameSite=None (which can't ever be
       // secure because it's an insecure URL) is NOT rejected, because
       // CookiesWithoutSameSiteMustBeSecure is not enabled.
       {false, false, "A=B; SameSite=None",
-       CanonicalCookie::CookieInclusionStatus::MakeFromReasonsForTesting(
-           std::vector<
-               CanonicalCookie::CookieInclusionStatus::ExclusionReason>(),
-           {CanonicalCookie::CookieInclusionStatus::
-                WARN_SAMESITE_NONE_INSECURE}),
+       CookieInclusionStatus::MakeFromReasonsForTesting(
+           std::vector<CookieInclusionStatus::ExclusionReason>(),
+           {CookieInclusionStatus::WARN_SAMESITE_NONE_INSECURE}),
        CookieEffectiveSameSite::NO_RESTRICTION},
       // Cookie set from an insecure URL which is defaulted into Lax is not
       // rejected.
       {false, false, "A=B",  // recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE, kShortAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE_ALLOW_UNSAFE,
+       kShortAge},
       {false, false, "A=B",  // not-recently-set session cookie.
-       CanonicalCookie::CookieInclusionStatus(),
-       CookieEffectiveSameSite::LAX_MODE, kLongAge},
+       CookieInclusionStatus(), CookieEffectiveSameSite::LAX_MODE, kLongAge},
   };
 
   auto cm = std::make_unique<CookieMonster>(nullptr, nullptr);
@@ -3820,10 +3910,9 @@ TEST_F(CookieMonsterTest, CookiesWithoutSameSiteMustBeSecure) {
                                           base::nullopt /* server_time */);
     // Make a copy so we can delete it after the test.
     CanonicalCookie cookie_copy = *cookie;
-    CanonicalCookie::CookieInclusionStatus result =
-        SetCanonicalCookieReturnStatus(
-            cm.get(), std::move(cookie), url,
-            true /* can_modify_httponly (irrelevant) */);
+    CookieInclusionStatus result = SetCanonicalCookieReturnStatus(
+        cm.get(), std::move(cookie), url,
+        true /* can_modify_httponly (irrelevant) */);
     EXPECT_EQ(test.expected_set_cookie_result, result)
         << "Test case " << i << " failed.";
     if (result.IsInclude()) {