Revert 35888 - Mac: Other approach for IPCing child task_ts....

base/process_util_posix.cc

 // Copyright (c) 2006-2008 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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 10 matching lines @@
 #include "base/logging.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
 
 const int kMicrosecondsPerSecond = 1000000;
 
-#if defined(OS_MACOSX)
-
-std::map<pid_t, task_t> g_map;
-
-task_t foobar(pid_t pid) {
-return g_map[pid];
-}
-#endif
-
-
-
 namespace base {
 
 namespace {
 
 int WaitpidWithTimeout(ProcessHandle handle, int64 wait_milliseconds,
                        bool* success) {
   // This POSIX version of this function only guarantees that we wait no less
   // than |wait_milliseconds| for the proces to exit.  The child process may
   // exit sometime before the timeout has ended but we may still block for
   // up to 0.25 seconds after the fact.
@@ skipping 232 matching lines @@
     if (i <= STDERR_FILENO)
       continue;
 
     int flags = fcntl(i, F_GETFD);
     if ((flags == -1) || (fcntl(i, F_SETFD, flags | FD_CLOEXEC) == -1)) {
       DLOG(ERROR) << "fcntl failure.";
     }
   }
 }
 
-#if defined(OS_MACOSX)
-
-#define CHECK_MACH_ERROR(err, s) \
-do { \
-  if (err != KERN_SUCCESS) { \
-    fprintf(stderr, "%s 0x%x", s, (int)err); \
-    exit(1); \
-  } \
-} while (0)
-
-static int
-setup_recv_port (mach_port_t *recv_port)
-{
-    kern_return_t       err;
-    mach_port_t         port = MACH_PORT_NULL;
-    err = mach_port_allocate (mach_task_self (),
-                              MACH_PORT_RIGHT_RECEIVE, &port);
-    CHECK_MACH_ERROR (err, "mach_port_allocate failed:");
-
-    err = mach_port_insert_right (mach_task_self (),
-                                  port,
-                                  port,
-                                  MACH_MSG_TYPE_MAKE_SEND);
-    CHECK_MACH_ERROR (err, "mach_port_insert_right failed:");
-
-    *recv_port = port;
-    return 0;
-}
-
-static int
-send_port (mach_port_t remote_port, mach_port_t port)
-{
-    kern_return_t       err;
-
-    struct {
-        mach_msg_header_t          header;
-        mach_msg_body_t            body;
-        mach_msg_port_descriptor_t task_port;
-    } msg;
-
-    msg.header.msgh_remote_port = remote_port;
-    msg.header.msgh_local_port = MACH_PORT_NULL;
-    msg.header.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_COPY_SEND, 0) |
-        MACH_MSGH_BITS_COMPLEX;
-    msg.header.msgh_size = sizeof msg;
-
-    msg.body.msgh_descriptor_count = 1;
-    msg.task_port.name = port;
-    msg.task_port.disposition = MACH_MSG_TYPE_COPY_SEND;
-    msg.task_port.type = MACH_MSG_PORT_DESCRIPTOR;
-
-    err = mach_msg_send (&msg.header);
-    CHECK_MACH_ERROR (err, "mach_msg_send failed:");
-
-    return 0;
-}
-
-static int
-recv_port (mach_port_t recv_port, mach_port_t *port)
-{
-    kern_return_t       err;
-    struct {
-        mach_msg_header_t          header;
-        mach_msg_body_t            body;
-        mach_msg_port_descriptor_t task_port;
-        mach_msg_trailer_t         trailer;
-    } msg;
-
-    err = mach_msg (&msg.header, MACH_RCV_MSG,
-                    0, sizeof msg, recv_port,
-                    MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-    CHECK_MACH_ERROR (err, "mach_msg failed:");
-
-    *port = msg.task_port.name;
-    return 0;
-}
-
-static task_t       child_task = MACH_PORT_NULL;
-
-pid_t
-sampling_fork ()
-{
-    kern_return_t       err;
-    mach_port_t         parent_recv_port = MACH_PORT_NULL;
-    mach_port_t         child_recv_port = MACH_PORT_NULL;
-
-    if (setup_recv_port (&parent_recv_port) != 0)
-        return -1;
-    err = task_set_bootstrap_port (mach_task_self (), parent_recv_port);
-    CHECK_MACH_ERROR (err, "task_set_bootstrap_port failed:");
-
-    pid_t               pid;
-    switch (pid = fork ()) {
-    case -1:
-        err = mach_port_deallocate (mach_task_self(), parent_recv_port);
-        CHECK_MACH_ERROR (err, "mach_port_deallocate failed:");
-        return pid;
-    case 0: /* child */
-        err = task_get_bootstrap_port (mach_task_self (), &parent_recv_port);
-        CHECK_MACH_ERROR (err, "task_get_bootstrap_port failed:");
-        if (setup_recv_port (&child_recv_port) != 0)
-            return -1;
-        if (send_port (parent_recv_port, mach_task_self ()) != 0)
-            return -1;
-        if (send_port (parent_recv_port, child_recv_port) != 0)
-            return -1;
-        if (recv_port (child_recv_port, &bootstrap_port) != 0)
-            return -1;
-        err = task_set_bootstrap_port (mach_task_self (), bootstrap_port);
-        CHECK_MACH_ERROR (err, "task_set_bootstrap_port failed:");
-        break;
-    default: /* parent */
-        err = task_set_bootstrap_port (mach_task_self (), bootstrap_port);
-        CHECK_MACH_ERROR (err, "task_set_bootstrap_port failed:");
-        if (recv_port (parent_recv_port, &child_task) != 0)
-            return -1;
-        if (recv_port (parent_recv_port, &child_recv_port) != 0)
-            return -1;
-        if (send_port (child_recv_port, bootstrap_port) != 0)
-            return -1;
-        err = mach_port_deallocate (mach_task_self(), parent_recv_port);
-        CHECK_MACH_ERROR (err, "mach_port_deallocate failed:");
-        break;
-    }
-
-    return pid;
-}
-#endif
-
 bool LaunchApp(const std::vector<std::string>& argv,
                const environment_vector& environ,
                const file_handle_mapping_vector& fds_to_remap,
                bool wait, ProcessHandle* process_handle) {
-#if defined(OS_MACOSX)
-  // Needs to be mutexed! :-(
-  pid_t pid = sampling_fork();
-  g_map[pid] = child_task;
-#else
   pid_t pid = fork();
-#endif
   if (pid < 0)
     return false;
 
   if (pid == 0) {
     // Child process
 #if defined(OS_MACOSX)
     RestoreDefaultExceptionHandler();
 #endif
 
     InjectiveMultimap fd_shuffle;
@@ skipping 379 matching lines @@
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
                              filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base