Track the original assets more efficiently in Phase.

pkg/barback/lib/src/phase.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.phase;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'asset_cascade.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
 import 'asset_set.dart';
 import 'group_runner.dart';
 import 'errors.dart';
+import 'multi_set.dart';
 import 'phase_forwarder.dart';
 import 'phase_input.dart';
 import 'phase_output.dart';
 import 'stream_pool.dart';
 import 'transformer.dart';
 import 'transformer_group.dart';
 import 'utils.dart';
 
 /// One phase in the ordered series of transformations in an [AssetCascade].
 ///
@@ skipping 24 matching lines @@
   /// For the first phase, these will be the source assets. For all other
   /// phases, they will be the outputs from the previous phase.
   final _inputs = new Map<AssetId, PhaseInput>();
 
   /// The forwarders for this phase.
   final _forwarders = new Map<AssetId, PhaseForwarder>();
 
   /// The outputs for this phase.
   final _outputs = new Map<AssetId, PhaseOutput>();
 
-  // TODO(nweiz): Don't re-calculate this on the fly all the time.
   /// The set of all [AssetNode.origin] properties of the input assets for this
   /// phase.
   ///
   /// This is used to determine which assets have been passed unmodified through
   /// [_inputs] or [_groups]. Each input asset has a PhaseInput in [_inputs]. If
   /// that input isn't consumed by any transformers, it will be forwarded
   /// through the PhaseInput. However, it's possible that it was consumed by a
   /// group, and so shouldn't be forwarded through the phase as a whole.
   ///
   /// In order to detect whether an output has been forwarded through a group or
   /// a PhaseInput, we must be able to distinguish it from other outputs with
   /// the same id. To do so, we check if its origin is in [_inputOrigins]. If
   /// so, it's been forwarded unmodified.
-  Set<AssetNode> get _inputOrigins =>
-    _inputs.values.map((input) => input.input.origin).toSet();
+  final _inputOrigins = new MultiSet<AssetNode>();
 
   /// A stream that emits an event whenever this phase becomes dirty and needs
   /// to be run.
   ///
   /// This may emit events when the phase was already dirty or while processing
   /// transforms. Events are emitted synchronously to ensure that the dirty
   /// state is thoroughly propagated as soon as any assets are changed.
   Stream get onDirty => _onDirtyPool.stream;
   final _onDirtyPool = new StreamPool.broadcast();
 
@@ skipping 50 matching lines @@
     // there's one additional channel for the non-grouped transformers.
     var forwarder = new PhaseForwarder(_groups.length + 1);
     _forwarders[node.id] = forwarder;
     forwarder.onForwarding.listen((asset) {
       _addOutput(asset);
 
       var exception = _outputs[asset.id].collisionException;
       if (exception != null) cascade.reportError(exception);
     });
 
+    _inputOrigins.add(node.origin);
     var input = new PhaseInput(this, node, _transformers);
     _inputs[node.id] = input;
     input.input.whenRemoved.then((_) {
+      _inputOrigins.remove(node.origin);
       _inputs.remove(node.id);
       _forwarders.remove(node.id).remove();
     });
     _onDirtyPool.add(input.onDirty);
     _onDirtyController.add(null);
 
     for (var group in _groups.values) {
       group.addInput(node);
     }
   }
@@ skipping 140 matching lines @@
       _outputs[asset.id].add(asset);
     } else {
       _outputs[asset.id] = new PhaseOutput(this, asset);
       _outputs[asset.id].onAsset.listen((output) {
         if (_next != null) _next.addInput(output);
       }, onDone: () => _outputs.remove(asset.id));
       if (_next != null) _next.addInput(_outputs[asset.id].output);
     }
   }
 }