Change Process.start to return a future that completes with a

runtime/bin/process_impl.dart

 // Copyright (c) 2012, 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.
 
 _exit(int status) native "Exit";
 
 class _ProcessStartStatus {
   int _errorCode;  // Set to OS error code if process start failed.
   String _errorMessage;  // Set to OS error message if process start failed.
 }
 
 
 class _Process extends NativeFieldWrapperClass1 implements Process {
   static Future<ProcessResult> run(String path,
                                    List<String> arguments,
                                    [ProcessOptions options]) {
-    return new _NonInteractiveProcess._start(path, arguments, options)._result;
+    return new _NonInteractiveProcess(path, arguments, options)._result;
   }
 
-  _Process.start(String path,
-                 List<String> arguments,
-                 ProcessOptions options) {
+  static Future<Process> start(String path,
+                               List<String> arguments,
+                               ProcessOptions options) {
+    Completer completer = new Completer();
+    _Process process = new _Process(path, arguments, options);
+    process._onStart = () {
+      process.onError = null;
+      completer.complete(process);
+    };
+    process.onError = (e) {
+      process.onError = null;
+      completer.completeException(e);
+    };
+    return completer.future;
+  }
+
+  _Process(String path, List<String> arguments, ProcessOptions options) {
     if (path is !String) {
       throw new ArgumentError("Path is not a String: $path");
     }
     _path = path;
 
     if (arguments is !List) {
       throw new ArgumentError("Arguments is not a List: $arguments");
     }
     int len = arguments.length;
     _arguments = new List<String>(len);
@@ skipping 225 matching lines @@
   void set onExit(void callback(int exitCode)) {
     if (_closed) {
       throw new ProcessException("Process closed");
     }
     if (_ended) {
       throw new ProcessException("Process killed");
     }
     _onExit = callback;
   }
 
   void set onError(void callback(e)) {

[Søren Gjesse, 2012/10/12 07:47:22]

Shouldn't we try to get rid of onError as well? As far as I can see besides
startup errors it is only used to report failures to kill the process.

[Mads Ager (google), 2012/10/12 08:44:46]

I would love to get rid of onError, that was one of my goals doing this. At
least we should clean up the case where the process is not started. It should
not be possible to get there anymore. There is one other case: we failed to send
a signal to the process. Maybe we should just throw an exception in that case?
Kill is synchronous in any case.  I'll go ahead and do that.

     _onError = callback;
   }
 
-  void set onStart(void callback()) {
-    _onStart = callback;
-  }
-
   void _reportError(e) {
     if (_onError != null) {
       _onError(e);
     } else {
       throw e;
     }
   }
 
   String _path;
   List<String> _arguments;
@@ skipping 11 matching lines @@
   Function _onError;
   Function _onStart;
 }
 
 
 // _NonInteractiveProcess is a wrapper around an interactive process
 // that buffers output so it can be delivered when the process exits.
 // _NonInteractiveProcess is used to implement the Process.run
 // method.
 class _NonInteractiveProcess {
-  _NonInteractiveProcess._start(String path,
-                                List<String> arguments,
-                                ProcessOptions options) {
+  _NonInteractiveProcess(String path,
+                         List<String> arguments,
+                         ProcessOptions options) {
     _completer = new Completer<ProcessResult>();
     // Extract output encoding options and verify arguments.
     var stdoutEncoding = Encoding.UTF_8;
     var stderrEncoding = Encoding.UTF_8;
     if (options !== null) {
       if (options.stdoutEncoding !== null) {
         stdoutEncoding = options.stdoutEncoding;
         if (stdoutEncoding is !Encoding) {
           throw new ArgumentError(
               'stdoutEncoding option is not an encoding: $stdoutEncoding');
         }
       }
       if (options.stderrEncoding !== null) {
         stderrEncoding = options.stderrEncoding;
         if (stderrEncoding is !Encoding) {
           throw new ArgumentError(
               'stderrEncoding option is not an encoding: $stderrEncoding');
         }
       }
     }
 
     // Start the underlying process.
-    _process = new _Process.start(path, arguments, options);
+    _process = new _Process(path, arguments, options);
 
     // Make sure stdin is closed.
-    _process.onStart = _process.stdin.close;
+    _process._onStart = _process.stdin.close;
 
     // Setup process error handling.
     _process.onError = (e) => _completer.completeException(e);
 
     // Setup process exit handling.
     _process.onExit = (exitCode) {
       _exitCode = exitCode;
       _checkDone();
     };
 
@@ skipping 44 matching lines @@
 
 class _ProcessResult implements ProcessResult {
   const _ProcessResult(int this.exitCode,
                        String this.stdout,
                        String this.stderr);
 
   final int exitCode;
   final String stdout;
   final String stderr;
 }