Always use ChannelMojo for content child processes.

content/child/child_thread_impl.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_impl.h"
 
 #include <signal.h>
 #include <string>
 #include <utility>
 
@@ skipping 43 matching lines @@
 #include "content/public/common/connection_filter.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/mojo_shell_connection.h"
 #include "content/public/common/service_names.h"
 #include "ipc/attachment_broker.h"
 #include "ipc/attachment_broker_unprivileged.h"
 #include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_platform_file.h"
-#include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/named_platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/interface_factory.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
@@ skipping 211 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ChannelBootstrapFilter);
 };
 
 }  // namespace
 
 ChildThread* ChildThread::Get() {
   return ChildThreadImpl::current();
 }
 
 ChildThreadImpl::Options::Options()
-    : channel_name(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kProcessChannelID)),
-      use_mojo_channel(base::CommandLine::ForCurrentProcess()->HasSwitch(
-                           switches::kMojoApplicationChannelToken) ||
-                       base::CommandLine::ForCurrentProcess()->HasSwitch(
-                           switches::kMojoChannelToken)),
-      auto_start_mojo_shell_connection(true),
-      connect_to_browser(false) {}
+    : auto_start_mojo_shell_connection(true), connect_to_browser(false) {}
 
 ChildThreadImpl::Options::Options(const Options& other) = default;
 
 ChildThreadImpl::Options::~Options() {
 }
 
 ChildThreadImpl::Options::Builder::Builder() {
 }
 
 ChildThreadImpl::Options::Builder&
 ChildThreadImpl::Options::Builder::InBrowserProcess(
     const InProcessChildThreadParams& params) {
   options_.browser_process_io_runner = params.io_runner();
-  options_.channel_name = params.channel_name();
   options_.in_process_application_token = params.application_token();
   return *this;
 }
 
 ChildThreadImpl::Options::Builder&
-ChildThreadImpl::Options::Builder::UseMojoChannel(bool use_mojo_channel) {
-  options_.use_mojo_channel = use_mojo_channel;
-  return *this;
-}
-
-ChildThreadImpl::Options::Builder&
 ChildThreadImpl::Options::Builder::AutoStartMojoShellConnection(
     bool auto_start) {
   options_.auto_start_mojo_shell_connection = auto_start;
   return *this;
 }
 
 ChildThreadImpl::Options::Builder&
 ChildThreadImpl::Options::Builder::ConnectToBrowser(
   bool connect_to_browser) {
   options_.connect_to_browser = connect_to_browser;
   return *this;
 }
 
 ChildThreadImpl::Options::Builder&
-ChildThreadImpl::Options::Builder::WithChannelName(
-    const std::string& channel_name) {
-  options_.channel_name = channel_name;
-  return *this;
-}
-
-ChildThreadImpl::Options::Builder&
 ChildThreadImpl::Options::Builder::AddStartupFilter(
     IPC::MessageFilter* filter) {
   options_.startup_filters.push_back(filter);
   return *this;
 }
 
 ChildThreadImpl::Options ChildThreadImpl::Options::Builder::Build() {
   return options_;
 }
 
@@ skipping 40 matching lines @@
       weak_factory_(this) {
   Init(options);
 }
 
 scoped_refptr<base::SequencedTaskRunner> ChildThreadImpl::GetIOTaskRunner() {
   if (IsInBrowserProcess())
     return browser_process_io_runner_;
   return ChildProcess::current()->io_task_runner();
 }
 
-void ChildThreadImpl::ConnectChannel(bool use_mojo_channel) {
-  bool create_pipe_now = true;
-  if (use_mojo_channel) {
-    VLOG(1) << "Mojo is enabled on child";
-    std::string channel_token;
-    mojo::ScopedMessagePipeHandle handle;
-    if (!IsInBrowserProcess()) {
-      channel_token =
-          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-              switches::kMojoChannelToken);
-    }
-
-    if (!channel_token.empty()) {
-      // TODO(rockot): Remove all paths which lead to this branch. The Channel
-      // connection should always be established by a shell connection from the
-      // browser. http://crbug.com/623396.
-      handle = mojo::edk::CreateChildMessagePipe(channel_token);
-    } else {
-      DCHECK(mojo_shell_connection_);
-      IPC::mojom::ChannelBootstrapPtr bootstrap;
-      handle = mojo::GetProxy(&bootstrap).PassMessagePipe();
-      mojo_shell_connection_->AddConnectionFilter(
-          base::MakeUnique<ChannelBootstrapFilter>(bootstrap.PassInterface()));
-    }
-
-    DCHECK(handle.is_valid());
-    channel_->Init(
-        IPC::ChannelMojo::CreateClientFactory(
-            std::move(handle), ChildProcess::current()->io_task_runner()),
-        create_pipe_now);
-    return;
+void ChildThreadImpl::ConnectChannel() {
+  std::string channel_token;
+  mojo::ScopedMessagePipeHandle handle;
+  if (!IsInBrowserProcess()) {
+    channel_token = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+        switches::kMojoChannelToken);
   }
 
-  VLOG(1) << "Mojo is disabled on child";
-  channel_->Init(channel_name_, IPC::Channel::MODE_CLIENT, create_pipe_now);
+  if (!channel_token.empty()) {
+    // TODO(rockot): Remove all paths which lead to this branch. The Channel
+    // connection should always be established by a shell connection from the
+    // browser. http://crbug.com/623396.
+    handle = mojo::edk::CreateChildMessagePipe(channel_token);
+  } else {
+    DCHECK(mojo_shell_connection_);
+    IPC::mojom::ChannelBootstrapPtr bootstrap;
+    handle = mojo::GetProxy(&bootstrap).PassMessagePipe();
+    mojo_shell_connection_->AddConnectionFilter(
+        base::MakeUnique<ChannelBootstrapFilter>(bootstrap.PassInterface()));
+  }
+
+  DCHECK(handle.is_valid());
+  channel_->Init(
+      IPC::ChannelMojo::CreateClientFactory(
+          std::move(handle), ChildProcess::current()->io_task_runner()),
+      true /* create_pipe_now */);
 }
 
 void ChildThreadImpl::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
 
@@ skipping 108 matching lines @@
   }
 
   IPC::AttachmentBroker* broker = IPC::AttachmentBroker::GetGlobal();
   if (broker && !broker->IsPrivilegedBroker())
     broker->RegisterBrokerCommunicationChannel(channel_.get());
 
   channel_->AddAssociatedInterface(
       base::Bind(&ChildThreadImpl::OnRouteProviderRequest,
                  base::Unretained(this)));
 
-  ConnectChannel(options.use_mojo_channel);
+  ConnectChannel();
 
   // This must always be done after ConnectChannel, because ConnectChannel() may
   // add a ConnectionFilter to the connection.
   if (options.auto_start_mojo_shell_connection && mojo_shell_connection_)
     StartMojoShellConnection();
 
   int connection_timeout = kConnectionTimeoutS;
   std::string connection_override =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kIPCConnectionTimeout);
@@ skipping 305 matching lines @@
   Listener* route = router_.GetRoute(routing_id);
   if (route)
     route->OnAssociatedInterfaceRequest(name, request.PassHandle());
 }
 
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return static_cast<bool>(browser_process_io_runner_);
 }
 
 }  // namespace content