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 187 matching lines @@
       throw new ProcessException("Process closed");
     }
     return _out.outputStream;
   }
 
   void kill([ProcessSignal signal = ProcessSignal.SIGTERM]) {
     if (signal is! ProcessSignal) {
       throw new ArgumentError(
           "Argument 'signal' must be a ProcessSignal");
     }
-    if (!_started) {
-      var e = new ProcessException("Cannot kill process that is not started");
-      _reportError(e);
-      return;
-    }
-    if (_ended) {
-      return;
-    }
-    if (_kill(this, signal._signalNumber)) {
-      return;
-    }
-    _reportError(new ProcessException("Could not kill process"));
-    return;
+    assert(_started);
+    if (_ended) return;
+    if (_kill(this, signal._signalNumber)) return;
+    throw new ProcessException("Could not kill process");

[Anders Johnsen, 2012/10/12 08:53:11]

Maybe change exception to "Could not send kill signal to process". The current
message is not very POSIX friendly.

[Mads Ager (google), 2012/10/12 08:56:25]

And an error message about signals is not very Windows friendly. :-)

[Anders Johnsen, 2012/10/12 08:58:10]

Hehe agreed, but if we mention both 'kill' and 'signal' we would cover both? ;)

   }
 
   bool _kill(Process p, int signal) native "Process_Kill";
 
   void close() {
     if (_closed) {
       throw new ProcessException("Process closed");
     }
     _in.close();
     _out.close();
     _err.close();
     _exitHandler.close();
     _closed = true;
   }
 
   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)) {
-    _onError = callback;
-  }
-
-  void set onStart(void callback()) {
-    _onStart = callback;
-  }
-
   void _reportError(e) {

[Søren Gjesse, 2012/10/12 11:44:04]

This is not used any more - right?

[Mads Ager (google), 2012/10/12 11:50:26]

It is still used internally to report startup errors. I'll see if I can locally
restructure to get rid of that. Thanks!

     if (_onError != null) {
       _onError(e);
     } else {
       throw e;
     }
   }
 
   String _path;
   List<String> _arguments;
   String _workingDirectory;
@@ skipping 10 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);
+    _process._onError = (e) => _completer.completeException(e);
 
     // Setup process exit handling.
     _process.onExit = (exitCode) {
       _exitCode = exitCode;
       _checkDone();
     };
 
     // Setup stdout handling.
     _stdoutBuffer = new StringBuffer();
     var stdoutStream = new StringInputStream(_process.stdout, stdoutEncoding);
@@ skipping 41 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;
 }