Introduce ChannelMojo

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>
 
@@ skipping 30 matching lines @@
 #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/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"
+#include "ipc/mojo/ipc_channel_mojo.h"
 
 #if defined(OS_WIN)
 #include "content/common/handle_enumerator_win.h"
 #endif
 
 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED)
 #include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
 #endif
 
 using tracked_objects::ThreadData;
@@ skipping 136 matching lines @@
     : sender_(sender) {}
 
 bool ChildThread::ChildThreadMessageRouter::Send(IPC::Message* msg) {
   return sender_->Send(msg);
 }
 
 ChildThread::ChildThread()
     : router_(this),
       channel_connected_factory_(this),
       in_browser_process_(false) {
-  channel_name_ = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+  InitOptions options;
+  options.channel_name = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kProcessChannelID);
-  Init();
+  Init(options);
 }
 
-ChildThread::ChildThread(const std::string& channel_name)
-    : channel_name_(channel_name),
-      router_(this),
+ChildThread::ChildThread(const InitOptions& options)
+    : router_(this),
       channel_connected_factory_(this),
       in_browser_process_(true) {
-  Init();
+  Init(options);
 }
 
-void ChildThread::Init() {
+scoped_ptr<IPC::SyncChannel> ChildThread::CreateChannel(bool use_mojo_channel) {
+  if (use_mojo_channel) {
+    VLOG(1) << "Mojo is enabled on child";
+    return IPC::SyncChannel::Create(
+        IPC::ChannelMojo::CreateBuilder(
+            channel_name_,
+            IPC::Channel::MODE_CLIENT,
+            ChildProcess::current()->io_message_loop_proxy()),
+        this,
+        ChildProcess::current()->io_message_loop_proxy(),
+        true,
+        ChildProcess::current()->GetShutDownEvent());
+  } else {
+    VLOG(1) << "Mojo is disabled on child";
+    return IPC::SyncChannel::Create(
+        channel_name_,
+        IPC::Channel::MODE_CLIENT,
+        this,
+        ChildProcess::current()->io_message_loop_proxy(),
+        true,
+        ChildProcess::current()->GetShutDownEvent());
+  }
+}
+
+void ChildThread::Init(const InitOptions& options) {
+  channel_name_ = options.channel_name;
+
   g_lazy_tls.Pointer()->Set(this);
   on_channel_error_called_ = false;
   message_loop_ = base::MessageLoop::current();
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // We must make sure to instantiate the IPC Logger *before* we create the
   // channel, otherwise we can get a callback on the IO thread which creates
   // the logger, and the logger does not like being created on the IO thread.
   IPC::Logging::GetInstance();
 #endif
-  channel_ =
-      IPC::SyncChannel::Create(channel_name_,
-                               IPC::Channel::MODE_CLIENT,
-                               this,
-                               ChildProcess::current()->io_message_loop_proxy(),
-                               true,
-                               ChildProcess::current()->GetShutDownEvent());
+  channel_ = CreateChannel(options.use_mojo_channel);
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (!in_browser_process_)
     IPC::Logging::GetInstance()->SetIPCSender(this);
 #endif
 
   mojo_application_.reset(new MojoApplication);
 
   sync_message_filter_ =
       new IPC::SyncMessageFilter(ChildProcess::current()->GetShutDownEvent());
   thread_safe_sender_ = new ThreadSafeSender(
@@ skipping 321 matching lines @@
   base::MessageLoop::current()->SetTimerSlack(timer_slack);
 
 #ifdef OS_WIN
   // Windows Vista+ has a fancy process backgrounding mode that can only be set
   // from within the process.
   base::Process::Current().SetProcessBackgrounded(background);
 #endif  // OS_WIN
 }
 
 }  // namespace content