Add support for killing a process with a given PID to dart:io

sdk/lib/io/process.dart

 // Copyright (c) 2014, 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.
 
 part of dart.io;
 
 // TODO(ager): The only reason for this class is that we
 // cannot patch a top-level at this point.
 class _ProcessUtils {
   external static void _exit(int status);
@@ skipping 328 matching lines @@
       String executable,
       List<String> arguments,
       {String workingDirectory,
        Map<String, String> environment,
        bool includeParentEnvironment: true,
        bool runInShell: false,
        Encoding stdoutEncoding: SYSTEM_ENCODING,
        Encoding stderrEncoding: SYSTEM_ENCODING});
 
   /**
+   * Kills the process with id [pid].
+   *
+   * Where possible, sends the [signal] to the process with id
+   * `pid`. This includes Linux and OS X. The default signal is
+   * [ProcessSignal.SIGTERM] which will normally terminate the
+   * process.
+   *
+   * On platforms without signal support, including Windows, the call
+   * just terminates the process with id `pid` in a platform specific
+   * way, and the `signal` parameter is ignored.
+   *
+   * Returns `true` if the signal is successfully delivered to the
+   * process. Otherwise the signal could not be sent, usually meaning
+   * that the process is already dead.
+   */
+  external static bool killPid(
+      int pid, [ProcessSignal signal = ProcessSignal.SIGTERM]);
+
+  /**
    * Returns the standard output stream of the process as a [:Stream:].
    */
   Stream<List<int>> get stdout;
 
   /**
    * Returns the standard error stream of the process as a [:Stream:].
    */
   Stream<List<int>> get stderr;
 
   /**
    * Returns the standard input stream of the process as an [IOSink].
    */
   IOSink get stdin;
 
   /**
    * Returns the process id of the process.
    */
   int get pid;
 
   /**
-   * On Linux and Mac OS, [kill] sends [signal] to the process. When the process
-   * terminates as a result of calling [kill], the value for [exitCode] may be a
-   * negative number corresponding to the provided [signal].
+   * Kills the process.
    *
-   * On Windows, [kill] kills the process, ignoring the [signal] flag.
+   * Where possible, sends the [signal] to the process. This includes
+   * Linux and OS X. The default signal is [ProcessSignal.SIGTERM]
+   * which will normally terminate the process.
    *
-   * Returns [:true:] if the signal is successfully sent and process is killed.
-   * Otherwise the signal could not be sent, usually meaning that the process is
-   * already dead.
+   * On platforms without signal support, including Windows, the call
+   * just terminates the process in a platform specific way, and the
+   * `signal` parameter is ignored.
+   *
+   * Returns `true` if the signal is successfully delivered to the
+   * process. Otherwise the signal could not be sent, usually meaning
+   * that the process is already dead.
    */
   bool kill([ProcessSignal signal = ProcessSignal.SIGTERM]);
 }
 
 
 /**
  * [ProcessResult] represents the result of running a non-interactive
  * process started with [:Process.run:].
  */
 abstract class ProcessResult {
@@ skipping 133 matching lines @@
   final int errorCode;
 
   const ProcessException(this.executable, this.arguments, [this.message = "",
                          this.errorCode = 0]);
   String toString() {
     var msg = (message == null) ? 'OS error code: $errorCode' : message;
     var args = arguments.join(' ');
     return "ProcessException: $msg\n  Command: $executable $args";
   }
 }