Move OpenProcessHandle to Process::Open.

sandbox/linux/services/unix_domain_socket_unittest.cc

 // Copyright 2014 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 <sched.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <vector>
 
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/unix_domain_socket_linux.h"
-#include "base/process/process_handle.h"
+#include "base/process/process.h"
 #include "sandbox/linux/services/syscall_wrappers.h"
 #include "sandbox/linux/tests/unit_tests.h"
 
 // Additional tests for base's UnixDomainSocket to make sure it behaves
 // correctly in the presence of sandboxing functionality (e.g., receiving
 // PIDs across namespaces).
 
 namespace sandbox {
 
 namespace {
@@ skipping 19 matching lines @@
   int status;
   CHECK_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
   CHECK(WIFEXITED(status));
   CHECK_EQ(0, WEXITSTATUS(status));
 }
 
 base::ProcessId GetParentProcessId(base::ProcessId pid) {
   // base::GetParentProcessId() is defined as taking a ProcessHandle instead of
   // a ProcessId, even though it's a POSIX-only function and IDs and Handles
   // are both simply pid_t on POSIX... :/
-  base::ProcessHandle handle;
-  CHECK(base::OpenProcessHandle(pid, &handle));
-  base::ProcessId ret = base::GetParentProcessId(pid);

[jln (very slow on Chromium), 2015/01/28 18:39:09]

Not related to your CL, but this should have been handle, not pid, right?

[rvargas (doing something else), 2015/02/02 19:47:09]

I believe so. The comment says that we need a handle to be correct but then
doesn't use it.

-  base::CloseProcessHandle(handle);
+  base::Process process = base::Process::Open(pid);
+  CHECK(process.IsValid());
+  base::ProcessId ret = base::GetParentProcessId(process.Handle());
   return ret;
 }
 
 // SendHello sends a "hello" to socket fd, and then blocks until the recipient
 // acknowledges it by calling RecvHello.
 void SendHello(int fd) {
   int pipe_fds[2];
   CHECK_EQ(0, pipe(pipe_fds));
   base::ScopedFD read_pipe(pipe_fds[0]);
   base::ScopedFD write_pipe(pipe_fds[1]);
@@ skipping 185 matching lines @@
 
   // Parent process.
   recv_sock.reset();
   SendHello(send_sock.get());
   WaitForExit(pid);
 }
 
 }  // namespace
 
 }  // namespace sandbox