Wire up process launch error codes.

content/browser/child_process_launcher.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_
 
 #include "base/files/scoped_file.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/threading/non_thread_safe.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 
 namespace base {
 class CommandLine;
 }
 
 namespace content {
 
+// Platform neutral result codes for process launches.
+// Each platform can optionally define its own specific set of error codes.
+// For Windows, these are sandbox::ResultCode starting at offset 1000 located in

[jam, 2016/04/28 15:41:14]

normally this is done by having the lower layer set an enum for max value it
needs (with some room to leave for further growth if it's in UMA). then content
etc can start its values there. i understand sandbox' enum is only on windows,
but it seems fine to have this enum here have an ifdef to start it at that value
(1000) on windows, otherwise it starts at 0. that way sandbox doesn't have to
keep the assumption that content etc won't use more than a thousand values.

[Will Harris, 2016/05/02 16:45:23]

I now start the enum in the lower layer, and then continue it up in content.

I added a static assert to verify that the ranges can never overlap, since I
can't just start at the end of sandbox (since that's a Win only header file).

+// sandbox/win/src/sandbox_types.h
+enum LaunchResultCode {
+  // Launch success.
+  LAUNCH_RESULT_SUCCESS = 0,
+  // Generic launch failure.
+  LAUNCH_RESULT_FAILURE,
+  // Placeholder for last item of the enum.
+  LAUNCH_RESULT_CODE_LAST_CODE
+};
+
 // 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 : public base::NonThreadSafe {
  public:
   class CONTENT_EXPORT Client {
    public:
     // Will be called on the thread that the ChildProcessLauncher was
     // constructed on.
     virtual void OnProcessLaunched() = 0;
 
-    virtual void OnProcessLaunchFailed() {};
+    virtual void OnProcessLaunchFailed(int error_code) {};
 
    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.
@@ skipping 45 matching lines @@
   // to launch the child process on the launcher thread.
   // It makes sure we always perform the necessary cleanup if the
   // client went away.
   static void DidLaunch(base::WeakPtr<ChildProcessLauncher> instance,
                         bool terminate_on_shutdown,
                         ZygoteHandle zygote,
 #if defined(OS_ANDROID)
                         base::ScopedFD ipcfd,
                         base::ScopedFD mojo_fd,
 #endif
-                        base::Process process);
+                        base::Process process,
+                        int error_code);
 
   // Notifies the client about the result of the operation.
   void Notify(ZygoteHandle zygote,
 #if defined(OS_ANDROID)
               base::ScopedFD ipcfd,
 #endif
-              base::Process process);
+              base::Process process,
+              int error_code);
 
 #if defined(MOJO_SHELL_CLIENT)
   // When this process is run from an external Mojo shell, this function will
   // create a channel and pass one end to the spawned process and register the
   // other end with the external shell, allowing the spawned process to bind an
   // Application request from the shell.
   void CreateMojoShellChannel(base::CommandLine* command_line,
                               int child_process_id);
 #endif
 
@@ skipping 12 matching lines @@
   mojo::edk::PlatformChannelPair mojo_platform_channel_;
 
   base::WeakPtrFactory<ChildProcessLauncher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildProcessLauncher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CHILD_PROCESS_LAUNCHER_H_