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

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 52 matching lines @@
        Encoding stderrEncoding: SYSTEM_ENCODING}) {
     return _runNonInteractiveProcessSync(executable,
                                          arguments,
                                          workingDirectory,
                                          environment,
                                          includeParentEnvironment,
                                          runInShell,
                                          stdoutEncoding,
                                          stderrEncoding);
   }
+
+  /* patch */ static bool killPid(
+      int pid, [ProcessSignal signal = ProcessSignal.SIGTERM]) {
+    if (signal is! ProcessSignal) {
+      throw new ArgumentError(
+          "Argument 'signal' must be a ProcessSignal");
+    }
+    return _ProcessUtils._killPid(pid, signal._signalNumber);
+  }
 }
 
 
 List<_SignalController> _signalControllers = new List(32);
 
 
 class _SignalController {
   final ProcessSignal signal;
 
   StreamController _controller;
@@ skipping 42 matching lines @@
 Function _getWatchSignalInternal() => _ProcessUtils._watchSignalInternal;
 
 
 patch class _ProcessUtils {
   /* patch */ static void _exit(int status) native "Process_Exit";
   /* patch */ static void _setExitCode(int status)
       native "Process_SetExitCode";
   /* patch */ static int _getExitCode() native "Process_GetExitCode";
   /* patch */ static void _sleep(int millis) native "Process_Sleep";
   /* patch */ static int _pid(Process process) native "Process_Pid";
+  static int _killPid(int pid, ProcessSignal signal)
+      native "Process_KillPid";
   /* patch */ static Stream<ProcessSignal> _watchSignal(ProcessSignal signal) {
     if (signal != ProcessSignal.SIGHUP &&
         signal != ProcessSignal.SIGINT &&
         signal != ProcessSignal.SIGTERM &&
         (Platform.isWindows ||
          (signal != ProcessSignal.SIGUSR1 &&
           signal != ProcessSignal.SIGUSR2 &&
           signal != ProcessSignal.SIGWINCH))) {
       throw new SignalException(
           "Listening for signal $signal is not supported");
@@ skipping 366 matching lines @@
 
   Future<int> get exitCode => _exitCode != null ? _exitCode.future : null;
 
   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);
+    return _ProcessUtils._killPid(pid, signal._signalNumber);
   }
 
-  bool _kill(Process p, int signal) native "Process_Kill";
-
   int get pid => _ProcessUtils._pid(this);
 
   String _path;
   List<String> _arguments;
   String _workingDirectory;
   List<String> _environment;
   bool _detach;
   // Private methods of Socket are used by _in, _out, and _err.
   _StdSink _stdin;
   _StdStream _stdout;
@@ skipping 81 matching lines @@
   const _ProcessResult(int this.pid,
                        int this.exitCode,
                        this.stdout,
                        this.stderr);
 
   final int pid;
   final int exitCode;
   final stdout;
   final stderr;
 }