Update charted to 0.4.8 and roll

packages/quiver/lib/testing/src/async/fake_async.dart

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 21 matching lines @@
 ///     test('testedFunc', () {
 ///       new FakeAsync().run((async) {
 ///         testedFunc(clock: async.getClock(initialTime));
 ///         async.elapse(duration);
 ///         expect(...)
 ///       });
 ///     });
 abstract class FakeAsync {
   factory FakeAsync() = _FakeAsync;
 
-  FakeAsync._();
-
   /// Returns a fake [Clock] whose time can is elapsed by calls to [elapse] and
   /// [elapseBlocking].
   ///
   /// The returned clock starts at [initialTime], and calls to [elapse] and
   /// [elapseBlocking] advance the clock, even if they occured before the call
   /// to this method.
   ///
   /// The clock can be passed as a dependency to the unit under test.
   Clock getClock(DateTime initialTime);
 
@@ skipping 28 matching lines @@
   /// If [duration] is negative, throws an [ArgumentError].
   void elapseBlocking(Duration duration);
 
   /// Runs [callback] in a [Zone] with fake timer and microtask scheduling.
   ///
   /// Uses
   /// [ZoneSpecification.createTimer], [ZoneSpecification.createPeriodicTimer],
   /// and [ZoneSpecification.scheduleMicrotask] to store callbacks for later
   /// execution within the zone via calls to [elapse].
   ///
-  /// [callback] is called with `this` as argument.
-  run(callback(FakeAsync self));
+  /// Calls [callback] with `this` as argument and returns the result returned
+  /// by [callback].
+  dynamic run(callback(FakeAsync self));
 
   /// Runs all remaining microtasks, including those scheduled as a result of
   /// running them, until there are no more microtasks scheduled.
   ///
   /// Does not run timers.
   void flushMicrotasks();
 
   /// Runs all timers until no timers remain (subject to [flushPeriodicTimers]
   /// option), including those scheduled as a result of running them.
   ///
   /// [timeout] lets you set the maximum amount of time the flushing will take.
   /// Throws a [StateError] if the [timeout] is exceeded. The default timeout
   /// is 1 hour. [timeout] is relative to the elapsed time.
-  void flushTimers({Duration timeout: const Duration(hours: 1),
+  void flushTimers(
+      {Duration timeout: const Duration(hours: 1),
       bool flushPeriodicTimers: true});
 
   /// The number of created periodic timers that have not been canceled.
   int get periodicTimerCount;
 
   /// The number of pending non periodic timers that have not been canceled.
   int get nonPeriodicTimerCount;
 
   /// The number of pending microtasks.
   int get microtaskCount;
 }
 
-class _FakeAsync extends FakeAsync {
+class _FakeAsync implements FakeAsync {
   Duration _elapsed = Duration.ZERO;
   Duration _elapsingTo;
   Queue<Function> _microtasks = new Queue();
   Set<_FakeTimer> _timers = new Set<_FakeTimer>();
 
-  _FakeAsync() : super._() {
-    _elapsed;
-  }
-
   @override
   Clock getClock(DateTime initialTime) =>
       new Clock(() => initialTime.add(_elapsed));
 
   @override
   void elapse(Duration duration) {
     if (duration.inMicroseconds < 0) {
       throw new ArgumentError('Cannot call elapse with negative duration');
     }
     if (_elapsingTo != null) {
@@ skipping 15 matching lines @@
       _elapsingTo = _elapsed;
     }
   }
 
   @override
   void flushMicrotasks() {
     _drainMicrotasks();
   }
 
   @override
-  void flushTimers({Duration timeout: const Duration(hours: 1),
+  void flushTimers(
+      {Duration timeout: const Duration(hours: 1),
       bool flushPeriodicTimers: true}) {
     final absoluteTimeout = _elapsed + timeout;
     _drainTimersWhile((_FakeTimer timer) {
       if (timer._nextCall > absoluteTimeout) {
         throw new StateError(
             'Exceeded timeout ${timeout} while flushing timers');
       }
       if (flushPeriodicTimers) {
         return _timers.isNotEmpty;
       } else {
         // translation: keep draining while non-periodic timers exist
         return _timers.any((_FakeTimer timer) => !timer._isPeriodic);
       }
     });
   }
 
   @override
   run(callback(FakeAsync self)) {
     if (_zone == null) {
       _zone = Zone.current.fork(specification: _zoneSpec);
     }
     return _zone.runGuarded(() => callback(this));
   }
+
   Zone _zone;
 
   @override
   int get periodicTimerCount =>
       _timers.where((_FakeTimer timer) => timer._isPeriodic).length;
 
   @override
   int get nonPeriodicTimerCount =>
       _timers.where((_FakeTimer timer) => !timer._isPeriodic).length;
 
   @override
   int get microtaskCount => _microtasks.length;
 
   ZoneSpecification get _zoneSpec => new ZoneSpecification(
-      createTimer: (_, __, ___, Duration duration, Function callback) {
-    return _createTimer(duration, callback, false);
-  }, createPeriodicTimer: (_, __, ___, Duration duration, Function callback) {
-    return _createTimer(duration, callback, true);
-  }, scheduleMicrotask: (_, __, ___, Function microtask) {
-    _microtasks.add(microtask);
-  });
+          createTimer: (_, __, ___, Duration duration, Function callback) {
+        return _createTimer(duration, callback, false);
+      }, createPeriodicTimer:
+              (_, __, ___, Duration duration, Function callback) {
+        return _createTimer(duration, callback, true);
+      }, scheduleMicrotask: (_, __, ___, Function microtask) {
+        _microtasks.add(microtask);
+      });
 
   _drainTimersWhile(bool predicate(_FakeTimer)) {
     _drainMicrotasks();
     _FakeTimer next;
     while ((next = _getNextTimer()) != null && predicate(next)) {
       _runTimer(next);
       _drainMicrotasks();
     }
   }
 
@@ skipping 14 matching lines @@
         (timer1, timer2) => timer1._nextCall.compareTo(timer2._nextCall));
   }
 
   _runTimer(_FakeTimer timer) {
     assert(timer.isActive);
     _elapseTo(timer._nextCall);
     if (timer._isPeriodic) {
       timer._callback(timer);
       timer._nextCall += timer._duration;
     } else {
+      _timers.remove(timer);
       timer._callback();
-      _timers.remove(timer);
     }
   }
 
   _drainMicrotasks() {
     while (_microtasks.isNotEmpty) {
       _microtasks.removeFirst()();
     }
   }
 
   _hasTimer(_FakeTimer timer) => _timers.contains(timer);
@@ skipping 17 matching lines @@
 
   _FakeTimer._(Duration duration, this._callback, this._isPeriodic, this._time)
       : _duration = duration < _minDuration ? _minDuration : duration {
     _nextCall = _time._elapsed + _duration;
   }
 
   bool get isActive => _time._hasTimer(this);
 
   cancel() => _time._cancelTimer(this);
 }