Ensure that a listener's OnChannelConnected is called before OnMessageReceive...

chrome/common/ipc_channel_proxy.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 "base/message_loop.h"
 #include "base/thread.h"
 #include "chrome/common/ipc_channel_proxy.h"
 #include "chrome/common/ipc_logging.h"
 #include "chrome/common/ipc_message_utils.h"
 
 namespace IPC {
 
 //-----------------------------------------------------------------------------
 
 ChannelProxy::Context::Context(Channel::Listener* listener,
                                MessageFilter* filter,
                                MessageLoop* ipc_message_loop)
     : listener_message_loop_(MessageLoop::current()),
       listener_(listener),
       ipc_message_loop_(ipc_message_loop),
-      channel_(NULL) {
+      channel_(NULL),
+      peer_pid_(0),
+      channel_connected_called_(false) {
   if (filter)
     filters_.push_back(filter);
 }
 
 void ChannelProxy::Context::CreateChannel(const std::wstring& id,
                                           const Channel::Mode& mode) {
   DCHECK(channel_ == NULL);
   channel_id_ = id;
   channel_ = new Channel(id, mode, this);
 }
@@ skipping 29 matching lines @@
   // NOTE: This code relies on the listener's message loop not going away while
   // this thread is active.  That should be a reasonable assumption, but it
   // feels risky.  We may want to invent some more indirect way of referring to
   // a MessageLoop if this becomes a problem.
   listener_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
       this, &Context::OnDispatchMessage, message));
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnChannelConnected(int32 peer_pid) {
+  peer_pid_ = peer_pid;
   for (size_t i = 0; i < filters_.size(); ++i)
     filters_[i]->OnChannelConnected(peer_pid);
 
   // See above comment about using listener_message_loop_ here.
   listener_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &Context::OnDispatchConnected, peer_pid));
+      this, &Context::OnDispatchConnected));
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnChannelError() {
   // See above comment about using listener_message_loop_ here.
   listener_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
       this, &Context::OnDispatchError));
 }
 
 // Called on the IPC::Channel thread
@@ skipping 66 matching lines @@
   }
 
   NOTREACHED() << "filter to be removed not found";
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchMessage(const Message& message) {
   if (!listener_)
     return;
 
+  OnDispatchConnected();
+
 #ifdef IPC_MESSAGE_LOG_ENABLED
   Logging* logger = Logging::current();
   if (message.type() == IPC_LOGGING_ID) {
     logger->OnReceivedLoggingMessage(message);
     return;
   }
 
   if (logger->Enabled())
     logger->OnPreDispatchMessage(message);
 #endif
 
   listener_->OnMessageReceived(message);
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (logger->Enabled())
     logger->OnPostDispatchMessage(message, channel_id_);
 #endif
 }
 
 // Called on the listener's thread
-void ChannelProxy::Context::OnDispatchConnected(int32 peer_pid) {
+void ChannelProxy::Context::OnDispatchConnected() {
+  if (channel_connected_called_)
+    return;
+
+  channel_connected_called_ = true;
   if (listener_)
-    listener_->OnChannelConnected(peer_pid);
+    listener_->OnChannelConnected(peer_pid_);
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchError() {
   if (listener_)
     listener_->OnChannelError();
 }
 
 //-----------------------------------------------------------------------------
 
@@ skipping 91 matching lines @@
 void ChannelProxy::OnClientConnected() {
   Channel *channel = context_.get()->channel_;
   DCHECK(channel); // Channel must have been created first.
   channel->OnClientConnected();
 }
 #endif
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC