Refactor: Simplify WaitableEventWatcher.

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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
@@ skipping 216 matching lines @@
         LAZY_INSTANCE_INITIALIZER;
 
 SyncChannel::SyncContext::SyncContext(
     Listener* listener,
     base::SingleThreadTaskRunner* ipc_task_runner,
     WaitableEvent* shutdown_event)
     : ChannelProxy::Context(listener, ipc_task_runner),
       received_sync_msgs_(ReceivedSyncMsgQueue::AddContext()),
       shutdown_event_(shutdown_event),
       restrict_dispatch_group_(kRestrictDispatchGroup_None) {
+  shutdown_watcher_callback_ = base::Bind(
+     &SyncChannel::SyncContext::OnWaitableEventSignaled,
+     base::Unretained(this));

[dmichael (off chromium), 2013/02/01 17:27:18]

Okay, so the problem is if you don't use base::Unretained here, SyncContext owns
a member that keeps a reference to ths SyncContext.

Maybe don't keep a member, and instead have a MakeCallback that generates one
instead, for use by the SyncChannel outside. WDYT? See below...

 }
 
 SyncChannel::SyncContext::~SyncContext() {
   while (!deserializers_.empty())
     Pop();
 }
 
 // Adds information about an outgoing sync message to the context so that
 // we know how to deserialize the reply.  Returns a handle that's set when
 // the reply has arrived.
@@ skipping 99 matching lines @@
   return Context::OnMessageReceivedNoFilter(msg);
 }
 
 void SyncChannel::SyncContext::OnChannelError() {
   CancelPendingSends();
   shutdown_watcher_.StopWatching();
   Context::OnChannelError();
 }
 
 void SyncChannel::SyncContext::OnChannelOpened() {
-  shutdown_watcher_.StartWatching(shutdown_event_, this);
+  shutdown_watcher_.StartWatching(shutdown_event_, shutdown_watcher_callback_);
   Context::OnChannelOpened();
 }
 
 void SyncChannel::SyncContext::OnChannelClosed() {
   CancelPendingSends();
   shutdown_watcher_.StopWatching();
   Context::OnChannelClosed();
 }
 
 void SyncChannel::SyncContext::OnSendTimeout(int message_id) {
@@ skipping 143 matching lines @@
 
 void SyncChannel::WaitForReplyWithNestedMessageLoop(SyncContext* context) {
   base::WaitableEventWatcher send_done_watcher;
 
   ReceivedSyncMsgQueue* sync_msg_queue = context->received_sync_msgs();
   DCHECK(sync_msg_queue != NULL);
 
   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();

[dmichael (off chromium), 2013/02/01 17:27:18]

If you instead just make the callback here (e.g., by calling
old_send_done_event_watcher->MakeCallback or something), then the context is
only ever owned by the callback on the stack and the WaitableEventWatcher that's
also on the stack.

     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->shutdown_watcher_callback());
 
   {
     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
     MessageLoop::current()->Run();
   }
 
   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);
   }
 }
 
 void SyncChannel::OnWaitableEventSignaled(WaitableEvent* event) {
   DCHECK(event == sync_context()->GetDispatchEvent());
   // 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();
 }
 
 void SyncChannel::StartWatching() {
   // Ideally we only want to watch this object when running a nested message
   // loop.  However, we don't know when it exits if there's another nested
   // message loop running under it or not, so we wouldn't know whether to
   // 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