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;

[Cutch, 2015/09/10 16:49:41]

All times reported over the service protocol should be expressed as milliseconds
since the epoch and transmitted as doubles. We need this so we can reconstruct
the DateTime object in the UI (running as JavaScript).

[ricow1, 2015/09/14 07:01:17]

I will change this in a follow up to be consistent across the board (I need to
change the tests a bit for the other resource classes as well, I don't want to
mix it with this). I have changed if for the process though, to be that time

 
   // 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 double startedAt;
+
+  static Map<int, _ProcessResourceInfo> startedProcesses =
+      new Map<int, _ProcessResourceInfo>();
+
+  _ProcessResourceInfo(this.process) :
+      startedAt = _IOResourceInfo._sw.elapsedMicroseconds / 1000000.0,

[Søren Gjesse, 2015/09/10 17:43:35]

This looks more like the current running time instead of start time. Maybe just
storing the start time will be fine. The UI can calculate running time from
that.

[ricow1, 2015/09/14 07:01:17]

done

+      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 == '__getStartedProcesses');
+    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);
   }
 
 }