Don't call read, if last read returned less bytes than was being read.

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;
 
 
 class _FileStream extends Stream<List<int>> {
   // Stream controller.
   StreamController<List<int>> _controller;
 
   // Information about the underlying file.
   String _path;
   RandomAccessFile _openedFile;
   int _position;
   int _end;
   final Completer _closeCompleter = new Completer();
 
   // Has the stream been paused or unsubscribed?
-  bool _paused = false;
   bool _unsubscribed = false;
 
   // Is there a read currently in progress?
-  bool _readInProgress = false;
+  bool _readInProgress = true;
   bool _closed = false;
 
-  // Block read but not yet send because stream is paused.
-  List<int> _currentBlock;
+  bool _atEnd = false;
 
   _FileStream(this._path, this._position, this._end) {
-    _setupController();
+    if (_position == null) _position = 0;
   }
 
-  _FileStream.forStdin() : _position = 0 {
-    _setupController();
-  }
+  _FileStream.forStdin() : _position = 0;
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
+    _setupController();
     return _controller.stream.listen(onData,
                                      onError: onError,
                                      onDone: onDone,
                                      cancelOnError: cancelOnError);
   }
 
   void _setupController() {
     _controller = new StreamController<List<int>>(sync: true,
         onListen: _start,
-        onPause: () => _paused = true,
-        onResume: _resume,
+        onResume: _readBlock,
         onCancel: () {
           _unsubscribed = true;
           return _closeFile();
         });
   }
 
   Future _closeFile() {
     if (_readInProgress || _closed) {
       return _closeCompleter.future;
     }
     _closed = true;
+
     void done() {
       _closeCompleter.complete();
       _controller.close();
     }
-    if (_openedFile != null) {
-      _openedFile.close()
-          .catchError(_controller.addError)
-          .whenComplete(done);
-      _openedFile = null;
-    } else {
-      done();
-    }
+
+    _openedFile.close()
+        .catchError(_controller.addError)
+        .whenComplete(done);
     return _closeCompleter.future;
   }
 
   void _readBlock() {
     // Don't start a new read if one is already in progress.
     if (_readInProgress) return;
+    if (_atEnd) {
+      _closeFile();
+      return;
+    }
     _readInProgress = true;
     int readBytes = _BLOCK_SIZE;
     if (_end != null) {
       readBytes = min(readBytes, _end - _position);
       if (readBytes < 0) {
         _readInProgress = false;
         if (!_unsubscribed) {
           _controller.addError(new RangeError("Bad end position: $_end"));
           _closeFile();
           _unsubscribed = true;
         }
         return;
       }
     }
     _openedFile.read(readBytes)
-      .whenComplete(() {
-        _readInProgress = false;
-      })
       .then((block) {
         if (_unsubscribed) {
           _closeFile();
           return;
         }
-        if (block.length == 0) {
-          if (!_unsubscribed) {
-            _closeFile();
-            _unsubscribed = true;
-          }
-          return;
+        _readInProgress = false;
+        _position += block.length;
+        if (block.length < readBytes ||
+            (_end != null && _position == _end)) {
+          _atEnd = true;
         }
-        _position += block.length;
-        if (_paused) {
-          _currentBlock = block;
-        } else {
-          _controller.add(block);
+        _controller.add(block);
+        if (!_controller.isPaused) {
           _readBlock();
         }
       })
-      .catchError((e) {
+      .catchError((e, s) {
         if (!_unsubscribed) {
-          _controller.addError(e);
+          _controller.addError(e, s);
           _closeFile();
           _unsubscribed = true;
         }
       });
   }
 
   void _start() {
-    if (_position == null) {
-      _position = 0;
-    } else if (_position < 0) {
+    if (_position < 0) {
       _controller.addError(new RangeError("Bad start position: $_position"));
       _controller.close();
       return;
     }
-    Future<RandomAccessFile> openFuture;
+
+    void onReady(RandomAccessFile file) {
+      _openedFile = file;
+      _readInProgress = false;
+      _readBlock();
+    }
+
+    void onOpenFile(RandomAccessFile file) {
+      if (_position > 0) {
+        file.setPosition(_position)
+            .then(onReady, onError: (e, s) {
+              _controller.addError(e, s);
+              _readInProgress = false;
+              _closeFile();
+            });
+      } else {
+        onReady(file);
+      }
+    }
+
+    void openFailed(error, stackTrace) {
+      _controller.addError(error, stackTrace);
+      _controller.close();
+      _closeCompleter.complete();
+    }
+
     if (_path != null) {
-      openFuture = new File(_path).open(mode: FileMode.READ);
+      new File(_path).open(mode: FileMode.READ)
+          .then(onOpenFile, onError: openFailed);
     } else {
-      openFuture = new Future.value(_File._openStdioSync(0));
+      try {
+        onOpenFile(_File._openStdioSync(0));
+      } catch (e, s) {
+        openFailed(e, s);
+      }
     }
-    _readInProgress = true;
-    openFuture
-      .then((RandomAccessFile opened) {
-        _openedFile = opened;
-        if (_position > 0) {
-          return opened.setPosition(_position);
-        }
-      })
-      .whenComplete(() {
-        _readInProgress = false;
-      })
-      .then((_) => _readBlock())
-      .catchError((e) {
-        _controller.addError(e);
-        _closeFile();
-      });
-  }
-
-  void _resume() {
-    _paused = false;
-    if (_currentBlock != null) {
-      _controller.add(_currentBlock);
-      _currentBlock = null;
-    }
-    // Resume reading unless we are already done.
-    if (_openedFile != null) _readBlock();
   }
 }
 
 class _FileStreamConsumer extends StreamConsumer<List<int>> {
   File _file;
   Future<RandomAccessFile> _openFuture;
 
   _FileStreamConsumer(File this._file, FileMode mode) {
     _openFuture = _file.open(mode: mode);
   }
@@ skipping 738 matching lines @@
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }