Add processes to Observatory

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 139 matching lines @@
   }
 }
 
 
 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 {
+// The NativeFieldWrapperClass1 can not be used with a mixin, due to missing
+// implicit constructor.
+class _ProcessImplNativeWrapper extends NativeFieldWrapperClass1 {}
+
+class _ProcessImpl extends _ProcessImplNativeWrapper with _ServiceObject
+    implements Process {
+  // Use default Map so we keep order.
+  static Map<int, _ProcessImpl> _processes = new Map<int, _ProcessImpl>();
+
   _ProcessImpl(String path,
                List<String> arguments,
                String this._workingDirectory,
                Map<String, String> environment,
                bool includeParentEnvironment,
-               bool runInShell) {
+               bool runInShell) : super() {
+    _processes[_serviceId] = this;
     if (runInShell) {
       arguments = _getShellArguments(path, arguments);
       path = _getShellCommand();
     }
 
     if (path is !String) {
       throw new ArgumentError("Path is not a String: $path");
     }
     _path = path;
 
@@ skipping 46 matching lines @@
     _stdin = new _StdSink(new _Socket._writePipe());
     // stdout coming from process.
     _stdout = new _StdStream(new _Socket._readPipe());
     // stderr coming from process.
     _stderr = new _StdStream(new _Socket._readPipe());
     _exitHandler = new _Socket._readPipe();
     _ended = false;
     _started = false;
   }
 
+  String get _serviceTypePath => 'io/processes';
+  String get _serviceTypeName => 'Process';
+
+  Map _toJSON(bool ref) {
+    var r = {
+      'id': _servicePath,
+      'type': _serviceType(ref),
+      'name': '$_path',
+      'user_name': '$_path',
+      'pid': '$pid',
+      'arguments': _arguments.join(' '),
+    };
+    if (ref) {
+      return r;
+    }
+    r['started'] = _started;
+    r['ended'] = _ended;
+    r['path'] = _path;
+    r['environment'] = _environment;
+    r['workingDirectory'] = _workingDirectory == null ? '.' : _workingDirectory;
+    return r;
+  }
+
   static String _getShellCommand() {
     if (Platform.isWindows) {
       return 'cmd.exe';
     }
     return '/bin/sh';
   }
 
   static List<String> _getShellArguments(String executable,
                                          List<String> arguments) {
     List<String> shellArguments = [];
@@ skipping 88 matching lines @@
                                   _exitHandler._nativeSocket,
                                   status);
       if (!success) {
         completer.completeError(
             new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode));
         return;
       }
-      // Reset values which are no longer needed.
-      _path = null;
-      _arguments = null;
-      _workingDirectory = null;
-      _environment = null;
 
       _started = true;
 
       // Setup an exit handler to handle internal cleanup and possible
       // callback when a process terminates.
       int exitDataRead = 0;
       final int EXIT_DATA_SIZE = 8;
       List<int> exitDataBuffer = new List<int>(EXIT_DATA_SIZE);
       _exitHandler.listen((data) {
 
         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;
           _exitCode.complete(exitCode(exitDataBuffer));
           // Kill stdin, helping hand if the user forgot to do it.
           _stdin._sink.destroy();
+          _processes.remove(_serviceId);
         }
 
         exitDataBuffer.setRange(exitDataRead, exitDataRead + data.length, data);
         exitDataRead += data.length;
         if (exitDataRead == EXIT_DATA_SIZE) {
           handleExit();
         }
       });
 
       completer.complete(this);
@@ skipping 12 matching lines @@
                                 _stdout._stream._nativeSocket,
                                 _stderr._stream._nativeSocket,
                                 _exitHandler._nativeSocket,
                                 status);
     if (!success) {
       throw new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode);
     }
-    // Reset values which are no longer needed.
-    _path = null;
-    _arguments = null;
-    _workingDirectory = null;
-    _environment = null;
 
     var result = _wait(
         _stdin._sink._nativeSocket,
         _stdout._stream._nativeSocket,
         _stderr._stream._nativeSocket,
         _exitHandler._nativeSocket);
 
     getOutput(output, encoding) {
       if (encoding == null) return output;
       return encoding.decode(output);
@@ skipping 139 matching lines @@
   const _ProcessResult(int this.pid,
                        int this.exitCode,
                        this.stdout,
                        this.stderr);
 
   final int pid;
   final int exitCode;
   final stdout;
   final stderr;
 }