Add resource metadata for open files.

sdk/lib/io/file_impl.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.
 
 part of dart.io;
 
 // Read the file in blocks of size 64k.
 const int _BLOCK_SIZE = 64 * 1024;
 
 
@@ skipping 550 matching lines @@
     if (result is OSError) {
       throw new FileSystemException(msg, path, result);
     }
   }
 }
 
 
 class _RandomAccessFile
     extends Object with _ServiceObject
     implements RandomAccessFile {
-  // Use default Map so we keep order.
-  static Map<int, _RandomAccessFile> _files = new Map<int, _RandomAccessFile>();
+  static bool _connectedResourceHandler = false;
 
   final String path;
   int _id;
   bool _asyncDispatched = false;
   SendPort _fileService;
 
-  int _totalRead = 0;
-  int _totalWritten = 0;
-  int _readCount = 0;
-  int _writeCount = 0;
-
+  _FileResourceInfo _resourceInfo;
 
   _RandomAccessFile(this._id, this.path) {
-    _files[_serviceId] = this;
-  }
-
-  String get _serviceTypePath => 'io/file/randomaccessfiles';
-  String get _serviceTypeName => 'RandomAccessFile';
-
-  Map _toJSON(bool ref) {
-    var r = {
-      'id': _servicePath,
-      'type': _serviceType(ref),
-      'name': '$path',
-      'user_name': '$path',
-    };
-    if (ref) {
-      return r;
-    }
-    r['asyncDispatched'] = _asyncDispatched;
-    r['fd'] = _getFD(_id);
-    r['totalRead'] = _totalRead;
-    r['totalWritten'] = _totalWritten;
-    r['readCount'] = _totalWritten;
-    r['writeCount'] = _writeCount;
-    return r;
+    _resourceInfo = new _FileResourceInfo(this);
+    _maybeConnectHandler();
   }
 
   void _maybePerformCleanup() {
     if (closed) {
-      _files.remove(_serviceId);
+      _FileResourceInfo.FileClosed(_resourceInfo);
     }
   }
 
   external static int _getFD(int id);
 
+  _maybeConnectHandler() {
+    if (!_connectedResourceHandler) {
+      // TODO(ricow): we probably need set these in some initialization code.
+      // We need to make sure that these are always awailable from the
+      // observatory even if no files (or sockets for the socket ones) are
+      // open.
+      registerExtension('__getOpenFiles',
+                        _FileResourceInfo.getOpenFiles);
+      registerExtension('__getFileByID',
+                        _FileResourceInfo.getFileInfoMapByID);
+      _connectedResourceHandler = true;
+    }
+  }
+
   Future<RandomAccessFile> close() {
     return _dispatch(_FILE_CLOSE, [_id], markClosed: true).then((result) {
       if (result != -1) {
         _id = result;
         _maybePerformCleanup();
         return this;
       } else {
         throw new FileSystemException("Cannot close file", path);
       }
     });
   }
 
   external static int _close(int id);
 
   void closeSync() {
     _checkAvailable();
     var id = _close(_id);
     if (id == -1) {
       throw new FileSystemException("Cannot close file", path);
     }
     _id = id;
     _maybePerformCleanup();
   }
 
   Future<int> readByte() {
     return _dispatch(_FILE_READ_BYTE, [_id]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "readByte failed", path);
       }
-      _readCount++;
-      _totalRead++;
+      _resourceInfo.readCount++;
+      _resourceInfo.totalRead++;
       return response;
     });
   }
 
   external static _readByte(int id);
 
   int readByteSync() {
     _checkAvailable();
     var result = _readByte(_id);
     if (result is OSError) {
       throw new FileSystemException("readByte failed", path, result);
     }
-    _readCount++;
-    _totalRead++;
+    _resourceInfo.readCount++;
+    _resourceInfo.totalRead++;
     return result;
   }
 
   Future<List<int>> read(int bytes) {
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
     return _dispatch(_FILE_READ, [_id, bytes]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "read failed", path);
       }
-      _readCount++;
-      _totalRead += response[1].length;
+      _resourceInfo.readCount++;
+      _resourceInfo.totalRead += response[1].length;
       return response[1];
     });
   }
 
   external static _read(int id, int bytes);
 
   List<int> readSync(int bytes) {
     _checkAvailable();
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
     var result = _read(_id, bytes);
     if (result is OSError) {
       throw new FileSystemException("readSync failed", path, result);
     }
-    _readCount++;
-    _totalRead += result.length;
+    _resourceInfo.readCount++;
+    _resourceInfo.totalRead += result.length;
     return result;
   }
 
   Future<int> readInto(List<int> buffer, [int start = 0, int end]) {
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError();
     }
     end = RangeError.checkValidRange(start, end, buffer.length);
     if (end == start) return new Future.value(0);
     int length = end - start;
     return _dispatch(_FILE_READ_INTO, [_id, length]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "readInto failed", path);
       }
       var read = response[1];
       var data = response[2];
       buffer.setRange(start, start + read, data);
-      _readCount++;
-      _totalRead += read;
+      _resourceInfo.readCount++;
+      _resourceInfo.totalRead += read;
       return read;
     });
   }
 
   external static _readInto(int id, List<int> buffer, int start, int end);
 
   int readIntoSync(List<int> buffer, [int start = 0, int end]) {
     _checkAvailable();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError();
     }
     end = RangeError.checkValidRange(start, end, buffer.length);
     if (end == start) return 0;
     var result = _readInto(_id, buffer, start, end);
     if (result is OSError) {
       throw new FileSystemException("readInto failed", path, result);
     }
-    _readCount++;
-    _totalRead += result;
+    _resourceInfo.readCount++;
+    _resourceInfo.totalRead += result;
     return result;
   }
 
   Future<RandomAccessFile> writeByte(int value) {
     if (value is !int) {
       throw new ArgumentError(value);
     }
     return _dispatch(_FILE_WRITE_BYTE, [_id, value]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "writeByte failed", path);
       }
-      _writeCount++;
-      _totalWritten++;
+      _resourceInfo.writeCount++;
+      _resourceInfo.totalWritten++;
       return this;
     });
   }
 
   external static _writeByte(int id, int value);
 
   int writeByteSync(int value) {
     _checkAvailable();
     if (value is !int) {
       throw new ArgumentError(value);
     }
     var result = _writeByte(_id, value);
     if (result is OSError) {
       throw new FileSystemException("writeByte failed", path, result);
     }
-    _writeCount++;
-    _totalWritten++;
+    _resourceInfo.writeCount++;
+    _resourceInfo.totalWritten++;
     return result;
   }
 
   Future<RandomAccessFile> writeFrom(
       List<int> buffer, [int start = 0, int end]) {
     if ((buffer is !List) ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError("Invalid arguments to writeFrom");
     }
     end = RangeError.checkValidRange(start, end, buffer.length);
     if (end == start) return new Future.value(this);
     _BufferAndStart result;
     try {
       result = _ensureFastAndSerializableByteData(buffer, start, end);
     } catch (e) {
       return new Future.error(e);
     }
 
     List request = new List(4);
     request[0] = _id;
     request[1] = result.buffer;
     request[2] = result.start;
     request[3] = end - (start - result.start);
     return _dispatch(_FILE_WRITE_FROM, request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "writeFrom failed", path);
       }
-      _writeCount++;
-      _totalWritten += end - (start - result.start);
+      _resourceInfo.writeCount++;
+      _resourceInfo.totalWritten += end - (start - result.start);
       return this;
     });
   }
 
   external static _writeFrom(int id, List<int> buffer, int start, int end);
 
   void writeFromSync(List<int> buffer, [int start = 0, int end]) {
     _checkAvailable();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError("Invalid arguments to writeFromSync");
     }
     end = RangeError.checkValidRange(start, end, buffer.length);
     if (end == start) return;
     _BufferAndStart bufferAndStart =
         _ensureFastAndSerializableByteData(buffer, start, end);
     var result = _writeFrom(_id,
                             bufferAndStart.buffer,
                             bufferAndStart.start,
                             end - (start - bufferAndStart.start));
     if (result is OSError) {
       throw new FileSystemException("writeFrom failed", path, result);
     }
-    _writeCount++;
-    _totalWritten += end - (start - bufferAndStart.start);
+    _resourceInfo.writeCount++;
+    _resourceInfo.totalWritten += end - (start - bufferAndStart.start);
   }
 
   Future<RandomAccessFile> writeString(String string,
                                        {Encoding encoding: UTF8}) {
     if (encoding is! Encoding) {
       throw new ArgumentError(encoding);
     }
     var data = encoding.encode(string);
     return writeFrom(data, 0, data.length);
   }
@@ skipping 210 matching lines @@
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }