Convert WaitableEvent::EventCallback to OnceCallback

ipc/ipc_sync_channel.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 "ipc/ipc_sync_channel.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 70 matching lines @@
   // is swapped back into |ReceivedSyncMsgQueue::top_send_done_event_watcher_|,
   // and its watch is resumed immediately.
   class NestedSendDoneWatcher {
    public:
     NestedSendDoneWatcher(SyncChannel::SyncContext* context,
                           base::RunLoop* run_loop)
         : sync_msg_queue_(context->received_sync_msgs()),
           outer_state_(sync_msg_queue_->top_send_done_event_watcher_),
           event_(context->GetSendDoneEvent()),
           callback_(
-              base::Bind(&SyncChannel::SyncContext::OnSendDoneEventSignaled,
-                         context,
-                         run_loop)) {
+              base::BindOnce(&SyncChannel::SyncContext::OnSendDoneEventSignaled,
+                             context,
+                             run_loop)) {
       sync_msg_queue_->top_send_done_event_watcher_ = this;
       if (outer_state_)
         outer_state_->StopWatching();
       StartWatching();
     }
 
     ~NestedSendDoneWatcher() {
       sync_msg_queue_->top_send_done_event_watcher_ = outer_state_;
       if (outer_state_)
         outer_state_->StartWatching();
     }
 
    private:
-    void StartWatching() { watcher_.StartWatching(event_, callback_); }
+    void Run(WaitableEvent* event) {
+      DCHECK(callback_);
+      std::move(callback_).Run(event);
+    }
+
+    void StartWatching() {
+      watcher_.StartWatching(event_, base::BindOnce(&NestedSendDoneWatcher::Run,
+                                                    base::Unretained(this)));

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

Out of curiosity, why do we need this intermediate OnceCallback? It seems like
we could just std::move(callback_) here.

[tzik, 2017/04/17 08:28:34]

StartWatching/StopWatching may be called more than once by other
NestedSendDoneWatcher instances (as |outer_state_| of the other instance), so we
can not consume |callback_| here.

+    }
+
     void StopWatching() { watcher_.StopWatching(); }
 
     ReceivedSyncMsgQueue* const sync_msg_queue_;
     NestedSendDoneWatcher* const outer_state_;
 
     base::WaitableEvent* const event_;
-    const base::WaitableEventWatcher::EventCallback callback_;
+    base::WaitableEventWatcher::EventCallback callback_;
     base::WaitableEventWatcher watcher_;
 
     DISALLOW_COPY_AND_ASSIGN(NestedSendDoneWatcher);
   };
 
   // Returns the ReceivedSyncMsgQueue instance for this thread, creating one
   // if necessary.  Call RemoveContext on the same thread when done.
   static ReceivedSyncMsgQueue* AddContext() {
     // We want one ReceivedSyncMsgQueue per listener thread (i.e. since multiple
     // SyncChannel objects can block the same thread).
@@ skipping 573 matching lines @@
       sync_context()->GetDispatchEvent(),
       base::Bind(&SyncChannel::OnDispatchEventSignaled,
                  base::Unretained(this)));
 }
 
 void SyncChannel::OnChannelInit() {
   pre_init_sync_message_filters_.clear();
 }
 
 }  // namespace IPC