Add the ability to run a callback between fork and exec.

base/process/launch.h

 // Copyright 2013 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 contains functions for launching subprocesses.
 
 #ifndef BASE_PROCESS_LAUNCH_H_
 #define BASE_PROCESS_LAUNCH_H_
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/environment.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_piece.h"
 
 #if defined(OS_POSIX)
 #include "base/posix/file_descriptor_shuffle.h"
 #elif defined(OS_WIN)
 #include <windows.h>
 #endif
 
 namespace base {
 
 class CommandLine;
 
 #if defined(OS_WIN)
 typedef std::vector<HANDLE> HandlesToInheritVector;
 #endif
 // TODO(viettrungluu): Only define this on POSIX?
 typedef std::vector<std::pair<int, int> > FileHandleMappingVector;
 
 // Options for launching a subprocess that are passed to LaunchProcess().
 // The default constructor constructs the object with default options.
 struct BASE_EXPORT LaunchOptions {
+#if defined(OS_POSIX)
+  // Delegate to be run in between fork and exec in the subprocess (see
+  // pre_exec_delegate below)
+  class BASE_EXPORT PreExecDelegate {
+   public:
+    virtual ~PreExecDelegate() {}

[jln (very slow on Chromium), 2015/01/07 00:40:37]

Style: add trivial constructor

[rickyz (no longer on Chrome), 2015/01/07 01:39:07]

Done.

+
+    // Since this is to be run between fork and exec, and fork may have happened
+    // while multiple threads were running, this code needs to be async safe.
+    virtual void RunAsyncSafe() = 0;
+  };

[jln (very slow on Chromium), 2015/01/07 00:40:37]

Style: DISALLOW_COPY_AND_ASSIGN

[rickyz (no longer on Chrome), 2015/01/07 01:39:06]

Done.

+#endif

[jln (very slow on Chromium), 2015/01/07 00:40:37]

style: // defined(OS_POSIX)

[rickyz (no longer on Chrome), 2015/01/07 01:39:06]

Done.

+
   LaunchOptions();
   ~LaunchOptions();
 
   // If true, wait for the process to complete.
   bool wait;
 
 #if defined(OS_WIN)
   bool start_hidden;
 
   // If non-null, inherit exactly the list of handles in this vector (these
@@ skipping 65 matching lines @@
 
 #if defined(OS_LINUX)
   // If non-zero, start the process using clone(), using flags as provided.
   int clone_flags;
 
   // By default, child processes will have the PR_SET_NO_NEW_PRIVS bit set. If
   // true, then this bit will not be set in the new child process.
   bool allow_new_privs;
 #endif  // defined(OS_LINUX)
 
+#if defined(OS_POSIX)
+  // If non-null, a delegate to be run immediately prior to executing the new
+  // program in the child process. Warning: If LaunchProcess was called in the
+  // presence of multiple threads, this essentially needs to be async-signal

[jln (very slow on Chromium), 2015/01/07 00:40:37]

s/this/"code running in this delegate"

[rickyz (no longer on Chrome), 2015/01/07 01:39:07]

Done.

+  // safe.
+  PreExecDelegate* pre_exec_delegate;

[jln (very slow on Chromium), 2015/01/07 00:40:37]

scoped_ptr?

[mdempsky, 2015/01/07 01:03:50]

scoped_ptr would mean the LaunchOptions take ownership of PreExecDelegate and
that it has to be destroyed/recreated for each launched process.  I think it
makes sense to use a non-owning raw pointer here (but that's a weak opinion).

[rickyz (no longer on Chrome), 2015/01/07 01:39:07]

scoped_ptr doesn't work here because we make copies of LaunchOptions in some
places
(https://code.google.com/p/chromium/codesearch#chromium/src/base/test/launcher...
and
https://code.google.com/p/chromium/codesearch#chromium/src/base/process/launc...).

Actually, I'm not too happy with how this interface turned out, since the
presence of pre_exec_delegate could make the LaunchOptions potentially
non-reusable. Perhaps this functionality belongs in a new argument to
LaunchProcess rather than in LaunchOptions, since the delegate is likely to
contain state specific to a particular invocation of LaunchProcess.

I guess it depends on how LaunchOptions is meant to be viewed - is it something
that's always expected to be tied to a single call to LaunchProcess, or is it
something that should be reusable?

[mdempsky, 2015/01/07 02:12:59]

It seems intuitive to me that if you reuse the same delegate for multiple calls
to LaunchProcess(), then that delegate needs to be safe to be called once per
LaunchProcess().  That said I'm open to alternatives if you think something else
is better.

+#endif
+
 #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)
   // If this name is non-empty, the new child, after fork() but before exec(),
   // will look up this server name in the bootstrap namespace. The resulting
   // service port will be replaced as the bootstrap port in the child. Because
@@ skipping 128 matching lines @@
 void ReplaceBootstrapPort(const std::string& replacement_bootstrap_name);
 #endif  // defined(OS_MACOSX)
 
 // Creates a LaunchOptions object suitable for launching processes in a test
 // binary. This should not be called in production/released code.
 BASE_EXPORT LaunchOptions LaunchOptionsForTest();
 
 }  // namespace base
 
 #endif  // BASE_PROCESS_LAUNCH_H_