Change CookieStore::DeleteCallback to take uint32_t.

net/cookies/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 26 matching lines @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "net/cookies/cookie_monster.h"
 
+#include <cstdint>

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

This should be in the header file instead (And should be stdint.h?)

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

Done.

 #include <functional>
 #include <memory>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 546 matching lines @@
   if (!callback.is_null()) {
     callback =
         base::BindOnce(&CookieMonster::RunCallback,
                        this->cookie_monster()->weak_ptr_factory_.GetWeakPtr(),
                        std::move(callback));
   }
   this->cookie_monster()->FlushStore(std::move(callback));
 }
 
 // Task class for DeleteAllCreatedBetween call.
-class CookieMonster::DeleteAllCreatedBetweenTask : public DeleteTask<int> {
+class CookieMonster::DeleteAllCreatedBetweenTask : public DeleteTask<uint32_t> {
  public:
   DeleteAllCreatedBetweenTask(CookieMonster* cookie_monster,
                               const Time& delete_begin,
                               const Time& delete_end,
                               DeleteCallback callback)
-      : DeleteTask<int>(cookie_monster, std::move(callback)),
+      : DeleteTask<uint32_t>(cookie_monster, std::move(callback)),
         delete_begin_(delete_begin),
         delete_end_(delete_end) {}
 
   // DeleteTask:
-  int RunDeleteTask() override;
+  uint32_t RunDeleteTask() override;
 
  protected:
   ~DeleteAllCreatedBetweenTask() override {}
 
  private:
   Time delete_begin_;
   Time delete_end_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenTask);
 };
 
-int CookieMonster::DeleteAllCreatedBetweenTask::RunDeleteTask() {
+uint32_t CookieMonster::DeleteAllCreatedBetweenTask::RunDeleteTask() {
   return this->cookie_monster()->DeleteAllCreatedBetween(delete_begin_,
                                                          delete_end_);
 }
 
 // Task class for DeleteAllCreatedBetweenWithPredicate call.
 class CookieMonster::DeleteAllCreatedBetweenWithPredicateTask
-    : public DeleteTask<int> {
+    : public DeleteTask<uint32_t> {
  public:
   DeleteAllCreatedBetweenWithPredicateTask(
       CookieMonster* cookie_monster,
       Time delete_begin,
       Time delete_end,
       base::Callback<bool(const CanonicalCookie&)> predicate,
       DeleteCallback callback)
-      : DeleteTask<int>(cookie_monster, std::move(callback)),
+      : DeleteTask<uint32_t>(cookie_monster, std::move(callback)),
         delete_begin_(delete_begin),
         delete_end_(delete_end),
         predicate_(predicate) {}
 
   // DeleteTask:
-  int RunDeleteTask() override;
+  uint32_t RunDeleteTask() override;
 
  protected:
   ~DeleteAllCreatedBetweenWithPredicateTask() override {}
 
  private:
   Time delete_begin_;
   Time delete_end_;
   base::Callback<bool(const CanonicalCookie&)> predicate_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenWithPredicateTask);
 };
 
-int CookieMonster::DeleteAllCreatedBetweenWithPredicateTask::RunDeleteTask() {
+uint32_t
+CookieMonster::DeleteAllCreatedBetweenWithPredicateTask::RunDeleteTask() {
   return this->cookie_monster()->DeleteAllCreatedBetweenWithPredicate(
       delete_begin_, delete_end_, predicate_);
 }
 
 // Task class for DeleteCanonicalCookie call.
-class CookieMonster::DeleteCanonicalCookieTask : public DeleteTask<int> {
+class CookieMonster::DeleteCanonicalCookieTask : public DeleteTask<uint32_t> {
  public:
   DeleteCanonicalCookieTask(CookieMonster* cookie_monster,
                             const CanonicalCookie& cookie,
                             DeleteCallback callback)
-      : DeleteTask<int>(cookie_monster, std::move(callback)), cookie_(cookie) {}
+      : DeleteTask<uint32_t>(cookie_monster, std::move(callback)),
+        cookie_(cookie) {}
 
   // DeleteTask:
-  int RunDeleteTask() override;
+  uint32_t RunDeleteTask() override;
 
  protected:
   ~DeleteCanonicalCookieTask() override {}
 
  private:
   CanonicalCookie cookie_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCanonicalCookieTask);
 };
 
-int CookieMonster::DeleteCanonicalCookieTask::RunDeleteTask() {
+uint32_t CookieMonster::DeleteCanonicalCookieTask::RunDeleteTask() {
   return this->cookie_monster()->DeleteCanonicalCookie(cookie_);
 }
 
 // Task class for SetCanonicalCookie call.
 class CookieMonster::SetCanonicalCookieTask : public CookieMonsterTask {
  public:
   SetCanonicalCookieTask(CookieMonster* cookie_monster,
                          std::unique_ptr<CanonicalCookie> cookie,
                          bool secure_source,
                          bool modify_http_only,
@@ skipping 160 matching lines @@
   std::string cookie_name_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCookieTask);
 };
 
 void CookieMonster::DeleteCookieTask::RunDeleteTask() {
   this->cookie_monster()->DeleteCookie(url_, cookie_name_);
 }
 
 // Task class for DeleteSessionCookies call.
-class CookieMonster::DeleteSessionCookiesTask : public DeleteTask<int> {
+class CookieMonster::DeleteSessionCookiesTask : public DeleteTask<uint32_t> {
  public:
   DeleteSessionCookiesTask(CookieMonster* cookie_monster,
                            DeleteCallback callback)
-      : DeleteTask<int>(cookie_monster, std::move(callback)) {}
+      : DeleteTask<uint32_t>(cookie_monster, std::move(callback)) {}
 
   // DeleteTask:
-  int RunDeleteTask() override;
+  uint32_t RunDeleteTask() override;
 
  protected:
   ~DeleteSessionCookiesTask() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeleteSessionCookiesTask);
 };
 
-int CookieMonster::DeleteSessionCookiesTask::RunDeleteTask() {
+uint32_t CookieMonster::DeleteSessionCookiesTask::RunDeleteTask() {
   return this->cookie_monster()->DeleteSessionCookies();
 }
 
 // Asynchronous CookieMonster API
 
 void CookieMonster::SetCookieWithDetailsAsync(const GURL& url,
                                               const std::string& name,
                                               const std::string& value,
                                               const std::string& domain,
                                               const std::string& path,
@@ skipping 297 matching lines @@
   std::sort(cookie_ptrs.begin(), cookie_ptrs.end(), CookieSorter);
 
   cookies.reserve(cookie_ptrs.size());
   for (std::vector<CanonicalCookie*>::const_iterator it = cookie_ptrs.begin();
        it != cookie_ptrs.end(); it++)
     cookies.push_back(**it);
 
   return cookies;
 }
 
-int CookieMonster::DeleteAllCreatedBetween(const Time& delete_begin,
-                                           const Time& delete_end) {
+uint32_t CookieMonster::DeleteAllCreatedBetween(const Time& delete_begin,
+                                                const Time& delete_end) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  int num_deleted = 0;
+  uint32_t num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     CanonicalCookie* cc = curit->second.get();
     ++it;
 
     if (cc->CreationDate() >= delete_begin &&
         (delete_end.is_null() || cc->CreationDate() < delete_end)) {
       InternalDeleteCookie(curit, true, /*sync_to_store*/
                            DELETE_COOKIE_CREATED_BETWEEN);
       ++num_deleted;
     }
   }
 
   return num_deleted;
 }
 
-int CookieMonster::DeleteAllCreatedBetweenWithPredicate(
+uint32_t CookieMonster::DeleteAllCreatedBetweenWithPredicate(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const base::Callback<bool(const CanonicalCookie&)>& predicate) {
-  int num_deleted = 0;
+  uint32_t num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     CanonicalCookie* cc = curit->second.get();
     ++it;
 
     if (cc->CreationDate() >= delete_begin &&
         // The assumption that null |delete_end| is equivalent to
         // Time::Max() is confusing.
         (delete_end.is_null() || cc->CreationDate() < delete_end) &&
         predicate.Run(*cc)) {
@@ skipping 62 matching lines @@
 
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     ++it;
     if (matching_cookies.find(curit->second.get()) != matching_cookies.end()) {
       InternalDeleteCookie(curit, true, DELETE_COOKIE_SINGLE);
     }
   }
 }
 
-int CookieMonster::DeleteCanonicalCookie(const CanonicalCookie& cookie) {
+uint32_t CookieMonster::DeleteCanonicalCookie(const CanonicalCookie& cookie) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   for (CookieMapItPair its = cookies_.equal_range(GetKey(cookie.Domain()));
        its.first != its.second; ++its.first) {
     // The creation date acts as the unique index...
     if (its.first->second->CreationDate() == cookie.CreationDate()) {
       InternalDeleteCookie(its.first, true, DELETE_COOKIE_CANONICAL);
-      return 1;
+      return 1u;
     }
   }
-  return 0;
+  return 0u;
 }
 
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!store_.get()) << "This method is only to be used by unit-tests.";
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
   MarkCookieStoreAsInitialized();
   if (ShouldFetchAllCookiesWhenFetchingAnyCookie())
     FetchAllCookiesIfNecessary();
 
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, creation_time,
                                              CookieOptions());
 }
 
-int CookieMonster::DeleteSessionCookies() {
+uint32_t CookieMonster::DeleteSessionCookies() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  int num_deleted = 0;
+  uint32_t num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     CanonicalCookie* cc = curit->second.get();
     ++it;
 
     if (!cc->IsPersistent()) {
       InternalDeleteCookie(curit, true, /*sync_to_store*/
                            DELETE_COOKIE_EXPIRED);
       ++num_deleted;
     }
@@ skipping 1135 matching lines @@
        it != hook_map_.end(); ++it) {
     std::pair<GURL, std::string> key = it->first;
     if (cookie.IncludeForRequestURL(key.first, opts) &&
         cookie.Name() == key.second) {
       it->second->Notify(cookie, cause);
     }
   }
 }
 
 }  // namespace net