Give Process.kill an optional argument to specify which signal to send.

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.
 
 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 59 matching lines @@
         }
         _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;
-    _killed = false;
+    _ended = false;
     _started = false;
     _onExit = null;
     // TODO(ager): Make the actual process starting really async instead of
     // simulating it with a timer.
     new Timer(0, (Timer ignore) => _start());
   }
 
   String _windowsArgumentEscape(String argument) {
     var result = argument;
     if (argument.contains('\t') || argument.contains(' ')) {
@@ skipping 80 matching lines @@
     _exitHandler.inputStream.onData = () {
 
       int exitCode(List<int> ints) {
         var code = _intFromBytes(ints, 0);
         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));
         }
       }
 
       exitDataRead += _exitHandler.inputStream.readInto(
           exitDataBuffer, exitDataRead, EXIT_DATA_SIZE - exitDataRead);
       if (exitDataRead == EXIT_DATA_SIZE) handleExit();
     };
 
@@ skipping 26 matching lines @@
     return _err.inputStream;
   }
 
   OutputStream get stdin() {
     if (_closed) {
       throw new ProcessException("Process closed");
     }
     return _out.outputStream;
   }
 
-  void kill() {
+  void kill([ProcessSignal signal = ProcessSignal.SIGTERM]) {
+    if (signal is! ProcessSignal) {
+      throw new IllegalArgumentException(
+          "Argument 'signal' must be a ProcessSignal");
+    }
     if (_closed && _pid === null) {
       _reportError(new ProcessException("Process closed"));
       return;
     }
-    if (_killed) {
+    if (_ended) {
       return;
     }
     // TODO(ager): Make the actual kill operation asynchronous.
-    if (_kill(_pid)) {
-      _killed = true;
+    if (_kill(_pid, signal._signalNumber)) {
       return;
     }
     _reportError(new ProcessException("Could not kill process"));
     return;
   }
 
-  void _kill(int pid) native "Process_Kill";
+  void _kill(int pid, 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 (_killed) {
+    if (_ended) {
       throw new ProcessException("Process killed");
     }
     _onExit = callback;
   }
 
   void set onError(void callback(e)) {
     _onError = callback;
   }
 
   void set onStart(void callback()) {
@@ skipping 12 matching lines @@
   ObjectArray<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;
   int _pid;
   bool _closed;
-  bool _killed;
+  bool _ended;
   bool _started;
   Function _onExit;
   Function _onError;
   Function _onStart;
 }
 
 
 // _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
@@ skipping 85 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;
 }