Big merge from experimental to bleeding edge.

runtime/bin/process_patch.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.
 
 patch class _WindowsCodePageDecoder {
   /* patch */ static String _decodeBytes(List<int> bytes)
       native "SystemEncodingToString";
 }
 
 
@@ skipping 35 matching lines @@
   _ProcessImpl(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);
+    _arguments = new List<String>.fixedLength(len);
     for (int i = 0; i < len; i++) {
       var arg = arguments[i];
       if (arg is !String) {
         throw new ArgumentError("Non-string argument: $arg");
       }
       _arguments[i] = arguments[i];
       if (Platform.operatingSystem == 'windows') {
         _arguments[i] = _windowsArgumentEscape(_arguments[i]);
       }
     }
@@ skipping 96 matching lines @@
                                   _in,
                                   _out,
                                   _err,
                                   _exitHandler,
                                   status);
       if (!success) {
         _in.close();
         _out.close();
         _err.close();
         _exitHandler.close();
-        completer.completeException(
+        completer.completeError(
             new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode));
         return;
       }
       _started = true;
 
       _in._closed = false;
       _out._closed = false;
       _err._closed = false;
       _exitHandler._closed = false;
 
       // Make sure to activate socket handlers now that the file
       // descriptors have been set.
       _in._activateHandlers();
       _out._activateHandlers();
       _err._activateHandlers();
 
       // Setup an exit handler to handle internal cleanup and possible
       // callback when a process terminates.
       int exitDataRead = 0;
       final int EXIT_DATA_SIZE = 8;
-      List<int> exitDataBuffer = new List<int>(EXIT_DATA_SIZE);
+      List<int> exitDataBuffer = new List<int>.fixedLength(EXIT_DATA_SIZE);
       _exitHandler.inputStream.onData = () {
 
         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;
         }
 
         void handleExit() {
           _ended = true;
-          if (_onExit != null) {
-            _onExit(exitCode(exitDataBuffer));
-          }
+          _exitCode = exitCode(exitDataBuffer);
+          if (_onExit != null) _onExit(_exitCode);
           _out.close();
         }
 
         exitDataRead += _exitHandler.inputStream.readInto(
             exitDataBuffer, exitDataRead, EXIT_DATA_SIZE - exitDataRead);
         if (exitDataRead == EXIT_DATA_SIZE) {
           _exitHandler.close();
           handleExit();
         }
       };
@@ skipping 28 matching lines @@
   bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]) {
     if (signal is! ProcessSignal) {
       throw new ArgumentError(
           "Argument 'signal' must be a ProcessSignal");
     }
     assert(_started);
     if (_ended) return false;
     return _kill(this, signal._signalNumber);
   }
 
+  void add(List<int> data) {
+    stdin.write(data);
+  }
+
+  void close() {
+    stdin.close();
+  }
+
+  void signalError(ASyncError error) {
+    // TODO(ajohnsen): close?
+  }
+
+  Stream<List<int>> get stdoutStream
+    => new _InputStreamController(stdout).stream;
+
+  Stream<List<int>> get stderrStream
+    => new _InputStreamController(stderr).stream;
+
   bool _kill(Process p, int signal) native "Process_Kill";
 
   void set onExit(void callback(int exitCode)) {
-    if (_ended) {
-      throw new ProcessException(_path, _arguments, "Process killed");
-    }
+    if (_ended) callback(_exitCode);
     _onExit = callback;
   }
 
   String _path;
   List<String> _arguments;
   String _workingDirectory;
   List<String> _environment;
   // Private methods of _Socket are used by _in, _out, and _err.
   _Socket _in;
   _Socket _out;
   _Socket _err;
   Socket _exitHandler;
+  int _exitCode;
   bool _ended;
   bool _started;
   Function _onExit;
 }
 
 
 // _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.
@@ skipping 51 matching lines @@
       _stderrBuffer = new StringBuffer();
       var stderrStream = new StringInputStream(p.stderr, stderrEncoding);
       stderrStream.onData = () {
         var data = stderrStream.read();
         if (data != null) _stderrBuffer.add(data);
       };
       stderrStream.onClosed = () {
         _stderrClosed = true;
         _checkDone();
       };
-    });
-
-    processFuture.handleException((error) {
-      _completer.completeException(error);
-      return true;
+    }).catchError((error) {
+      _completer.completeError(error.error);
     });
   }
 
   void _checkDone() {
     if (_exitCode != null && _stderrClosed && _stdoutClosed) {
       _completer.complete(new _ProcessResult(_exitCode,
                                              _stdoutBuffer.toString(),
                                              _stderrBuffer.toString()));
     }
   }
@@ skipping 11 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;
 }