Fix a synchrony bug in barback.

pkg/barback/lib/src/asset_node.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.
 
 library barback.asset_node;
 
 import 'dart:async';
 
 import 'asset.dart';
 import 'asset_id.dart';
@@ skipping 44 matching lines @@
   /// or removed, the appropriate portion of the asset graph is dirtied before
   /// any [Barback.getAssetById] calls emit newly-incorrect values.
   Stream<AssetState> get onStateChange => _stateChangeController.stream;
 
   /// This is synchronous so that a source being updated will always be
   /// propagated through the build graph before anything that depends on it is
   /// requested.
   final _stateChangeController =
       new StreamController<AssetState>.broadcast(sync: true);
 
-  /// Returns a Future that completes when the node's asset is available.
+  /// Calls [callback] when the node's asset is available.
   ///
-  /// If the asset is currently available, this completes synchronously to
-  /// ensure that the asset is still available in the [Future.then] callback.
+  /// If the asset is currently available, this calls [callback] synchronously
+  /// to ensure that the asset is still available.
   ///
-  /// If the asset is removed before becoming available, this will throw an
-  /// [AssetNotFoundException].
-  Future<Asset> get whenAvailable {
-    return _waitForState((state) => state.isAvailable || state.isRemoved)
-        .then((state) {
+  /// The return value of [callback] is piped to the returned Future. If the
+  /// asset is removed before becoming available, the returned future will throw
+  /// an [AssetNotFoundException].
+  Future whenAvailable(callback(Asset asset)) {
+    return _waitForState((state) => state.isAvailable || state.isRemoved,
+        (state) {
       if (state.isRemoved) throw new AssetNotFoundException(id);
-      return asset;
+      return callback(asset);
     });
   }
 
-  /// Returns a Future that completes when the node's asset is removed.
+  /// Calls [callback] when the node's asset is removed.
   ///
-  /// If the asset is already removed when this is called, it completes
+  /// If the asset is already removed when this is called, it calls [callback]
   /// synchronously.
-  Future get whenRemoved => _waitForState((state) => state.isRemoved);
+  ///
+  /// The return value of [callback] is piped to the returned Future.
+  Future whenRemoved(callback()) =>
+    _waitForState((state) => state.isRemoved, (_) => callback());
 
   /// Runs [callback] repeatedly until the node's asset has maintained the same
   /// value for the duration.
   ///
   /// This will run [callback] as soon as the asset is available (synchronously
   /// if it's available immediately). If the [state] changes at all while
   /// waiting for the Future returned by [callback] to complete, it will be
   /// re-run as soon as it completes and the asset is available again. This will
   /// continue until [state] doesn't change at all.
   ///
   /// If this asset is removed, this will throw an [AssetNotFoundException] as
   /// soon as [callback]'s Future is finished running.
   Future tryUntilStable(Future callback(Asset asset)) {
-    return whenAvailable.then((asset) {
+    return whenAvailable((asset) {
       var modifiedDuringCallback = false;
       var subscription;
       subscription = onStateChange.listen((_) {
         modifiedDuringCallback = true;
         subscription.cancel();
       });
 
       return callback(asset).then((result) {
         subscription.cancel();
 
         // If the asset was modified at all while running the callback, the
         // result was invalid and we should try again.
         if (modifiedDuringCallback) return tryUntilStable(callback);
         return result;
       });
     });
   }
 
-  /// Returns a Future that completes as soon as the node is in a state that
-  /// matches [test].
+  /// Calls [callback] as soon as the node is in a state that matches [test].
   ///
-  /// The Future completes synchronously if this is already in such a state.
-  Future<AssetState> _waitForState(bool test(AssetState state)) {
-    if (test(state)) return new Future.sync(() => state);
-    return onStateChange.firstWhere(test);
+  /// [callback] is called synchronously if this is already in such a state.
+  ///
+  /// The return value of [callback] is piped to the returned Future.
+  Future _waitForState(bool test(AssetState state),
+      callback(AssetState state)) {
+    if (test(state)) return new Future.sync(() => callback(state));
+    return onStateChange.firstWhere(test).then((_) => callback(state));
   }
 
   AssetNode._(this.id, this._transform, this._origin)
       : _state = AssetState.DIRTY;
 
   AssetNode._available(Asset asset, this._transform, this._origin)
       : id = asset.id,
         _asset = asset,
         _state = AssetState.AVAILABLE;
 }
@@ skipping 84 matching lines @@
 
   /// Whether this state is [AssetState.DIRTY].
   bool get isDirty => this == AssetState.DIRTY;
 
   final String name;
 
   const AssetState._(this.name);
 
   String toString() => name;
 }