More minor type improvements in dart:async.

sdk/lib/async/stream_transformers.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.async;
 
 /**
  * Wraps an [_EventSink] so it exposes only the [EventSink] interface.
  */
 class _EventSinkWrapper<T> implements EventSink<T> {
@@ skipping 197 matching lines @@
   final _TransformErrorHandler<T> _handleError;
   final _TransformDoneHandler<T> _handleDone;
 
   /// The output sink where the handlers should send their data into.
   final EventSink<T> _sink;
 
   _HandlerEventSink(
       this._handleData, this._handleError, this._handleDone, this._sink);
 
   void add(S data) {
-    _handleData(data, _sink);
+    if (_handleData != null) {
+      _handleData(data, _sink);
+    } else {
+      _sink.add(data as T);
+    }
   }
 
   void addError(Object error, [StackTrace stackTrace]) {
-    _handleError(error, stackTrace, _sink);
+    if (_handleError != null) {
+      _handleError(error, stackTrace, _sink);
+    } else {
+      _sink.addError(error, stackTrace);
+    }
   }
 
   void close() {
-    _handleDone(_sink);
+    if (_handleDone != null) {
+      _handleDone(_sink);
+    } else {
+      _sink.close();
+    }
   }
 }
 
 /**
  * A StreamTransformer that transformers events with the given handlers.
  *
  * Note that this transformer can only be used once.
  */
 class _StreamHandlerTransformer<S, T> extends _StreamSinkTransformer<S, T> {
   _StreamHandlerTransformer(
       {void handleData(S data, EventSink<T> sink),
       void handleError(Object error, StackTrace stackTrace, EventSink<T> sink),
       void handleDone(EventSink<T> sink)})
       : super((EventSink<T> outputSink) {
-          if (handleData == null) handleData = _defaultHandleData;
-          if (handleError == null) handleError = _defaultHandleError;
-          if (handleDone == null) handleDone = _defaultHandleDone;
           return new _HandlerEventSink<S, T>(
               handleData, handleError, handleDone, outputSink);
         });
 
   Stream<T> bind(Stream<S> stream) {
     return super.bind(stream);
   }
-
-  /** Default data handler forwards all data. */
-  static void _defaultHandleData(var data, EventSink sink) {
-    sink.add(data);
-  }
-
-  /** Default error handler forwards all errors. */
-  static void _defaultHandleError(
-      error, StackTrace stackTrace, EventSink sink) {
-    sink.addError(error, stackTrace);
-  }
-
-  /** Default done handler forwards done. */
-  static void _defaultHandleDone(EventSink sink) {
-    sink.close();
-  }
 }
 
 /// A closure mapping a stream and cancelOnError to a StreamSubscription.
 typedef StreamSubscription<T> _SubscriptionTransformer<S, T>(
     Stream<S> stream, bool cancelOnError);
 
 /**
  * A [StreamTransformer] that minimizes the number of additional classes.
  *
  * Instead of implementing three classes: a [StreamTransformer], a [Stream]
@@ skipping 30 matching lines @@
   StreamSubscription<T> listen(void onData(T event),
       {Function onError, void onDone(), bool cancelOnError}) {
     cancelOnError = identical(true, cancelOnError);
     StreamSubscription<T> result = _transformer(_stream, cancelOnError);
     result.onData(onData);
     result.onError(onError);
     result.onDone(onDone);
     return result;
   }
 }