Stop using chrome-sandbox to determine real pids

base/posix/unix_domain_socket_linux.cc

 // Copyright (c) 2011 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 "base/posix/unix_domain_socket_linux.h"
 
 #include <errno.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <unistd.h>
@@ skipping 131 matching lines @@
 
   return r;
 }
 
 // static
 ssize_t UnixDomainSocket::SendRecvMsg(int fd,
                                       uint8_t* reply,
                                       unsigned max_reply_len,
                                       int* result_fd,
                                       const Pickle& request) {
-  return UnixDomainSocket::SendRecvMsgWithFlags(fd, reply, max_reply_len,
-                                                0,  /* recvmsg_flags */
-                                                result_fd, request);
+  const int recvmsg_flags = 0;
+  const int request_fd = -1;
+  return SendRecvMsgImpl(
+      fd, reply, max_reply_len, recvmsg_flags, result_fd, request, request_fd);
 }
 
 // static
+ssize_t UnixDomainSocket::SendRecvMsgWithFD(int fd,
+                                            uint8_t* reply,
+                                            unsigned max_reply_len,
+                                            int* result_fd,
+                                            const Pickle& request,
+                                            int request_fd) {
+  const int recvmsg_flags = 0;
+  return SendRecvMsgImpl(
+      fd, reply, max_reply_len, recvmsg_flags, result_fd, request, request_fd);
+}
+
+// static
 ssize_t UnixDomainSocket::SendRecvMsgWithFlags(int fd,
                                                uint8_t* reply,
                                                unsigned max_reply_len,
                                                int recvmsg_flags,
                                                int* result_fd,
                                                const Pickle& request) {
+  const int request_fd = -1;
+  return SendRecvMsgImpl(
+      fd, reply, max_reply_len, recvmsg_flags, result_fd, request, request_fd);
+}
+
+// static
+ssize_t UnixDomainSocket::SendRecvMsgImpl(int fd,
+                                          uint8_t* reply,
+                                          unsigned max_reply_len,
+                                          int recvmsg_flags,
+                                          int* result_fd,
+                                          const Pickle& request,
+                                          int request_fd) {
   int fds[2];
 
   // This socketpair is only used for the IPC and is cleaned up before
   // returning.
   if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds) == -1)
     return -1;
 
   std::vector<int> fd_vector;
   fd_vector.push_back(fds[1]);
+  if (request_fd != -1)
+    fd_vector.push_back(request_fd);
   if (!SendMsg(fd, request.data(), request.size(), fd_vector)) {
     close(fds[0]);
     close(fds[1]);
     return -1;
   }
   close(fds[1]);
 
   fd_vector.clear();
   // When porting to OSX keep in mind it doesn't support MSG_NOSIGNAL, so the
   // sender might get a SIGPIPE.
@@ skipping 12 matching lines @@
     NOTREACHED();
 
     return -1;
   }
 
   if (result_fd)
     *result_fd = fd_vector.empty() ? -1 : fd_vector[0];
 
   return reply_len;
 }