Roll to pickup pool changes

packages/barback/lib/src/graph/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.graph.transform_node;
 
 import 'dart:async';
 
 import 'package:async/async.dart';
 
@@ skipping 50 matching lines @@
 
   /// The subscription to [phase]'s [Phase.onStatusChange] stream.
   StreamSubscription<NodeStatus> _phaseStatusSubscription;
 
   /// How far along [this] is in processing its assets.
   NodeStatus get status {
     if (_state == _State.APPLIED || _state == _State.DECLARED) {
       return NodeStatus.IDLE;
     }
 
-    if (_declaring && _state != _State.DECLARING &&
+    if (_declaring &&
+        _state != _State.DECLARING &&
         _state != _State.NEEDS_DECLARE) {
       return NodeStatus.MATERIALIZING;
     } else {
       return NodeStatus.RUNNING;
     }
   }
 
   /// The [TransformInfo] describing this node.
   ///
   /// [TransformInfo] is the publicly-visible representation of a transform
   /// node.
-  TransformInfo get info => new TransformInfo(transformer,
-      new AssetId(phase.cascade.package, key));
+  TransformInfo get info =>
+      new TransformInfo(transformer, new AssetId(phase.cascade.package, key));
 
   /// Whether this is a declaring transform.
   ///
   /// This is usually identical to `transformer is
   /// DeclaringAggregateTransformer`, but if a declaring and non-lazy
   /// transformer emits an error during `declareOutputs` it's treated as though
   /// it wasn't declaring.
-  bool get _declaring => transformer is DeclaringAggregateTransformer &&
+  bool get _declaring =>
+      transformer is DeclaringAggregateTransformer &&
       (_state == _State.DECLARING || _declaredOutputs != null);
 
   /// Whether this transform has been forced since it last finished applying.
   ///
   /// A transform being forced means it should run until it generates outputs
   /// and is no longer dirty. This is always true for non-declaring
   /// transformers, since they always need to eagerly generate outputs.
   bool _forced;
 
   /// The subscriptions to each secondary input's [AssetNode.onStateChange]
@@ skipping 30 matching lines @@
   /// The current state of [this].
   var _state = _State.DECLARED;
 
   /// Whether [this] has been marked as removed.
   bool get _isRemoved => _streams.onAssetController.isClosed;
 
   // If [transformer] is declaring but not lazy and [primary] is available, we
   // can run [apply] even if [force] hasn't been called, since [transformer]
   // should run eagerly if possible.
   bool get _canRunDeclaringEagerly =>
-      _declaring && transformer is! LazyAggregateTransformer &&
+      _declaring &&
+      transformer is! LazyAggregateTransformer &&
       _primaries.every((input) => input.state.isAvailable);
 
   /// Which primary inputs the most recent run of this transform has declared
   /// that it consumes.
   ///
   /// This starts out `null`, indicating that the transform hasn't declared
   /// anything yet. This is not meaningful unless [_state] is [_State.APPLIED]
   /// or [_State.DECLARED].
   Set<AssetId> _consumedPrimaries;
 
@@ skipping 59 matching lines @@
     });
 
     _run();
   }
 
   /// Adds [input] as a primary input for this node.
   void addPrimary(AssetNode input) {
     _primaries.add(input);
     if (_forced) input.force();
 
-    _primarySubscriptions[input.id] = input.onStateChange
-        .listen((_) => _onPrimaryStateChange(input));
+    _primarySubscriptions[input.id] =
+        input.onStateChange.listen((_) => _onPrimaryStateChange(input));
 
     if (_state == _State.DECLARING && !_declareController.isDone) {
       // If we're running `declareOutputs` and its id stream isn't closed yet,
       // pass this in as another id.
       _declareController.addId(input.id);
       _maybeFinishDeclareController();
     } else if (_state == _State.APPLYING) {
       // If we're running `apply`, we need to wait until [input] is available
       // before we pass it into the stream. If it's available now, great; if
       // not, [_onPrimaryStateChange] will handle it.
@@ skipping 50 matching lines @@
     if (_state == _State.DECLARED) _apply();
   }
 
   /// Marks this transform as dirty.
   ///
   /// Specifically, this should be called when one of the transform's inputs'
   /// contents change, or when a secondary input is removed. Primary inputs
   /// being added or removed are handled by [addInput] and
   /// [_onPrimaryStateChange].
   void _dirty() {
-    if (_state == _State.DECLARING || _state == _State.NEEDS_DECLARE ||
+    if (_state == _State.DECLARING ||
+        _state == _State.NEEDS_DECLARE ||
         _state == _State.NEEDS_APPLY) {
       // If we already know that [_apply] needs to be run, there's nothing to do
       // here.
       return;
     }
 
     if (!_forced && !_canRunDeclaringEagerly) {
       // [forced] should only ever be false for a declaring transformer.
       assert(_declaring);
 
@@ skipping 64 matching lines @@
         // pass it to the stream.
         _applyController.addInput(input.asset);
         _maybeFinishApplyController();
       }
     } else {
       if (_forced) input.force();
 
       var controller = _passThroughControllers[input.id];
       if (controller != null) controller.setDirty();
 
-      if (_state == _State.APPLYING && !_applyController.addedId(input.id) &&
+      if (_state == _State.APPLYING &&
+          !_applyController.addedId(input.id) &&
           (_forced || !input.isLazy)) {
         // If the input hasn't yet been added to the transform's input stream,
         // there's no need to consider the transformation dirty. However, if the
         // input is lazy and we're running eagerly, we need to restart the
         // transformation.
         return;
       }
       _dirty();
     }
   }
@@ skipping 74 matching lines @@
         // If `declareOutputs` fails, fall back to treating a declaring
         // transformer as though it were eager.
         if (transformer is! LazyAggregateTransformer) _forced = true;
         callback();
         return;
       }
 
       _consumedPrimaries = controller.consumedPrimaries;
       _declaredOutputs = controller.outputIds;
       var invalidIds = _declaredOutputs
-          .where((id) => id.package != phase.cascade.package).toSet();
+          .where((id) => id.package != phase.cascade.package)
+          .toSet();
       for (var id in invalidIds) {
         _declaredOutputs.remove(id);
         // TODO(nweiz): report this as a warning rather than a failing error.
         phase.cascade.reportError(new InvalidOutputException(info, id));
       }
 
       for (var primary in _primaries) {
         if (_declaredOutputs.contains(primary.id)) continue;
         _passThrough(primary.id);
       }
@@ skipping 170 matching lines @@
           return;
         }
 
         var message = new StringBuffer("Not yet complete after "
             "${niceDuration(_timeInTransformer.elapsed)}");
         if (_pendingSecondaryInputs.isNotEmpty) {
           message.write(", waiting on input(s) "
               "${_pendingSecondaryInputs.keys.join(", ")}");
         }
         _streams.onLogController.add(new LogEntry(
-              info,
-              info.primaryId,
-              LogLevel.FINE,
-              message.toString(),
-              null));
+            info, info.primaryId, LogLevel.FINE, message.toString(), null));
       });
 
       return transformer.apply(controller.transform);
     }).whenComplete(() {
       transformCounterTimer.cancel();
       _timeInTransformer.stop();
       _timeAwaitingInputs.stop();
 
       // Cancel the controller here even if `apply` wasn't interrupted. Since
       // the apply is finished, we want to close out the controller's streams.
@@ skipping 14 matching lines @@
       if (_state == _State.NEEDS_APPLY) return false;
       if (_state == _State.NEEDS_DECLARE) return false;
       if (controller.loggedError) return true;
 
       // If the transformer took long enough, log its duration in fine output.
       // That way it's not always visible, but users running with "pub serve
       // --verbose" can see it.
       var ranLong = _timeInTransformer.elapsed > new Duration(seconds: 1);
       var ranLongLocally =
           _timeInTransformer.elapsed - _timeAwaitingInputs.elapsed >
-            new Duration(milliseconds: 200);
+              new Duration(milliseconds: 200);
 
       // Report the transformer's timing information if it spent more than 0.2s
       // doing things other than waiting for its secondary inputs or if it spent
       // more than 1s in total.
       if (ranLongLocally || ranLong) {
         _streams.onLogController.add(new LogEntry(
-            info, info.primaryId, LogLevel.FINE,
+            info,
+            info.primaryId,
+            LogLevel.FINE,
             "Took ${niceDuration(_timeInTransformer.elapsed)} "
-              "(${niceDuration(_timeAwaitingInputs.elapsed)} awaiting "
-              "secondary inputs).",
+            "(${niceDuration(_timeAwaitingInputs.elapsed)} awaiting "
+            "secondary inputs).",
             null));
       }
 
       _handleApplyResults(controller);
       return false;
     }).catchError((error, stackTrace) {
       // If the transform became dirty while processing, ignore any errors from
       // it.
       if (_state == _State.NEEDS_APPLY || _isRemoved) return false;
 
@@ skipping 190 matching lines @@
   /// declaring and [APPLYING] otherwise. If a primary input is added or
   /// removed, this will transition to [DECLARING].
   static const APPLIED = const _State._("applied");
 
   final String name;
 
   const _State._(this.name);
 
   String toString() => name;
 }