Change the handling of the close event in the StringInputStream

runtime/bin/string_stream.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.
 
 // Utility class which can deliver bytes one by one from a number of
 // buffers added.
 class _BufferList {
   _BufferList() : _index = 0, _length = 0, _buffers = new Queue();
 
   void add(List<int> buffer) {
@@ skipping 180 matching lines @@
     // If there is buffered data return that first.
     var decodedString = _decoder.decoded;
     if (_buffer !== null) {
       var result = _buffer;
       _resetBuffer();
       if (decodedString !== null) result += decodedString;
       return result;
     } else {
       if (decodedString !== null) {
         return decodedString;
+      } else if (_inputClosed) {
+        _streamClosed();
+        return null;
       } else {
         _readData();
         return _decoder.decoded;
       }
     }
   }
 
   String readLine() {
+    if (_closed) return null;
     // Get line from the buffer if possible.
     if (_buffer !== null) {
       var result = _readLineFromBuffer();
       if (result !== null) return result;
     }
     // Try to fill more data into the buffer and read a line.
     if (_fillBuffer()) {
-      if (_eof && _buffer === null) return null;
+      if (_eof && _buffer === null) {
+        _streamClosed();
+        return null;
+      }
       return _readLineFromBuffer();
     }
     return null;
   }
 
   String get encoding() => _encoding;
 
   bool get closed() => _closed;
 
   void set dataHandler(void callback()) {
     _clientDataHandler = callback;
   }
 
   void set closeHandler(void callback()) {
     _clientCloseHandler = callback;
   }
 
   void _dataHandler() {
     _readData();
     if (!_decoder.isEmpty() && _clientDataHandler !== null) {
       _clientDataHandler();
     }
   }
 
   void _closeHandler() {
-    _closed = true;
-    if (_clientDataHandler !== null) _clientDataHandler();
-    if (_clientCloseHandler !== null) _clientCloseHandler();
+    _inputClosed = true;
+    if (_buffer !== null || !_decoder.isEmpty()) {
+      // If there is still data buffered in either the buffer or the
+      // decoder call the data handler.
+      if (_clientDataHandler !== null) _clientDataHandler();
+    } else {
+      closed_ = true;
+      if (_clientCloseHandler !== null) _clientCloseHandler();
+    }
   }
 
   void _readData() {
     List<int> data = _input.read();
     if (data !== null) {
       _decoder.write(data);
     }
   }
 
   String _readLineFromBuffer() {
     // Both \n or \r indicates a new line. If \r is followed by \n the
     // \n is part of the line breaking character.
     for (int i = _bufferLineStart; i < _buffer.length; i++) {
       String char = _buffer[i];
       if (char == '\r') {
         if (i == _buffer.length - 1) {
           if (_eof) {
             var result = _buffer.substring(_bufferLineStart, i);
             _resetBuffer();
+            _streamClosed();
             return result;
           } else {
             return null;
           }
         }
         var result = _buffer.substring(_bufferLineStart, i);
         _bufferLineStart = i + 1;
         if (_buffer[_bufferLineStart] == '\n') _bufferLineStart++;
+        if (_bufferLineStart == _buffer.length) _resetBuffer();
         return result;
       } else if (char == '\n') {
         var result = _buffer.substring(_bufferLineStart, i);
         _bufferLineStart = i + 1;
+        if (_bufferLineStart == _buffer.length) _resetBuffer();
         return result;
       }
     }
     if (_eof) {
       var result = _buffer;
       _resetBuffer();
+      _streamClosed();
       return result;
     }
     return null;
   }
 
   void _resetBuffer() {
     _buffer = null;
     _bufferLineStart = null;
   }
 
   // Fill decoded data into the buffer. Returns true if more data was
   // added or end of file was reached.
   bool _fillBuffer() {
     if (_eof) return false;
-    if (_buffer !== null && _bufferLineStart == _buffer.length) {
-      _buffer = null;
-      _bufferLineStart = null;
-    }
-    _readData();
+    if (!_inputClosed) _readData();
     var decodedString = _decoder.decoded;
-    if (decodedString === null && _closed) {
+    if (decodedString === null && _inputClosed) {
       _eof = true;
       return true;
     }
     if (_buffer === null) {
       _buffer = decodedString;
       if (_buffer !== null) {
         _bufferLineStart = 0;
         return true;
       }
     } else if (decodedString !== null) {
       _buffer = _buffer.substring(_bufferLineStart) + decodedString;
       _bufferLineStart = 0;
       return true;
     }
     return false;
   }
 
+  void _streamClosed() {
+    _closed = true;
+
+    // TODO(sgjesse): Find a better way of scheduling callbacks from
+    // the event loop.
+    void issueCloseCallback(Timer timer) {
+      if (_clientCloseHandler !== null) _clientCloseHandler();
+    }
+    new Timer(issueCloseCallback, 0, false);
+  }
+
   InputStream _input;
   String _encoding;
   _Decoder _decoder;
   String _buffer;  // String can be buffered here if readLine is used.
   int _bufferLineStart;  // Current offset into _buffer if any.
-  bool _closed = false;
+  bool _inputClosed = false;  // Is the underlying input stream closed?
+  bool _closed = false;  // Is this stream closed.
   bool _eof = false;  // Has all data been read from the decoder?
   var _clientDataHandler;
   var _clientCloseHandler;
 }