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

sdk/lib/io/io_resource_info.dart

 // Copyright (c) 2015, 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.
 
 part of dart.io;
 
 abstract class _IOResourceInfo {
   final String type;
   final int id;
   String get name;
   static int _count = 0;
 
+  static final Stopwatch _sw = new Stopwatch()..start();
+
   _IOResourceInfo(this.type) : id = _IOResourceInfo.getNextID();
 
-  String toJSON();
-
   /// Get the full set of values for a specific implementation. This is normally
   /// looked up based on an id from a referenceValueMap.
   Map<String, String> get fullValueMap;
 
   /// The reference map, used to return a list of values, e.g., getting
   /// all open sockets. The structure of this is shared among all subclasses.
   Map<String, String> get referenceValueMap =>
       {
         // The type for a reference object is prefixed with @ in observatory.
         'type': '@$type',
         'id': id,
         'name': name,
       };
 
   static int getNextID() => _count++;
 }
 
 abstract class _ReadWriteResourceInfo extends _IOResourceInfo {
   int totalRead;
   int totalWritten;
   int readCount;
   int writeCount;
   double lastRead;
   double lastWrite;
 
-  static final Stopwatch _sw = new Stopwatch()..start();
-  static double get timestamp => _sw.elapsedMicroseconds / 1000000.0;
+  static double get timestamp =>
+      _IOResourceInfo._sw.elapsedMicroseconds / 1000000.0;
 
   // Not all call sites use this. In some cases, e.g., a socket, a read does
   // not always mean that we actually read some bytes (we may do a read to see
   // if there are some bytes available).
   void addRead(int bytes) {
     totalRead += bytes;
     readCount++;
     lastRead = timestamp;
   }
 
@@ skipping 22 matching lines @@
       'type': type,
       'id': id,
       'name': name,
       'total_read': totalRead,
       'total_written': totalWritten,
       'read_count': readCount,
       'write_count': writeCount,
       'last_read': lastRead,
       'last_write': lastWrite
     };
-
-  String toJSON() {
-    return JSON.encode(fullValueMap);
-  }
 }
 
 class _FileResourceInfo extends _ReadWriteResourceInfo {
   static const String TYPE = '_file';
 
   final file;
 
   static Map<int, _FileResourceInfo> openFiles =
       new Map<int, _FileResourceInfo>();
 
@@ skipping 34 matching lines @@
       openFiles.containsKey(id) ? openFiles[id].getFileInfoMap() : {};
     var json = JSON.encode(result);
     return new Future.value(new ServiceExtensionResponse.result(json));
   }
 
   String get name {
     return '${file.path}';
   }
 }
 
+class _ProcessResourceInfo extends _IOResourceInfo{
+  static const String TYPE = '_process';
+  final process;
+  final int startedAt;
+
+  static Map<int, _ProcessResourceInfo> startedProcesses =
+      new Map<int, _ProcessResourceInfo>();
+
+  _ProcessResourceInfo(this.process) :
+      startedAt = new DateTime.now().millisecondsSinceEpoch,
+      super(TYPE) {
+    ProcessStarted(this);
+  }
+
+  String get name => process._path;
+
+  void stopped() => ProcessStopped(this);
+
+  Map<String, String> get fullValueMap =>
+    {
+      'type': type,
+      'id': id,
+      'name': name,
+      'pid': process.pid,
+      'started_at': startedAt,
+      'arguments': process._arguments,
+      'working_directory':
+          process._workingDirectory == null ? '.' : process._workingDirectory,
+    };
+
+  static ProcessStarted(_ProcessResourceInfo info) {
+    assert(!startedProcesses.containsKey(info.id));
+    startedProcesses[info.id] = info;
+  }
+
+  static ProcessStopped(_ProcessResourceInfo info) {
+    assert(startedProcesses.containsKey(info.id));
+    startedProcesses.remove(info.id);
+  }
+
+  static Iterable<Map<String, String>> getStartedProcessesList() =>
+      new List.from(startedProcesses.values.map((e) => e.referenceValueMap));
+
+  static Future<ServiceExtensionResponse> getStartedProcesses(
+      String function, Map<String, String> params) {
+    assert(function == '__getProcesses');
+    var data = {'type': '_startedprocesses', 'data': getStartedProcessesList()};
+    var json = JSON.encode(data);
+    return new Future.value(new ServiceExtensionResponse.result(json));
+  }
+
+  static Future<ServiceExtensionResponse> getProcessInfoMapById(
+      String function, Map<String, String> params) {
+    var id = int.parse(params['id']);
+    var result = startedProcesses.containsKey(id)
+        ? startedProcesses[id].fullValueMap
+        : {};
+    var json = JSON.encode(result);
+    return new Future.value(new ServiceExtensionResponse.result(json));
+  }
+}
+
 class _SocketResourceInfo extends _ReadWriteResourceInfo {
   static const String TCP_STRING = 'TCP';
   static const String UDP_STRING = 'UDP';
   static const String TYPE = '_socket';
 
   final socket;
 
   static Map<int, _SocketResourceInfo> openSockets =
       new Map<int, _SocketResourceInfo>();
 
@@ skipping 62 matching lines @@
     assert(!openSockets.containsKey(info.id));
     openSockets[info.id] = info;
   }
 
   static SocketClosed(_SocketResourceInfo info) {
     assert(openSockets.containsKey(info.id));
     openSockets.remove(info.id);
   }
 
 }