Use token-based initialisation for the utility process MojoApplication.

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"
@@ skipping 13 matching lines @@
 #include "content/browser/browser_child_process_host_impl.h"
 #include "content/browser/mojo/mojo_application_host.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"
 #include "content/common/utility_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/sandbox_type.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "ipc/ipc_switches.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 #include "content/public/browser/zygote_handle_linux.h"
 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
@@ skipping 196 matching lines @@
 #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;
 
-  bool mojo_result = mojo_application_host_->Init();
-  if (!mojo_result) {
-    NotifyAndDelete();
-    return false;
-  }
-
   // Name must be set or metrics_service will crash in any test which
   // launches a UtilityProcessHost.
   process_.reset(new BrowserChildProcessHostImpl(PROCESS_TYPE_UTILITY, this));
   process_->SetName(name_);
 
   std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty()) {
     NotifyAndDelete();
     return false;
   }
 
   if (RenderProcessHost::run_renderer_in_process()) {
     DCHECK(g_utility_main_thread_factory);
+    mojo::ScopedMessagePipeHandle mojo_handle =
+        mojo_application_host_->InitWithPipe();
+    if (!mojo_handle.is_valid()) {
+      NotifyAndDelete();
+      return false;
+    }
+
     // 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(
             channel_id, BrowserThread::UnsafeGetMessageLoopForThread(
-                            BrowserThread::IO)->task_runner())));
+                            BrowserThread::IO)->task_runner(),
+            mojo::MessagePipeHandle(), mojo_handle.release())));
     in_process_thread_->Start();
-    OnProcessLaunched();
   } 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.
       // As a workaround skip calling it here, since the executable name is
@@ skipping 56 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
 
+    std::string mojo_token = mojo_application_host_->InitWithToken();
+    cmd_line->AppendSwitchASCII(switches::kMojoApplicationChannelToken,
+                                mojo_token);
+
     process_->Launch(
         new UtilitySandboxedProcessLauncherDelegate(exposed_dir_,
                                                     run_elevated_,
                                                     no_sandbox_, env_,
                                                     process_->GetHost()),
         cmd_line,
         true);
   }
 
   return true;
@@ skipping 26 matching lines @@
 void UtilityProcessHostImpl::OnProcessCrashed(int exit_code) {
   if (!client_.get())
     return;
 
   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UtilityProcessHostClient::OnProcessCrashed, client_.get(),
             exit_code));
 }
 
-void UtilityProcessHostImpl::OnProcessLaunched() {
-  DCHECK(mojo_application_host_);
-  base::ProcessHandle handle;
-  if (RenderProcessHost::run_renderer_in_process())
-    handle = base::GetCurrentProcessHandle();
-  else
-    handle = process_->GetData().handle;
-
-  mojo_application_host_->Activate(this, handle);
-}
-
 void UtilityProcessHostImpl::NotifyAndDelete() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&UtilityProcessHostImpl::NotifyLaunchFailedAndDelete,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 // static
 void UtilityProcessHostImpl::NotifyLaunchFailedAndDelete(
     base::WeakPtr<UtilityProcessHostImpl> host) {
   if (!host)
     return;
 
   host->OnProcessLaunchFailed();
   delete host.get();
 }
 
 }  // namespace content