Change dart:io to use Future for one-shot operations.

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.
 
 class _ProcessStartStatus {
   int _errorCode;  // Set to OS error code if process start failed.
   String _errorMessage;  // Set to OS error message if process start failed.
 }
 
 
-// Abstract factory class capable of producing interactive and
-// non-interactive processes.
 class _Process {
-
-  factory Process.start(String path,
-                        List<String> arguments,
-                        [ProcessOptions options]) {
+  static InteractiveProcess start(String path,
+                                  List<String> arguments,
+                                  [ProcessOptions options]) {
     return new _InteractiveProcess.start(path, arguments, options);
   }
 
-  factory Process.run(String path,
-                      List<String> arguments,
-                      ProcessOptions options,
-                      void callback(int exitCode,
-                                    String stdout,
-                                    String stderr)) {
-    return new _NonInteractiveProcess.start(path,
-                                            arguments,
-                                            options,
-                                            callback);
+  static Future<ProcessResult> run(String path,
+                                   List<String> arguments,
+                                   [ProcessOptions options]) {
+    return new _NonInteractiveProcess._start(path, arguments, options)._result;
   }
 }
 
 
 // _InteractiveProcess is the actual implementation of all processes
 // started from Dart code.
-class _InteractiveProcess implements Process {
+class _InteractiveProcess implements InteractiveProcess {
 
   _InteractiveProcess.start(String path,
                             List<String> arguments,
                             ProcessOptions options) {
     if (path is !String) {
       throw new IllegalArgumentException("Path is not a String: $path");
     }
     _path = path;
 
     if (arguments is !List) {
@@ skipping 42 matching lines @@
     _in = new _Socket._internalReadOnly();  // stdout coming from process.
     _out = new _Socket._internalWriteOnly();  // stdin going to process.
     _err = new _Socket._internalReadOnly();  // stderr coming from process.
     _exitHandler = new _Socket._internalReadOnly();
     _closed = false;
     _killed = false;
     _started = false;
     _onExit = null;
     // TODO(ager): Make the actual process starting really async instead of
     // simulating it with a timer.
-    new Timer(0, (Timer ignore) => start());
+    new Timer(0, (Timer ignore) => _start());
   }
 
   String _windowsArgumentEscape(String argument) {
     var result = argument;
     if (argument.contains('\t') || argument.contains(' ')) {
       // Produce something that the C runtime on Windows will parse
       // back as this string.
 
       // Replace any number of '\' followed by '"' with
       // twice as many '\' followed by '\"'.
@@ skipping 35 matching lines @@
     return result;
   }
 
   int _intFromBytes(List<int> bytes, int offset) {
     return (bytes[offset] +
             (bytes[offset + 1] << 8) +
             (bytes[offset + 2] << 16) +
             (bytes[offset + 3] << 24));
   }
 
-  void start() {
+  void _start() {
     var status = new _ProcessStartStatus();
-    bool success = _start(_path,
-                          _arguments,
-                          _workingDirectory,
-                          _environment,
-                          _in,
-                          _out,
-                          _err,
-                          _exitHandler,
-                          status);
+    bool success = _startNative(_path,
+                                _arguments,
+                                _workingDirectory,
+                                _environment,
+                                _in,
+                                _out,
+                                _err,
+                                _exitHandler,
+                                status);
     if (!success) {
       close();
-      _reportError(new ProcessException(status._errorMessage, status._errorCode));
+      _reportError(new ProcessException(status._errorMessage,
+                                        status._errorCode));
       return;
     }
     _started = true;
 
     // Make sure to activate socket handlers now that the file
     // descriptors have been set.
     _in._activateHandlers();
     _out._activateHandlers();
     _err._activateHandlers();
 
@@ skipping 20 matching lines @@
       exitDataRead += _exitHandler.inputStream.readInto(
           exitDataBuffer, exitDataRead, EXIT_DATA_SIZE - exitDataRead);
       if (exitDataRead == EXIT_DATA_SIZE) handleExit();
     };
 
     if (_onStart !== null) {
       _onStart();
     }
   }
 
-  bool _start(String path,
-              List<String> arguments,
-              String workingDirectory,
-              List<String> environment,
-              Socket input,
-              Socket output,
-              Socket error,
-              Socket exitHandler,
-              _ProcessStartStatus status) native "Process_Start";
+  bool _startNative(String path,
+                    List<String> arguments,
+                    String workingDirectory,
+                    List<String> environment,
+                    Socket input,
+                    Socket output,
+                    Socket error,
+                    Socket exitHandler,
+                    _ProcessStartStatus status) native "Process_Start";
 
   InputStream get stdout() {
     if (_closed) {
       throw new ProcessException("Process closed");
     }
     return _in.inputStream;
   }
 
   InputStream get stderr() {
     if (_closed) {
@@ skipping 82 matching lines @@
   Function _onError;
   Function _onStart;
 }
 
 
 // _NonInteractiveProcess is a wrapper around an interactive process
 // that restricts the interface to disallow access to the streams and
 // buffers output so it can be delivered to the callback when the
 // process exits.
 class _NonInteractiveProcess implements Process {
-  _NonInteractiveProcess.start(String path,
-                               List<String> arguments,
-                               ProcessOptions options,
-                               Function this._callback) {
+  _NonInteractiveProcess._start(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 IllegalArgumentException(
               'stdoutEncoding option is not an encoding: $stdoutEncoding');
         }
       }
       if (options.stderrEncoding !== null) {
         stderrEncoding = options.stderrEncoding;
         if (stderrEncoding is !Encoding) {
           throw new IllegalArgumentException(
               'stderrEncoding option is not an encoding: $stderrEncoding');
         }
       }
     }
 
     // Start the underlying process.
     _process = new _InteractiveProcess.start(path, arguments, options);
 
+    // Setup process error handling.
+    _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);
     stdoutStream.onData = () {
@@ skipping 13 matching lines @@
       if (data != null) _stderrBuffer.add(data);
     };
     stderrStream.onClosed = () {
       _stderrClosed = true;
       _checkDone();
     };
   }
 
   void _checkDone() {
     if (_exitCode != null && _stderrClosed && _stdoutClosed) {
-      _callback(_exitCode, _stdoutBuffer.toString(), _stderrBuffer.toString());
+      _completer.complete(new _ProcessResult(_exitCode,
+                                             _stdoutBuffer.toString(),
+                                             _stderrBuffer.toString()));
     }
   }
 
-  InputStream get stdout() {
-    throw new UnsupportedOperationException(
-        'Cannot get stdout stream for process started with '
-        'the run constructor. The entire stdout '
-        'will be supplied in the callback on completion.');
-  }
+  Future<ProcessResult> get _result() => _completer.future;
 
-  InputStream get stderr() {
-    throw new UnsupportedOperationException(
-        'Cannot get stderr stream for process started with '
-        'the run constructor. The entire stderr '
-        'will be supplied in the callback on completion.');
-  }
-
-  OutputStream get stdin() {
-    throw new UnsupportedOperationException(
-        'Cannot communicate via stdin with process started with '
-        'the run constructor');
-  }
-
-  void set onStart(void callback()) => _process.onStart = callback;
-
-  void set onExit(void callback(int exitCode)) {
-    throw new UnsupportedOperationException(
-        'Cannot set exit handler on process started with '
-        'the run constructor. The exit code will '
-        'be supplied in the callback on completion.');
-  }
-
-  void set onError(void callback(e)) {
-    _process.onError = callback;
-  }
-
-  void kill() => _process.kill();
-
-  void close() => _process.close();
-
-  Process _process;
-  Function _callback;
+  Completer<ProcessResult> _completer;
+  InteractiveProcess _process;
   StringBuffer _stdoutBuffer;
   StringBuffer _stderrBuffer;
   int _exitCode;
   bool _stdoutClosed = false;
   bool _stderrClosed = false;
 }
+
+
+class _ProcessResult implements ProcessResult {
+  const _ProcessResult(int this.exitCode,
+                       String this.stdout,
+                       String this.stderr);
+
+  final int exitCode;
+  final String stdout;
+  final String stderr;
+}