Make sure that _FileInputStream._fillBuffer is not entered again before it finishes.

runtime/bin/file_impl.dart

 // Copyright (c) 2012, 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 extends _BaseDataInputStream implements InputStream {
   _FileInputStream(String name)
       : _data = [],
         _position = 0,
         _filePosition = 0 {
     var file = new File(name);
@@ skipping 47 matching lines @@
   }
 
   void _fillBuffer() {
     Expect.equals(_position, _data.length);
     if (_openedFile == null) return;  // Called before the file is opened.
     int size = Math.min(_bufferLength, _fileLength - _filePosition);
     if (size == 0) {
       _closeFile();
       return;
     }
+    if (_activeFillBufferCall) return;

[Ivan Posva, 2012/06/12 15:56:52]

Comment about buffer filling in flight please.

+    _activeFillBufferCall = true;
     if (_data.length != size) {
       _data = new Uint8List(size);
+      _position = _data.length;

[Bill Hesse, 2012/06/12 15:18:10]

This was probably the cause of a bug.  It could cause a negative value for
available().

[Ivan Posva, 2012/06/12 15:56:52]

This is very confusing. Please add a comment explaining what this does.
Basically you are signaling nothing available yet.

     }
     var future = _openedFile.readList(_data, 0, _data.length);
     future.then((read) {
       _filePosition += read;
       if (read != _data.length) {
         _data = _data.getRange(0, read);
       }
       _position = 0;
+      _activeFillBufferCall = false;
 
       if (_fileLength == _filePosition) {
         _closeFile();
       }
       _checkScheduleCallbacks();
     });
+    future.handleException((e) {
+      _activeFillBufferCall = false;
+      _reportError(e);
+      return true;
+    });
   }
 
   int available() {
     return closed ? 0 : _data.length - _position;
   }
 
   void pipe(OutputStream output, [bool close = true]) {
     _pipe(this, output, close: close);
   }
 
   void _finishRead() {
     if (_position == _data.length && !_streamMarkedClosed) {
       _fillBuffer();
     } else {
       _checkScheduleCallbacks();
     }
   }
 
   List<int> _read(int bytesToRead) {
     List<int> result;
     if (_position == 0 && bytesToRead == _data.length) {
       result = _data;
       _data = [];

[Ivan Posva, 2012/06/12 15:56:52]

_data = const [];

     } else {
       result = new Uint8List(bytesToRead);
       result.setRange(0, bytesToRead, _data, _position);
       _position += bytesToRead;
     }
     _finishRead();
     return result;
   }
 
   int _readInto(List<int> buffer, int offset, int len) {
@@ skipping 11 matching lines @@
     _closeFile();
   }
 
   static final int _bufferLength = 64 * 1024;
 
   RandomAccessFile _openedFile;
   List<int> _data;
   int _position;
   int _filePosition;
   int _fileLength;
+  bool _activeFillBufferCall = false;
 }
 
 
 class _PendingOperation {
   const _PendingOperation(this._id);
   static final _PendingOperation CLOSE = const _PendingOperation(0);
   static final _PendingOperation FLUSH = const _PendingOperation(1);
   final int _id;
 }
 
@@ skipping 993 matching lines @@
           new FileIOException("File closed '$_name'"));
     });
     return completer.future;
   }
 
   final String _name;
   int _id;
 
   SendPort _fileService;
 }