Simulate data and close callbacks on a synchronous file input stream

runtime/bin/file_impl.dart

 // Copyright (c) 2011, 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.
 
 class _FileInputStream implements FileInputStream {
   _FileInputStream(File file) {
     _file = new File(file.name);
     _file.openSync();
+    _length = _file.lengthSync();
+    _checkScheduleCallbacks();
   }
 
   List<int> read([int len]) {
+    if (_closed) return null;
     int bytesToRead = available();
     if (bytesToRead == 0) {
+      _checkScheduleCallbacks();
       return null;
     }
     if (len !== null) {
       if (len <= 0) {
         throw new StreamException("Illegal length $len");
       } else if (bytesToRead > len) {
         bytesToRead = len;
       }
     }
     List<int> buffer = new List<int>(bytesToRead);
     int bytesRead = _file.readListSync(buffer, 0, bytesToRead);
     if (bytesRead < bytesToRead) {
       List<int> newBuffer = new List<int>(bytesRead);
       newBuffer.copyFrom(buffer, 0, 0, bytesRead);
       return newBuffer;
     } else {
       return buffer;
     }
   }
 
   int readInto(List<int> buffer, int offset, int len) {
     if (offset === null) offset = 0;
     if (len === null) len = buffer.length;
     if (offset < 0) throw new StreamException("Illegal offset $offset");
     if (len < 0) throw new StreamException("Illegal length $len");
-    return _file.readListSync(buffer, offset, len);
+    int result = _file.readListSync(buffer, offset, len);
+    _checkScheduleCallbacks();
+    return result;
   }
 
   int available() {
-    return _file.lengthSync() - _file.positionSync();
+    return _length - _file.positionSync();
   }
 
-  bool closed() {
-    _file.positionSync() == _file.lengthSync();
-  }
+  bool closed() => _eof;
 
   void close() {
     _file.closeSync();
+    _closed = true;
   }
 
   void set dataHandler(void callback()) {
-    // TODO(sgjesse): How to handle this?
+    _clientDataHandler = callback;
+    _checkScheduleCallbacks();
   }
 
   void set closeHandler(void callback()) {
-    // TODO(sgjesse): How to handle this?
+    _clientCloseHandler = callback;
   }
 
   void set errorHandler(void callback()) {
     // TODO(sgjesse): How to handle this?
   }
 
+  void _checkScheduleCallbacks() {
+    // TODO(sgjesse): Find a better way of scheduling callbacks from
+    // the event loop.
+    void issueDataCallback(Timer timer) {
+      _scheduledDataCallback = null;
+      if (_clientDataHandler !== null) {
+        _clientDataHandler();
+        _checkScheduleCallbacks();
+      }
+    }
+
+    void issueCloseCallback(Timer timer) {
+      _scheduledCloseCallback = null;
+      if (!_closed) {
+        if (_clientCloseHandler !== null) _clientCloseHandler();
+        _closed = true;
+      }
+    }
+
+    // Schedule data callback if there is more data to read. Schedule
+    // close callback once when all data has been read. Only schedule
+    // a new callback if the previous one have actually been called.

[Mads Ager (google), 2011/12/06 15:16:37]

have ->  has

+    if (available() > 0) {
+      if (_scheduledDataCallback == null) {
+        _scheduledDataCallback = new Timer(issueDataCallback, 0, false);
+      }
+    } else if (!_eof && !_closed) {
+      if (_scheduledCloseCallback == null) {
+        _scheduledCloseCallback = new Timer(issueCloseCallback, 0, false);
+        _eof = true;
+      }
+    }
+  }
+
   File _file;
+  int _length;
+  bool _eof = false;
+  bool _closed = false;
+  Timer _scheduledDataCallback;
+  Timer _scheduledCloseCallback;
+  var _clientDataHandler;
+  var _clientCloseHandler;
 }
 
 
 class _FileOutputStream implements FileOutputStream {
   _FileOutputStream(File file) {
     _file = new File(file.name);
     _file.openSync(true);
   }
 
   bool write(List<int> buffer, [bool copyBuffer = false]) {
@@ skipping 966 matching lines @@
   var _readListHandler;
   var _noPendingWriteHandler;
   var _positionHandler;
   var _setPositionHandler;
   var _truncateHandler;
   var _lengthHandler;
   var _flushHandler;
   var _fullPathHandler;
   var _errorHandler;
 }