Don't use any member variables when sending a sync call...

ipc/ipc_sync_channel.cc

 // Copyright (c) 2006-2008 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/lazy_instance.h"
 #include "base/logging.h"
 #include "base/thread_local.h"
 #include "base/message_loop.h"
@@ skipping 325 matching lines @@
 }
 
 void SyncChannel::SyncContext::CancelPendingSends() {
   AutoLock auto_lock(deserializers_lock_);
   PendingSyncMessageQueue::iterator iter;
   for (iter = deserializers_.begin(); iter != deserializers_.end(); iter++)
     iter->done_event->Signal();
 }
 
 void SyncChannel::SyncContext::OnWaitableEventSignaled(WaitableEvent* event) {
-  DCHECK(event == shutdown_event_);
-  // Process shut down before we can get a reply to a synchronous message.
-  // Cancel pending Send calls, which will end up setting the send done event.
-  CancelPendingSends();
+  if (event == shutdown_event_) {
+    // Process shut down before we can get a reply to a synchronous message.
+    // Cancel pending Send calls, which will end up setting the send done event.
+    CancelPendingSends();
+  } else {
+    // We got the reply, timed out or the process shutdown.
+    DCHECK(event == GetSendDoneEvent());
+    MessageLoop::current()->Quit();
+  }
 }
 
 
 SyncChannel::SyncChannel(
     const std::string& channel_id, Channel::Mode mode,
     Channel::Listener* listener, MessageFilter* filter,
     MessageLoop* ipc_message_loop, bool create_pipe_now,
     WaitableEvent* shutdown_event)
     : ChannelProxy(
           channel_id, mode, ipc_message_loop,
@@ skipping 41 matching lines @@
   if (timeout_ms != base::kNoTimeout) {
     // We use the sync message id so that when a message times out, we don't
     // confuse it with another send that is either above/below this Send in
     // the call stack.
     context->ipc_message_loop()->PostDelayedTask(FROM_HERE,
         NewRunnableMethod(context.get(),
             &SyncContext::OnSendTimeout, message_id), timeout_ms);
   }
 
   // Wait for reply, or for any other incoming synchronous messages.
-  WaitForReply(pump_messages_event);
+  // *this* might get deleted, so only call static functions at this point.
+  WaitForReply(context, pump_messages_event);
 
   return context->Pop();
 }
 
-void SyncChannel::WaitForReply(WaitableEvent* pump_messages_event) {
+void SyncChannel::WaitForReply(
+    SyncContext* context, WaitableEvent* pump_messages_event) {
   while (true) {
     WaitableEvent* objects[] = {
-      sync_context()->GetDispatchEvent(),
-      sync_context()->GetSendDoneEvent(),
+      context->GetDispatchEvent(),
+      context->GetSendDoneEvent(),
       pump_messages_event
     };
 
     unsigned count = pump_messages_event ? 3: 2;
     size_t result = WaitableEvent::WaitMany(objects, count);
     if (result == 0 /* dispatch event */) {
       // We're waiting for a reply, but we received a blocking synchronous
       // call.  We must process it or otherwise a deadlock might occur.
-      sync_context()->GetDispatchEvent()->Reset();
-      sync_context()->DispatchMessages();
+      context->GetDispatchEvent()->Reset();
+      context->DispatchMessages();
       continue;
     }
 
     if (result == 2 /* pump_messages_event */)
-      WaitForReplyWithNestedMessageLoop();  // Start a nested message loop.
+      WaitForReplyWithNestedMessageLoop(context);  // Run a nested message loop.
 
     break;
   }
 }
 
-void SyncChannel::WaitForReplyWithNestedMessageLoop() {
+void SyncChannel::WaitForReplyWithNestedMessageLoop(SyncContext* context) {
   base::WaitableEventWatcher send_done_watcher;
 
-  ReceivedSyncMsgQueue* sync_msg_queue = sync_context()->received_sync_msgs();
+  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::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_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(sync_context()->GetSendDoneEvent(), this);
+  send_done_watcher.StartWatching(context->GetSendDoneEvent(), context);
   bool old_state = MessageLoop::current()->NestableTasksAllowed();
 
   MessageLoop::current()->SetNestableTasksAllowed(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->SetNestableTasksAllowed(old_state);
 
   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);
   }
 }
 
 void SyncChannel::OnWaitableEventSignaled(WaitableEvent* event) {
-  WaitableEvent* dispatch_event = sync_context()->GetDispatchEvent();
-  if (event == dispatch_event) {
-    // The call to DispatchMessages might delete this object, so reregister
-    // the object watcher first.
-    dispatch_event->Reset();
-    dispatch_watcher_.StartWatching(dispatch_event, this);
-    sync_context()->DispatchMessages();
-  } else {
-    // We got the reply, timed out or the process shutdown.
-    DCHECK(event == sync_context()->GetSendDoneEvent());
-    MessageLoop::current()->Quit();
-  }
+  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);
+  sync_context()->DispatchMessages();
 }
 
 }  // namespace IPC