Change CookieStore::DeleteCallback to take uint32_t.

net/cookies/cookie_store_unittest.h

 // 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.
 
 #ifndef NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 
+#include <cstdint>

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

stdint.h?

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

Done.

 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/threading/thread.h"
@@ skipping 201 matching lines @@
                     const GURL& url,
                     const std::string& cookie_name) {
     DCHECK(cs);
     NoResultCookieCallback callback;
     cs->DeleteCookieAsync(
         url, cookie_name,
         base::Bind(&NoResultCookieCallback::Run, base::Unretained(&callback)));
     callback.WaitUntilDone();
   }
 
-  int DeleteCanonicalCookie(CookieStore* cs, const CanonicalCookie& cookie) {
+  uint32_t DeleteCanonicalCookie(CookieStore* cs,
+                                 const CanonicalCookie& cookie) {
     DCHECK(cs);
-    ResultSavingCookieCallback<int> callback;
+    ResultSavingCookieCallback<uint32_t> callback;
     cs->DeleteCanonicalCookieAsync(
-        cookie, base::Bind(&ResultSavingCookieCallback<int>::Run,
+        cookie, base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
                            base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
-  int DeleteCreatedBetween(CookieStore* cs,
-                            const base::Time& delete_begin,
-                            const base::Time& delete_end) {
+  uint32_t DeleteCreatedBetween(CookieStore* cs,
+                                const base::Time& delete_begin,
+                                const base::Time& delete_end) {
     DCHECK(cs);
-    ResultSavingCookieCallback<int> callback;
+    ResultSavingCookieCallback<uint32_t> callback;
     cs->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
-        base::Bind(
-            &ResultSavingCookieCallback<int>::Run,
-            base::Unretained(&callback)));
+        base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
+                   base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
-  int DeleteAllCreatedBetweenWithPredicate(
+  uint32_t DeleteAllCreatedBetweenWithPredicate(
       CookieStore* cs,
       const base::Time delete_begin,
       const base::Time delete_end,
       const CookieStore::CookiePredicate& predicate) {
     DCHECK(cs);
-    ResultSavingCookieCallback<int> callback;
+    ResultSavingCookieCallback<uint32_t> callback;
     cs->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();
   }
 
-  int DeleteSessionCookies(CookieStore* cs) {
+  uint32_t DeleteSessionCookies(CookieStore* cs) {
     DCHECK(cs);
-    ResultSavingCookieCallback<int> callback;
+    ResultSavingCookieCallback<uint32_t> callback;
     cs->DeleteSessionCookiesAsync(
-        base::Bind(
-            &ResultSavingCookieCallback<int>::Run,
-            base::Unretained(&callback)));
+        base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
+                   base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
-  int DeleteAll(CookieStore* cs) {
+  uint32_t DeleteAll(CookieStore* cs) {
     DCHECK(cs);
-    ResultSavingCookieCallback<int> callback;
-    cs->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<int>::Run,
+    ResultSavingCookieCallback<uint32_t> callback;
+    cs->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<uint32_t>::Run,
                                   base::Unretained(&callback)));
     callback.WaitUntilDone();
     return callback.result();
   }
 
   // Returns the CookieStore for the test - each test only uses one CookieStore.
   CookieStore* GetCookieStore() {
     if (!cookie_store_)
       cookie_store_ = CookieStoreTestTraits::Create();
     return cookie_store_.get();
@@ skipping 916 matching lines @@
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), kValidCookieLine));
   EXPECT_EQ("A=B", this->GetCookies(cs, this->http_www_foo_.url()));
 
   // Set a persistent cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(),
                               "C=D; expires=Mon, 18-Apr-22 22:50:13 GMT"));
 
   EXPECT_EQ(2u, this->GetAllCookies(cs).size());
 
   // Delete both, and make sure it works
-  EXPECT_EQ(2, this->DeleteAll(cs));
+  EXPECT_EQ(2u, this->DeleteAll(cs));
   EXPECT_EQ(0u, this->GetAllCookies(cs).size());
 }
 
 TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) {
   CookieStore* cs = this->GetCookieStore();
   const base::Time last_month = base::Time::Now() -
                                 base::TimeDelta::FromDays(30);
   const base::Time last_minute = base::Time::Now() -
                                  base::TimeDelta::FromMinutes(1);
   const base::Time next_minute = base::Time::Now() +
                                  base::TimeDelta::FromMinutes(1);
   const base::Time next_month = base::Time::Now() +
                                 base::TimeDelta::FromDays(30);
 
   // Add a cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "A=B"));
   // Check that the cookie is in the store.
   this->MatchCookieLines("A=B",
                          this->GetCookies(cs, this->http_www_foo_.url()));
 
   // Remove cookies in empty intervals.
-  EXPECT_EQ(0, this->DeleteCreatedBetween(cs, last_month, last_minute));
-  EXPECT_EQ(0, this->DeleteCreatedBetween(cs, next_minute, next_month));
+  EXPECT_EQ(0u, this->DeleteCreatedBetween(cs, last_month, last_minute));
+  EXPECT_EQ(0u, this->DeleteCreatedBetween(cs, next_minute, next_month));
   // Check that the cookie is still there.
   this->MatchCookieLines("A=B",
                          this->GetCookies(cs, this->http_www_foo_.url()));
 
   // Remove the cookie with an interval defined by two dates.
-  EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, next_minute));
+  EXPECT_EQ(1u, this->DeleteCreatedBetween(cs, last_minute, next_minute));
   // Check that the cookie disappeared.
   this->MatchCookieLines(std::string(),
                          this->GetCookies(cs, this->http_www_foo_.url()));
 
   // Add another cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "C=D"));
   // Check that the cookie is in the store.
   this->MatchCookieLines("C=D",
                          this->GetCookies(cs, this->http_www_foo_.url()));
 
   // Remove the cookie with a null ending time.
-  EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, base::Time()));
+  EXPECT_EQ(1u, this->DeleteCreatedBetween(cs, last_minute, base::Time()));
   // Check that the cookie disappeared.
   this->MatchCookieLines(std::string(),
                          this->GetCookies(cs, this->http_www_foo_.url()));
 }
 
 namespace {
 static bool CookieHasValue(const std::string& value,
                            const CanonicalCookie& cookie) {
   return cookie.Value() == value;
 }
 }
 
 TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetweenWithPredicate) {
   CookieStore* cs = this->GetCookieStore();
   base::Time now = base::Time::Now();
   base::Time last_month = base::Time::Now() - base::TimeDelta::FromDays(30);
   base::Time last_minute = base::Time::Now() - base::TimeDelta::FromMinutes(1);
   std::string desired_value("B");
 
   // These 3 cookies match the time range and host.
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "A=B"));
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "C=D"));
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "Y=Z"));
   EXPECT_TRUE(this->SetCookie(cs, this->https_www_foo_.url(), "E=B"));
 
   // Delete cookies.
-  EXPECT_EQ(2,  // Deletes A=B, E=B
+  EXPECT_EQ(2u,  // Deletes A=B, E=B
             this->DeleteAllCreatedBetweenWithPredicate(
                 cs, now, base::Time::Max(),
                 base::Bind(&CookieHasValue, desired_value)));
 
   // Check that we deleted the right ones.
   this->MatchCookieLines("C=D;Y=Z",
                          this->GetCookies(cs, this->https_www_foo_.url()));
 
   // Now check that using a null predicate will do nothing.
-  EXPECT_EQ(0, this->DeleteAllCreatedBetweenWithPredicate(
-                   cs, now, base::Time::Max(), CookieStore::CookiePredicate()));
+  EXPECT_EQ(0u,
+            this->DeleteAllCreatedBetweenWithPredicate(
+                cs, now, base::Time::Max(), CookieStore::CookiePredicate()));
 
   // Finally, check that we don't delete cookies when our time range is off.
   desired_value = "D";
-  EXPECT_EQ(0, this->DeleteAllCreatedBetweenWithPredicate(
-                   cs, last_month, last_minute,
-                   base::Bind(&CookieHasValue, desired_value)));
+  EXPECT_EQ(0u, this->DeleteAllCreatedBetweenWithPredicate(
+                    cs, last_month, last_minute,
+                    base::Bind(&CookieHasValue, desired_value)));
   this->MatchCookieLines("C=D;Y=Z",
                          this->GetCookies(cs, this->https_www_foo_.url()));
   // Same thing, but with a good time range.
-  EXPECT_EQ(1, this->DeleteAllCreatedBetweenWithPredicate(
-                   cs, now, base::Time::Max(),
-                   base::Bind(&CookieHasValue, desired_value)));
+  EXPECT_EQ(1u, this->DeleteAllCreatedBetweenWithPredicate(
+                    cs, now, base::Time::Max(),
+                    base::Bind(&CookieHasValue, desired_value)));
   this->MatchCookieLines("Y=Z",
                          this->GetCookies(cs, this->https_www_foo_.url()));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestSecure) {
   CookieStore* cs = this->GetCookieStore();
 
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "A=B"));
   this->MatchCookieLines("A=B",
                          this->GetCookies(cs, this->http_www_foo_.url()));
@@ skipping 112 matching lines @@
   CookieStore* cs = this->GetCookieStore();
 
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookieWithOptions(cs, url_foo, "a", options));
   CookieList list = this->GetAllCookiesForURL(cs, url_foo);
   EXPECT_EQ(1u, list.size());
   EXPECT_EQ("", list[0].Name());
   EXPECT_EQ("a", list[0].Value());
-  EXPECT_EQ(1, this->DeleteAll(cs));
+  EXPECT_EQ(1u, this->DeleteAll(cs));
 
   EXPECT_TRUE(this->SetCookieWithOptions(cs, url_foo, "=b", options));
   list = this->GetAllCookiesForURL(cs, url_foo);
   EXPECT_EQ(1u, list.size());
   EXPECT_EQ("", list[0].Name());
   EXPECT_EQ("b", list[0].Value());
-  EXPECT_EQ(1, this->DeleteAll(cs));
+  EXPECT_EQ(1u, this->DeleteAll(cs));
 }
 
 TYPED_TEST_P(CookieStoreTest, CookieOrdering) {
   // Put a random set of cookies into a store and make sure they're returned in
   // the right order.
   // Cookies should be sorted by path length and creation time, as per RFC6265.
   CookieStore* cs = this->GetCookieStore();
   EXPECT_TRUE(
       this->SetCookie(cs, GURL("http://d.c.b.a.foo.com/aa/x.html"), "c=1"));
   EXPECT_TRUE(this->SetCookie(cs, GURL("http://b.a.foo.com/aa/bb/cc/x.html"),
@@ skipping 102 matching lines @@
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "A=B;Path=/foo"));
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "A=C;Path=/bar"));
   EXPECT_EQ(2u, this->GetAllCookies(cs).size());
   EXPECT_EQ("A=B", this->GetCookies(cs, this->www_foo_foo_.url()));
   EXPECT_EQ("A=C", this->GetCookies(cs, this->www_foo_bar_.url()));
 
   // Delete the "/foo" cookie, and make sure only it was deleted.
   CookieList cookies = this->GetCookieListWithOptions(
       cs, this->www_foo_foo_.url(), CookieOptions());
   ASSERT_EQ(1u, cookies.size());
-  EXPECT_EQ(1, this->DeleteCanonicalCookie(cs, cookies[0]));
+  EXPECT_EQ(1u, this->DeleteCanonicalCookie(cs, cookies[0]));
   EXPECT_EQ(1u, this->GetAllCookies(cs).size());
   EXPECT_EQ("", this->GetCookies(cs, this->www_foo_foo_.url()));
   EXPECT_EQ("A=C", this->GetCookies(cs, this->www_foo_bar_.url()));
 
   // Deleting the "/foo" cookie again should fail.
-  EXPECT_EQ(0, this->DeleteCanonicalCookie(cs, cookies[0]));
+  EXPECT_EQ(0u, this->DeleteCanonicalCookie(cs, cookies[0]));
 
   // Try to delete the "/bar" cookie after overwriting it with a new cookie.
   cookies = this->GetCookieListWithOptions(cs, this->www_foo_bar_.url(),
                                            CookieOptions());
   ASSERT_EQ(1u, cookies.size());
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(), "A=D;Path=/bar"));
-  EXPECT_EQ(0, this->DeleteCanonicalCookie(cs, cookies[0]));
+  EXPECT_EQ(0u, this->DeleteCanonicalCookie(cs, cookies[0]));
   EXPECT_EQ(1u, this->GetAllCookies(cs).size());
   EXPECT_EQ("A=D", this->GetCookies(cs, this->www_foo_bar_.url()));
 
   // Delete the new "/bar" cookie.
   cookies = this->GetCookieListWithOptions(cs, this->www_foo_bar_.url(),
                                            CookieOptions());
   ASSERT_EQ(1u, cookies.size());
-  EXPECT_EQ(1, this->DeleteCanonicalCookie(cs, cookies[0]));
+  EXPECT_EQ(1u, this->DeleteCanonicalCookie(cs, cookies[0]));
   EXPECT_EQ(0u, this->GetAllCookies(cs).size());
   EXPECT_EQ("", this->GetCookies(cs, this->www_foo_bar_.url()));
 }
 
 TYPED_TEST_P(CookieStoreTest, DeleteSessionCookie) {
   CookieStore* cs = this->GetCookieStore();
   // Create a session cookie and a persistent cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->http_www_foo_.url(),
                               std::string(kValidCookieLine)));
   EXPECT_TRUE(this->SetCookie(
@@ skipping 46 matching lines @@
                            EmptyName,
                            CookieOrdering,
                            GetAllCookiesAsync,
                            DeleteCookieAsync,
                            DeleteCanonicalCookieAsync,
                            DeleteSessionCookie);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_UNITTEST_H_