Revert of Establish MojoChildConnection from BrowserChildProcessHostImpl

content/browser/utility_process_host_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/browser/utility_process_host_impl.h"
 
 #include <utility>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
 #include "content/browser/browser_child_process_host_impl.h"
 #include "content/browser/mojo/mojo_child_connection.h"
 #include "content/browser/mojo/mojo_shell_context.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/in_process_child_thread_params.h"
@@ skipping 127 matching lines @@
       is_batch_mode_(false),
       no_sandbox_(false),
       run_elevated_(false),
 #if defined(OS_LINUX)
       child_flags_(ChildProcessHost::CHILD_ALLOW_SELF),
 #else
       child_flags_(ChildProcessHost::CHILD_NORMAL),
 #endif
       started_(false),
       name_(base::ASCIIToUTF16("utility process")),
+      child_token_(mojo::edk::GenerateRandomToken()),
       weak_ptr_factory_(this) {
-  process_.reset(new BrowserChildProcessHostImpl(
-      PROCESS_TYPE_UTILITY, this, kUtilityMojoApplicationName));
+  process_.reset(new BrowserChildProcessHostImpl(PROCESS_TYPE_UTILITY, this,
+                                                 child_token_));
+  mojo_child_connection_.reset(new MojoChildConnection(
+      kUtilityMojoApplicationName,
+      base::StringPrintf("%d_0", process_->GetData().id), child_token_,
+      MojoShellContext::GetConnectorForIOThread(),
+      BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 }
 
 UtilityProcessHostImpl::~UtilityProcessHostImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (is_batch_mode_)
     EndBatchMode();
 }
 
 base::WeakPtr<UtilityProcessHost> UtilityProcessHostImpl::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
@@ skipping 44 matching lines @@
   env_ = env;
 }
 
 #endif  // OS_POSIX
 
 bool UtilityProcessHostImpl::Start() {
   return StartProcess();
 }
 
 shell::InterfaceProvider* UtilityProcessHostImpl::GetRemoteInterfaces() {
-  return process_->child_connection()->GetRemoteInterfaces();
+  return mojo_child_connection_->GetRemoteInterfaces();
 }
 
 void UtilityProcessHostImpl::SetName(const base::string16& name) {
   name_ = name;
 }
 
 #if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 // static
 void UtilityProcessHostImpl::EarlyZygoteLaunch() {
   DCHECK(!g_utility_zygote);
   g_utility_zygote = CreateZygote();
 }
 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
 bool UtilityProcessHostImpl::StartProcess() {
   if (started_)
     return true;
   started_ = true;
 
   if (is_batch_mode_)
     return true;
 
   process_->SetName(name_);
-  process_->GetHost()->CreateChannelMojo();
+
+  std::string mojo_channel_token =
+      process_->GetHost()->CreateChannelMojo(child_token_);
+  if (mojo_channel_token.empty()) {
+    NotifyAndDelete(LAUNCH_RESULT_FAILURE);
+    return false;
+  }
 
   if (RenderProcessHost::run_renderer_in_process()) {
     DCHECK(g_utility_main_thread_factory);
     // See comment in RenderProcessHostImpl::Init() for the background on why we
     // support single process mode this way.
     in_process_thread_.reset(
         g_utility_main_thread_factory(InProcessChildThreadParams(
             std::string(), BrowserThread::UnsafeGetMessageLoopForThread(
                             BrowserThread::IO)->task_runner(),
-            std::string(),
-            process_->child_connection()->service_token())));
+            mojo_channel_token, mojo_child_connection_->service_token())));
     in_process_thread_->Start();
   } else {
     const base::CommandLine& browser_command_line =
         *base::CommandLine::ForCurrentProcess();
 
     bool has_cmd_prefix = browser_command_line.HasSwitch(
         switches::kUtilityCmdPrefix);
 
     #if defined(OS_ANDROID)
       // readlink("/prof/self/exe") sometimes fails on Android at startup.
@@ skipping 16 matching lines @@
       if (exe_path.empty()) {
         NOTREACHED() << "Unable to get utility process binary name.";
         return false;
       }
 
       base::CommandLine* cmd_line = new base::CommandLine(exe_path);
     #endif
 
     cmd_line->AppendSwitchASCII(switches::kProcessType,
                                 switches::kUtilityProcess);
+    cmd_line->AppendSwitchASCII(switches::kMojoChannelToken,
+                                mojo_channel_token);
     std::string locale = GetContentClient()->browser()->GetApplicationLocale();
     cmd_line->AppendSwitchASCII(switches::kLang, locale);
 
 #if defined(OS_WIN)
     cmd_line->AppendArg(switches::kPrefetchArgumentOther);
 #endif  // defined(OS_WIN)
 
     if (no_sandbox_)
       cmd_line->AppendSwitch(switches::kNoSandbox);
 
@@ skipping 19 matching lines @@
       cmd_line->AppendSwitchPath(switches::kUtilityProcessAllowedDir,
                                  exposed_dir_);
     }
 
 #if defined(OS_WIN)
     // Let the utility process know if it is intended to be elevated.
     if (run_elevated_)
       cmd_line->AppendSwitch(switches::kUtilityProcessRunningElevated);
 #endif
 
+    cmd_line->AppendSwitchASCII(switches::kMojoApplicationChannelToken,
+                                mojo_child_connection_->service_token());
+
     process_->Launch(
         new UtilitySandboxedProcessLauncherDelegate(exposed_dir_,
                                                     run_elevated_,
                                                     no_sandbox_, env_,
                                                     process_->GetHost()),
         cmd_line,
         true);
   }
 
   return true;
@@ skipping 47 matching lines @@
     base::WeakPtr<UtilityProcessHostImpl> host,
     int error_code) {
   if (!host)
     return;
 
   host->OnProcessLaunchFailed(error_code);
   delete host.get();
 }
 
 }  // namespace content