Add an option for starting a detached process with stdio connected

runtime/bin/process_patch.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 patch class _WindowsCodePageDecoder {
   /* patch */ static String _decodeBytes(List<int> bytes)
       native "SystemEncodingToString";
 }
 
 
 patch class _WindowsCodePageEncoder {
   /* patch */ static List<int> _encodeString(String string)
       native "StringToSystemEncoding";
 }
 
 
 patch class Process {
   /* patch */ static Future<Process> start(
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
        bool includeParentEnvironment: true,
        bool runInShell: false,
-       bool detach: false}) {
+       ProcessStartMode mode: ProcessStartMode.NORMAL}) {
     _ProcessImpl process = new _ProcessImpl(executable,
                                             arguments,
                                             workingDirectory,
                                             environment,
                                             includeParentEnvironment,
                                             runInShell,
-                                            detach);
+                                            mode);
     return process._start();
   }
 
   /* patch */ static Future<ProcessResult> run(
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
        bool includeParentEnvironment: true,
        bool runInShell: false,
@@ skipping 126 matching lines @@
     implements Process {
   // Use default Map so we keep order.
   static Map<int, _ProcessImpl> _processes = new Map<int, _ProcessImpl>();
 
   _ProcessImpl(String path,
                List<String> arguments,
                String this._workingDirectory,
                Map<String, String> environment,
                bool includeParentEnvironment,
                bool runInShell,
-               bool detach) : super() {
+               ProcessStartMode mode) : super() {
     _processes[_serviceId] = this;
     if (runInShell) {
       arguments = _getShellArguments(path, arguments);
       path = _getShellCommand();
     }
 
     if (path is !String) {
       throw new ArgumentError("Path is not a String: $path");
     }
     _path = path;
@@ skipping 36 matching lines @@
       Platform.environment.forEach((key, value) {
         assert(key is String);
         assert(value is String);
         // Do not override keys already set as part of environment.
         if (!environment.containsKey(key)) {
           _environment.add('$key=$value');
         }
       });
     }
 
-    if (detach is !bool) {
-      throw new ArgumentError("Detach is not a boolean: $detach");
+    if (mode is !ProcessStartMode) {
+      throw new ArgumentError("Mode is not a ProcessStartMode: $mode");
     }
-    _detach = detach;
+    _mode = mode;
 
-
-    if (!detach) {
+    if (mode != ProcessStartMode.DETACHED) {
       // stdin going to process.
       _stdin = new _StdSink(new _Socket._writePipe());
       _stdin._sink._owner = this;
       // stdout coming from process.
       _stdout = new _StdStream(new _Socket._readPipe());
       _stdout._stream._owner = this;
       // stderr coming from process.
       _stderr = new _StdStream(new _Socket._readPipe());
       _stderr._stream._owner = this;
+    }
+    if (mode == ProcessStartMode.NORMAL) {
       _exitHandler = new _Socket._readPipe();
     }
     _ended = false;
     _started = false;
   }
 
   String get _serviceTypePath => 'io/processes';
   String get _serviceTypeName => 'Process';
 
   Map _toJSON(bool ref) {
@@ skipping 105 matching lines @@
 
   int _intFromBytes(List<int> bytes, int offset) {
     return (bytes[offset] +
             (bytes[offset + 1] << 8) +
             (bytes[offset + 2] << 16) +
             (bytes[offset + 3] << 24));
   }
 
   Future<Process> _start() {
     var completer = new Completer();
-    if (!_detach) {
+    if (_mode == ProcessStartMode.NORMAL) {
       _exitCode = new Completer<int>();
     }
     // TODO(ager): Make the actual process starting really async instead of
     // simulating it with a timer.
     Timer.run(() {
       var status = new _ProcessStartStatus();
       bool success =
           _startNative(_path,
                        _arguments,
                        _workingDirectory,
                        _environment,
-                       _detach,
-                       _detach ? null : _stdin._sink._nativeSocket,
-                       _detach ? null : _stdout._stream._nativeSocket,
-                       _detach ? null : _stderr._stream._nativeSocket,
-                       _detach ? null : _exitHandler._nativeSocket,
+                       _mode.index,
+                       _mode == ProcessStartMode.DETACHED
+                           ? null : _stdin._sink._nativeSocket,
+                       _mode == ProcessStartMode.DETACHED
+                           ? null : _stdout._stream._nativeSocket,
+                       _mode == ProcessStartMode.DETACHED
+                           ? null : _stderr._stream._nativeSocket,
+                       _mode != ProcessStartMode.NORMAL
+                           ? null : _exitHandler._nativeSocket,
                        status);
       if (!success) {
         completer.completeError(
             new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode));
         return;
       }
 
       _started = true;
 
       // Setup an exit handler to handle internal cleanup and possible
       // callback when a process terminates.
-      if (!_detach) {
+      if (_mode == ProcessStartMode.NORMAL) {
         int exitDataRead = 0;
         final int EXIT_DATA_SIZE = 8;
         List<int> exitDataBuffer = new List<int>(EXIT_DATA_SIZE);
         _exitHandler.listen((data) {
 
           int exitCode(List<int> ints) {
             var code = _intFromBytes(ints, 0);
             var negative = _intFromBytes(ints, 4);
             assert(negative == 0 || negative == 1);
             return (negative == 0) ? code : -code;
@@ skipping 22 matching lines @@
   }
 
   ProcessResult _runAndWait(Encoding stdoutEncoding,
                             Encoding stderrEncoding) {
     var status = new _ProcessStartStatus();
     _exitCode = new Completer<int>();
     bool success = _startNative(_path,
                                 _arguments,
                                 _workingDirectory,
                                 _environment,
-                                false,
+                                ProcessStartMode.NORMAL.index,
                                 _stdin._sink._nativeSocket,
                                 _stdout._stream._nativeSocket,
                                 _stderr._stream._nativeSocket,
                                 _exitHandler._nativeSocket,
                                 status);
     if (!success) {
       throw new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode);
@@ skipping 16 matching lines @@
         result[0],
         result[1],
         getOutput(result[2], stdoutEncoding),
         getOutput(result[3], stderrEncoding));
   }
 
   bool _startNative(String path,
                     List<String> arguments,
                     String workingDirectory,
                     List<String> environment,
-                    bool detach,
+                    int mode,
                     _NativeSocket stdin,
                     _NativeSocket stdout,
                     _NativeSocket stderr,
                     _NativeSocket exitHandler,
                     _ProcessStartStatus status) native "Process_Start";
 
   _wait(_NativeSocket stdin,
         _NativeSocket stdout,
         _NativeSocket stderr,
         _NativeSocket exitHandler) native "Process_Wait";
@@ skipping 23 matching lines @@
   }
 
   bool _kill(Process p, int signal) native "Process_Kill";
 
   int get pid => _ProcessUtils._pid(this);
 
   String _path;
   List<String> _arguments;
   String _workingDirectory;
   List<String> _environment;
-  bool _detach;
+  ProcessStartMode _mode;
   // Private methods of Socket are used by _in, _out, and _err.
   _StdSink _stdin;
   _StdStream _stdout;
   _StdStream _stderr;
   Socket _exitHandler;
   bool _ended;
   bool _started;
   Completer<int> _exitCode;
 }
 
@@ skipping 58 matching lines @@
       bool includeParentEnvironment,
       bool runInShell,
       Encoding stdoutEncoding,
       Encoding stderrEncoding) {
   var process = new _ProcessImpl(executable,
                                  arguments,
                                  workingDirectory,
                                  environment,
                                  includeParentEnvironment,
                                  runInShell,
-                                 false);
+                                 ProcessStartMode.NORMAL);
   return process._runAndWait(stdoutEncoding, stderrEncoding);
 }
 
 
 class _ProcessResult implements ProcessResult {
   const _ProcessResult(int this.pid,
                        int this.exitCode,
                        this.stdout,
                        this.stderr);
 
   final int pid;
   final int exitCode;
   final stdout;
   final stderr;
 }