Decouple IPC::MessageFilter from IPC::Channel

content/public/browser/browser_message_filter.cc

Index: content/public/browser/browser_message_filter.cc
diff --git a/content/public/browser/browser_message_filter.cc b/content/public/browser/browser_message_filter.cc
index 377cfb79d35b66f10b22b85d0e8d126db7b5dc24..89d871557b58a1c4101fd02a019c983c11e7fd2b 100644
--- a/content/public/browser/browser_message_filter.cc
+++ b/content/public/browser/browser_message_filter.cc
@@ -12,6 +12,7 @@
 #include "base/process/process_handle.h"
 #include "base/task_runner.h"
 #include "content/browser/browser_child_process_host_impl.h"
+#include "content/browser/browser_message_filter_peer.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
@@ -30,23 +31,23 @@ class BrowserMessageFilter::Internal : public IPC::MessageFilter {
   virtual ~Internal() {}
 
   // IPC::MessageFilter implementation:
-  virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
-    filter_->channel_ = channel;
-    filter_->OnFilterAdded(channel);
+  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
+    filter_->sender_ = sender;
+    filter_->OnFilterAdded(sender);
   }
 
   virtual void OnFilterRemoved() OVERRIDE {
     filter_->OnFilterRemoved();
+    filter_->OnFilterRemovedFromHost();
   }
 
-  virtual void OnChannelClosing() OVERRIDE {
-    filter_->channel_ = NULL;
-    filter_->OnChannelClosing();
+  virtual void OnSenderClosing() OVERRIDE {
+    filter_->sender_ = NULL;
+    filter_->OnSenderClosing();
   }
 
-  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE {
-    filter_->peer_pid_ = peer_pid;
-    filter_->OnChannelConnected(peer_pid);
+  virtual void OnSenderConnected() OVERRIDE {
+    filter_->OnSenderConnected();
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
@@ -101,43 +102,22 @@ class BrowserMessageFilter::Internal : public IPC::MessageFilter {
 
 BrowserMessageFilter::BrowserMessageFilter(uint32 message_class_to_filter)
     : internal_(NULL),
-      channel_(NULL),
-#if defined(OS_WIN)
-      peer_handle_(base::kNullProcessHandle),
-#endif
-      peer_pid_(base::kNullProcessId),
+      sender_(NULL),
+      peer_(NULL),
       message_classes_to_filter_(1, message_class_to_filter) {}
 
 BrowserMessageFilter::BrowserMessageFilter(
     const uint32* message_classes_to_filter,
     size_t num_message_classes_to_filter)
     : internal_(NULL),
-      channel_(NULL),
-#if defined(OS_WIN)
-      peer_handle_(base::kNullProcessHandle),
-#endif
-      peer_pid_(base::kNullProcessId),
+      sender_(NULL),
+      peer_(NULL),
       message_classes_to_filter_(
           message_classes_to_filter,
           message_classes_to_filter + num_message_classes_to_filter) {
   DCHECK(num_message_classes_to_filter);
 }
 
-base::ProcessHandle BrowserMessageFilter::PeerHandle() {
-#if defined(OS_WIN)
-  base::AutoLock lock(peer_handle_lock_);
-  if (peer_handle_ == base::kNullProcessHandle)
-    base::OpenPrivilegedProcessHandle(peer_pid_, &peer_handle_);
-
-  return peer_handle_;
-#else
-  base::ProcessHandle result = base::kNullProcessHandle;
-  base::OpenPrivilegedProcessHandle(peer_pid_, &result);
-  return result;
-#endif
-}
-
-
 void BrowserMessageFilter::OnDestruct() const {
   delete this;
 }
@@ -161,8 +141,8 @@ bool BrowserMessageFilter::Send(IPC::Message* message) {
     return true;
   }
 
-  if (channel_)
-    return channel_->Send(message);
+  if (sender_)
+    return sender_->Send(message);
 
   delete message;
   return false;
@@ -199,14 +179,8 @@ bool BrowserMessageFilter::CheckCanDispatchOnUI(const IPC::Message& message,
 }
 
 void BrowserMessageFilter::BadMessageReceived() {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kDisableKillAfterBadIPC))
-    return;
-
-  BrowserChildProcessHostImpl::HistogramBadMessageTerminated(
-      PROCESS_TYPE_RENDERER);
-  base::KillProcess(PeerHandle(), content::RESULT_CODE_KILLED_BAD_MESSAGE,
-                    false);
+  if (peer_)
+    peer_->BadMessageReceived();
 }
 
 BrowserMessageFilter::~BrowserMessageFilter() {
@@ -218,10 +192,31 @@ BrowserMessageFilter::~BrowserMessageFilter() {
 
 IPC::MessageFilter* BrowserMessageFilter::GetFilter() {
   // We create this on demand so that if a filter is used in a unit test but
-  // never attached to a channel, we don't leak Internal and this;
+  // never attached to a sender, we don't leak Internal and this;
   DCHECK(!internal_) << "Should only be called once.";
   internal_ = new Internal(this);
   return internal_;
 }
 
+void BrowserMessageFilter::OnFilterAddedToHost(BrowserMessageFilterPeer* peer) {
+  DCHECK(!peer_);
+  peer_ = peer;
+}
+
+void BrowserMessageFilter::OnFilterRemovedFromHost() {
+  peer_ = NULL;
+}
+
+base::ProcessHandle BrowserMessageFilter::PeerHandle() {
+  if (!peer_)
+    return base::kNullProcessHandle;
+  return peer_->GetHandle();
+}
+
+base::ProcessId BrowserMessageFilter::peer_pid() const {
+  if (!peer_)
+    return base::kNullProcessId;
+  return peer_->pid();
+}
+
 }  // namespace content