Adopt base::OnceCallback in base::BarrierClosure

base::BarrierClosure calls the given callback object only once upon the
Nth invocation of resulting wrapper callback. That means, the wrapped
callback should be OnceCallback, and the resulting callback should be
RepeatingCallback.

BUG=714018

Review-Url: https://codereview.chromium.org/2833293004
Cr-Commit-Position: refs/heads/master@{#467664}

base/barrier_closure.cc

@@ -4,50 +4,48 @@
 
 #include "base/barrier_closure.h"
 
+#include <utility>
+
 #include "base/atomic_ref_count.h"
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 
+namespace base {
 namespace {
 
 // Maintains state for a BarrierClosure.
 class BarrierInfo {
  public:
-  BarrierInfo(int num_callbacks_left, const base::Closure& done_closure);
+  BarrierInfo(int num_callbacks_left, OnceClosure done_closure);
   void Run();
 
  private:
-  base::AtomicRefCount num_callbacks_left_;
-  base::Closure done_closure_;
+  AtomicRefCount num_callbacks_left_;
+  OnceClosure done_closure_;
 };
 
-BarrierInfo::BarrierInfo(int num_callbacks, const base::Closure& done_closure)
+BarrierInfo::BarrierInfo(int num_callbacks, OnceClosure done_closure)
     : num_callbacks_left_(num_callbacks),
-      done_closure_(done_closure) {
-}
+      done_closure_(std::move(done_closure)) {}
 
 void BarrierInfo::Run() {
-  DCHECK(!base::AtomicRefCountIsZero(&num_callbacks_left_));
-  if (!base::AtomicRefCountDec(&num_callbacks_left_)) {
-    base::Closure done_closure = done_closure_;
-    done_closure_.Reset();
-    done_closure.Run();
-  }
+  DCHECK(!AtomicRefCountIsZero(&num_callbacks_left_));
+  if (!AtomicRefCountDec(&num_callbacks_left_))
+    std::move(done_closure_).Run();
 }
 
 }  // namespace
 
-namespace base {
-
-base::Closure BarrierClosure(int num_callbacks_left,
-                             const base::Closure& done_closure) {
+RepeatingClosure BarrierClosure(int num_callbacks_left,
+                                OnceClosure done_closure) {
   DCHECK_GE(num_callbacks_left, 0);
 
   if (num_callbacks_left == 0)
-    done_closure.Run();
+    std::move(done_closure).Run();
 
-  return base::Bind(&BarrierInfo::Run,
-                    base::Owned(
-                        new BarrierInfo(num_callbacks_left, done_closure)));
+  return BindRepeating(
+      &BarrierInfo::Run,
+      Owned(new BarrierInfo(num_callbacks_left, std::move(done_closure))));
 }
 
 }  // namespace base

base/barrier_closure.h

@@ -6,7 +6,7 @@
 #define BASE_BARRIER_CLOSURE_H_
 
 #include "base/base_export.h"
-#include "base/callback_forward.h"
+#include "base/callback.h"
 
 namespace base {
 
@@ -19,11 +19,9 @@ namespace base {
 // maintained as a base::AtomicRefCount. |done_closure| will be run on
 // the thread that calls the final Run() on the returned closures.
 //
-// |done_closure| is also Reset() on the final calling thread but due to the
-// refcounted nature of callbacks, it is hard to know what thread resources
-// will be released on.
-BASE_EXPORT base::Closure BarrierClosure(int num_closures,
-                                         const base::Closure& done_closure);
+// |done_closure| is also cleared on the final calling thread.
+BASE_EXPORT RepeatingClosure BarrierClosure(int num_closures,
+                                            OnceClosure done_closure);
 
 }  // namespace base