Consolidating the mojo NativeRunner functionality.

services/service_manager/runner/host/service_process_launcher.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2016 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 "services/service_manager/runner/host/child_process_host.h"
-
-#include <stdint.h>
+#include "services/service_manager/runner/host/service_process_launcher.h"
 
 #include <utility>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
-#include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/interface_ptr_info.h"
 #include "mojo/public/cpp/system/core.h"
-#include "services/service_manager/native_runner_delegate.h"
 #include "services/service_manager/public/cpp/standalone_service/switches.h"
 #include "services/service_manager/runner/common/client_util.h"
 #include "services/service_manager/runner/common/switches.h"
 
 #if defined(OS_LINUX)
 #include "sandbox/linux/services/namespace_sandbox.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
@@ skipping 20 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScopedDllDirectoryOverride);
 };
 
 }  // namespace
 #endif  // defined(OS_WIN) && defined(COMPONENT_BUILD)
 
 namespace service_manager {
 
-ChildProcessHost::ChildProcessHost(base::TaskRunner* launch_process_runner,
-                                   NativeRunnerDelegate* delegate,
-                                   bool start_sandboxed,
-                                   const Identity& target,
-                                   const base::FilePath& service_path)
+ServiceProcessLauncher::ServiceProcessLauncher(
+    base::TaskRunner* launch_process_runner,
+    Delegate* delegate,
+    const base::FilePath& service_path)
     : launch_process_runner_(launch_process_runner),
       delegate_(delegate),
-      start_sandboxed_(start_sandboxed),
-      target_(target),
+      start_sandboxed_(false),
       service_path_(service_path),
       child_token_(mojo::edk::GenerateRandomToken()),
       start_child_process_event_(
           base::WaitableEvent::ResetPolicy::AUTOMATIC,
           base::WaitableEvent::InitialState::NOT_SIGNALED),
       weak_factory_(this) {
   if (service_path_.empty())
     service_path_ = base::CommandLine::ForCurrentProcess()->GetProgram();
 }
 
-ChildProcessHost::~ChildProcessHost() {
-  DCHECK(!mojo_ipc_channel_)
-      << "Destroying ChildProcessHost before calling Join";
+ServiceProcessLauncher::~ServiceProcessLauncher() {
+  Join();
 }
 
-mojom::ServicePtr ChildProcessHost::Start(
+mojom::ServicePtr ServiceProcessLauncher::Start(
     const Identity& target,
-    const ProcessReadyCallback& callback,
-    const base::Closure& quit_closure) {
+    bool start_sandboxed,
+    const ProcessReadyCallback& callback) {
   DCHECK(!child_process_.IsValid());
 
+  start_sandboxed_ = start_sandboxed;
+  target_ = target;
+
   const base::CommandLine& parent_command_line =
       *base::CommandLine::ForCurrentProcess();
 
   std::unique_ptr<base::CommandLine> child_command_line(
       new base::CommandLine(service_path_));
 
   child_command_line->AppendArguments(parent_command_line, false);
 
   child_command_line->AppendSwitchASCII(::switches::kProcessServiceName,
                                         target.name());
 #ifndef NDEBUG
   child_command_line->AppendSwitchASCII("u", target.user_id());
 #endif
 
   if (start_sandboxed_)
     child_command_line->AppendSwitch(::switches::kEnableSandbox);
 
   mojo_ipc_channel_.reset(new mojo::edk::PlatformChannelPair);
   mojo_ipc_channel_->PrepareToPassClientHandleToChildProcess(
       child_command_line.get(), &handle_passing_info_);
 
   mojom::ServicePtr client =
-      PassServiceRequestOnCommandLine(child_command_line.get(),
-                                          child_token_);
+      PassServiceRequestOnCommandLine(child_command_line.get(), child_token_);
   launch_process_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&ChildProcessHost::DoLaunch, base::Unretained(this),
+      base::Bind(&ServiceProcessLauncher::DoLaunch, base::Unretained(this),
                  base::Passed(&child_command_line)),
-      base::Bind(&ChildProcessHost::DidStart,
+      base::Bind(&ServiceProcessLauncher::DidStart,
                  weak_factory_.GetWeakPtr(), callback));
   return client;
 }
 
-void ChildProcessHost::Join() {
+void ServiceProcessLauncher::Join() {
   if (mojo_ipc_channel_)
     start_child_process_event_.Wait();
   mojo_ipc_channel_.reset();
   if (child_process_.IsValid()) {
     int rv = -1;
     LOG_IF(ERROR, !child_process_.WaitForExit(&rv))
         << "Failed to wait for child process";
     child_process_.Close();
   }
 }
 
-void ChildProcessHost::DidStart(const ProcessReadyCallback& callback) {
+void ServiceProcessLauncher::DidStart(const ProcessReadyCallback& callback) {
   if (child_process_.IsValid()) {
     callback.Run(child_process_.Pid());
   } else {
     LOG(ERROR) << "Failed to start child process";
     mojo_ipc_channel_.reset();
     callback.Run(base::kNullProcessId);
   }
 }
 
-void ChildProcessHost::DoLaunch(
+void ServiceProcessLauncher::DoLaunch(
     std::unique_ptr<base::CommandLine> child_command_line) {
   if (delegate_) {
     delegate_->AdjustCommandLineArgumentsForTarget(target_,
                                                    child_command_line.get());
   }
 
   base::LaunchOptions options;
 
   base::FilePath exe_dir;
   base::PathService::Get(base::DIR_EXE, &exe_dir);
@@ skipping 84 matching lines @@
           child_process_.Handle(),
           mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(
               mojo_ipc_channel_->PassServerHandle().release().handle)),
           child_token_);
     }
   }
   start_child_process_event_.Signal();
 }
 
 }  // namespace service_manager