Shift cookie system callbacks to OnceCallback to impedance match mojo.

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 413 matching lines @@
                            const std::string& value,
                            const std::string& domain,
                            const std::string& path,
                            base::Time creation_time,
                            base::Time expiration_time,
                            base::Time last_access_time,
                            bool secure,
                            bool http_only,
                            CookieSameSite same_site,
                            CookiePriority priority,
-                           const SetCookiesCallback& callback)
+                           SetCookiesCallback callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         name_(name),
         value_(value),
         domain_(domain),
         path_(path),
         creation_time_(creation_time),
         expiration_time_(expiration_time),
         last_access_time_(last_access_time),
         secure_(secure),
         http_only_(http_only),
         same_site_(same_site),
         priority_(priority),
-        callback_(callback) {}
+        callback_(std::move(callback)) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~SetCookieWithDetailsTask() override {}
 
  private:
   GURL url_;
   std::string name_;
@@ skipping 10 matching lines @@
   SetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetCookieWithDetailsTask);
 };
 
 void CookieMonster::SetCookieWithDetailsTask::Run() {
   bool success = this->cookie_monster()->SetCookieWithDetails(
       url_, name_, value_, domain_, path_, creation_time_, expiration_time_,
       last_access_time_, secure_, http_only_, same_site_, priority_);
   if (!callback_.is_null())
-    callback_.Run(success);
+    std::move(callback_).Run(success);
 }
 
 // Task class for GetAllCookies call.
 class CookieMonster::GetAllCookiesTask : public CookieMonsterTask {
  public:
   GetAllCookiesTask(CookieMonster* cookie_monster,
-                    const GetCookieListCallback& callback)
-      : CookieMonsterTask(cookie_monster), callback_(callback) {}
+                    GetCookieListCallback callback)
+      : CookieMonsterTask(cookie_monster), callback_(std::move(callback)) {}
 
   // CookieMonsterTask
   void Run() override;
 
  protected:
   ~GetAllCookiesTask() override {}
 
  private:
   GetCookieListCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetAllCookiesTask);
 };
 
 void CookieMonster::GetAllCookiesTask::Run() {
   if (!callback_.is_null()) {
     CookieList cookies = this->cookie_monster()->GetAllCookies();
-    callback_.Run(cookies);
+    std::move(callback_).Run(cookies);
   }
 }
 
 // Task class for GetCookieListWithOptionsAsync call.
 class CookieMonster::GetCookieListWithOptionsTask : public CookieMonsterTask {
  public:
   GetCookieListWithOptionsTask(CookieMonster* cookie_monster,
                                const GURL& url,
                                const CookieOptions& options,
-                               const GetCookieListCallback& callback)
+                               GetCookieListCallback callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
-        callback_(callback) {}
+        callback_(std::move(callback)) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~GetCookieListWithOptionsTask() override {}
 
  private:
   GURL url_;
   CookieOptions options_;
   GetCookieListCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetCookieListWithOptionsTask);
 };
 
 void CookieMonster::GetCookieListWithOptionsTask::Run() {
   if (!callback_.is_null()) {
     CookieList cookies =
         this->cookie_monster()->GetCookieListWithOptions(url_, options_);
-    callback_.Run(cookies);
+    std::move(callback_).Run(cookies);
   }
 }
 
 template <typename Result>
 struct CallbackType {
-  typedef base::Callback<void(Result)> Type;
+  typedef base::OnceCallback<void(Result)> Type;
 };
 
 template <>
 struct CallbackType<void> {
-  typedef base::Closure Type;
+  typedef base::OnceClosure Type;
 };
 
 // Base task class for Delete*Task.
 template <typename Result>
 class CookieMonster::DeleteTask : public CookieMonsterTask {
  public:
   DeleteTask(CookieMonster* cookie_monster,
-             const typename CallbackType<Result>::Type& callback)
-      : CookieMonsterTask(cookie_monster), callback_(callback) {}
+             typename CallbackType<Result>::Type callback)
+      : CookieMonsterTask(cookie_monster), callback_(std::move(callback)) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~DeleteTask() override;
 
  private:
   // Runs the delete task and returns a result.
   virtual Result RunDeleteTask() = 0;
   // Runs the delete task and then returns a callback to be called after
   // flushing the persistent store.
   // TODO(mmenke): This seems like a pretty ugly and needlessly confusing API.
   // Simplify it?
-  base::Closure RunDeleteTaskAndBindCallback();
+  base::OnceClosure RunDeleteTaskAndBindCallback();
 
   typename CallbackType<Result>::Type callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteTask);
 };
 
 template <typename Result>
 CookieMonster::DeleteTask<Result>::~DeleteTask() {
 }
 
 template <typename Result>
-base::Closure
+base::OnceClosure
 CookieMonster::DeleteTask<Result>::RunDeleteTaskAndBindCallback() {
   Result result = RunDeleteTask();
   if (callback_.is_null())
-    return base::Closure();
-  return base::Bind(callback_, result);
+    return base::OnceClosure();
+  return base::BindOnce(std::move(callback_), result);
 }
 
 template <>
-base::Closure CookieMonster::DeleteTask<void>::RunDeleteTaskAndBindCallback() {
+base::OnceClosure
+CookieMonster::DeleteTask<void>::RunDeleteTaskAndBindCallback() {
   RunDeleteTask();
-  return callback_;
+  return std::move(callback_);
 }
 
 template <typename Result>
 void CookieMonster::DeleteTask<Result>::Run() {
-  base::Closure callback = RunDeleteTaskAndBindCallback();
+  base::OnceClosure callback = RunDeleteTaskAndBindCallback();
   if (!callback.is_null()) {
-    callback = base::Bind(
-        &CookieMonster::RunCallback,
-        this->cookie_monster()->weak_ptr_factory_.GetWeakPtr(), callback);
+    callback =
+        base::BindOnce(&CookieMonster::RunCallback,
+                       this->cookie_monster()->weak_ptr_factory_.GetWeakPtr(),
+                       std::move(callback));
   }
-  this->cookie_monster()->FlushStore(callback);
+  this->cookie_monster()->FlushStore(std::move(callback));
 }
 
 // Task class for DeleteAllCreatedBetween call.
 class CookieMonster::DeleteAllCreatedBetweenTask : public DeleteTask<int> {
  public:
   DeleteAllCreatedBetweenTask(CookieMonster* cookie_monster,
                               const Time& delete_begin,
                               const Time& delete_end,
-                              const DeleteCallback& callback)
-      : DeleteTask<int>(cookie_monster, callback),
+                              DeleteCallback callback)
+      : DeleteTask<int>(cookie_monster, std::move(callback)),
         delete_begin_(delete_begin),
         delete_end_(delete_end) {}
 
   // DeleteTask:
   int RunDeleteTask() override;
 
  protected:
   ~DeleteAllCreatedBetweenTask() override {}
 
  private:
@@ skipping 10 matching lines @@
 
 // Task class for DeleteAllCreatedBetweenWithPredicate call.
 class CookieMonster::DeleteAllCreatedBetweenWithPredicateTask
     : public DeleteTask<int> {
  public:
   DeleteAllCreatedBetweenWithPredicateTask(
       CookieMonster* cookie_monster,
       Time delete_begin,
       Time delete_end,
       base::Callback<bool(const CanonicalCookie&)> predicate,
-      const DeleteCallback& callback)
-      : DeleteTask<int>(cookie_monster, callback),
+      DeleteCallback callback)
+      : DeleteTask<int>(cookie_monster, std::move(callback)),
         delete_begin_(delete_begin),
         delete_end_(delete_end),
         predicate_(predicate) {}
 
   // DeleteTask:
   int 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() {
   return this->cookie_monster()->DeleteAllCreatedBetweenWithPredicate(
       delete_begin_, delete_end_, predicate_);
 }
 
 // Task class for DeleteCanonicalCookie call.
 class CookieMonster::DeleteCanonicalCookieTask : public DeleteTask<int> {
  public:
   DeleteCanonicalCookieTask(CookieMonster* cookie_monster,
                             const CanonicalCookie& cookie,
-                            const DeleteCallback& callback)
-      : DeleteTask<int>(cookie_monster, callback), cookie_(cookie) {}
+                            DeleteCallback callback)
+      : DeleteTask<int>(cookie_monster, std::move(callback)), cookie_(cookie) {}
 
   // DeleteTask:
   int RunDeleteTask() override;
 
  protected:
   ~DeleteCanonicalCookieTask() override {}
 
  private:
   CanonicalCookie cookie_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCanonicalCookieTask);
 };
 
 int 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,
-                         const SetCookiesCallback& callback)
+                         SetCookiesCallback callback)
       : CookieMonsterTask(cookie_monster),
         cookie_(std::move(cookie)),
         secure_source_(secure_source),
         modify_http_only_(modify_http_only),
-        callback_(callback) {}
+        callback_(std::move(callback)) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~SetCanonicalCookieTask() override {}
 
  private:
   std::unique_ptr<CanonicalCookie> cookie_;
   bool secure_source_;
   bool modify_http_only_;
   SetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetCanonicalCookieTask);
 };
 
 void CookieMonster::SetCanonicalCookieTask::Run() {
   bool result = this->cookie_monster()->SetCanonicalCookie(
       std::move(cookie_), secure_source_, modify_http_only_);
   if (!callback_.is_null())
-    callback_.Run(result);
+    std::move(callback_).Run(result);
 }
 
 // Task class for SetCookieWithOptions call.
 class CookieMonster::SetCookieWithOptionsTask : public CookieMonsterTask {
  public:
   SetCookieWithOptionsTask(CookieMonster* cookie_monster,
                            const GURL& url,
                            const std::string& cookie_line,
                            const CookieOptions& options,
-                           const SetCookiesCallback& callback)
+                           SetCookiesCallback callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         cookie_line_(cookie_line),
         options_(options),
-        callback_(callback) {}
+        callback_(std::move(callback)) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~SetCookieWithOptionsTask() override {}
 
  private:
   GURL url_;
   std::string cookie_line_;
   CookieOptions options_;
   SetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetCookieWithOptionsTask);
 };
 
 void CookieMonster::SetCookieWithOptionsTask::Run() {
   bool result = this->cookie_monster()->SetCookieWithOptions(url_, cookie_line_,
                                                              options_);
   if (!callback_.is_null())
-    callback_.Run(result);
+    std::move(callback_).Run(result);
 }
 
 // Task class for SetAllCookies call.
 class CookieMonster::SetAllCookiesTask : public CookieMonsterTask {
  public:
   SetAllCookiesTask(CookieMonster* cookie_monster,
                     const CookieList& list,
-                    const SetCookiesCallback& callback)
-      : CookieMonsterTask(cookie_monster), list_(list), callback_(callback) {}
+                    SetCookiesCallback callback)
+      : CookieMonsterTask(cookie_monster),
+        list_(list),
+        callback_(std::move(callback)) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~SetAllCookiesTask() override {}
 
  private:
   CookieList list_;
   SetCookiesCallback callback_;
@@ skipping 11 matching lines @@
   for (CookieList::const_iterator it = negative_diff.begin();
        it != negative_diff.end(); ++it) {
     this->cookie_monster()->DeleteCanonicalCookie(*it);
   }
 
   bool result = true;
   if (positive_diff.size() > 0)
     result = this->cookie_monster()->SetAllCookies(list_);
 
   if (!callback_.is_null())
-    callback_.Run(result);
+    std::move(callback_).Run(result);
 }
 
 // Task class for GetCookiesWithOptions call.
 class CookieMonster::GetCookiesWithOptionsTask : public CookieMonsterTask {
  public:
   GetCookiesWithOptionsTask(CookieMonster* cookie_monster,
                             const GURL& url,
                             const CookieOptions& options,
-                            const GetCookiesCallback& callback)
+                            GetCookiesCallback callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
-        callback_(callback) {}
+        callback_(std::move(callback)) {}
 
   // CookieMonsterTask:
   void Run() override;
 
  protected:
   ~GetCookiesWithOptionsTask() override {}
 
  private:
   GURL url_;
   CookieOptions options_;
   GetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetCookiesWithOptionsTask);
 };
 
 void CookieMonster::GetCookiesWithOptionsTask::Run() {
   std::string cookie =
       this->cookie_monster()->GetCookiesWithOptions(url_, options_);
   if (!callback_.is_null())
-    callback_.Run(cookie);
+    std::move(callback_).Run(cookie);
 }
 
 // Task class for DeleteCookie call.
 class CookieMonster::DeleteCookieTask : public DeleteTask<void> {
  public:
   DeleteCookieTask(CookieMonster* cookie_monster,
                    const GURL& url,
                    const std::string& cookie_name,
-                   const base::Closure& callback)
-      : DeleteTask<void>(cookie_monster, callback),
+                   base::OnceClosure callback)
+      : DeleteTask<void>(cookie_monster, std::move(callback)),
         url_(url),
         cookie_name_(cookie_name) {}
 
   // DeleteTask:
   void RunDeleteTask() override;
 
  protected:
   ~DeleteCookieTask() override {}
 
  private:
   GURL url_;
   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> {
  public:
   DeleteSessionCookiesTask(CookieMonster* cookie_monster,
-                           const DeleteCallback& callback)
-      : DeleteTask<int>(cookie_monster, callback) {}
+                           DeleteCallback callback)
+      : DeleteTask<int>(cookie_monster, std::move(callback)) {}
 
   // DeleteTask:
   int RunDeleteTask() override;
 
  protected:
   ~DeleteSessionCookiesTask() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeleteSessionCookiesTask);
 };
 
 int 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,
-    Time creation_time,
-    Time expiration_time,
-    Time last_access_time,
-    bool secure,
-    bool http_only,
-    CookieSameSite same_site,
-    CookiePriority priority,
-    const SetCookiesCallback& callback) {
+void CookieMonster::SetCookieWithDetailsAsync(const GURL& url,
+                                              const std::string& name,
+                                              const std::string& value,
+                                              const std::string& domain,
+                                              const std::string& path,
+                                              Time creation_time,
+                                              Time expiration_time,
+                                              Time last_access_time,
+                                              bool secure,
+                                              bool http_only,
+                                              CookieSameSite same_site,
+                                              CookiePriority priority,
+                                              SetCookiesCallback callback) {
   scoped_refptr<SetCookieWithDetailsTask> task = new SetCookieWithDetailsTask(
       this, url, name, value, domain, path, creation_time, expiration_time,
-      last_access_time, secure, http_only, same_site, priority, callback);
+      last_access_time, secure, http_only, same_site, priority,
+      std::move(callback));
   DoCookieTaskForURL(task, url);
 }
 
-void CookieMonster::FlushStore(const base::Closure& callback) {
+void CookieMonster::FlushStore(base::OnceClosure callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (initialized_ && store_.get()) {
     if (channel_id_service_) {
       channel_id_service_->GetChannelIDStore()->Flush();
     }
-    store_->Flush(callback);
+    store_->Flush(std::move(callback));
   } else if (!callback.is_null()) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  std::move(callback));
   }
 }
 
 void CookieMonster::SetForceKeepSessionState() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (store_)
     store_->SetForceKeepSessionState();
 }
 
 void CookieMonster::SetAllCookiesAsync(const CookieList& list,
-                                       const SetCookiesCallback& callback) {
+                                       SetCookiesCallback callback) {
   scoped_refptr<SetAllCookiesTask> task =
-      new SetAllCookiesTask(this, list, callback);
+      new SetAllCookiesTask(this, list, std::move(callback));

[kinuko, 2017/06/19 10:52:07]

I wonder if (eventually) these all CookieMonsterTasks could also be move-only /
retained by unique_ptr (looks like the common usage is to push back into
pending_tasks_ and eventually just run it, though I could be missing various
things)

[Randy Smith (Not in Mondays), 2017/06/21 17:54:53]

Yes, I think that would be a good design.  I'd also like to think about whether
they can all be abstracted away by just using callbacks; there's a metric tone
of boilerplate around the CookieMonsterTasks it would be nice to find a way to
get rid of.

   DoCookieTask(task);
 }
 
 void CookieMonster::SetCanonicalCookieAsync(
     std::unique_ptr<CanonicalCookie> cookie,
     bool secure_source,
     bool modify_http_only,
-    const SetCookiesCallback& callback) {
+    SetCookiesCallback callback) {
   DCHECK(cookie->IsCanonical());
-  scoped_refptr<SetCanonicalCookieTask> task = new SetCanonicalCookieTask(
-      this, std::move(cookie), secure_source, modify_http_only, callback);
+  scoped_refptr<SetCanonicalCookieTask> task =
+      new SetCanonicalCookieTask(this, std::move(cookie), secure_source,
+                                 modify_http_only, std::move(callback));
 
   // TODO(rdsmith): Switch to DoCookieTaskForURL (or the equivalent).
   // This is tricky because we don't have the scheme in this routine
   // and DoCookieTaskForURL uses cookie_util::GetEffectiveDomain(scheme, host)
   // to generate the database key to block behind.
   DoCookieTask(task);
 }
 
-void CookieMonster::SetCookieWithOptionsAsync(
-    const GURL& url,
-    const std::string& cookie_line,
-    const CookieOptions& options,
-    const SetCookiesCallback& callback) {
-  scoped_refptr<SetCookieWithOptionsTask> task =
-      new SetCookieWithOptionsTask(this, url, cookie_line, options, callback);
+void CookieMonster::SetCookieWithOptionsAsync(const GURL& url,
+                                              const std::string& cookie_line,
+                                              const CookieOptions& options,
+                                              SetCookiesCallback callback) {
+  scoped_refptr<SetCookieWithOptionsTask> task = new SetCookieWithOptionsTask(
+      this, url, cookie_line, options, std::move(callback));
 
   DoCookieTaskForURL(task, url);
 }
 
-void CookieMonster::GetCookiesWithOptionsAsync(
-    const GURL& url,
-    const CookieOptions& options,
-    const GetCookiesCallback& callback) {
+void CookieMonster::GetCookiesWithOptionsAsync(const GURL& url,
+                                               const CookieOptions& options,
+                                               GetCookiesCallback callback) {
   scoped_refptr<GetCookiesWithOptionsTask> task =
-      new GetCookiesWithOptionsTask(this, url, options, callback);
+      new GetCookiesWithOptionsTask(this, url, options, std::move(callback));
 
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::GetCookieListWithOptionsAsync(
     const GURL& url,
     const CookieOptions& options,
-    const GetCookieListCallback& callback) {
+    GetCookieListCallback callback) {
   scoped_refptr<GetCookieListWithOptionsTask> task =
-      new GetCookieListWithOptionsTask(this, url, options, callback);
+      new GetCookieListWithOptionsTask(this, url, options, std::move(callback));
 
   DoCookieTaskForURL(task, url);
 }
 
-void CookieMonster::GetAllCookiesAsync(const GetCookieListCallback& callback) {
-  scoped_refptr<GetAllCookiesTask> task = new GetAllCookiesTask(this, callback);
+void CookieMonster::GetAllCookiesAsync(GetCookieListCallback callback) {
+  scoped_refptr<GetAllCookiesTask> task =
+      new GetAllCookiesTask(this, std::move(callback));
 
   DoCookieTask(task);
 }
 
 void CookieMonster::DeleteCookieAsync(const GURL& url,
                                       const std::string& cookie_name,
-                                      const base::Closure& callback) {
+                                      base::OnceClosure callback) {
   scoped_refptr<DeleteCookieTask> task =
-      new DeleteCookieTask(this, url, cookie_name, callback);
+      new DeleteCookieTask(this, url, cookie_name, std::move(callback));
 
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
-                                               const DeleteCallback& callback) {
+                                               DeleteCallback callback) {
   scoped_refptr<DeleteCanonicalCookieTask> task =
-      new DeleteCanonicalCookieTask(this, cookie, callback);
+      new DeleteCanonicalCookieTask(this, cookie, std::move(callback));
 
   DoCookieTask(task);
 }
 
-void CookieMonster::DeleteAllCreatedBetweenAsync(
-    const Time& delete_begin,
-    const Time& delete_end,
-    const DeleteCallback& callback) {
+void CookieMonster::DeleteAllCreatedBetweenAsync(const Time& delete_begin,
+                                                 const Time& delete_end,
+                                                 DeleteCallback callback) {
   scoped_refptr<DeleteAllCreatedBetweenTask> task =
-      new DeleteAllCreatedBetweenTask(this, delete_begin, delete_end, callback);
+      new DeleteAllCreatedBetweenTask(this, delete_begin, delete_end,
+                                      std::move(callback));
 
   DoCookieTask(task);
 }
 
 void CookieMonster::DeleteAllCreatedBetweenWithPredicateAsync(
     const Time& delete_begin,
     const Time& delete_end,
     const base::Callback<bool(const CanonicalCookie&)>& predicate,
-    const DeleteCallback& callback) {
+    DeleteCallback callback) {
   if (predicate.is_null()) {
-    callback.Run(0);
+    std::move(callback).Run(0);
     return;
   }
   scoped_refptr<DeleteAllCreatedBetweenWithPredicateTask> task =
       new DeleteAllCreatedBetweenWithPredicateTask(
-          this, delete_begin, delete_end, predicate, callback);
+          this, delete_begin, delete_end, predicate, std::move(callback));
   DoCookieTask(task);
 }
 
 void CookieMonster::DeleteSessionCookiesAsync(
-    const CookieStore::DeleteCallback& callback) {
+    CookieStore::DeleteCallback callback) {
   scoped_refptr<DeleteSessionCookiesTask> task =
-      new DeleteSessionCookiesTask(this, callback);
+      new DeleteSessionCookiesTask(this, std::move(callback));
 
   DoCookieTask(task);
 }
 
 void CookieMonster::SetCookieableSchemes(
     const std::vector<std::string>& schemes) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Calls to this method will have no effect if made after a WebView or
   // CookieManager instance has been created.
@@ skipping 1416 matching lines @@
       PartialDiffCookieSorter);
 
   // Select any new cookie for addition (or update) if no old cookie is exactly
   // equivalent.
   std::set_difference(new_cookies->begin(), new_cookies->end(),
                       old_cookies->begin(), old_cookies->end(),
                       std::inserter(*cookies_to_add, cookies_to_add->begin()),
                       FullDiffCookieSorter);
 }
 
-void CookieMonster::RunCallback(const base::Closure& callback) {
+void CookieMonster::RunCallback(base::OnceClosure callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  callback.Run();
+  std::move(callback).Run();
 }
 
 void CookieMonster::RunCookieChangedCallbacks(const CanonicalCookie& cookie,
                                               ChangeCause cause) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CookieOptions opts;
   opts.set_include_httponly();
   opts.set_same_site_cookie_mode(
       CookieOptions::SameSiteCookieMode::INCLUDE_STRICT_AND_LAX);
   // Note that the callbacks in hook_map_ are wrapped with RunAsync(), so they
   // are guaranteed to not take long - they just post a RunAsync task back to
   // the appropriate thread's message loop and return.
   // TODO(mmenke): Consider running these synchronously?
   for (CookieChangedHookMap::iterator it = hook_map_.begin();
        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