Also wrap stdin/stdout/stderr on Process.

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";
 }
 
 
@@ skipping 72 matching lines @@
       env.forEach((key, value) {
         if (key is !String || value is !String) {
           throw new ArgumentError(
               "Environment key or value is not a string: ($key, $value)");
         }
         _environment.add('$key=$value');
       });
     }
 
     // stdin going to process.
-    _stdin = new _Socket._writePipe();
+    _stdin = new _StdSink(new _Socket._writePipe());
     // stdout coming from process.
-    _stdout = new _Socket._readPipe();
+    _stdout = new _StdStream(new _Socket._readPipe());
     // stderr coming from process.
-    _stderr = new _Socket._readPipe();
+    _stderr = new _StdStream(new _Socket._readPipe());
     _exitHandler = new _Socket._readPipe();
     _ended = false;
     _started = false;
   }
 
   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.
@@ skipping 48 matching lines @@
   Future<Process> _start() {
     var completer = new Completer();
     // 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,
-                                  _stdin._nativeSocket,
-                                  _stdout._nativeSocket,
-                                  _stderr._nativeSocket,
+                                  _stdin._sink._nativeSocket,
+                                  _stdout._stream._nativeSocket,
+                                  _stderr._stream._nativeSocket,
                                   _exitHandler._nativeSocket,
                                   status);
       if (!success) {
         completer.completeError(
             new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode));
         return;
       }
@@ skipping 10 matching lines @@
           var code = _intFromBytes(ints, 0);
           var negative = _intFromBytes(ints, 4);
           assert(negative == 0 || negative == 1);
           return (negative == 0) ? code : -code;
         }
 
         void handleExit() {
           _ended = true;
           _exitCode.complete(exitCode(exitDataBuffer));
           // Kill stdin, helping hand if the user forgot to do it.
-          _stdin.destroy();
+          _stdin._sink.destroy();
         }
 
         exitDataBuffer.setRange(exitDataRead, data.length, data);
         exitDataRead += data.length;
         if (exitDataRead == EXIT_DATA_SIZE) {
           handleExit();
         }
       });
 
       completer.complete(this);
     });
     return completer.future;
   }
 
   bool _startNative(String path,
                     List<String> arguments,
                     String workingDirectory,
                     List<String> environment,
                     _NativeSocket stdin,
                     _NativeSocket stdout,
                     _NativeSocket stderr,
                     _NativeSocket exitHandler,
                     _ProcessStartStatus status) native "Process_Start";
 
   Stream<List<int>> get stdout {
-    // TODO(ajohnsen): Get stream object only.
     return _stdout;
   }
 
   Stream<List<int>> get stderr {
-    // TODO(ajohnsen): Get stream object only.
     return _stderr;
   }
 
   IOSink get stdin {
-    // TODO(ajohnsen): Get consumer object only.
     return _stdin;
   }
 
   Future<int> get exitCode => _exitCode.future;
 
   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);
   }
 
   bool _kill(Process p, int signal) native "Process_Kill";
 
   String _path;
   List<String> _arguments;
   String _workingDirectory;
   List<String> _environment;
   // Private methods of Socket are used by _in, _out, and _err.
-  Socket _stdin;
-  Socket _stdout;
-  Socket _stderr;
+  _StdSink _stdin;
+  _StdStream _stdout;
+  _StdStream _stderr;
   Socket _exitHandler;
   bool _ended;
   bool _started;
   final Completer<int> _exitCode = new Completer<int>();
 }
 
 
 // _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
@@ skipping 56 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;
 }