Change times reported from io resource meta data to be milliseconds since epoch

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();
+  static final _startTime = new DateTime.now().millisecondsSinceEpoch;
+
+  static double get timestamp => _startTime + _sw.elapsedMicroseconds/1000;
 
   _IOResourceInfo(this.type) : id = _IOResourceInfo.getNextID();
 
   /// 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 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;
+    lastRead = _IOResourceInfo.timestamp;
   }
 
   // In cases where we read but did not neccesarily get any bytes, use this to
   // update the readCount and timestamp. Manually update totalRead if any bytes
   // where acutally read.
   void didRead() => addRead(0);
 
   void addWrite(int bytes) {
     totalWritten += bytes;
     writeCount++;
-    lastWrite = timestamp;
+    lastWrite = _IOResourceInfo.timestamp;
   }
 
   _ReadWriteResourceInfo(String type) :
     totalRead = 0,
     totalWritten = 0,
     readCount = 0,
     writeCount = 0,
     lastRead = 0.0,
     lastWrite = 0.0,
     super(type);
@@ skipping 60 matching lines @@
   }
 
   String get name {
     return '${file.path}';
   }
 }
 
 class _ProcessResourceInfo extends _IOResourceInfo{
   static const String TYPE = '_process';
   final process;
-  final int startedAt;
+  final double startedAt;
 
   static Map<int, _ProcessResourceInfo> startedProcesses =
       new Map<int, _ProcessResourceInfo>();
 
   _ProcessResourceInfo(this.process) :
-      startedAt = new DateTime.now().millisecondsSinceEpoch,
+      startedAt = _IOResourceInfo.timestamp,
       super(TYPE) {
     ProcessStarted(this);
   }
 
   String get name => process._path;
 
   void stopped() => ProcessStopped(this);
 
   Map<String, String> get fullValueMap =>
     {
@@ skipping 114 matching lines @@
     assert(!openSockets.containsKey(info.id));
     openSockets[info.id] = info;
   }
 
   static SocketClosed(_SocketResourceInfo info) {
     assert(openSockets.containsKey(info.id));
     openSockets.remove(info.id);
   }
 
 }