Launches a privileged utility process.

content/browser/child_process_launcher.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/child_process_launcher.h"
 
 #include <utility>  // For std::pair.
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 14 matching lines @@
 #include "base/files/file_path.h"
 #include "content/common/sandbox_win.h"
 #include "content/public/common/sandbox_init.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #elif defined(OS_MACOSX)
 #include "content/browser/mach_broker_mac.h"
 #elif defined(OS_ANDROID)
 #include "base/android/jni_android.h"
 #include "content/browser/android/child_process_launcher_android.h"
 #elif defined(OS_POSIX)
+#include "base/memory/shared_memory.h"
 #include "base/memory/singleton.h"
 #include "content/browser/renderer_host/render_sandbox_host_linux.h"
 #include "content/browser/zygote_host/zygote_host_impl_linux.h"
 #include "content/common/child_process_sandbox_support_impl_linux.h"
 #endif
 
 #if defined(OS_POSIX)
+#include "base/metrics/stats_table.h"
 #include "base/posix/global_descriptors.h"
 #endif
 
 namespace content {
 
 // Having the functionality of ChildProcessLauncher be in an internal
 // ref counted object allows us to automatically terminate the process when the
 // parent class destructs, while still holding on to state that we need.
 class ChildProcessLauncher::Context
     : public base::RefCountedThreadSafe<ChildProcessLauncher::Context> {
@@ skipping 12 matching lines @@
           terminate_child_on_shutdown_ = !CommandLine::ForCurrentProcess()->
               HasSwitch(switches::kChildCleanExit);
 #else
           terminate_child_on_shutdown_ = true;
 #endif
   }
 
   void Launch(
 #if defined(OS_WIN)
       SandboxedProcessLauncherDelegate* delegate,
+      bool launch_elevated,
 #elif defined(OS_ANDROID)
       int ipcfd,
 #elif defined(OS_POSIX)
       bool use_zygote,
       const base::EnvironmentMap& environ,
       int ipcfd,
 #endif
       CommandLine* cmd_line,
       int child_process_id,
       Client* client) {
     client_ = client;
 
     CHECK(BrowserThread::GetCurrentThreadIdentifier(&client_thread_id_));
 
 #if defined(OS_ANDROID)
     // We need to close the client end of the IPC channel to reliably detect
     // child termination. We will close this fd after we create the child
     // process which is asynchronous on Android.
     ipcfd_ = ipcfd;
 #endif
     BrowserThread::PostTask(
         BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
         base::Bind(
             &Context::LaunchInternal,
             make_scoped_refptr(this),
             client_thread_id_,
             child_process_id,
 #if defined(OS_WIN)
             delegate,
+            launch_elevated,
 #elif defined(OS_ANDROID)
             ipcfd,
 #elif defined(OS_POSIX)
             use_zygote,
             environ,
             ipcfd,
 #endif
+

[jam, 2014/01/30 21:41:03]

nit: drop the empty line

[Drew Haven, 2014/01/31 20:00:12]

Done.

             cmd_line));
   }
 
 #if defined(OS_ANDROID)
   static void OnChildProcessStarted(
       // |this_object| is NOT thread safe. Only use it to post a task back.
       scoped_refptr<Context> this_object,
       BrowserThread::ID client_thread_id,
       const base::TimeTicks begin_launch_time,
       base::ProcessHandle handle) {
@@ skipping 56 matching lines @@
     }
   }
 
   static void LaunchInternal(
       // |this_object| is NOT thread safe. Only use it to post a task back.
       scoped_refptr<Context> this_object,
       BrowserThread::ID client_thread_id,
       int child_process_id,
 #if defined(OS_WIN)
       SandboxedProcessLauncherDelegate* delegate,
+      bool launch_elevated,
 #elif defined(OS_ANDROID)
       int ipcfd,
 #elif defined(OS_POSIX)
       bool use_zygote,
       const base::EnvironmentMap& env,
       int ipcfd,
 #endif
       CommandLine* cmd_line) {
     scoped_ptr<CommandLine> cmd_line_deleter(cmd_line);
     base::TimeTicks begin_launch_time = base::TimeTicks::Now();
 
 #if defined(OS_WIN)
-    scoped_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
-    base::ProcessHandle handle = StartSandboxedProcess(delegate, cmd_line);
-#elif defined(OS_ANDROID)
-    // Android WebView runs in single process, ensure that we never get here
-    // when running in single process mode.
-    CHECK(!cmd_line->HasSwitch(switches::kSingleProcess));
-
+    base::ProcessHandle handle = base::kNullProcessHandle;
+    if (launch_elevated) {
+      base::LaunchOptions options;
+      options.start_hidden = true;
+      base::LaunchElevatedProcess(*cmd_line, options, &handle);
+    } else {
+      scoped_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
+      handle = StartSandboxedProcess(delegate, cmd_line);
+    }
+#elif defined(OS_POSIX)
     std::string process_type =
         cmd_line->GetSwitchValueASCII(switches::kProcessType);
     std::vector<FileDescriptorInfo> files_to_register;
     files_to_register.push_back(
         FileDescriptorInfo(kPrimaryIPCChannel,
-                                    base::FileDescriptor(ipcfd, false)));
+                           base::FileDescriptor(ipcfd, false)));
+    base::StatsTable* stats_table = base::StatsTable::current();

[jam, 2014/01/30 21:41:03]

this, and some of the other changes in this file are not from your change and
are from changes that are already landed. can you update your checkout so that
it shows diff from trunk instead of an earlier revision?

[Drew Haven, 2014/01/31 20:00:12]

Done.

+    if (stats_table &&
+        base::SharedMemory::IsHandleValid(
+            stats_table->GetSharedMemoryHandle())) {
+      files_to_register.push_back(
+          FileDescriptorInfo(kStatsTableSharedMemFd,
+                             stats_table->GetSharedMemoryHandle()));
+    }
+#endif
+
+#if defined(OS_ANDROID)
+    // Android WebView runs in single process, ensure that we never get here
+    // when running in single process mode.
+    CHECK(!cmd_line->HasSwitch(switches::kSingleProcess));
 
     GetContentClient()->browser()->
         GetAdditionalMappedFilesForChildProcess(*cmd_line, child_process_id,
                                                 &files_to_register);
 
     StartChildProcess(cmd_line->argv(), files_to_register,
         base::Bind(&ChildProcessLauncher::Context::OnChildProcessStarted,
                    this_object, client_thread_id, begin_launch_time));
 
 #elif defined(OS_POSIX)
     base::ProcessHandle handle = base::kNullProcessHandle;
     // We need to close the client end of the IPC channel to reliably detect
     // child termination.
     file_util::ScopedFD ipcfd_closer(&ipcfd);
 
-    std::string process_type =
-        cmd_line->GetSwitchValueASCII(switches::kProcessType);
-    std::vector<FileDescriptorInfo> files_to_register;
-    files_to_register.push_back(
-        FileDescriptorInfo(kPrimaryIPCChannel,
-                                    base::FileDescriptor(ipcfd, false)));
-
 #if !defined(OS_MACOSX)
     GetContentClient()->browser()->
         GetAdditionalMappedFilesForChildProcess(*cmd_line, child_process_id,
                                                 &files_to_register);
     if (use_zygote) {
       handle = ZygoteHostImpl::GetInstance()->ForkRequest(cmd_line->argv(),
                                                           files_to_register,
                                                           process_type);
     } else
     // Fall through to the normal posix case below when we're not zygoting.
@@ skipping 80 matching lines @@
 #endif
     starting_ = false;
     process_.set_handle(handle);
     if (!handle)
       LOG(ERROR) << "Failed to launch child process";
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
     zygote_ = zygote;
 #endif
     if (client_) {
-      client_->OnProcessLaunched();
+      if (handle) {
+        client_->OnProcessLaunched();
+      } else {
+        client_->OnProcessLaunchFailed();
+      }
     } else {
       Terminate();
     }
   }
 
   void Terminate() {
     if (!process_.handle())
       return;
 
     if (!terminate_child_on_shutdown_)
@@ skipping 17 matching lines @@
     base::Process process(handle);
     process.SetProcessBackgrounded(background);
   }
 
   static void TerminateInternal(
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
       bool zygote,
 #endif
       base::ProcessHandle handle) {
 #if defined(OS_ANDROID)
-    LOG(INFO) << "ChromeProcess: Stopping process with handle " << handle;
+    VLOG(0) << "ChromeProcess: Stopping process with handle " << handle;
     StopChildProcess(handle);
 #else
     base::Process process(handle);
      // Client has gone away, so just kill the process.  Using exit code 0
     // means that UMA won't treat this as a crash.
     process.Terminate(RESULT_CODE_NORMAL_EXIT);
     // On POSIX, we must additionally reap the child.
 #if defined(OS_POSIX)
 #if !defined(OS_MACOSX)
     if (zygote) {
@@ skipping 24 matching lines @@
   int ipcfd_;
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
   bool zygote_;
 #endif
 };
 
 
 ChildProcessLauncher::ChildProcessLauncher(
 #if defined(OS_WIN)
     SandboxedProcessLauncherDelegate* delegate,
+    bool launch_elevated,
 #elif defined(OS_POSIX)
     bool use_zygote,
     const base::EnvironmentMap& environ,
     int ipcfd,
 #endif
     CommandLine* cmd_line,
     int child_process_id,
     Client* client) {
   context_ = new Context();
   context_->Launch(
 #if defined(OS_WIN)
       delegate,
+      launch_elevated,
 #elif defined(OS_ANDROID)
       ipcfd,
 #elif defined(OS_POSIX)
       use_zygote,
       environ,
       ipcfd,
 #endif
       cmd_line,
       child_process_id,
       client);
@@ skipping 19 matching lines @@
   if (handle == base::kNullProcessHandle) {
     // Process is already gone, so return the cached termination status.
     if (exit_code)
       *exit_code = context_->exit_code_;
     return context_->termination_status_;
   }
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
   if (context_->zygote_) {
     context_->termination_status_ = ZygoteHostImpl::GetInstance()->
         GetTerminationStatus(handle, known_dead, &context_->exit_code_);
-  } else
+  } else if (known_dead) {
+    context_->termination_status_ =
+        base::GetKnownDeadTerminationStatus(handle, &context_->exit_code_);
+  } else {
 #elif defined(OS_MACOSX)
   if (known_dead) {
     context_->termination_status_ =
         base::GetKnownDeadTerminationStatus(handle, &context_->exit_code_);
-  } else
+  } else {
+#elif defined(OS_ANDROID)
+  if (IsChildProcessOomProtected(handle)) {
+      context_->termination_status_ = base::TERMINATION_STATUS_OOM_PROTECTED;
+  } else {
+#else
+  {
 #endif
-  {
     context_->termination_status_ =
         base::GetTerminationStatus(handle, &context_->exit_code_);
   }
 
   if (exit_code)
     *exit_code = context_->exit_code_;
 
   // POSIX: If the process crashed, then the kernel closed the socket
   // for it and so the child has already died by the time we get
   // here. Since GetTerminationStatus called waitpid with WNOHANG,
@@ skipping 14 matching lines @@
           GetHandle(), background));
 }
 
 void ChildProcessLauncher::SetTerminateChildOnShutdown(
   bool terminate_on_shutdown) {
   if (context_.get())
     context_->set_terminate_child_on_shutdown(terminate_on_shutdown);
 }
 
 }  // namespace content