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

base/process_util.h

 // 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.
 
 // This file/namespace contains utility functions for enumerating, ending and
 // computing statistics of processes.
 
 #ifndef BASE_PROCESS_UTIL_H_
 #define BASE_PROCESS_UTIL_H_
 
@@ skipping 214 matching lines @@
 
 // Close all file descriptors, except those which are a destination in the
 // given multimap. Only call this function in a child process where you know
 // that there aren't any other threads.
 BASE_EXPORT void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
 #endif  // defined(OS_POSIX)
 
 typedef std::vector<std::pair<std::string, std::string> > EnvironmentVector;
 typedef std::vector<std::pair<int, int> > FileHandleMappingVector;
 
-#if defined(OS_MACOSX)
-// Used with LaunchOptions::synchronize and LaunchSynchronize, a
-// LaunchSynchronizationHandle is an opaque value that LaunchProcess will
-// create and set, and that LaunchSynchronize will consume and destroy.
-typedef int* LaunchSynchronizationHandle;
-#endif  // defined(OS_MACOSX)
-
 // Options for launching a subprocess that are passed to LaunchProcess().
 // The default constructor constructs the object with default options.
 struct LaunchOptions {
   LaunchOptions()
       : wait(false),
         debug(false),
 #if defined(OS_WIN)
         start_hidden(false),
         inherit_handles(false),
         as_user(NULL),
         empty_desktop_name(false),
         job_handle(NULL),
         stdin_handle(NULL),
         stdout_handle(NULL),
         stderr_handle(NULL),
         force_breakaway_from_job_(false)
 #else
         environ(NULL),
         fds_to_remap(NULL),
         maximize_rlimits(NULL),
         new_process_group(false)
 #if defined(OS_LINUX)
       , clone_flags(0)
 #endif  // OS_LINUX
 #if defined(OS_CHROMEOS)
       , ctrl_terminal_fd(-1)
 #endif  // OS_CHROMEOS
-#if defined(OS_MACOSX)
-      , synchronize(NULL)
-#endif  // defined(OS_MACOSX)
 #endif  // !defined(OS_WIN)
   {}
 
   // If true, wait for the process to complete.
   bool wait;
 
   // If true, print more debugging info (OS-dependent).
   bool debug;
 
 #if defined(OS_WIN)
@@ skipping 61 matching lines @@
   // If non-zero, start the process using clone(), using flags as provided.
   int clone_flags;
 #endif  // defined(OS_LINUX)
 
 #if defined(OS_CHROMEOS)
   // If non-negative, the specified file descriptor will be set as the launched
   // process' controlling terminal.
   int ctrl_terminal_fd;
 #endif  // defined(OS_CHROMEOS)
 
-#if defined(OS_MACOSX)
-  // When non-NULL, a new LaunchSynchronizationHandle will be created and
-  // stored in *synchronize whenever LaunchProcess returns true in the parent
-  // process. The child process will have been created (with fork) but will
-  // be waiting (before exec) for the parent to call LaunchSynchronize with
-  // this handle. Only when LaunchSynchronize is called will the child be
-  // permitted to continue execution and call exec. LaunchSynchronize
-  // destroys the handle created by LaunchProcess.
-  //
-  // When synchronize is non-NULL, the parent must call LaunchSynchronize
-  // whenever LaunchProcess returns true. No exceptions.
-  //
-  // Synchronization is useful when the parent process needs to guarantee that
-  // it can take some action (such as recording the newly-forked child's
-  // process ID) before the child does something (such as using its process ID
-  // to communicate with its parent).
-  //
-  // |synchronize| and |wait| must not both be set simultaneously.
-  LaunchSynchronizationHandle* synchronize;
-#endif  // defined(OS_MACOSX)
-
 #endif  // !defined(OS_WIN)
 };
 
 // Launch a process via the command line |cmdline|.
 // See the documentation of LaunchOptions for details on |options|.
 //
 // Returns true upon success.
 //
 // Upon success, if |process_handle| is non-NULL, it will be filled in with the
 // handle of the launched process.  NOTE: In this case, the caller is
@@ skipping 51 matching lines @@
 
 // AlterEnvironment returns a modified environment vector, constructed from the
 // given environment and the list of changes given in |changes|. Each key in
 // the environment is matched against the first element of the pairs. In the
 // event of a match, the value is replaced by the second of the pair, unless
 // the second is empty, in which case the key-value is removed.
 //
 // The returned array is allocated using new[] and must be freed by the caller.
 BASE_EXPORT char** AlterEnvironment(const EnvironmentVector& changes,
                                     const char* const* const env);
-
-#if defined(OS_MACOSX)
-
-// After a successful call to LaunchProcess with LaunchOptions::synchronize
-// set, the parent process must call LaunchSynchronize to allow the child
-// process to proceed, and to destroy the LaunchSynchronizationHandle.
-BASE_EXPORT void LaunchSynchronize(LaunchSynchronizationHandle handle);
-
-#endif  // defined(OS_MACOSX)
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_WIN)
 // Set JOBOBJECT_EXTENDED_LIMIT_INFORMATION to JobObject |job_object|.
 // As its limit_info.BasicLimitInformation.LimitFlags has
 // JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE.
 // When the provide JobObject |job_object| is closed, the binded process will
 // be terminated.
 BASE_EXPORT bool SetJobObjectAsKillOnJobClose(HANDLE job_object);
 #endif  // defined(OS_WIN)
@@ skipping 449 matching lines @@
 // YOUR CODE IS LIKELY TO BE REVERTED.  THANK YOU.
 //
 // TODO(shess): Weird place to put it, but this is where the OOM
 // killer currently lives.
 BASE_EXPORT void* UncheckedMalloc(size_t size);
 #endif  // defined(OS_MACOSX)
 
 }  // namespace base
 
 #endif  // BASE_PROCESS_UTIL_H_