Add access to process id for both current process and processes started

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 16 matching lines @@
                                                [ProcessOptions options]) {
     return _runNonInteractiveProcess(executable, arguments, options);
   }
 }
 
 
 patch class _ProcessUtils {
   /* patch */ static _exit(int status) native "Process_Exit";
   /* patch */ static _setExitCode(int status) native "Process_SetExitCode";
   /* patch */ static _sleep(int millis) native "Process_Sleep";
+  /* patch */ static _pid(Process process) native "Process_Pid";
 }
 
 
 class _ProcessStartStatus {
   int _errorCode;  // Set to OS error code if process start failed.
   String _errorMessage;  // Set to OS error message if process start failed.
 }
 
 
 class _ProcessImpl extends NativeFieldWrapperClass1 implements Process {
@@ skipping 193 matching lines @@
       throw new ArgumentError(
           "Argument 'signal' must be a ProcessSignal");
     }
     assert(_started);
     if (_ended) return false;
     return _kill(this, 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;
   // Private methods of Socket are used by _in, _out, and _err.
   _StdSink _stdin;
   _StdStream _stdout;
   _StdStream _stderr;
   Socket _exitHandler;
   bool _ended;
@@ skipping 24 matching lines @@
       stderrEncoding = options.stderrEncoding;
       if (stderrEncoding is !Encoding) {
         throw new ArgumentError(
             'stderrEncoding option is not an encoding: $stderrEncoding');
       }
     }
   }
 
   // Start the underlying process.
   return Process.start(path, arguments, options).then((Process p) {
+    int pid = p.pid;
+
     // Make sure the process stdin is closed.
     p.stdin.close();
 
     // Setup stdout handling.
     Future<StringBuffer> stdout = p.stdout
         .transform(new StringDecoder(stdoutEncoding))
         .fold(
             new StringBuffer(),
             (buf, data) {
               buf.write(data);
               return buf;
             });
 
     Future<StringBuffer> stderr = p.stderr
         .transform(new StringDecoder(stderrEncoding))
         .fold(
             new StringBuffer(),
             (buf, data) {
               buf.write(data);
               return buf;
             });
 
     return Future.wait([p.exitCode, stdout, stderr]).then((result) {
-      return new _ProcessResult(result[0],
+      return new _ProcessResult(pid,
+                                result[0],
                                 result[1].toString(),
                                 result[2].toString());
     });
   });
 }
 
 
 class _ProcessResult implements ProcessResult {
-  const _ProcessResult(int this.exitCode,
+  const _ProcessResult(int this.pid,

[Anders Johnsen, 2013/04/17 09:13:06]

I'm not sure it makes sense to get the pid of an already terminated process?

[Søren Gjesse, 2013/04/17 10:15:12]

Not sure either, but sometimes processes write files including the pid it had,
so it might be handy. I will keep it there.

+                       int this.exitCode,
                        String this.stdout,
                        String this.stderr);
 
+  final int pid;
   final int exitCode;
   final String stdout;
   final String stderr;
 }