Redo StreamTransformers so they work with Stack traces.

pkg/utf/lib/utf_stream.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.utf;
 
 abstract class _StringDecoder
-    extends StreamEventTransformer<List<int>, String> {
+    implements StreamTransformer<List<int>, String>, EventSink<List<int>> {
   List<int> _carry;
   List<int> _buffer;
   int _replacementChar;
 
+  EventSink<String> _outSink;
+
   _StringDecoder(int this._replacementChar);
 
-  void handleData(List<int> bytes, EventSink<String> sink) {
+  Stream<String> bind(Stream<List<int>> stream) {
+    return new Stream.eventTransformed(
+        stream,
+        (EventSink<String> sink) {
+          if (_outSink != null) {
+            throw new StateError("String decoder already used");
+          }
+          _outSink = sink;
+          return this;
+        });
+  }
+
+  void add(List<int> bytes) {
     try {
       _buffer = <int>[];
       List<int> carry = _carry;
       _carry = null;
       int pos = 0;
       int available = bytes.length;
       // If we have carry-over data, start from negative index, indicating carry
       // index.
       int goodChars = 0;
       if (carry != null) pos = -carry.length;
@@ skipping 22 matching lines @@
           break;
         } else {
           // Invalid byte at position pos - 1
           _buffer.length = goodChars;
           _addChar(-1);
           goodChars = _buffer.length;
         }
       }
       if (_buffer.length > 0) {
         // Limit to 'goodChars', if lower than actual charCodes in the buffer.
-        sink.add(new String.fromCharCodes(_buffer));
+        _outSink.add(new String.fromCharCodes(_buffer));
       }
       _buffer = null;
-    } catch (e) {
-      sink.addError(e);
+    } catch (e, stackTrace) {
+      _outSink.addError(e, stackTrace);
     }
   }
 
-  void handleDone(EventSink<String> sink) {
+  void addError(Object error, [StackTrace stackTrace]) {
+    _outSink.addError(error, stackTrace);
+  }
+
+  void close() {
     if (_carry != null) {
       if (_replacementChar != null) {
-        sink.add(new String.fromCharCodes(
+        _outSink.add(new String.fromCharCodes(
             new List.filled(_carry.length, _replacementChar)));
       } else {
         throw new ArgumentError('Invalid codepoint');
       }
     }
-    sink.close();
+    _outSink.close();
   }
 
   int _processBytes(int getNext());
 
   void _addChar(int char) {
     void error() {
       if (_replacementChar != null) {
         char = _replacementChar;
       } else {
         throw new ArgumentError('Invalid codepoint');
@@ skipping 57 matching lines @@
       _addChar(value);
       return 1 + additionalBytes;
     }
     _addChar(value);
     return 1;
   }
 }
 
 
 abstract class _StringEncoder
-    extends StreamEventTransformer<String, List<int>> {
+    implements StreamTransformer<String, List<int>>, EventSink<String> {
 
-  void handleData(String data, EventSink<List<int>> sink) {
-    sink.add(_processString(data));
+  EventSink<List<int>> _outSink;
+
+  Stream<List<int>> bind(Stream<String> stream) {
+    return new Stream.eventTransformed(
+        stream,
+        (EventSink<List<int>> sink) {
+          if (_outSink != null) {
+            throw new StateError("String encoder already used");
+          }
+          _outSink = sink;
+          return this;
+        });
   }
 
+  void add(String data) {
+    _outSink.add(_processString(data));
+  }
+
+  void addError(Object error, [StackTrace stackTrace]) {
+    _outSink.addError(error, stackTrace);
+  }
+
+  void close() { _outSink.close(); }
+
   List<int> _processString(String string);
 }
 
 /**
  * StringTransformer that UTF-8 encodes a stream of strings.
  */
 class Utf8EncoderTransformer extends _StringEncoder {
   List<int> _processString(String string) {
     var bytes = [];
     int pos = 0;
@@ skipping 20 matching lines @@
       }
       for (int i = additionalBytes; i > 0; i--) {
         // 10xxxxxx (xxxxxx is next 6 bits from the top).
         bytes.add(((charCode >> (6 * (i - 1))) & 0x3F) | 0x80);
       }
       pos += additionalBytes + 1;
     }
     return bytes;
   }
 }