CacheStorage: Migrate to BindOnce/OnceCallback/OnceClosure

content/browser/cache_storage/cache_storage_scheduler.h

 // Copyright 2015 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 CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_SCHEDULER_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_SCHEDULER_H_
 
 #include <list>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 // operation by calling ScheduleOperation() with your callback. Once your
 // operation is done be sure to call CompleteOperationAndRunNext() to schedule
 // the next operation.
 class CONTENT_EXPORT CacheStorageScheduler {
  public:
   explicit CacheStorageScheduler(CacheStorageSchedulerClient client_type);
   virtual ~CacheStorageScheduler();
 
   // Adds the operation to the tail of the queue and starts it if the scheduler
   // is idle.
-  void ScheduleOperation(const base::Closure& closure);
+  void ScheduleOperation(base::OnceClosure closure);
 
   // Call this after each operation completes. It cleans up the current
   // operation and starts the next.
   void CompleteOperationAndRunNext();
 
   // Returns true if there are any running or pending operations.
   bool ScheduledOperations() const;
 
   // Wraps |callback| to also call CompleteOperationAndRunNext.
   template <typename... Args>
-  base::Callback<void(Args...)> WrapCallbackToRunNext(
-      const base::Callback<void(Args...)>& callback) {
-    return base::Bind(&CacheStorageScheduler::RunNextContinuation<Args...>,
-                      weak_ptr_factory_.GetWeakPtr(), callback);
+  base::OnceCallback<void(Args...)> WrapCallbackToRunNext(
+      base::OnceCallback<void(Args...)> callback) {
+    return base::BindOnce(
+        &CacheStorageScheduler::RunNextOnceContinuation<Args...>,
+        weak_ptr_factory_.GetWeakPtr(), std::move(callback));
+  }
+  template <typename... Args>
+  base::RepeatingCallback<void(Args...)> WrapCallbackToRunNext(

[jsbell, 2017/06/19 23:45:00]

The overload is necessary to support background_sync which uses an instance of
CacheStorageScheduler. That should be converted over as well, but it can be a
follow-up CL.

+      const base::RepeatingCallback<void(Args...)>& callback) {
+    return base::BindRepeating(
+        &CacheStorageScheduler::RunNextRepeatingContinuation<Args...>,
+        weak_ptr_factory_.GetWeakPtr(), callback);
   }
 
  private:
   void RunOperationIfIdle();
 
   template <typename... Args>
-  void RunNextContinuation(const base::Callback<void(Args...)>& callback,
-                           Args... args) {
+  void RunNextOnceContinuation(base::OnceCallback<void(Args...)> callback,
+                               Args... args) {
     // Grab a weak ptr to guard against the scheduler being deleted during the
     // callback.
     base::WeakPtr<CacheStorageScheduler> scheduler =
+        weak_ptr_factory_.GetWeakPtr();
+
+    std::move(callback).Run(std::forward<Args>(args)...);
+    if (scheduler)
+      CompleteOperationAndRunNext();
+  }
+  template <typename... Args>
+  void RunNextRepeatingContinuation(
+      const base::RepeatingCallback<void(Args...)>& callback,
+      Args... args) {
+    // Grab a weak ptr to guard against the scheduler being deleted during the
+    // callback.
+    base::WeakPtr<CacheStorageScheduler> scheduler =
         weak_ptr_factory_.GetWeakPtr();
 
     callback.Run(std::forward<Args>(args)...);
     if (scheduler)
       CompleteOperationAndRunNext();
   }
 
   std::list<std::unique_ptr<CacheStorageOperation>> pending_operations_;
   std::unique_ptr<CacheStorageOperation> running_operation_;
   CacheStorageSchedulerClient client_type_;
 
   base::WeakPtrFactory<CacheStorageScheduler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageScheduler);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_SCHEDULER_H_