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

runtime/bin/process.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 the Dart VM process with the given [status] code. */
 void exit(int status) {
   if (status is !int) {
     throw new ArgumentError("int status expected");
   }
   _exit(status);
 }
 
 /**
  * [Process] is used to start new processes using the static
  * [start] and [run] methods.
  */
 class Process {
   /**
    * Starts a process running the [executable] with the specified
    * [arguments]. Returns a [:Future<Process>:] that completes with a
    * Process instance when the process has been successfully
    * started. That [Process] object can be used to interact with the
    * process. If the process cannot be started the returned [Future]
    * completes with an exception.
    *
    * An optional [ProcessOptions] object can be passed to specify
    * options other than the executable and the arguments.
+   *
+   * Users must read all data coming on the [stdout] and [stderr]
+   * streams of processes started with [:Process.start:]. If the user
+   * does not read all data on the streams the underlying system
+   * resources will not be freed since there is still pending data.
    */
   static Future<Process> start(String executable,
                                List<String> arguments,
                                [ProcessOptions options]) {
     return _Process.start(executable, arguments, options);
   }
 
   /**
    * Starts a process and runs it non-interactively to completion. The
    * process run is [executable] with the specified [arguments].
@@ skipping 51 matching lines @@
    * meanings. When the process terminates as a result of calling
    * [kill] [onExit] is called.
    *
    * Returns [:true:] if the process is successfully killed (the
    * signal is successfully sent). Returns [:false:] if the process
    * could not be killed (the signal could not be sent). Usually,
    * a [:false:] return value from kill means that the process is
    * already dead.
    */
   abstract bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]);
-
-  /**
-   * Terminates the streams of a process. [close] must be called on a
-   * process to free the system resources associated with it if not all
-   * data on the stdout and stderr streams have been read. Usually,
-   * close should be called in [onExit], but care must be taken to actually
-   * wait on the stderr and stdout streams to close if all data is required.
-   * Once a process has been closed it can no longer be killed and [onExit]
-   * is detached so the application is not notified of process termination.
-   */
-  abstract void close();
 }
 
 
 /**
  * [ProcessResult] represents the result of running a non-interactive
  * process started with [:Process.run:].
  */
 abstract class ProcessResult {
   /**
    * Exit code for the process.
@@ skipping 104 matching lines @@
   /**
    * Contains the system message for the process exception if any.
    */
   final String message;
 
   /**
    * Contains the OS error code for the process exception if any.
    */
   final int errorCode;
 }