Update EnsureProcessGetsReaped to receive a pid.

content/browser/zygote_host/zygote_host_impl_linux.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/zygote_host/zygote_host_impl_linux.h"
 
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 140 matching lines @@
 
   base::ScopedFD dummy_fd;
   if (using_suid_sandbox_) {
     scoped_ptr<sandbox::SetuidSandboxClient>
         sandbox_client(sandbox::SetuidSandboxClient::Create());
     sandbox_client->PrependWrapper(&cmd_line);
     sandbox_client->SetupLaunchOptions(&options, &fds_to_map, &dummy_fd);
     sandbox_client->SetupLaunchEnvironment();
   }
 
-  base::ProcessHandle process = -1;
   options.fds_to_remap = &fds_to_map;
-  base::LaunchProcess(cmd_line.argv(), options, &process);
-  CHECK(process != -1) << "Failed to launch zygote process";
+  base::Process process = base::LaunchProcess(cmd_line.argv(), options);
+  CHECK(process.IsValid()) << "Failed to launch zygote process";
   dummy_fd.reset();
 
   if (using_suid_sandbox_) {
     // The SUID sandbox will execute the zygote in a new PID namespace, and
     // the main zygote process will then fork from there.  Watch now our
     // elaborate dance to find and validate the zygote's PID.
 
     // First we receive a message from the zygote boot process.
     base::ProcessId boot_pid;
     CHECK(ReceiveFixedMessage(
         fds[0], kZygoteBootMessage, sizeof(kZygoteBootMessage), &boot_pid));
 
     // Within the PID namespace, the zygote boot process thinks it's PID 1,
     // but its real PID can never be 1. This gives us a reliable test that
     // the kernel is translating the sender's PID to our namespace.
     CHECK_GT(boot_pid, 1)
         << "Received invalid process ID for zygote; kernel might be too old? "
            "See crbug.com/357670 or try using --"
         << switches::kDisableSetuidSandbox << " to workaround.";
 
     // Now receive the message that the zygote's ready to go, along with the
     // main zygote process's ID.
     CHECK(ReceiveFixedMessage(
         fds[0], kZygoteHelloMessage, sizeof(kZygoteHelloMessage), &pid_));
     CHECK_GT(pid_, 1);
 
-    if (process != pid_) {
+    if (process.pid() != pid_) {
       // Reap the sandbox.
-      base::EnsureProcessGetsReaped(process);
+      base::EnsureProcessGetsReaped(process.pid());
     }
   } else {
     // Not using the SUID sandbox.
-    pid_ = process;
+    // Note that ~base::Process() will reset the internal value, but there's no

[jln (very slow on Chromium), 2015/01/13 19:19:23]

Feel free to keep, but this confused me a little.
Isn't this captured entirely by the fact that pid_ is not a reference?

[rvargas (doing something else), 2015/01/13 19:37:04]

The pattern
{
   ScopedFoo foo = Bar();
   foo_ = foo.get();
}

generally introduces a bug. I'm just trying to explain why it is OK to do that
in this particular case (it would be a bug if this code were platform
independent).

Suggestions for better wording are welcome :)

+    // real "handle" on POSIX so that is safe.
+    pid_ = process.pid();
   }
 
   close(fds[1]);
   control_fd_ = fds[0];
 
   Pickle pickle;
   pickle.WriteInt(kZygoteCommandGetSandboxStatus);
   if (!SendMessage(pickle, NULL))
     LOG(FATAL) << "Cannot communicate with zygote";
   // We don't wait for the reply. We'll read it in ReadReply.
@@ skipping 256 matching lines @@
     // TODO(stevenjb): Investigate further and fix.
     if (IsHeapProfilerRunning())
       return;
 #endif
     std::vector<std::string> adj_oom_score_cmdline;
     adj_oom_score_cmdline.push_back(sandbox_binary_);
     adj_oom_score_cmdline.push_back(sandbox::kAdjustOOMScoreSwitch);
     adj_oom_score_cmdline.push_back(base::Int64ToString(pid));
     adj_oom_score_cmdline.push_back(base::IntToString(score));
 
-    base::ProcessHandle sandbox_helper_process;
+    base::Process sandbox_helper_process;
     base::LaunchOptions options;
 
     // sandbox_helper_process is a setuid binary.
     options.allow_new_privs = true;
 
-    if (base::LaunchProcess(adj_oom_score_cmdline, options,
-                            &sandbox_helper_process)) {
-      base::EnsureProcessGetsReaped(sandbox_helper_process);
-    }
+    sandbox_helper_process =
+        base::LaunchProcess(adj_oom_score_cmdline, options);
+    if (sandbox_helper_process.IsValid())
+      base::EnsureProcessGetsReaped(sandbox_helper_process.pid());
   } else if (!using_suid_sandbox_) {
     if (!base::AdjustOOMScore(pid, score))
       PLOG(ERROR) << "Failed to adjust OOM score of renderer with pid " << pid;
   }
 }
 #endif
 
 void ZygoteHostImpl::EnsureProcessTerminated(pid_t process) {
   DCHECK(init_);
   Pickle pickle;
@@ skipping 58 matching lines @@
   return pid_;
 }
 
 int ZygoteHostImpl::GetSandboxStatus() const {
   if (have_read_sandbox_status_word_)
     return sandbox_status_;
   return 0;
 }
 
 }  // namespace content