Launches a privileged utility process.

content/browser/child_process_launcher_impl.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.
 
-#ifndef CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_H_
-#define CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_H_
+#ifndef CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_IMPL_H_
+#define CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_IMPL_H_
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
+#include "content/browser/child_process_launcher.h"
 #include "content/common/content_export.h"
 
 class CommandLine;
 
 namespace content {
 class SandboxedProcessLauncherDelegate;
 
-// Launches a process asynchronously and notifies the client of the process
-// handle when it's available.  It's used to avoid blocking the calling thread
-// on the OS since often it can take > 100 ms to create the process.
-class CONTENT_EXPORT ChildProcessLauncher {
+// All standard process-launching uses this class to launch the process.
+class CONTENT_EXPORT ChildProcessLauncherImpl : public ChildProcessLauncher {

[jam, 2014/01/24 22:14:03]

why are you adding an interface around ChildProcessLauncher to support elevated
instead of adding an extra flag? we have supported different security mechanisms
like disabling sandbox or allowing a directory through that way.

[Drew Haven, 2014/01/27 21:43:51]

When I started writing this I only added the LaunchElevated function for
Windows.  It might not be necessary or possible to do cleanly on some other
platforms and I didn't want to affect that code.  Perhaps I should add an error
for those platforms?  What I ended up with was a mess of #if defined(OS_WIN). 
In order to simply things, largely just so I could understand it, I duplicated
the ChildProcessLauncher code and started pulling out the stuff that was
irrelevant or unnecessary.  The implementation may not have ended up that
different, so perhaps I should attempt to merge them back together.  If we do
that I'd like to add implementations for the function to other OSes, but I think
at least for a long time those would be errors because we really only need this
in Windows (so far) for a few specific functions.

I tried to stick with the flag-based approach above this level.

[jam, 2014/01/27 21:55:45]

Yeah, please use one implementation. child_process_launcher.cc is hard to read
because of all the ifdefs. It's time to make the arguments be in a struct, which
will make things cleaner as it gets passed around to methods and across threads.

  public:
-  class CONTENT_EXPORT Client {
-   public:
-    // Will be called on the thread that the ChildProcessLauncher was
-    // constructed on.
-    virtual void OnProcessLaunched() = 0;
-
-   protected:
-    virtual ~Client() {}
-  };
-
   // Launches the process asynchronously, calling the client when the result is
   // ready.  Deleting this object before the process is created is safe, since
   // the callback won't be called.  If the process is still running by the time
   // this object destructs, it will be terminated.
   // Takes ownership of cmd_line.
-  ChildProcessLauncher(
+  ChildProcessLauncherImpl(
 #if defined(OS_WIN)
       SandboxedProcessLauncherDelegate* delegate,
 #elif defined(OS_POSIX)
       bool use_zygote,
       const base::EnvironmentMap& environ,
       int ipcfd,
 #endif
       CommandLine* cmd_line,
       int child_process_id,
       Client* client);
-  ~ChildProcessLauncher();
+
+  ~ChildProcessLauncherImpl();
 
   // True if the process is being launched and so the handle isn't available.
-  bool IsStarting();
+  virtual bool IsStarting() OVERRIDE;
 
   // Getter for the process handle.  Only call after the process has started.
-  base::ProcessHandle GetHandle();
+  virtual base::ProcessHandle GetHandle() OVERRIDE;
 
   // Call this when the child process exits to know what happened to it.
   // |known_dead| can be true if we already know the process is dead as it can
   // help the implemention figure the proper TerminationStatus.
   // On Linux, the use of |known_dead| is subtle and can be crucial if an
   // accurate status is important. With |known_dead| set to false, a dead
   // process could be seen as running. With |known_dead| set to true, the
   // process will be killed if it was still running. See ZygoteHostImpl for
   // more discussion of Linux implementation details.
   // |exit_code| is the exit code of the process if it exited (e.g. status from
   // waitpid if on posix, from GetExitCodeProcess on Windows). |exit_code| may
   // be NULL.
-  base::TerminationStatus GetChildTerminationStatus(bool known_dead,
-                                                    int* exit_code);
+  virtual base::TerminationStatus GetChildTerminationStatus(bool known_dead,
+                                                    int* exit_code) OVERRIDE;
 
   // Changes whether the process runs in the background or not.  Only call
   // this after the process has started.
-  void SetProcessBackgrounded(bool background);
+  virtual void SetProcessBackgrounded(bool background) OVERRIDE;
 
   // Controls whether the child process should be terminated on browser
   // shutdown.
-  void SetTerminateChildOnShutdown(bool terminate_on_shutdown);
+  virtual void SetTerminateChildOnShutdown(bool terminate_on_shutdown) OVERRIDE;
 
  private:
   class Context;
 
   scoped_refptr<Context> context_;
 
-  DISALLOW_COPY_AND_ASSIGN(ChildProcessLauncher);
+  DISALLOW_COPY_AND_ASSIGN(ChildProcessLauncherImpl);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_H_
+#endif  // CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_IMPL_H_