Change CookieStore::DeleteCallback to take uint32_t.

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 <cstdint>

[mmenke, 2017/07/05 16:58:49]

stdint.h?

[Randy Smith (Not in Mondays), 2017/07/08 13:03:26]

Done.

 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
@@ skipping 138 matching lines @@
     DCHECK(cm);
     ResultSavingCookieCallback<bool> callback;
     cm->SetCanonicalCookieAsync(
         std::move(cookie), secure_source, modify_http_only,
         base::Bind(&ResultSavingCookieCallback<bool>::Run,
                    base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
-  int DeleteAllCreatedBetween(CookieMonster* cm,
-                              const base::Time& delete_begin,
-                              const base::Time& delete_end) {
+  uint32_t DeleteAllCreatedBetween(CookieMonster* cm,
+                                   const base::Time& delete_begin,
+                                   const base::Time& delete_end) {
     DCHECK(cm);
-    ResultSavingCookieCallback<int> callback;
+    ResultSavingCookieCallback<uint32_t> callback;
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(&ResultSavingCookieCallback<int>::Run,
+        base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
                    base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
-  int DeleteAllCreatedBetweenWithPredicate(CookieMonster* cm,
-                                           const base::Time delete_begin,
-                                           const base::Time delete_end,
-                                           const CookiePredicate& predicate) {
+  uint32_t DeleteAllCreatedBetweenWithPredicate(
+      CookieMonster* cm,
+      const base::Time delete_begin,
+      const base::Time delete_end,
+      const CookiePredicate& predicate) {
     DCHECK(cm);
-    ResultSavingCookieCallback<int> callback;
+    ResultSavingCookieCallback<uint32_t> callback;
     cm->DeleteAllCreatedBetweenWithPredicateAsync(
         delete_begin, delete_end, predicate,
-        base::Bind(&ResultSavingCookieCallback<int>::Run,
+        base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
                    base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
   // Helper for PredicateSeesAllCookies test; repopulates CM with same layout
   // each time.
   void PopulateCmForPredicateCheck(CookieMonster* cm) {
     GURL url_top_level_domain_plus_1(kTopLevelDomainPlus1);
     GURL url_top_level_domain_plus_2(kTopLevelDomainPlus2);
@@ skipping 1151 matching lines @@
   options.set_include_httponly();
 
   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_foo_.url(),
                                    "C=D; httponly", options));
   EXPECT_EQ("A=B; C=D",
             GetCookiesWithOptions(cm.get(), http_www_foo_.url(), options));
 
-  EXPECT_EQ(2, DeleteAll(cm.get()));
+  EXPECT_EQ(2u, DeleteAll(cm.get()));
   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_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.
+  EXPECT_EQ(1u, 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_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()));
+  EXPECT_EQ(0u, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99),
+                                        Time()));
 
   // Create 5 cookies with different creation dates.
   EXPECT_TRUE(
       cm->SetCookieWithCreationTime(http_www_foo_.url(), "T-0=Now", now));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
       http_www_foo_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
       http_www_foo_.url(), "T-2=DayBefore", now - TimeDelta::FromDays(2)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
       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)));
+  EXPECT_EQ(2u, 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));
+      1u, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(2), now));
 
   // Make sure the delete_begin is inclusive.
   EXPECT_EQ(
-      1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(7), now));
+      1u, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(7), now));
 
   // Delete the last (now) item.
-  EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), Time(), Time()));
+  EXPECT_EQ(1u, DeleteAllCreatedBetween(cm.get(), Time(), Time()));
 
   // Really make sure everything is gone.
-  EXPECT_EQ(0, DeleteAll(cm.get()));
+  EXPECT_EQ(0u, DeleteAll(cm.get()));
 }
 
 TEST_F(CookieMonsterTest,
        TestCookieDeleteAllCreatedBetweenTimestampsWithPredicate) {
   std::unique_ptr<CookieMonster> cm(new CookieMonster(nullptr, nullptr));
   Time now = Time::Now();
 
   CanonicalCookie test_cookie;
   CookiePredicate true_predicate =
       base::Bind(&AlwaysTrueCookiePredicate, &test_cookie);
 
   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));
+      0u, DeleteAllCreatedBetweenWithPredicate(
+              cm.get(), now - TimeDelta::FromDays(99), Time(), true_predicate));
 
   // Create 5 cookies with different creation dates.
   EXPECT_TRUE(
       cm->SetCookieWithCreationTime(http_www_foo_.url(), "T-0=Now", now));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
       http_www_foo_.url(), "T-1=Yesterday", now - TimeDelta::FromDays(1)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
       http_www_foo_.url(), "T-2=DayBefore", now - TimeDelta::FromDays(2)));
   EXPECT_TRUE(cm->SetCookieWithCreationTime(
       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));
+  EXPECT_EQ(0u, 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()));
+  EXPECT_EQ(0u, 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));
+  EXPECT_EQ(2u, 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,
+  EXPECT_EQ(0u,
             DeleteAllCreatedBetweenWithPredicate(
                 cm.get(), now - TimeDelta::FromDays(2), now, false_predicate));
-  EXPECT_EQ(1,
+  EXPECT_EQ(1u,
             DeleteAllCreatedBetweenWithPredicate(
                 cm.get(), now - TimeDelta::FromDays(2), now, true_predicate));
   // Check our cookie values.
   std::unique_ptr<CanonicalCookie> expected_cookie =
       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,
+  EXPECT_EQ(0u,
             DeleteAllCreatedBetweenWithPredicate(
                 cm.get(), now - TimeDelta::FromDays(7), now, false_predicate));
-  EXPECT_EQ(1,
+  EXPECT_EQ(1u,
             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));
+  EXPECT_EQ(0u, DeleteAllCreatedBetweenWithPredicate(cm.get(), Time(), Time(),
+                                                     false_predicate));
+  EXPECT_EQ(1u, DeleteAllCreatedBetweenWithPredicate(cm.get(), Time(), Time(),
+                                                     true_predicate));
   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()));
+  EXPECT_EQ(0u, 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));
@@ skipping 421 matching lines @@
 }
 
 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
   // host, http_only, host secure, and all domain cookies.
   CookiePredicate value_matcher = base::Bind(&CookieValuePredicate, kTrueValue);
 
   PopulateCmForPredicateCheck(cm.get());
-  EXPECT_EQ(7, DeleteAllCreatedBetweenWithPredicate(
-                   cm.get(), base::Time(), base::Time::Now(), value_matcher));
+  EXPECT_EQ(7u, DeleteAllCreatedBetweenWithPredicate(
+                    cm.get(), base::Time(), base::Time::Now(), value_matcher));
 
   EXPECT_EQ("dom_2=B; dom_3=C; host_3=C",
             GetCookies(cm.get(), GURL(kTopLevelDomainPlus3)));
   EXPECT_EQ("dom_2=B; host_2=B; sec_host=B",
             GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure)));
   EXPECT_EQ("", GetCookies(cm.get(), GURL(kTopLevelDomainPlus1)));
   EXPECT_EQ("dom_path_2=B; host_path_2=B; dom_2=B; host_2=B; sec_host=B",
             GetCookies(cm.get(), GURL(kTopLevelDomainPlus2Secure +
                                       std::string("/dir1/dir2/xxx"))));
 }
@@ skipping 341 matching lines @@
 // Tests that case that DeleteAll is waiting for load to complete, and then a
 // get is queued. The get should wait to run until after all the cookies are
 // retrieved, and should return nothing, since all cookies were just deleted.
 TEST_F(CookieMonsterTest, WhileLoadingDeleteAllGetForURL) {
   const GURL kUrl = GURL(kTopLevelDomainPlus1);
 
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   store->set_store_load_commands(true);
   std::unique_ptr<CookieMonster> cm(new CookieMonster(store.get(), nullptr));
 
-  ResultSavingCookieCallback<int> delete_callback;
-  cm->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<int>::Run,
+  ResultSavingCookieCallback<uint32_t> delete_callback;
+  cm->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
                                 base::Unretained(&delete_callback)));
 
   GetCookieListCallback get_cookie_list_callback;
   cm->GetCookieListWithOptionsAsync(
       kUrl, CookieOptions(),
       base::Bind(&GetCookieListCallback::Run,
                  base::Unretained(&get_cookie_list_callback)));
 
   // Only the main load should have been queued.
   ASSERT_EQ(1u, store->commands().size());
   ASSERT_EQ(CookieStoreCommand::LOAD, store->commands()[0].type);
 
   std::vector<std::unique_ptr<CanonicalCookie>> cookies;
   // When passed to the CookieMonster, it takes ownership of the pointed to
   // cookies.
   cookies.push_back(
       CanonicalCookie::Create(kUrl, "a=b", base::Time::Now(), CookieOptions()));
   ASSERT_TRUE(cookies[0]);
   store->commands()[0].loaded_callback.Run(std::move(cookies));
 
   delete_callback.WaitUntilDone();
-  EXPECT_EQ(1, delete_callback.result());
+  EXPECT_EQ(1u, delete_callback.result());
 
   get_cookie_list_callback.WaitUntilDone();
   EXPECT_EQ(0u, get_cookie_list_callback.cookies().size());
 }
 
 // Tests that a set cookie call sandwiched between two get all cookies, all
 // before load completes, affects the first but not the second. The set should
 // also not trigger a LoadCookiesForKey (As that could complete only after the
 // main load for the store).
 TEST_F(CookieMonsterTest, WhileLoadingGetAllSetGetAll) {
@@ skipping 420 matching lines @@
 // 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_foo_.url(), "X=Y; path=/"));
 
   ASSERT_EQ(0, store->flush_count());
-  EXPECT_EQ(1, DeleteAll(cm.get()));
+  EXPECT_EQ(1u, 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,
@@ skipping 654 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