Do error propagation for decoder errors in string stream.

lib/io/string_stream.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.
 
 // Interface for decoders decoding binary data into string data. The
 // decoder keeps track of line breaks during decoding.
 abstract class _StringDecoder {
   // Add more binary data to be decoded. The ownership of the buffer
   // is transfered to the decoder and the caller most not modify it any more.
   int write(List<int> buffer);
@@ skipping 12 matching lines @@
   // call to [decode] or [decodeLine]. Returns null if no decoded data
   // is available. If [len] is not specified all decoded characters
   // are returned.
   String decoded([int len]);
 
   // Get the string data decoded since the last call to [decode] or
   // [decodeLine] up to the next line break present. Returns null if
   // no line break is present. The line break character sequence is
   // discarded.
   String get decodedLine;
+
+  // Set the handler that will be called if an error ocurs while decoding.
+  void set onError(Function callback);
 }
 
 
 class _StringDecoders {
   static _StringDecoder decoder(Encoding encoding) {
     if (encoding == Encoding.UTF_8) {
       return new _UTF8Decoder();
     } else if (encoding == Encoding.ISO_8859_1) {
       return new _Latin1Decoder();
     } else if (encoding == Encoding.ASCII) {
@@ skipping 116 matching lines @@
   _BufferList _bufferList;
   int _resultOffset = 0;
   List<int> _result;
   int _lineBreaks = 0;  // Number of line breaks in the current list.
   // The positions of the line breaks are tracked in terms of absolute
   // character positions from the begining of the decoded data.
   Queue<int> _lineBreakEnds;  // Character position of known line breaks.
   int _charOffset = 0;  // Character number of the first character in the list.
   int _charCount = 0;  // Total number of characters decoded.
   int _lastCharCode = -1;
+  Function onError;
 
   final int LF = 10;
   final int CR = 13;
 }
 
 
 // Utility class for decoding UTF-8 from data delivered as a stream of
 // bytes.
 class _UTF8Decoder extends _StringDecoderBase {
   // Process the next UTF-8 encoded character.
@@ skipping 35 matching lines @@
 
 
 // Utility class for decoding ascii data delivered as a stream of
 // bytes.
 class _AsciiDecoder extends _StringDecoderBase {
   // Process the next ascii encoded character.
   bool _processNext() {
     while (_bufferList.length > 0) {
       int byte = _bufferList.next();
       if (byte > 127) {
-        throw new DecoderException("Illegal ASCII character $byte");
+        var error = new DecoderException("Illegal ASCII character $byte");
+        if (onError != null) {
+          onError(error);
+          return false;
+        } else {
+          throw error;
+        }
       }
       addChar(byte);
     }
     return true;
   }
 }
 
 
 // Utility class for decoding Latin-1 data delivered as a stream of
 // bytes.
@@ skipping 167 matching lines @@
     _checkInstallDataHandler();
     _checkScheduleCallback();
   }
 
   void set onClosed(void callback()) {
     _clientCloseHandler = callback;
   }
 
   void set onError(void callback(e)) {
     _input.onError = callback;
+    _decoder.onError = (e) { 
+      _clientCloseHandler = null;
+      _input.close();
+      callback(e);
+    };
   }
 
   void _onData() {
     _readData();
     if (!_decoder.isEmpty && _clientDataHandler !== null) {
       _clientDataHandler();
     }
     if (_decoder.lineBreaks > 0 && _clientLineHandler !== null) {
       _clientLineHandler();
     }
     _checkScheduleCallback();
     _checkInstallDataHandler();
   }
 
   void _onClosed() {
     _inputClosed = true;
-    if (_decoder.isEmpty && _clientCloseHandler != null) {
+    if (_decoder.isEmpty && _clientCloseHandler !=  null) {
       _clientCloseHandler();
-      _closed = true;
     } else {
       _checkScheduleCallback();
     }
   }
 
   void _readData() {
     List<int> data = _input.read();
     if (data !== null) {
       _decoder.write(data);
     }
@@ skipping 82 matching lines @@
   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?
   Timer _scheduledDataCallback;
   Timer _scheduledLineCallback;
   Timer _scheduledCloseCallback;
   Function _clientDataHandler;
   Function _clientLineHandler;
   Function _clientCloseHandler;
 }