Redo StreamTransformers so they work with Stack traces.

sdk/lib/async/stream_pipe.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.
 
 part of dart.async;
 
 /**
  * Utility function to attach a stack trace to an [error]  if it doesn't have
  * one already.
  */
@@ skipping 386 matching lines @@
         sink._addError(_asyncError(e, s), s);
         return null;
       }
       if (!isEqual) {
         sink._add(inputEvent);
         _previous = inputEvent;
       }
     }
   }
 }
-
-// Stream transformations and event transformations.
-
-typedef void _TransformDataHandler<S, T>(S data, EventSink<T> sink);
-typedef void _TransformErrorHandler<T>(Object error, EventSink<T> sink);
-typedef void _TransformDoneHandler<T>(EventSink<T> sink);
-
-/** Default data handler forwards all data. */
-void _defaultHandleData(var data, EventSink sink) {
-  sink.add(data);
-}
-
-/** Default error handler forwards all errors. */
-void _defaultHandleError(error, EventSink sink) {
-  sink.addError(error);
-}
-
-/** Default done handler forwards done. */
-void _defaultHandleDone(EventSink sink) {
-  sink.close();
-}
-
-
-/**
- * A [StreamTransformer] that modifies stream events.
- *
- * This class is used by [StreamTransformer]'s factory constructor.
- * It is actually an [StreamEventTransformer] where the functions used to
- * modify the events are passed as constructor arguments.
- *
- * If an argument is omitted, it acts as the default method from
- * [StreamEventTransformer].
- */
-class _StreamTransformerImpl<S, T> extends StreamEventTransformer<S, T> {
-  final _TransformDataHandler<S, T> _handleData;
-  final _TransformErrorHandler<T> _handleError;
-  final _TransformDoneHandler<T> _handleDone;
-
-  _StreamTransformerImpl(void handleData(S data, EventSink<T> sink),
-                         void handleError(data, EventSink<T> sink),
-                         void handleDone(EventSink<T> sink))
-      : this._handleData  = (handleData == null  ? _defaultHandleData
-                                                 : handleData),
-        this._handleError = (handleError == null ? _defaultHandleError
-                                                 : handleError),
-        this._handleDone  = (handleDone == null  ? _defaultHandleDone
-                                                 : handleDone);
-
-  void handleData(S data, EventSink<T> sink) {
-    _handleData(data, sink);
-  }
-
-  void handleError(error, EventSink<T> sink) {
-    _handleError(error, sink);
-  }
-
-  void handleDone(EventSink<T> sink) {
-    _handleDone(sink);
-  }
-}
-