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) {
 }
 
 ChannelProxy::Context::~Context() {
 }
 
 void ChannelProxy::Context::CreateChannel(const IPC::ChannelHandle& handle,
                                           const Channel::Mode& mode) {
   DCHECK(channel_.get() == NULL);
   channel_id_ = handle.name;
@@ skipping 39 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;
   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 61 matching lines @@
   {
     base::AutoLock auto_lock(pending_filters_lock_);
     new_filters.swap(pending_filters_);
   }
 
   for (size_t i = 0; i < new_filters.size(); ++i) {
     filters_.push_back(new_filters[i]);
 
     // If the channel has already been created, then we need to send this
     // message so that the filter gets access to the Channel.
-    if (channel_.get())
+    if (channel_.get()) {
       new_filters[i]->OnFilterAdded(channel_.get());
-    // Ditto for if the channel has been connected.
-    if (peer_pid_)
-      new_filters[i]->OnChannelConnected(peer_pid_);
+      // Ditto for if the channel has been connected.
+      base::ProcessId peer_pid = channel_->peer_pid();
+      if (peer_pid)
+        new_filters[i]->OnChannelConnected(peer_pid);
+    }
   }
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnRemoveFilter(MessageFilter* filter) {
   for (size_t i = 0; i < filters_.size(); ++i) {
     if (filters_[i].get() == filter) {
       filter->OnFilterRemoved();
       filters_.erase(filters_.begin() + i);
       return;
@@ skipping 47 matching lines @@
 #endif
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchConnected() {
   if (channel_connected_called_)
     return;
 
   channel_connected_called_ = true;
   if (listener_)
-    listener_->OnChannelConnected(peer_pid_);
+    listener_->OnChannelConnected(channel_->peer_pid());
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchError() {
   if (listener_)
     listener_->OnChannelError();
 }
 
 //-----------------------------------------------------------------------------
 
@@ skipping 85 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 {

[jam, 2012/04/04 19:05:00]

ChannelProxy gets called on the listener thread, but the IPC::Channel lives on
the IO thread, so it's not correct to call its member functions on the
listener's thread..

[jschuh, 2012/04/04 19:18:08]

That is a subtlety I definitely did not appreciate. So, I'll just keep the
ChannelProxy::peer_pid_ as it was before and update it when the channel
connects.

+  if (context_.get() && context_->channel_.get())
+    return context_->channel_->peer_pid();
+  return 0;

[Tom Sepez, 2012/04/04 19:07:07]

return base::kNullProcessId constant?  Any reason to believe base::ProcessID
will be both an int/ptr as opposed to a struct, and/or 0.

[jschuh, 2012/04/04 21:05:13]

Done.

+}
+
 #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