Make IPC channels track their peer process ID

ipc/ipc_channel_proxy.h

 // 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.
 
 #ifndef IPC_IPC_CHANNEL_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 150 matching lines @@
   void AddFilter(MessageFilter* filter);
   void RemoveFilter(MessageFilter* filter);
 
   void set_outgoing_message_filter(OutgoingMessageFilter* filter) {
     outgoing_message_filter_ = filter;
   }
 
   // Called to clear the pointer to the IPC message loop when it's going away.
   void ClearIPCMessageLoop();
 
+  // Get the process ID for the connected peer.
+  // Returns base::kNullProcessId if the peer is not connected yet.
+  base::ProcessId peer_pid() const { return context_->peer_pid_; }
+
 #if defined(OS_POSIX)
   // Calls through to the underlying channel's methods.
   int GetClientFileDescriptor();
   int TakeClientFileDescriptor();
   bool GetClientEuid(uid_t* client_euid) const;
 #endif  // defined(OS_POSIX)
 
  protected:
   class Context;
   // A subclass uses this constructor if it needs to add more information
@@ skipping 58 matching lines @@
     void OnDispatchError();
 
     scoped_refptr<base::MessageLoopProxy> listener_message_loop_;
     Channel::Listener* listener_;
 
     // List of filters.  This is only accessed on the IPC thread.
     std::vector<scoped_refptr<MessageFilter> > filters_;
     scoped_refptr<base::MessageLoopProxy> ipc_message_loop_;
     scoped_ptr<Channel> channel_;
     std::string channel_id_;
-    int peer_pid_;
     bool channel_connected_called_;
 
     // Holds filters between the AddFilter call on the listerner thread and the
     // IPC thread when they're added to filters_.
     std::vector<scoped_refptr<MessageFilter> > pending_filters_;
     // Lock for pending_filters_.
     base::Lock pending_filters_lock_;
+
+    // Cached copy of the peer process ID. Set on IPC but read on both IPC and
+    // listener threads.
+    base::ProcessId peer_pid_;
   };
 
   Context* context() { return context_; }
 
   OutgoingMessageFilter* outgoing_message_filter() {
     return outgoing_message_filter_;
   }
 
  private:
   friend class SendCallbackHelper;
 
   // By maintaining this indirection (ref-counted) to our internal state, we
   // can safely be destroyed while the background thread continues to do stuff
   // that involves this data.
   scoped_refptr<Context> context_;
 
   OutgoingMessageFilter* outgoing_message_filter_;
 
   // Whether the channel has been initialized.
   bool did_init_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_