Add tracking of open processes to the new io resource tracking.

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 158 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.
 }
 
 
 // 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>();
+class _ProcessImpl extends _ProcessImplNativeWrapper implements Process {
+  _ProcessResourceInfo _resourceInfo;
+  static bool connectedResourceHandler = false;
 
   _ProcessImpl(String path,
                List<String> arguments,
                String this._workingDirectory,
                Map<String, String> environment,
                bool includeParentEnvironment,
                bool runInShell,
                ProcessStartMode mode) : super() {
-    _processes[_serviceId] = this;
+    if (!connectedResourceHandler) {
+      registerExtension('__getProcesses',
+                        _ProcessResourceInfo.getStartedProcesses);
+      registerExtension('__getProcessById',
+                        _ProcessResourceInfo.getProcessInfoMapById);
+      connectedResourceHandler = true;
+    }
+
     if (runInShell) {
       arguments = _getShellArguments(path, arguments);
       path = _getShellCommand();
     }
 
     if (path is !String) {
       throw new ArgumentError("Path is not a String: $path");
     }
     _path = path;
 
@@ skipping 58 matching lines @@
       _stderr = new _StdStream(new _Socket._readPipe());
       _stderr._stream._owner = this;
     }
     if (mode == ProcessStartMode.NORMAL) {
       _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;
-    if (_stdin._sink._nativeSocket.owner != null) {
-      r['stdin'] = _stdin._sink._nativeSocket._toJSON(true);
-    }
-    if (_stdout._stream._nativeSocket.owner != null) {
-      r['stdout'] = _stdout._stream._nativeSocket._toJSON(true);
-    }
-    if (_stderr._stream._nativeSocket.owner != null) {
-      r['stderr'] = _stderr._stream._nativeSocket._toJSON(true);
-    }
-    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 99 matching lines @@
       if (!success) {
         completer.completeError(
             new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode));
         return;
       }
 
       _started = true;
+      _resourceInfo = new _ProcessResourceInfo(this);
 
       // Setup an exit handler to handle internal cleanup and possible
       // callback when a process terminates.
       if (_mode == ProcessStartMode.NORMAL) {
         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);
+            _resourceInfo.stopped();
           }
 
           exitDataBuffer.setRange(
               exitDataRead, exitDataRead + data.length, data);
           exitDataRead += data.length;
           if (exitDataRead == EXIT_DATA_SIZE) {
             handleExit();
           }
         });
       }
@@ skipping 17 matching lines @@
                                 _stderr._stream._nativeSocket,
                                 _exitHandler._nativeSocket,
                                 status);
     if (!success) {
       throw new ProcessException(_path,
                                  _arguments,
                                  status._errorMessage,
                                  status._errorCode);
     }
 
+    _resourceInfo = new _ProcessResourceInfo(this);
+
     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);
     }
 
-    _processes.remove(_serviceId);
+    _resourceInfo.stopped();
 
     return new ProcessResult(
         result[0],
         result[1],
         getOutput(result[2], stdoutEncoding),
         getOutput(result[3], stderrEncoding));
   }
 
   bool _startNative(String path,
                     List<String> arguments,
@@ skipping 116 matching lines @@
       Encoding stderrEncoding) {
   var process = new _ProcessImpl(executable,
                                  arguments,
                                  workingDirectory,
                                  environment,
                                  includeParentEnvironment,
                                  runInShell,
                                  ProcessStartMode.NORMAL);
   return process._runAndWait(stdoutEncoding, stderrEncoding);
 }