Convert WaitableEvent::EventCallback to OnceCallback

base/synchronization/waitable_event_watcher_posix.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 "base/synchronization/waitable_event_watcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 43 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Flag);
 };
 
 // -----------------------------------------------------------------------------
 // This is an asynchronous waiter which posts a task to a SequencedTaskRunner
 // when fired. An AsyncWaiter may only be in a single wait-list.
 // -----------------------------------------------------------------------------
 class AsyncWaiter : public WaitableEvent::Waiter {
  public:
   AsyncWaiter(scoped_refptr<SequencedTaskRunner> task_runner,
-              const base::Closure& callback,
+              base::OnceClosure callback,

[Tom Sepez, 2017/04/14 18:49:55]

Funny, I thought this would have to be a base::OnceClosure&& but I guess it
works ...

[dcheng, 2017/04/14 21:56:58]

In Google/Chromium, move-only types are passed by value (for anything that's not
a move constructor/assignment operator). This works because the callsites have
to turn the parameter into an rvalue with std::move(), so this invokes the move
constructor when calling the function.

               Flag* flag)
       : task_runner_(std::move(task_runner)),
-        callback_(callback),
+        callback_(std::move(callback)),
         flag_(flag) {}
 
   bool Fire(WaitableEvent* event) override {
     // Post the callback if we haven't been cancelled.
     if (!flag_->value())
-      task_runner_->PostTask(FROM_HERE, callback_);
+      task_runner_->PostTask(FROM_HERE, std::move(callback_));
 
     // We are removed from the wait-list by the WaitableEvent itself. It only
     // remains to delete ourselves.
     delete this;
 
     // We can always return true because an AsyncWaiter is never in two
     // different wait-lists at the same time.
     return true;
   }
 
   // See StopWatching for discussion
   bool Compare(void* tag) override { return tag == flag_.get(); }
 
  private:
   const scoped_refptr<SequencedTaskRunner> task_runner_;
-  const base::Closure callback_;
+  base::OnceClosure callback_;
   const scoped_refptr<Flag> flag_;
 };
 
 // -----------------------------------------------------------------------------
 // For async waits we need to run a callback on a sequence. We do this by
 // posting an AsyncCallbackHelper task, which calls the callback and keeps track
 // of when the event is canceled.
 // -----------------------------------------------------------------------------
 void AsyncCallbackHelper(Flag* flag,
-                         const WaitableEventWatcher::EventCallback& callback,
+                         WaitableEventWatcher::EventCallback callback,
                          WaitableEvent* event) {
   // Runs on the sequence that called StartWatching().
   if (!flag->value()) {
     // This is to let the WaitableEventWatcher know that the event has occured.
     flag->Set();
-    callback.Run(event);
+    std::move(callback).Run(event);
   }
 }
 
 WaitableEventWatcher::WaitableEventWatcher() {
   sequence_checker_.DetachFromSequence();
 }
 
 WaitableEventWatcher::~WaitableEventWatcher() {
   // The destructor may be called from a different sequence than StartWatching()
   // when there is no active watch. To avoid triggering a DCHECK in
   // StopWatching(), do not call it when there is no active watch.
   if (cancel_flag_ && !cancel_flag_->value())
     StopWatching();
 }
 
 // -----------------------------------------------------------------------------
 // The Handle is how the user cancels a wait. After deleting the Handle we
 // insure that the delegate cannot be called.
 // -----------------------------------------------------------------------------
-bool WaitableEventWatcher::StartWatching(
-    WaitableEvent* event,
-    const EventCallback& callback) {
+bool WaitableEventWatcher::StartWatching(WaitableEvent* event,
+                                         EventCallback callback) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(SequencedTaskRunnerHandle::Get());
 
   // A user may call StartWatching from within the callback function. In this
   // case, we won't know that we have finished watching, expect that the Flag
   // will have been set in AsyncCallbackHelper().
   if (cancel_flag_.get() && cancel_flag_->value())
     cancel_flag_ = nullptr;
 
   DCHECK(!cancel_flag_) << "StartWatching called while still watching";
 
   cancel_flag_ = new Flag;
-  const Closure internal_callback = base::Bind(
-      &AsyncCallbackHelper, base::RetainedRef(cancel_flag_), callback, event);
+  OnceClosure internal_callback =
+      base::BindOnce(&AsyncCallbackHelper, base::RetainedRef(cancel_flag_),
+                     std::move(callback), event);
   WaitableEvent::WaitableEventKernel* kernel = event->kernel_.get();
 
   AutoLock locked(kernel->lock_);
 
   if (kernel->signaled_) {
     if (!kernel->manual_reset_)
       kernel->signaled_ = false;
 
     // No hairpinning - we can't call the delegate directly here. We have to
     // post a task to the SequencedTaskRunnerHandle as usual.
-    SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE, internal_callback);
+    SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                               std::move(internal_callback));
     return true;
   }
 
   kernel_ = kernel;
-  waiter_ = new AsyncWaiter(SequencedTaskRunnerHandle::Get(), internal_callback,
-                            cancel_flag_.get());
+  waiter_ = new AsyncWaiter(SequencedTaskRunnerHandle::Get(),
+                            std::move(internal_callback), cancel_flag_.get());
   event->Enqueue(waiter_);
 
   return true;
 }
 
 void WaitableEventWatcher::StopWatching() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!cancel_flag_.get())  // if not currently watching...
     return;
@@ skipping 55 matching lines @@
   // If the waiter has already run then the task has been enqueued. If the Task
   // hasn't yet run, the flag will stop the delegate from getting called. (This
   // is thread safe because one may only delete a Handle from the sequence that
   // called StartWatching()).
   //
   // If the delegate has already been called then we have nothing to do. The
   // task has been deleted by the MessageLoop.
 }
 
 }  // namespace base