Create a ResourceMessageFilter to filter resource related IPCs. This gets ri...

chrome/common/child_process_host.cc

 // Copyright (c) 2010 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 "chrome/common/child_process_host.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "chrome/common/child_process_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/plugin_messages.h"
 #include "ipc/ipc_logging.h"
-#include "ipc/ipc_message.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #endif  // OS_LINUX
 
 ChildProcessHost::ChildProcessHost()
     : ALLOW_THIS_IN_INITIALIZER_LIST(listener_(this)),
       opening_channel_(false) {
 }
 
 ChildProcessHost::~ChildProcessHost() {
+  for (size_t i = 0; i < filters_.size(); ++i) {
+    filters_[i]->OnChannelClosing();
+    filters_[i]->OnFilterRemoved();
+  }
+}
+
+void ChildProcessHost::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
+  filters_.push_back(filter);
+
+  if (channel_.get())
+    filter->OnFilterAdded(channel_.get());
 }
 
 // static
 FilePath ChildProcessHost::GetChildPath(bool allow_self) {
   FilePath child_path;
 
   child_path = CommandLine::ForCurrentProcess()->GetSwitchValuePath(
       switches::kBrowserSubprocessPath);
   if (!child_path.empty())
     return child_path;
@@ skipping 64 matching lines @@
 #endif  // OS_WIN
 
 
 bool ChildProcessHost::CreateChannel() {
   channel_id_ = ChildProcessInfo::GenerateRandomChannelID(this);
   channel_.reset(new IPC::Channel(
       channel_id_, IPC::Channel::MODE_SERVER, &listener_));
   if (!channel_->Connect())
     return false;
 
+  for (size_t i = 0; i < filters_.size(); ++i)
+    filters_[i]->OnFilterAdded(channel_.get());
+
   // Make sure these messages get sent first.
 #if defined(IPC_MESSAGE_LOG_ENABLED)
   bool enabled = IPC::Logging::GetInstance()->Enabled();
-  SendOnChannel(new PluginProcessMsg_SetIPCLoggingEnabled(enabled));
+  Send(new PluginProcessMsg_SetIPCLoggingEnabled(enabled));
 #endif
 
-  SendOnChannel(new PluginProcessMsg_AskBeforeShutdown());
+  Send(new PluginProcessMsg_AskBeforeShutdown());
 
   opening_channel_ = true;
 
   return true;
 }
 
 void ChildProcessHost::InstanceCreated() {
   Notify(NotificationType::CHILD_INSTANCE_CREATED);
 }
 
-bool ChildProcessHost::SendOnChannel(IPC::Message* msg) {
+bool ChildProcessHost::Send(IPC::Message* message) {
   if (!channel_.get()) {
-    delete msg;
+    delete message;
     return false;
   }
-  return channel_->Send(msg);
+  return channel_->Send(message);
 }
 
 void ChildProcessHost::OnChildDied() {
   delete this;
 }
 
-bool ChildProcessHost::InterceptMessageFromChild(const IPC::Message& msg) {
-  return false;
-}
-
 ChildProcessHost::ListenerHook::ListenerHook(ChildProcessHost* host)
     : host_(host) {
 }
 
 void ChildProcessHost::ListenerHook::OnMessageReceived(
     const IPC::Message& msg) {
 #ifdef IPC_MESSAGE_LOG_ENABLED
   IPC::Logging* logger = IPC::Logging::GetInstance();
   if (msg.type() == IPC_LOGGING_ID) {
     logger->OnReceivedLoggingMessage(msg);
     return;
   }
 
   if (logger->Enabled())
     logger->OnPreDispatchMessage(msg);
 #endif
 
-  bool handled = host_->InterceptMessageFromChild(msg);
+  if (msg.type() == PluginProcessHostMsg_ShutdownRequest::ID &&
+      host_->CanShutdown()) {
+    host_->Send(new PluginProcessMsg_Shutdown());
+  }
 
-  if (!handled) {
-    if (msg.type() == PluginProcessHostMsg_ShutdownRequest::ID) {
-      if (host_->CanShutdown())
-        host_->SendOnChannel(new PluginProcessMsg_Shutdown());
-    } else {
-      host_->OnMessageReceived(msg);
+  bool handled = false;
+  for (size_t i = 0; i < host_->filters_.size(); ++i) {
+    if (host_->filters_[i]->OnMessageReceived(msg)) {
+      handled = true;
+      break;
     }
   }
 
+  if (!handled)
+    host_->OnMessageReceived(msg);
+
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (logger->Enabled())
     logger->OnPostDispatchMessage(msg, host_->channel_id_);
 #endif
 }
 
 void ChildProcessHost::ListenerHook::OnChannelConnected(int32 peer_pid) {
   host_->opening_channel_ = false;
   host_->OnChannelConnected(peer_pid);
   // Notify in the main loop of the connection.
   host_->Notify(NotificationType::CHILD_PROCESS_HOST_CONNECTED);
+
+  for (size_t i = 0; i < host_->filters_.size(); ++i)
+    host_->filters_[i]->OnChannelConnected(peer_pid);
 }
 
 void ChildProcessHost::ListenerHook::OnChannelError() {
   host_->opening_channel_ = false;
   host_->OnChannelError();
 
+  for (size_t i = 0; i < host_->filters_.size(); ++i)
+    host_->filters_[i]->OnChannelError();
+
   // This will delete host_, which will also destroy this!
   host_->OnChildDied();
 }
 
 void ChildProcessHost::ForceShutdown() {
-  SendOnChannel(new PluginProcessMsg_Shutdown());
+  Send(new PluginProcessMsg_Shutdown());
 }