[Mac] Remove base::LaunchSynchronize and rewrite content::MachBroker.

base/process_util_posix.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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 586 matching lines @@
 }
 
 bool LaunchProcess(const std::vector<std::string>& argv,
                    const LaunchOptions& options,
                    ProcessHandle* process_handle) {
   size_t fd_shuffle_size = 0;
   if (options.fds_to_remap) {
     fd_shuffle_size = options.fds_to_remap->size();
   }
 
-#if defined(OS_MACOSX)
-  if (options.synchronize) {
-    // When synchronizing, the "read" end of the synchronization pipe needs
-    // to make it to the child process. This is handled by mapping it back to
-    // itself.
-    ++fd_shuffle_size;
-  }
-#endif  // defined(OS_MACOSX)
-
   InjectiveMultimap fd_shuffle1;
   InjectiveMultimap fd_shuffle2;
   fd_shuffle1.reserve(fd_shuffle_size);
   fd_shuffle2.reserve(fd_shuffle_size);
 
   scoped_ptr<char*[]> argv_cstr(new char*[argv.size() + 1]);
   scoped_ptr<char*[]> new_environ;
   if (options.environ)
     new_environ.reset(AlterEnvironment(*options.environ, GetEnvironment()));
 
-#if defined(OS_MACOSX)
-  int synchronization_pipe_fds[2];
-  file_util::ScopedFD synchronization_read_fd;
-  file_util::ScopedFD synchronization_write_fd;
-
-  if (options.synchronize) {
-    // wait means "don't return from LaunchProcess until the child exits", and
-    // synchronize means "return from LaunchProcess but don't let the child
-    // run until LaunchSynchronize is called". These two options are highly
-    // incompatible.
-    DCHECK(!options.wait);
-
-    // Create the pipe used for synchronization.
-    if (HANDLE_EINTR(pipe(synchronization_pipe_fds)) != 0) {
-      DPLOG(ERROR) << "pipe";
-      return false;
-    }
-
-    // The parent process will only use synchronization_write_fd as the write
-    // side of the pipe. It can close the read side as soon as the child
-    // process has forked off. The child process will only use
-    // synchronization_read_fd as the read side of the pipe. In that process,
-    // the write side can be closed as soon as it has forked.
-    synchronization_read_fd.reset(&synchronization_pipe_fds[0]);
-    synchronization_write_fd.reset(&synchronization_pipe_fds[1]);
-  }
-#endif  // OS_MACOSX
-
   pid_t pid;
 #if defined(OS_LINUX)
   if (options.clone_flags) {
     pid = syscall(__NR_clone, options.clone_flags, 0, 0, 0);
   } else
 #endif
   {
     pid = fork();
   }
 
@@ skipping 72 matching lines @@
 #if defined(OS_MACOSX)
     RestoreDefaultExceptionHandler();
 #endif  // defined(OS_MACOSX)
 
     ResetChildSignalHandlersToDefaults();
 
     if (options.debug) {
       RAW_LOG(INFO, "Right after signal/exception handler restoration.");
     }
 
-#if defined(OS_MACOSX)
-    if (options.synchronize) {
-      // The "write" side of the synchronization pipe belongs to the parent.
-      synchronization_write_fd.reset();  // closes synchronization_pipe_fds[1]
-    }
-#endif  // defined(OS_MACOSX)
-
 #if 0
     // When debugging it can be helpful to check that we really aren't making
     // any hidden calls to malloc.
     void *malloc_thunk =
         reinterpret_cast<void*>(reinterpret_cast<intptr_t>(malloc) & ~4095);
     mprotect(malloc_thunk, 4096, PROT_READ | PROT_WRITE | PROT_EXEC);
     memset(reinterpret_cast<void*>(malloc), 0xff, 8);
 #endif  // 0
 
     // DANGER: no calls to malloc are allowed from now on:
@@ skipping 19 matching lines @@
            it != options.fds_to_remap->end(); ++it) {
         fd_shuffle1.push_back(InjectionArc(it->first, it->second, false));
         fd_shuffle2.push_back(InjectionArc(it->first, it->second, false));
       }
     }
 
     if (options.debug) {
       RAW_LOG(INFO, "Right after fd_shuffle push_backs.");
     }
 
-#if defined(OS_MACOSX)
-    if (options.synchronize) {
-      // Remap the read side of the synchronization pipe back onto itself,
-      // ensuring that it won't be closed by CloseSuperfluousFds.
-      int keep_fd = *synchronization_read_fd.get();
-      fd_shuffle1.push_back(InjectionArc(keep_fd, keep_fd, false));
-      fd_shuffle2.push_back(InjectionArc(keep_fd, keep_fd, false));
-    }
-#endif  // defined(OS_MACOSX)
-
     if (options.environ)
       SetEnvironment(new_environ.get());
 
     // fd_shuffle1 is mutated by this call because it cannot malloc.
     if (!ShuffleFileDescriptors(&fd_shuffle1))
       _exit(127);
 
     if (options.debug) {
       RAW_LOG(INFO, "Right after ShuffleFileDescriptors");
     }
 
     CloseSuperfluousFds(fd_shuffle2);
 
     if (options.debug) {
       RAW_LOG(INFO, "Right after CloseSuperfluousFds");
     }
 
-#if defined(OS_MACOSX)
-    if (options.synchronize) {
-      // Do a blocking read to wait until the parent says it's OK to proceed.
-      // The byte that's read here is written by LaunchSynchronize.
-      char read_char;
-      int read_result =
-          HANDLE_EINTR(read(*synchronization_read_fd.get(), &read_char, 1));
-      if (read_result != 1) {
-        RAW_LOG(ERROR, "LaunchProcess: synchronization read: error");
-        _exit(127);
-      }
-
-      // The pipe is no longer useful. Don't let it live on in the new process
-      // after exec.
-      synchronization_read_fd.reset();  // closes synchronization_pipe_fds[0]
-    }
-#endif  // defined(OS_MACOSX)
-
     if (options.debug) {
       RAW_LOG(INFO, "Right before execvp");
     }
 
     for (size_t i = 0; i < argv.size(); i++)
       argv_cstr[i] = const_cast<char*>(argv[i].c_str());
     argv_cstr[argv.size()] = NULL;
     execvp(argv_cstr[0], argv_cstr.get());
 
     RAW_LOG(ERROR, "LaunchProcess: failed to execvp:");
     RAW_LOG(ERROR, argv_cstr[0]);
     _exit(127);
   } else {
     // Parent process
     if (options.wait) {
       // While this isn't strictly disk IO, waiting for another process to
       // finish is the sort of thing ThreadRestrictions is trying to prevent.
       base::ThreadRestrictions::AssertIOAllowed();
       pid_t ret = HANDLE_EINTR(waitpid(pid, 0, 0));
       DPCHECK(ret > 0);
     }
 
     if (process_handle)
       *process_handle = pid;
-
-#if defined(OS_MACOSX)
-    if (options.synchronize) {
-      // The "read" side of the synchronization pipe belongs to the child.
-      synchronization_read_fd.reset();  // closes synchronization_pipe_fds[0]
-      *options.synchronize = new int(*synchronization_write_fd.release());
-    }
-#endif  // defined(OS_MACOSX)
   }
 
   return true;
 }
 
 
 bool LaunchProcess(const CommandLine& cmdline,
                    const LaunchOptions& options,
                    ProcessHandle* process_handle) {
   return LaunchProcess(cmdline.argv(), options, process_handle);
 }
 
-#if defined(OS_MACOSX)
-void LaunchSynchronize(LaunchSynchronizationHandle handle) {
-  int synchronization_fd = *handle;
-  file_util::ScopedFD synchronization_fd_closer(&synchronization_fd);
-  delete handle;
-
-  // Write a '\0' character to the pipe.
-  if (HANDLE_EINTR(write(synchronization_fd, "", 1)) != 1) {
-    DPLOG(ERROR) << "write";
-  }
-}
-#endif  // defined(OS_MACOSX)
-
 ProcessMetrics::~ProcessMetrics() { }
 
 void RaiseProcessToHighPriority() {
   // On POSIX, we don't actually do anything here.  We could try to nice() or
   // setpriority() or sched_getscheduler, but these all require extra rights.
 }
 
 TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
   return GetTerminationStatusImpl(handle, false /* can_block */, exit_code);
 }
@@ skipping 468 matching lines @@
   if (IsChildDead(process))
     return;
 
   BackgroundReaper* reaper = new BackgroundReaper(process, 0);
   PlatformThread::CreateNonJoinable(0, reaper);
 }
 
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace base