Update charted to 0.4.8 and roll

packages/async/lib/src/stream_splitter.dart

 // Copyright (c) 2015, 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.
 
-library async.stream_splitter;
+import 'dart:async';
 
-import 'dart:async';
-import 'dart:collection';
-
-import '../result.dart';
 import 'future_group.dart';
+import 'result.dart';
 
 /// A class that splits a single source stream into an arbitrary number of
 /// (single-subscription) streams (called "branch") that emit the same events.
 ///
 /// Each branch will emit all the same values and errors as the source stream,
 /// regardless of which values have been emitted on other branches. This means
 /// that the splitter stores every event that has been emitted so far, which may
 /// consume a lot of memory. The user can call [close] to indicate that no more
 /// branches will be created, and this memory will be released.
 ///
@@ skipping 31 matching lines @@
   /// Whether [_stream] is done emitting events.
   var _isDone = false;
 
   /// Whether [close] has been called.
   var _isClosed = false;
 
   /// Splits [stream] into [count] identical streams.
   ///
   /// [count] defaults to 2. This is the same as creating [count] branches and
   /// then closing the [StreamSplitter].
-  static List<Stream> splitFrom(Stream stream, [int count]) {
+  static List<Stream<T>> splitFrom<T>(Stream<T> stream, [int count]) {
     if (count == null) count = 2;
-    var splitter = new StreamSplitter(stream);
-    var streams = new List.generate(count, (_) => splitter.split());
+    var splitter = new StreamSplitter<T>(stream);
+    var streams = new List<Stream>.generate(count, (_) => splitter.split());
     splitter.close();
     return streams;
   }
 
   StreamSplitter(this._stream);
 
   /// Returns a single-subscription stream that's a copy of the input stream.
   ///
   /// This will throw a [StateError] if [close] has been called.
   Stream<T> split() {
     if (_isClosed) {
       throw new StateError("Can't call split() on a closed StreamSplitter.");
     }
 
-    var controller;
-    controller = new StreamController<T>(
-        onListen: _onListen,
-        onPause: _onPause,
-        onResume: _onResume,
-        onCancel: () => _onCancel(controller));
+    var controller = new StreamController<T>(
+        onListen: _onListen, onPause: _onPause, onResume: _onResume);
+    controller.onCancel = () => _onCancel(controller);
 
     for (var result in _buffer) {
       result.addTo(controller);
     }
 
     if (_isDone) {
       _closeGroup.add(controller.close());
     } else {
       _controllers.add(controller);
     }
@@ skipping 46 matching lines @@
   /// subscription if we have.
   void _onListen() {
     if (_isDone) return;
 
     if (_subscription != null) {
       // Resume the subscription in case it was paused, either because all the
       // controllers were paused or because the last one was canceled. If it
       // wasn't paused, this will be a no-op.
       _subscription.resume();
     } else {
-      _subscription = _stream.listen(
-          _onData, onError: _onError, onDone: _onDone);
+      _subscription =
+          _stream.listen(_onData, onError: _onError, onDone: _onDone);
     }
   }
 
   /// Pauses [_subscription] if every controller is paused.
   void _onPause() {
     if (!_controllers.every((controller) => controller.isPaused)) return;
     _subscription.pause();
   }
 
   /// Resumes [_subscription].
@@ skipping 39 matching lines @@
   }
 
   /// Marks [_controllers] as done.
   void _onDone() {
     _isDone = true;
     for (var controller in _controllers) {
       _closeGroup.add(controller.close());
     }
   }
 }