Update ChildProcessLauncher to use the new version of LaunchProcess.

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 306 matching lines @@
   base::EnvironmentMap env = delegate->GetEnvironment();
   base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #elif defined(OS_POSIX)
   bool use_zygote = delegate->ShouldUseZygote();
   base::EnvironmentMap env = delegate->GetEnvironment();
   base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #endif
   scoped_ptr<base::CommandLine> cmd_line_deleter(cmd_line);
   base::TimeTicks begin_launch_time = base::TimeTicks::Now();
 
+  base::Process process;
 #if defined(OS_WIN)
-  base::Process process;
   if (launch_elevated) {
     base::LaunchOptions options;
     options.start_hidden = true;
     process = base::LaunchElevatedProcess(*cmd_line, options);
   } else {
     process = StartSandboxedProcess(delegate, cmd_line);
   }
 #elif defined(OS_POSIX)
   std::string process_type =
       cmd_line->GetSwitchValueASCII(switches::kProcessType);
@@ skipping 25 matching lines @@
   StartChildProcess(
       cmd_line->argv(),
       child_process_id,
       files_to_register.Pass(),
       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.
 
 #if !defined(OS_MACOSX)
   GetContentClient()->browser()->GetAdditionalMappedFilesForChildProcess(
       *cmd_line, child_process_id, files_to_register.get());
   if (use_zygote) {
-    handle = ZygoteHostImpl::GetInstance()->ForkRequest(
+    base::ProcessHandle handle = ZygoteHostImpl::GetInstance()->ForkRequest(
         cmd_line->argv(), files_to_register.Pass(), process_type);
+    process = base::Process(handle);
   } else
   // Fall through to the normal posix case below when we're not zygoting.
 #endif  // !defined(OS_MACOSX)
   {
     // Convert FD mapping to FileHandleMappingVector
     base::FileHandleMappingVector fds_to_map =
         files_to_register->GetMappingWithIDAdjustment(
             base::GlobalDescriptors::kBaseDescriptor);
 
 #if !defined(OS_MACOSX)
@@ skipping 29 matching lines @@
     const int bootstrap_sandbox_policy = delegate->GetSandboxType();
     if (ShouldEnableBootstrapSandbox() &&
         bootstrap_sandbox_policy != SANDBOX_TYPE_INVALID) {
       options.replacement_bootstrap_name =
           GetBootstrapSandbox()->server_bootstrap_name();
       GetBootstrapSandbox()->PrepareToForkWithPolicy(
           bootstrap_sandbox_policy);
     }
 #endif  // defined(OS_MACOSX)
 
-    bool launched = base::LaunchProcess(*cmd_line, options, &handle);
-    if (!launched)
-      handle = base::kNullProcessHandle;
+    process = base::LaunchProcess(*cmd_line, options);
 
 #if defined(OS_MACOSX)
     if (ShouldEnableBootstrapSandbox() &&
         bootstrap_sandbox_policy != SANDBOX_TYPE_INVALID) {
-      GetBootstrapSandbox()->FinishedFork(handle);
+      GetBootstrapSandbox()->FinishedFork(process.Handle());
     }
 
-    if (launched)
-      broker->AddPlaceholderForPid(handle, child_process_id);
+    if (process.IsValid())
+      broker->AddPlaceholderForPid(process.pid(), child_process_id);
 
     // After updating the broker, release the lock and let the child's
     // messasge be processed on the broker's thread.
     broker->GetLock().Release();
 #endif  // defined(OS_MACOSX)
   }
-  base::Process process(handle);
 #endif  // else defined(OS_POSIX)
 #if !defined(OS_ANDROID)
   if (process.IsValid())
     RecordHistograms(begin_launch_time);
   BrowserThread::PostTask(
       client_thread_id, FROM_HERE,
       base::Bind(&Context::Notify,
                  this_object.get(),
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
                  use_zygote,
@@ skipping 144 matching lines @@
   context_->SetProcessBackgrounded(background);
 }
 
 void ChildProcessLauncher::SetTerminateChildOnShutdown(
     bool terminate_on_shutdown) {
   if (context_.get())
     context_->set_terminate_child_on_shutdown(terminate_on_shutdown);
 }
 
 }  // namespace content