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 = [],
+      : _data = const [],
         _position = 0,
         _filePosition = 0 {
     var file = new File(name);
     var future = file.open(FileMode.READ);
     future.handleException((e) {
       _reportError(e);
       return true;
     });
     future.then(_setupOpenedFile);
   }
 
   _FileInputStream.fromStdio(int fd)
-      : _data = [],
+      : _data = const [],
         _position = 0,
         _filePosition = 0 {
     assert(fd == 0);
     _setupOpenedFile(_File._openStdioSync(fd));
   }
 
   void _setupOpenedFile(RandomAccessFile openedFile) {
     _openedFile = openedFile;
     if (_streamMarkedClosed) {
       // This input stream has already been closed.
@@ skipping 27 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 there is currently a _fillBuffer call waiting on readList,
+    // let it fill the buffer instead of us.
+    if (_activeFillBufferCall) return;
+    _activeFillBufferCall = true;
     if (_data.length != size) {
       _data = new Uint8List(size);
+      // Maintain the invariant signalling that the buffer is empty.
+      _position = _data.length;
     }
     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 = [];
+      _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) {
     buffer.setRange(offset, len, _data, _position);
     _position += len;
     _finishRead();
     return len;
   }
 
   void _close() {
-    _data = [];
+    _data = const [];
     _position = 0;
     _filePosition = 0;
     _fileLength = 0;
     _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;
 }