Move Barback to a more thoroughly push-based model.

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 78 matching lines @@
 
   /// Calls [callback] when the node's asset is removed.
   ///
   /// If the asset is already removed when this is called, it calls [callback]
   /// synchronously.
   ///
   /// 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.
+  /// Returns a [Future] that completes when [state] changes from its current
+  /// value to any other value.
   ///
-  /// 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((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;
-      });
-    });
+  /// The returned [Future] will contain the new state.
+  Future<AssetState> whenStateChanges() {
+    var startState = state;
+    return _waitForState((state) => state != startState, (state) => state);
   }
 
   /// Calls [callback] as soon as the node is in a state that matches [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 syncFuture(() => callback(state));
@@ skipping 149 matching lines @@
 
   /// Whether this state is [AssetState.DIRTY].
   bool get isDirty => this == AssetState.DIRTY;
 
   final String name;
 
   const AssetState._(this.name);
 
   String toString() => name;
 }