(NOT READY FOR REVIEW) Introduce MessagePortBypassFilter.

content/child/child_thread.cc

 // Copyright (c) 2012 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 "content/child/child_thread.h"
 
 #include <signal.h>
 
 #include <string>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/leak_annotations.h"
+#include "base/id_map.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/kill.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local.h"
 #include "base/tracked_objects.h"
 #include "components/tracing/child_trace_message_filter.h"
 #include "content/child/child_histogram_message_filter.h"
 #include "content/child/child_process.h"
 #include "content/child/child_resource_message_filter.h"
 #include "content/child/child_shared_bitmap_manager.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/power_monitor_broadcast_source.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/child/quota_message_filter.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/child/service_worker/service_worker_dispatcher.h"
 #include "content/child/service_worker/service_worker_message_filter.h"
 #include "content/child/socket_stream_dispatcher.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/websocket_dispatcher.h"
 #include "content/common/child_process_messages.h"
+#include "content/common/message_port_messages.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
 
 #if defined(OS_WIN)
 #include "content/common/handle_enumerator_win.h"
 #endif
 
@@ skipping 134 matching lines @@
     g_lazy_child_thread_cv = LAZY_INSTANCE_INITIALIZER;
 
 void QuitMainThreadMessageLoop() {
   base::MessageLoop::current()->Quit();
 }
 
 #endif
 
 }  // namespace
 
+MessagePortBypassFilter::MessagePortBypassFilter(
+    base::SingleThreadTaskRunner* ipc_task_runner)
+    : ipc_task_runner_(ipc_task_runner),
+      child_thread_loop_(base::MessageLoopProxy::current()) {}
+
+MessagePortBypassFilter::~MessagePortBypassFilter() {}
+
+bool MessagePortBypassFilter::OnMessageReceived(const IPC::Message& message) {
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
+  IPC::Listener* listener = routes_.Lookup(message.routing_id());
+  if (!listener)
+    return false;
+  if (message.type() != MessagePortMsg_Message::ID)
+    return false;
+  return listener->OnMessageReceived(message);
+}
+
+bool MessagePortBypassFilter::GetSupportedMessageClasses(
+    std::vector<uint32>* supported_message_classes) const {
+  supported_message_classes->push_back(MessagePortMsgStart);
+  return true;
+}
+
+void MessagePortBypassFilter::AddRoute(int32 routing_id,
+                                       IPC::Listener* listener) {
+  DCHECK(child_thread_loop_->BelongsToCurrentThread());
+  ipc_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &MessagePortBypassFilter::AddRouteOnIO, this, routing_id, listener));
+}
+
+void MessagePortBypassFilter::AddRouteOnIO(int32 routing_id,
+                                           IPC::Listener* listener) {
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
+  routes_.AddWithID(listener, routing_id);
+}
+
+void MessagePortBypassFilter::RemoveRoute(int32 routing_id,
+                                          const base::Closure& callback) {
+  DCHECK(child_thread_loop_->BelongsToCurrentThread());
+  ipc_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&MessagePortBypassFilter::RemoveRouteOnIO,
+                 this,
+                 routing_id,
+                 callback));
+}
+
+void MessagePortBypassFilter::RemoveRouteOnIO(int32 routing_id,
+                                              const base::Closure& callback) {
+  DCHECK(ipc_task_runner_->BelongsToCurrentThread());
+  routes_.Remove(routing_id);
+  child_thread_loop_->PostTask(FROM_HERE, callback);
+}
+
 ChildThread::ChildThreadMessageRouter::ChildThreadMessageRouter(
     IPC::Sender* sender)
     : sender_(sender) {}
 
 bool ChildThread::ChildThreadMessageRouter::Send(IPC::Message* msg) {
   return sender_->Send(msg);
 }
 
 ChildThread::ChildThread()
     : router_(this),
@@ skipping 50 matching lines @@
 
   service_worker_message_filter_ =
       new ServiceWorkerMessageFilter(thread_safe_sender_.get());
   service_worker_dispatcher_.reset(
       new ServiceWorkerDispatcher(thread_safe_sender_.get()));
 
   quota_message_filter_ =
       new QuotaMessageFilter(thread_safe_sender_.get());
   quota_dispatcher_.reset(new QuotaDispatcher(thread_safe_sender_.get(),
                                               quota_message_filter_.get()));
+  message_port_bypass_filter_ = new MessagePortBypassFilter(
+      ChildProcess::current()->io_message_loop_proxy());
 
   channel_->AddFilter(histogram_message_filter_.get());
   channel_->AddFilter(sync_message_filter_.get());
   channel_->AddFilter(new tracing::ChildTraceMessageFilter(
       ChildProcess::current()->io_message_loop_proxy()));
   channel_->AddFilter(resource_message_filter_.get());
   channel_->AddFilter(quota_message_filter_->GetFilter());
   channel_->AddFilter(service_worker_message_filter_->GetFilter());
+  channel_->AddFilter(message_port_bypass_filter_.get());
 
   // In single process mode we may already have a power monitor
   if (!base::PowerMonitor::Get()) {
     scoped_ptr<PowerMonitorBroadcastSource> power_monitor_source(
       new PowerMonitorBroadcastSource());
     channel_->AddFilter(power_monitor_source->GetMessageFilter());
 
     power_monitor_.reset(new base::PowerMonitor(
         power_monitor_source.PassAs<base::PowerMonitorSource>()));
   }
@@ skipping 255 matching lines @@
   // inflight that would addref it.
   Send(new ChildProcessHostMsg_ShutdownRequest);
 }
 
 void ChildThread::EnsureConnected() {
   VLOG(0) << "ChildThread::EnsureConnected()";
   base::KillProcess(base::GetCurrentProcessHandle(), 0, false);
 }
 
 }  // namespace content