Make IPC channels track their peer process ID

ipc/ipc_channel_proxy.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 48 matching lines @@
   delete this;
 }
 
 //------------------------------------------------------------------------------
 
 ChannelProxy::Context::Context(Channel::Listener* listener,
                                base::MessageLoopProxy* ipc_message_loop)
     : listener_message_loop_(base::MessageLoopProxy::current()),
       listener_(listener),
       ipc_message_loop_(ipc_message_loop),
-      peer_pid_(0),
-      channel_connected_called_(false) {
+      channel_connected_called_(false),
+      peer_pid_(base::kNullProcessId) {
 }
 
 ChannelProxy::Context::~Context() {
 }
 
 void ChannelProxy::Context::CreateChannel(const IPC::ChannelHandle& handle,
                                           const Channel::Mode& mode) {
   DCHECK(channel_.get() == NULL);
   channel_id_ = handle.name;
   channel_.reset(new Channel(handle, mode, this));
@@ skipping 38 matching lines @@
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnChannelConnected(int32 peer_pid) {
   // Add any pending filters.  This avoids a race condition where someone
   // creates a ChannelProxy, calls AddFilter, and then right after starts the
   // peer process.  The IO thread could receive a message before the task to add
   // the filter is run on the IO thread.
   OnAddFilter();
 
-  peer_pid_ = peer_pid;
+  // We cache off the peer_pid so it can be safely accessed from both threads.
+  peer_pid_ = channel_->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, base::Bind(&Context::OnDispatchConnected, this));
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnChannelError() {
@@ skipping 239 matching lines @@
 void ChannelProxy::RemoveFilter(MessageFilter* filter) {
   context_->ipc_message_loop()->PostTask(
       FROM_HERE, base::Bind(&Context::OnRemoveFilter, context_.get(),
                             make_scoped_refptr(filter)));
 }
 
 void ChannelProxy::ClearIPCMessageLoop() {
   context()->ClearIPCMessageLoop();
 }
 
+base::ProcessId ChannelProxy::peer_pid() const {
+  return context_.get() ? context_->peer_pid_ : base::kNullProcessId;

[jam, 2012/04/05 00:11:42]

are you sure you need to null check context_?

[jschuh, 2012/04/05 00:23:06]

You're right. It's always passed or created in the constructor. Since it's a
simple getter I'll just move it to an inline in the header.

+}
+
 #if defined(OS_POSIX) && !defined(OS_NACL)
 // See the TODO regarding lazy initialization of the channel in
 // ChannelProxy::Init().
 int ChannelProxy::GetClientFileDescriptor() {
   Channel* channel = context_.get()->channel_.get();
   // Channel must have been created first.
   DCHECK(channel) << context_.get()->channel_id_;
   return channel->GetClientFileDescriptor();
 }
 
 int ChannelProxy::TakeClientFileDescriptor() {
   Channel* channel = context_.get()->channel_.get();
   // Channel must have been created first.
   DCHECK(channel) << context_.get()->channel_id_;
   return channel->TakeClientFileDescriptor();
 }
 
 bool ChannelProxy::GetClientEuid(uid_t* client_euid) const {
   Channel* channel = context_.get()->channel_.get();
   // Channel must have been created first.
   DCHECK(channel) << context_.get()->channel_id_;
   return channel->GetClientEuid(client_euid);
 }
 #endif
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC