Get rid of 'close' on process. It is very easy to use incorrectly and cut off data from your stream…

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.
 }
@@ skipping 55 matching lines @@
               "Environment key or value is not a string: ($key, $value)");
         }
         _environment.add('$key=$value');
       });
     }
 
     _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;
     _ended = false;
     _started = false;
     _onExit = null;
   }
 
   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 54 matching lines @@
       bool success = _startNative(_path,
                                   _arguments,
                                   _workingDirectory,
                                   _environment,
                                   _in,
                                   _out,
                                   _err,
                                   _exitHandler,
                                   status);
       if (!success) {
-        close();
+        _in.close();
+        _out.close();
+        _err.close();
+        _exitHandler.close();
         completer.completeException(
             new ProcessException(status._errorMessage, status._errorCode));
         return;
       }
       _started = true;
 
       _in._closed = false;
       _out._closed = false;
       _err._closed = false;
       _exitHandler._closed = false;
@@ skipping 16 matching lines @@
           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));
           }
+          _out.close();
         }
 
         exitDataRead += _exitHandler.inputStream.readInto(
             exitDataBuffer, exitDataRead, EXIT_DATA_SIZE - exitDataRead);
         if (exitDataRead == EXIT_DATA_SIZE) handleExit();
       };
 
       completer.complete(this);
     });
     return completer.future;
   }
 
   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) {
-      throw new ProcessException("Process closed");
-    }
     return _err.inputStream;
   }
 
   OutputStream get stdin {
-    if (_closed) {
-      throw new ProcessException("Process closed");
-    }
     return _out.outputStream;
   }
 
   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";
 
-  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;
   }
 
   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;
-  bool _closed;
   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 87 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;
 }