Expose aggregate transformers in pub.

dart/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart

Index: dart/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart
diff --git a/dart/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart b/dart/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart
index 2fc1a0fbf3a70a25b14dea6ee7b3af768f21e41a..bbe0acd73a17b4ed1c791df700bc4a78ad27ba1e 100644
--- a/dart/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart
+++ b/dart/sdk/lib/_internal/pub/lib/src/barback/foreign_transformer.dart
@@ -12,6 +12,7 @@ import 'package:barback/barback.dart';
 import '../../../asset/dart/serialize.dart';
 import '../barback.dart';
 import 'excluding_transformer.dart';
+import 'excluding_aggregate_transformer.dart';
 
 /// A wrapper for a transformer that's in a different isolate.
 class _ForeignTransformer extends Transformer {
@@ -64,6 +65,58 @@ class _ForeignLazyTransformer extends _ForeignDeclaringTransformer
       : super(map);
 }
 
+/// A wrapper for an aggregate transformer that's in a different isolate.
+class _ForeignAggregateTransformer extends AggregateTransformer {
+  /// The port with which we communicate with the child isolate.
+  ///
+  /// This port and all messages sent across it are specific to this
+  /// transformer.
+  final SendPort _port;
+
+  /// The result of calling [toString] on the transformer in the isolate.
+  final String _toString;
+
+  _ForeignAggregateTransformer(Map map)
+      : _port = map['port'],
+        _toString = map['toString'];
+
+  Future<String> classifyPrimary(AssetId id) {
+    return call(_port, {
+      'type': 'classifyPrimary',
+      'id': serializeId(id)
+    });
+  }
+
+  Future apply(AggregateTransform transform) {
+    return call(_port, {
+      'type': 'apply',
+      'transform': serializeAggregateTransform(transform)
+    });
+  }
+
+  String toString() => _toString;
+}
+
+class _ForeignDeclaringAggregateTransformer extends _ForeignAggregateTransformer
+    implements DeclaringAggregateTransformer {
+  _ForeignDeclaringAggregateTransformer(Map map)
+      : super(map);
+
+  Future declareOutputs(DeclaringAggregateTransform transform) {
+    return call(_port, {
+      'type': 'declareOutputs',
+      'transform': serializeDeclaringAggregateTransform(transform)
+    });
+  }
+}
+
+class _ForeignLazyAggregateTransformer
+    extends _ForeignDeclaringAggregateTransformer
+    implements LazyAggregateTransformer {
+  _ForeignLazyAggregateTransformer(Map map)
+      : super(map);
+}
+
 /// A wrapper for a transformer group that's in a different isolate.
 class _ForeignGroup implements TransformerGroup {
   final Iterable<Iterable> phases;
@@ -73,7 +126,7 @@ class _ForeignGroup implements TransformerGroup {
 
   _ForeignGroup(TransformerId id, Map map)
       : phases = map['phases'].map((phase) {
-          return phase.map((transformer) => deserializeTransformerOrGroup(
+          return phase.map((transformer) => deserializeTransformerLike(
               transformer, id)).toList();
         }).toList(),
         _toString = map['toString'];
@@ -81,8 +134,9 @@ class _ForeignGroup implements TransformerGroup {
   String toString() => _toString;
 }
 
-/// Converts a serializable map into a [Transformer] or a [TransformerGroup].
-deserializeTransformerOrGroup(Map map, TransformerId id) {
+/// Converts a serializable map into a [Transformer], an [AggregateTransformer],
+/// or a [TransformerGroup].
+deserializeTransformerLike(Map map, TransformerId id) {
   var transformer;
   switch(map['type']) {
     case 'TransformerGroup': return new _ForeignGroup(id, map);
@@ -95,8 +149,23 @@ deserializeTransformerOrGroup(Map map, TransformerId id) {
     case 'LazyTransformer':
       transformer = new _ForeignLazyTransformer(map);
       break;
+    case 'AggregateTransformer':
+      transformer = new _ForeignAggregateTransformer(map);
+      break;
+    case 'DeclaringAggregateTransformer':
+      transformer = new _ForeignDeclaringAggregateTransformer(map);
+      break;
+    case 'LazyAggregateTransformer':
+      transformer = new _ForeignLazyAggregateTransformer(map);
+      break;
     default: assert(false);
   }
 
-  return ExcludingTransformer.wrap(transformer, id.includes, id.excludes);
+  if (transformer is Transformer) {
+    return ExcludingTransformer.wrap(transformer, id.includes, id.excludes);
+  } else {
+    assert(transformer is AggregateTransformer);
+    return ExcludingAggregateTransformer.wrap(
+        transformer, id.includes, id.excludes);
+  }
 }