Use patching for dart:io.

lib/io/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.
 
+class _ProcessUtils {

[Søren Gjesse, 2012/10/30 09:28:32]

TODO?

[Mads Ager (google), 2012/10/30 11:12:40]

Done.

+  external static _exit(int status);
+}
+
 /** 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);
+  _ProcessUtils._exit(status);
 }
 
 /**
  * [Process] is used to start new processes using the static
  * [start] and [run] methods.
  */
-class Process {
+abstract 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);
-  }
+  external static Future<Process> start(String executable,
+                                        List<String> arguments,
+                                        [ProcessOptions options]);
 
   /**
    * Starts a process and runs it non-interactively to completion. The
    * process run is [executable] with the specified [arguments].
    *
    * An optional [ProcessOptions] object can be passed to specify
    * options other than the executable and the arguments.
    *
    * Returns a [:Future<ProcessResult>:] that completes with the
    * result of running the process, i.e., exit code, standard out and
    * standard in.
    */
-  static Future<ProcessResult> run(String executable,
-                                   List<String> arguments,
-                                   [ProcessOptions options]) {
-    return _Process.run(executable, arguments, options);
-  }
+  external static Future<ProcessResult> run(String executable,
+                                            List<String> arguments,
+                                            [ProcessOptions options]);
 
   /**
    * Returns an input stream of the process stdout.
    *
    * Throws an [UnsupportedError] if the process is
    * non-interactive.
    */
-  abstract InputStream get stdout;
+  InputStream get stdout;
 
   /**
    * Returns an input stream of the process stderr.
    *
    * Throws an [UnsupportedError] if the process is
    * non-interactive.
    */
-  abstract InputStream get stderr;
+  InputStream get stderr;
 
   /**
    * Returns an output stream to the process stdin.
    *
    * Throws an [UnsupportedError] if the process is
    * non-interactive.
    */
-  abstract OutputStream get stdin;
+  OutputStream get stdin;
 
   /**
    * Sets an exit handler which gets invoked when the process
    * terminates.
    *
    * Throws an [UnsupportedError] if the process is
    * non-interactive.
    */
-  abstract void set onExit(void callback(int exitCode));
+  void set onExit(void callback(int exitCode));
 
   /**
    * On Windows, [kill] kills the process, ignoring the [signal]
    * flag. On Posix systems, [kill] sends [signal] to the
    * process. Depending on the signal giving, it'll have different
    * 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]);
+  bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]);
 }
 
 
 /**
  * [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;
 }