Format all dart: library files

sdk/lib/async/stream_transformers.dart

Index: sdk/lib/async/stream_transformers.dart
diff --git a/sdk/lib/async/stream_transformers.dart b/sdk/lib/async/stream_transformers.dart
index fa32bc48974adc90185de85286fb6b02192569cb..c4cbf04332b7403cb7b1fd6d0964b0b02bf7951f 100644
--- a/sdk/lib/async/stream_transformers.dart
+++ b/sdk/lib/async/stream_transformers.dart
@@ -11,11 +11,17 @@ class _EventSinkWrapper<T> implements EventSink<T> {
   _EventSink _sink;
   _EventSinkWrapper(this._sink);
 
-  void add(T data) { _sink._add(data); }
+  void add(T data) {
+    _sink._add(data);
+  }
+
   void addError(error, [StackTrace stackTrace]) {
     _sink._addError(error, stackTrace);
   }
-  void close() { _sink._close(); }
+
+  void close() {
+    _sink._close();
+  }
 }
 
 /**
@@ -33,19 +39,14 @@ class _SinkTransformerStreamSubscription<S, T>
   /// The subscription to the input stream.
   StreamSubscription<S> _subscription;
 
-  _SinkTransformerStreamSubscription(Stream<S> source,
-                                     _SinkMapper<S, T> mapper,
-                                     void onData(T data),
-                                     Function onError,
-                                     void onDone(),
-                                     bool cancelOnError)
+  _SinkTransformerStreamSubscription(Stream<S> source, _SinkMapper<S, T> mapper,
+      void onData(T data), Function onError, void onDone(), bool cancelOnError)
       // We set the adapter's target only when the user is allowed to send data.
       : super(onData, onError, onDone, cancelOnError) {
     _EventSinkWrapper<T> eventSink = new _EventSinkWrapper<T>(this);
     _transformerSink = mapper(eventSink);
-    _subscription = source.listen(_handleData,
-                                  onError: _handleError,
-                                  onDone: _handleDone);
+    _subscription =
+        source.listen(_handleData, onError: _handleError, onDone: _handleDone);
   }
 
   /** Whether this subscription is still subscribed to its source. */
@@ -144,7 +145,6 @@ class _SinkTransformerStreamSubscription<S, T>
   }
 }
 
-
 typedef EventSink<S> _SinkMapper<S, T>(EventSink<T> output);
 
 /**
@@ -159,8 +159,8 @@ class _StreamSinkTransformer<S, T> implements StreamTransformer<S, T> {
   final _SinkMapper<S, T> _sinkMapper;
   const _StreamSinkTransformer(this._sinkMapper);
 
-  Stream<T> bind(Stream<S> stream)
-      => new _BoundSinkStream<S, T>(stream, _sinkMapper);
+  Stream<T> bind(Stream<S> stream) =>
+      new _BoundSinkStream<S, T>(stream, _sinkMapper);
 }
 
 /**
@@ -179,9 +179,7 @@ class _BoundSinkStream<S, T> extends Stream<T> {
   _BoundSinkStream(this._stream, this._sinkMapper);
 
   StreamSubscription<T> listen(void onData(T event),
-                               { Function onError,
-                                 void onDone(),
-                                 bool cancelOnError }) {
+      {Function onError, void onDone(), bool cancelOnError}) {
     cancelOnError = identical(true, cancelOnError);
     StreamSubscription<T> subscription =
         new _SinkTransformerStreamSubscription<S, T>(
@@ -192,9 +190,11 @@ class _BoundSinkStream<S, T> extends Stream<T> {
 
 /// Data-handler coming from [StreamTransformer.fromHandlers].
 typedef void _TransformDataHandler<S, T>(S data, EventSink<T> sink);
+
 /// Error-handler coming from [StreamTransformer.fromHandlers].
 typedef void _TransformErrorHandler<T>(
     Object error, StackTrace stackTrace, EventSink<T> sink);
+
 /// Done-handler coming from [StreamTransformer.fromHandlers].
 typedef void _TransformDoneHandler<T>(EventSink<T> sink);
 
@@ -211,14 +211,20 @@ class _HandlerEventSink<S, T> implements EventSink<S> {
   /// The output sink where the handlers should send their data into.
   final EventSink<T> _sink;
 
-  _HandlerEventSink(this._handleData, this._handleError, this._handleDone,
-                    this._sink);
+  _HandlerEventSink(
+      this._handleData, this._handleError, this._handleDone, this._sink);
+
+  void add(S data) {
+    _handleData(data, _sink);
+  }
 
-  void add(S data) { _handleData(data, _sink); }
   void addError(Object error, [StackTrace stackTrace]) {
     _handleError(error, stackTrace, _sink);
   }
-  void close() { _handleDone(_sink); }
+
+  void close() {
+    _handleDone(_sink);
+  }
 }
 
 /**
@@ -227,9 +233,8 @@ class _HandlerEventSink<S, T> implements EventSink<S> {
  * 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),
+  _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) {
@@ -250,8 +255,8 @@ class _StreamHandlerTransformer<S, T> extends _StreamSinkTransformer<S, T> {
   }
 
   /** Default error handler forwards all errors. */
-  static void _defaultHandleError(error, StackTrace stackTrace,
-                                  EventSink sink) {
+  static void _defaultHandleError(
+      error, StackTrace stackTrace, EventSink sink) {
     sink.addError(error, stackTrace);
   }
 
@@ -300,9 +305,7 @@ class _BoundSubscriptionStream<S, T> extends Stream<T> {
   _BoundSubscriptionStream(this._stream, this._transformer);
 
   StreamSubscription<T> listen(void onData(T event),
-                               { Function onError,
-                                 void onDone(),
-                                 bool cancelOnError }) {
+      {Function onError, void onDone(), bool cancelOnError}) {
     cancelOnError = identical(true, cancelOnError);
     StreamSubscription<T> result = _transformer(_stream, cancelOnError);
     result.onData(onData);