Refactor: Simplify WaitableEventWatcher.

ipc/ipc_sync_channel.cc

Index: ipc/ipc_sync_channel.cc
diff --git a/ipc/ipc_sync_channel.cc b/ipc/ipc_sync_channel.cc
index a300c0f786702843e48c23ab73069f9fab3e0b42..fe1b70765fa12010de49a50e7a2d72a921b95dc4 100644
--- a/ipc/ipc_sync_channel.cc
+++ b/ipc/ipc_sync_channel.cc
@@ -353,7 +353,9 @@ void SyncChannel::SyncContext::OnChannelError() {
 }
 
 void SyncChannel::SyncContext::OnChannelOpened() {
-  shutdown_watcher_.StartWatching(shutdown_event_, this);
+  shutdown_watcher_.StartWatching(
+      shutdown_event_,
+      base::Bind(&SyncChannel::SyncContext::OnWaitableEventSignaled, this));

[brettw, 2013/02/01 18:19:25]

Does this have the same leak? It seems like any time you don't use unretained
and add a StartWatching callback on yourself, you set up a circular cycle.

[dmichael (off chromium), 2013/02/01 18:26:28]

Oh yeah, I think so. In this case, since the watcher is a member and therefore
won't invoke you after you're destroyed, it's probably safe to use
base::Unretained (maybe with a comment)

[teravest, 2013/02/01 18:30:47]

Done.

   Context::OnChannelOpened();
 }
 
@@ -396,6 +398,10 @@ void SyncChannel::SyncContext::OnWaitableEventSignaled(WaitableEvent* event) {
   }
 }
 
+base::WaitableEventWatcher::EventCallback
+    SyncChannel::SyncContext::MakeWaitableEventCallback() {
+  return base::Bind(&SyncChannel::SyncContext::OnWaitableEventSignaled, this);
+}
 
 SyncChannel::SyncChannel(
     const IPC::ChannelHandle& channel_handle,
@@ -517,21 +523,22 @@ void SyncChannel::WaitForReplyWithNestedMessageLoop(SyncContext* context) {
   base::WaitableEventWatcher* old_send_done_event_watcher =
       sync_msg_queue->top_send_done_watcher();
 
-  base::WaitableEventWatcher::Delegate* old_delegate = NULL;
+  base::WaitableEventWatcher::EventCallback old_callback;
   base::WaitableEvent* old_event = NULL;
 
   // Maintain a local global stack of send done delegates to ensure that
   // nested sync calls complete in the correct sequence, i.e. the
   // outermost call completes first, etc.
   if (old_send_done_event_watcher) {
-    old_delegate = old_send_done_event_watcher->delegate();
+    old_callback = old_send_done_event_watcher->callback();
     old_event = old_send_done_event_watcher->GetWatchedEvent();
     old_send_done_event_watcher->StopWatching();
   }
 
   sync_msg_queue->set_top_send_done_watcher(&send_done_watcher);
 
-  send_done_watcher.StartWatching(context->GetSendDoneEvent(), context);
+  send_done_watcher.StartWatching(context->GetSendDoneEvent(),
+                                  context->MakeWaitableEventCallback());
 
   {
     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
@@ -540,7 +547,7 @@ void SyncChannel::WaitForReplyWithNestedMessageLoop(SyncContext* context) {
 
   sync_msg_queue->set_top_send_done_watcher(old_send_done_event_watcher);
   if (old_send_done_event_watcher && old_event) {
-    old_send_done_event_watcher->StartWatching(old_event, old_delegate);
+    old_send_done_event_watcher->StartWatching(old_event, old_callback);
   }
 }
 
@@ -549,7 +556,7 @@ void SyncChannel::OnWaitableEventSignaled(WaitableEvent* event) {
   // The call to DispatchMessages might delete this object, so reregister
   // the object watcher first.
   event->Reset();
-  dispatch_watcher_.StartWatching(event, this);
+  dispatch_watcher_.StartWatching(event, dispatch_watcher_callback_);
   sync_context()->DispatchMessages();
 }
 
@@ -560,7 +567,11 @@ void SyncChannel::StartWatching() {
   // stop or keep watching.  So we always watch it, and create the event as
   // manual reset since the object watcher might otherwise reset the event
   // when we're doing a WaitMany.
-  dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(), this);
+  dispatch_watcher_callback_ =
+      base::Bind(&SyncChannel::OnWaitableEventSignaled,
+                  base::Unretained(this));
+  dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(),
+                                  dispatch_watcher_callback_);
 }
 
 }  // namespace IPC