Eliminate a potential race in IPC::ChannelProxy

ipc/ipc_channel_nacl.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_channel_nacl.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <sys/types.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
 #include "base/threading/simple_thread.h"
 #include "ipc/file_descriptor_set_posix.h"
+#include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "native_client/src/public/imc_syscalls.h"
 #include "native_client/src/public/imc_types.h"
 
 namespace IPC {
 
 struct MessageContents {
   std::vector<char> data;
   std::vector<int> fds;
 };
@@ skipping 101 matching lines @@
     const char *modestr = (mode_ & MODE_SERVER_FLAG) ? "server" : "client";
     LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name
                  << "\" in " << modestr << " mode";
   }
 }
 
 Channel::ChannelImpl::~ChannelImpl() {
   Close();
 }
 
+base::ProcessId Channel::ChannelImpl::peer_pid() const {
+  // This shouldn't actually get used in the untrusted side of the proxy, and we
+  // don't have the real pid anyway.
+  return -1;
+}
+
 bool Channel::ChannelImpl::Connect() {
   if (pipe_ == -1) {
-    DLOG(INFO) << "Channel creation failed: " << pipe_name_;
+    DLOG(WARNING) << "Channel creation failed: " << pipe_name_;
     return false;
   }
 
   // Note that Connect is called on the "Channel" thread (i.e., the same thread
   // where Channel::Send will be called, and the same thread that should receive
   // messages). The constructor might be invoked on another thread (see
   // ChannelProxy for an example of that). Therefore, we must wait until Connect
   // is called to decide which MessageLoopProxy to pass to ReaderThreadRunner.
   reader_thread_runner_.reset(
       new ReaderThreadRunner(
           pipe_,
           base::Bind(&Channel::ChannelImpl::DidRecvMsg,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&Channel::ChannelImpl::ReadDidFail,
                      weak_ptr_factory_.GetWeakPtr()),
           base::MessageLoopProxy::current()));
   reader_thread_.reset(
       new base::DelegateSimpleThread(reader_thread_runner_.get(),
                                      "ipc_channel_nacl reader thread"));
   reader_thread_->Start();
   waiting_connect_ = false;
   // If there were any messages queued before connection, send them.
   ProcessOutgoingMessages();
+  base::MessageLoopProxy::current()->PostTask(FROM_HERE,
+      base::Bind(&Channel::ChannelImpl::CallOnChannelConnected,
+                 weak_ptr_factory_.GetWeakPtr()));
+
   return true;
 }
 
 void Channel::ChannelImpl::Close() {
   // For now, we assume that at shutdown, the reader thread will be woken with
   // a failure (see NaClIPCAdapter::BlockingRead and CloseChannel). Or... we
   // might simply be killed with no chance to clean up anyway :-).
   // If untrusted code tries to close the channel prior to shutdown, it's likely
   // to hang.
   // TODO(dmichael): Can we do anything smarter here to make sure the reader
@@ skipping 109 matching lines @@
       msg->file_descriptor_set()->CommitAll();
     }
 
     // Message sent OK!
     DVLOG(2) << "sent message @" << msg.get() << " with type " << msg->type()
              << " on fd " << pipe_;
   }
   return true;
 }
 
+void Channel::ChannelImpl::CallOnChannelConnected() {
+  listener()->OnChannelConnected(peer_pid());
+}
+
 Channel::ChannelImpl::ReadState Channel::ChannelImpl::ReadData(
     char* buffer,
     int buffer_len,
     int* bytes_read) {
   *bytes_read = 0;
   if (pipe_ == -1)
     return READ_FAILED;
   if (read_queue_.empty())
     return READ_PENDING;
   while (!read_queue_.empty() && *bytes_read < buffer_len) {
@@ skipping 59 matching lines @@
 
 bool Channel::Connect() {
   return channel_impl_->Connect();
 }
 
 void Channel::Close() {
   channel_impl_->Close();
 }
 
 base::ProcessId Channel::peer_pid() const {
-  // This shouldn't actually get used in the untrusted side of the proxy, and we
-  // don't have the real pid anyway.
-  return -1;
+  return channel_impl_->peer_pid();
 }
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 }  // namespace IPC