Allow child thread to install filters prior to channel connection.

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 182 matching lines @@
   base::MessageLoop::current()->Quit();
 }
 
 #endif
 
 }  // namespace
 
 ChildThread::Options::Options()
     : channel_name(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID)),
-      use_mojo_channel(false) {}
+      use_mojo_channel(false),
+      in_browser_process(false) {
+}
 
 ChildThread::Options::Options(bool mojo)
     : channel_name(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID)),
-      use_mojo_channel(mojo) {}
+      use_mojo_channel(mojo),
+      in_browser_process(true) {
+}
 
+ChildThread::Options::Options(std::string name, bool mojo)
+    : channel_name(name), use_mojo_channel(mojo), in_browser_process(true) {
+}
+
+ChildThread::Options::~Options() {
+}
 
 ChildThread::ChildThreadMessageRouter::ChildThreadMessageRouter(
     IPC::Sender* sender)
     : sender_(sender) {}
 
 bool ChildThread::ChildThreadMessageRouter::Send(IPC::Message* msg) {
   return sender_->Send(msg);
 }
 
 ChildThread::ChildThread()
     : router_(this),
       in_browser_process_(false),
       channel_connected_factory_(this) {
   Init(Options());
 }
 
 ChildThread::ChildThread(const Options& options)
     : router_(this),
-      in_browser_process_(true),
+      in_browser_process_(options.in_browser_process),
       channel_connected_factory_(this) {
   Init(options);
 }
 
-scoped_ptr<IPC::SyncChannel> ChildThread::CreateChannel(bool use_mojo_channel) {
+void ChildThread::ConnectChannel(bool use_mojo_channel) {
+  bool create_pipe_now = true;
   if (use_mojo_channel) {
     VLOG(1) << "Mojo is enabled on child";
-    return IPC::SyncChannel::Create(
-        IPC::ChannelMojo::CreateClientFactory(channel_name_),
-        this,
-        ChildProcess::current()->io_message_loop_proxy(),
-        true,
-        ChildProcess::current()->GetShutDownEvent());
+    channel_->Init(IPC::ChannelMojo::CreateClientFactory(channel_name_),
+                   create_pipe_now);
+    return;
   }
 
   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());
+  channel_->Init(channel_name_, IPC::Channel::MODE_CLIENT, create_pipe_now);
 }
 
 void ChildThread::Init(const Options& 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_ = CreateChannel(options.use_mojo_channel);
+  channel_ = IPC::SyncChannel::Create(
+      this, ChildProcess::current()->io_message_loop_proxy(),
+      ChildProcess::current()->GetShutDownEvent());
 #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 54 matching lines @@
         power_monitor_source.Pass()));
   }
 
 #if defined(OS_POSIX)
   // Check that --process-type is specified so we don't do this in unit tests
   // and single-process mode.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kProcessType))
     channel_->AddFilter(new SuicideOnChannelErrorFilter());
 #endif
 
+  // Add filters passed here via options.
+  for (auto startup_filter : options.startup_filters) {
+    channel_->AddFilter(startup_filter);
+  }
+
+  ConnectChannel(options.use_mojo_channel);
+
   int connection_timeout = kConnectionTimeoutS;
   std::string connection_override =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kIPCConnectionTimeout);
   if (!connection_override.empty()) {
     int temp;
     if (base::StringToInt(connection_override, &temp))
       connection_timeout = temp;
   }
 
@@ skipping 256 matching lines @@
 
 void ChildThread::OnProcessBackgrounded(bool background) {
   // Set timer slack to maximum on main thread when in background.
   base::TimerSlack timer_slack = base::TIMER_SLACK_NONE;
   if (background)
     timer_slack = base::TIMER_SLACK_MAXIMUM;
   base::MessageLoop::current()->SetTimerSlack(timer_slack);
 }
 
 }  // namespace content