Don't limit transformer parallelism in barback.

pkg/barback/test/transformer/mock.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.test.transformer.mock;
 
 import 'dart:async';
 
 import 'package:barback/barback.dart';
 import 'package:barback/src/utils.dart';
 import 'package:scheduled_test/scheduled_test.dart';
 
 /// The abstract base class for transformers used to test barback.
 ///
 /// This adds the ability to pause and resume different components of the
 /// transformers, and to tell whether they're running, when they start running,
 /// and how many times they've run.
 ///
 /// Transformers extending this should override [doIsPrimary] and [doApply]
 /// rather than [isPrimary] and [apply], and they should use [getInput] and
 /// [getPrimary] rather than [transform.getInput] and [transform.primaryInput].
 abstract class MockTransformer extends Transformer {
   /// The number of times the transformer has been applied.
   ///
   /// This is scheduled. The Future will complete at the point in the schedule
   /// that this is called.
   Future<int> get numRuns => schedule(() => _numRuns);
   var _numRuns = 0;
 
-  Future<int> get maxParallelRuns => schedule(() => _maxParallelRuns);
-  var _maxParallelRuns = 0;
-
   /// The number of currently running transforms.
   int _runningTransforms = 0;
 
   /// A completer for pausing the transformer before it finishes running [apply].
   Completer _apply;
 
   /// Completers for pausing the transformer before it finishes running
   /// [isPrimary].
   final _isPrimary = new Map<AssetId, Completer>();
 
@@ skipping 129 matching lines @@
           return _isPrimary[asset.id].future;
         }
       }).then((_) => result);
     });
   }
 
   Future apply(Transform transform) {
     _numRuns++;
     if (_runningTransforms == 0) _started.complete();
     _runningTransforms++;
-    if (_runningTransforms > _maxParallelRuns) {
-      _maxParallelRuns = _runningTransforms;
-    }
     return newFuture(() => doApply(transform)).then((_) {
       if (_apply != null) return _apply.future;
     }).whenComplete(() {
       _runningTransforms--;
       if (_runningTransforms == 0) _started = new Completer();
     });
   }
 
   /// The wrapped version of [isPrimary] for subclasses to override.
   Future<bool> doIsPrimary(Asset asset);
 
   /// The wrapped version of [doApply] for subclasses to override.
   Future doApply(Transform transform);
 }