Shift cookie system callbacks to OnceCallback to impedance match mojo.

net/extras/sqlite/sqlite_persistent_cookie_store.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/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <iterator>
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 106 matching lines @@
   // Batch a cookie addition.
   void AddCookie(const CanonicalCookie& cc);
 
   // Batch a cookie access time update.
   void UpdateCookieAccessTime(const CanonicalCookie& cc);
 
   // Batch a cookie deletion.
   void DeleteCookie(const CanonicalCookie& cc);
 
   // Commit pending operations as soon as possible.
-  void Flush(const base::Closure& callback);
+  void Flush(base::OnceClosure callback);
 
   // Commit any pending operations and close the database.  This must be called
   // before the object is destructed.
   void Close(const base::Closure& callback);
 
   // Post background delete of all cookies that match |cookies|.
   void DeleteAllInList(const std::list<CookieOrigin>& cookies);
 
  private:
   friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>;
@@ skipping 37 matching lines @@
                                     const LoadedCallback& loaded_callback,
                                     const base::Time& posted_at);
 
   // Notifies the CookieMonster when loading completes for a specific domain key
   // or for all domain keys. Triggers the callback and passes it all cookies
   // that have been loaded from DB since last IO notification.
   void Notify(const LoadedCallback& loaded_callback, bool load_success);
 
   // Flushes (Commits) pending operations on the background runner, and invokes
   // |callback| on the client thread when done.
-  void FlushAndNotifyInBackground(const base::Closure& callback);
+  void FlushAndNotifyInBackground(base::OnceClosure callback);
 
   // Sends notification when the entire store is loaded, and reports metrics
   // for the total time to load and aggregated results from any priority loads
   // that occurred.
   void CompleteLoadInForeground(const LoadedCallback& loaded_callback,
                                 bool load_success);
 
   // Sends notification when a single priority load completes. Updates priority
   // load metric data. The data is sent only after the final load completes.
   void CompleteLoadForKeyInForeground(const LoadedCallback& loaded_callback,
@@ skipping 28 matching lines @@
   void InternalBackgroundClose(const base::Closure& callback);
 
   void DeleteSessionCookiesOnStartup();
 
   void BackgroundDeleteAllInList(const std::list<CookieOrigin>& cookies);
 
   void DatabaseErrorCallback(int error, sql::Statement* stmt);
   void KillDatabase();
 
   void PostBackgroundTask(const tracked_objects::Location& origin,
-                          const base::Closure& task);
+                          base::OnceClosure task);
   void PostClientTask(const tracked_objects::Location& origin,
-                      const base::Closure& task);
+                      base::OnceClosure task);
 
   // Shared code between the different load strategies to be used after all
   // cookies have been loaded.
   void FinishedLoadingCookies(const LoadedCallback& loaded_callback,
                               bool success);
 
   const base::FilePath path_;
   std::unique_ptr<sql::Connection> db_;
   sql::MetaTable meta_table_;
 
@@ skipping 292 matching lines @@
   }
 
   PostClientTask(
       FROM_HERE,
       base::Bind(
           &SQLitePersistentCookieStore::Backend::CompleteLoadForKeyInForeground,
           this, loaded_callback, success, posted_at));
 }
 
 void SQLitePersistentCookieStore::Backend::FlushAndNotifyInBackground(
-    const base::Closure& callback) {
+    base::OnceClosure callback) {
   Commit();
   if (!callback.is_null())
-    PostClientTask(FROM_HERE, callback);
+    PostClientTask(FROM_HERE, std::move(callback));
 }
 
 void SQLitePersistentCookieStore::Backend::CompleteLoadForKeyInForeground(
     const LoadedCallback& loaded_callback,
     bool load_success,
     const ::Time& requested_at) {
   DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
 
   UMA_HISTOGRAM_CUSTOM_TIMES("Cookie.TimeKeyLoadTotalWait",
                              base::Time::Now() - requested_at,
@@ skipping 631 matching lines @@
       default:
         NOTREACHED();
         break;
     }
   }
   bool succeeded = transaction.Commit();
   UMA_HISTOGRAM_ENUMERATION("Cookie.BackingStoreUpdateResults",
                             succeeded ? 0 : 1, 2);
 }
 
-void SQLitePersistentCookieStore::Backend::Flush(
-    const base::Closure& callback) {
+void SQLitePersistentCookieStore::Backend::Flush(base::OnceClosure callback) {
   DCHECK(!background_task_runner_->RunsTasksInCurrentSequence());
-  PostBackgroundTask(FROM_HERE, base::Bind(&Backend::FlushAndNotifyInBackground,
-                                           this, callback));
+  PostBackgroundTask(FROM_HERE,
+                     base::BindOnce(&Backend::FlushAndNotifyInBackground, this,
+                                    std::move(callback)));
 }
 
 // Fire off a close message to the background runner.  We could still have a
 // pending commit timer or Load operations holding references on us, but if/when
 // this fires we will already have been cleaned up and it will be ignored.
 void SQLitePersistentCookieStore::Backend::Close(
     const base::Closure& callback) {
   if (background_task_runner_->RunsTasksInCurrentSequence()) {
     InternalBackgroundClose(callback);
   } else {
@@ skipping 116 matching lines @@
     if (!del_smt.Run())
       NOTREACHED() << "Could not delete a cookie from the DB.";
   }
 
   if (!transaction.Commit())
     LOG(WARNING) << "Unable to delete cookies on shutdown.";
 }
 
 void SQLitePersistentCookieStore::Backend::PostBackgroundTask(
     const tracked_objects::Location& origin,
-    const base::Closure& task) {
-  if (!background_task_runner_->PostTask(origin, task)) {
+    base::OnceClosure task) {
+  if (!background_task_runner_->PostTask(origin, std::move(task))) {
     LOG(WARNING) << "Failed to post task from " << origin.ToString()
                  << " to background_task_runner_.";
   }
 }
 
 void SQLitePersistentCookieStore::Backend::PostClientTask(
     const tracked_objects::Location& origin,
-    const base::Closure& task) {
-  if (!client_task_runner_->PostTask(origin, task)) {
+    base::OnceClosure task) {
+  if (!client_task_runner_->PostTask(origin, std::move(task))) {
     LOG(WARNING) << "Failed to post task from " << origin.ToString()
                  << " to client_task_runner_.";
   }
 }
 
 void SQLitePersistentCookieStore::Backend::FinishedLoadingCookies(
     const LoadedCallback& loaded_callback,
     bool success) {
   PostClientTask(FROM_HERE, base::Bind(&Backend::CompleteLoadInForeground, this,
                                        loaded_callback, success));
@@ skipping 60 matching lines @@
 
 void SQLitePersistentCookieStore::DeleteCookie(const CanonicalCookie& cc) {
   if (backend_)
     backend_->DeleteCookie(cc);
 }
 
 void SQLitePersistentCookieStore::SetForceKeepSessionState() {
   // This store never discards session-only cookies, so this call has no effect.
 }
 
-void SQLitePersistentCookieStore::Flush(const base::Closure& callback) {
+void SQLitePersistentCookieStore::Flush(base::OnceClosure callback) {
   if (backend_)
-    backend_->Flush(callback);
+    backend_->Flush(std::move(callback));
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
   Close(base::Closure());
 }
 
 }  // namespace net