Roll forward commits r33138, r33135, and r33134.

pkg/barback/lib/src/transform_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.transform_node;
 
 import 'dart:async';
 
 import 'package:source_maps/span.dart';
 
@@ skipping 47 matching lines @@
 
   /// Whether [transformer] is lazy and this transform has yet to be forced.
   bool _isLazy;
 
   /// The subscriptions to each input's [AssetNode.onStateChange] stream.
   var _inputSubscriptions = new Map<AssetId, StreamSubscription>();
 
   /// The controllers for the asset nodes emitted by this node.
   var _outputControllers = new Map<AssetId, AssetNodeController>();
 
-  /// A stream that emits an event whenever [this] is no longer dirty.
+  // TODO(nweiz): It's weird that this is different than the [onDone] stream the
+  // other nodes emit. See if we can make that more consistent.
+  /// A stream that emits an event whenever [onDirty] changes its value.
   ///
   /// This is synchronous in order to guarantee that it will emit an event as
-  /// soon as [isDirty] flips from `true` to `false`.
-  Stream get onDone => _onDoneController.stream;
-  final _onDoneController = new StreamController.broadcast(sync: true);
+  /// soon as [isDirty] changes. It's possible for this to emit multiple events
+  /// while [isDirty] is `true`. However, it will only emit a single event each
+  /// time [isDirty] becomes `false`.
+  Stream get onStateChange => _onStateChangeController.stream;
+  final _onStateChangeController = new StreamController.broadcast(sync: true);
 
   /// A stream that emits any new assets emitted by [this].
   ///
   /// Assets are emitted synchronously to ensure that any changes are thoroughly
   /// propagated as soon as they occur.
   Stream<AssetNode> get onAsset => _onAssetController.stream;
   final _onAssetController = new StreamController<AssetNode>(sync: true);
 
   /// A stream that emits an event whenever this transform logs an entry.
   ///
@@ skipping 27 matching lines @@
 
   /// Marks this transform as removed.
   ///
   /// This causes all of the transform's outputs to be marked as removed as
   /// well. Normally this will be automatically done internally based on events
   /// from the primary input, but it's possible for a transform to no longer be
   /// valid even if its primary input still exists.
   void remove() {
     _hasBecomeDirty = false;
     _onAssetController.close();
-    _onDoneController.close();
+    _onStateChangeController.close();
     _primarySubscription.cancel();
     for (var subscription in _inputSubscriptions.values) {
       subscription.cancel();
     }
     for (var controller in _outputControllers.values) {
       controller.setRemoved();
     }
   }
 
   /// If [transformer] is lazy, ensures that its concrete outputs will be
@@ skipping 17 matching lines @@
 
   /// Marks this transform as dirty.
   ///
   /// This causes all of the transform's outputs to be marked as dirty as well.
   void _dirty() {
     for (var controller in _outputControllers.values) {
       controller.setDirty();
     }
 
     _hasBecomeDirty = true;
+    _onStateChangeController.add(null);
     if (!_isApplying && !_pendingIsPrimary) _apply();
   }
 
   /// Applies this transform.
   void _apply() {
     assert(!_onAssetController.isClosed);
 
     // Clear all the old input subscriptions. If an input is re-used, we'll
     // re-subscribe.
     for (var subscription in _inputSubscriptions.values) {
       subscription.cancel();
     }
     _inputSubscriptions.clear();
 
     _isApplying = true;
+    _onStateChangeController.add(null);
     primary.whenAvailable((_) {
       _hasBecomeDirty = false;
 
       // TODO(nweiz): If [transformer] is a [DeclaringTransformer] but not a
       // [LazyTransformer], we can get some mileage out of doing a declarative
       // first so we know how to hook up the assets.
       if (_isLazy) return _declareLazy();
       return _applyImmediate();
     }).catchError((error, stackTrace) {
       // If the transform became dirty while processing, ignore any errors from
@@ skipping 16 matching lines @@
     }).then((_) {
       if (_onAssetController.isClosed) return;
 
       _isApplying = false;
       if (_hasBecomeDirty) {
         // Re-apply the transform if it became dirty while applying.
         if (!_pendingIsPrimary) _apply();
       } else {
         assert(!isDirty);
         // Otherwise, notify the parent nodes that it's no longer dirty.
-        _onDoneController.add(null);
+        _onStateChangeController.add(null);
       }
     });
   }
 
   /// Gets the asset for an input [id].
   ///
   /// If an input with that ID cannot be found, throws an
   /// [AssetNotFoundException].
   Future<Asset> getInput(AssetId id) {
     return phase.getInput(id).then((node) {
@@ skipping 99 matching lines @@
   void _log(AssetId asset, LogLevel level, String message, Span span) {
     // If the log isn't already associated with an asset, use the primary.
     if (asset == null) asset = primary.id;
     var entry = new LogEntry(info, asset, level, message, span);
     _onLogController.add(entry);
   }
 
   String toString() =>
     "transform node in $_location for $transformer on $primary";
 }