Fix all strong-mode warnings.

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';
+
 import '../asset/asset.dart';
 import '../asset/asset_id.dart';
 import '../asset/asset_node.dart';
 import '../asset/asset_node_set.dart';
 import '../errors.dart';
 import '../log.dart';
 import '../transformer/aggregate_transform.dart';
 import '../transformer/aggregate_transformer.dart';
 import '../transformer/declaring_aggregate_transform.dart';
 import '../transformer/declaring_aggregate_transformer.dart';
@@ skipping 411 matching lines @@
 
     _state = _State.DECLARING;
     var controller = new DeclaringAggregateTransformController(this);
     _declareController = controller;
     _streams.onLogPool.add(controller.onLog);
     for (var primary in _primaries) {
       controller.addId(primary.id);
     }
     _maybeFinishDeclareController();
 
-    syncFuture(() {
+    new Future.sync(() {
       return (transformer as DeclaringAggregateTransformer)
           .declareOutputs(controller.transform);
     }).whenComplete(() {
       // Cancel the controller here even if `declareOutputs` wasn't interrupted.
       // Since the declaration is finished, we want to close out the
       // controller's streams.
       controller.cancel();
       _declareController = null;
     }).then((_) {
       if (_isRemoved) return;
@@ skipping 170 matching lines @@
   Future<bool> _runApply() {
     var controller = new AggregateTransformController(this);
     _applyController = controller;
     _streams.onLogPool.add(controller.onLog);
     for (var primary in _primaries) {
       if (!primary.state.isAvailable) continue;
       controller.addInput(primary.asset);
     }
     _maybeFinishApplyController();
 
-    return syncFuture(() {
+    return DelegatingFuture.typed(new Future.sync(() {
       _timeInTransformer.reset();
       _timeAwaitingInputs.reset();
       _timeInTransformer.start();
       return transformer.apply(controller.transform);
     }).whenComplete(() {
       _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 39 matching lines @@
       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;
 
       // Catch all transformer errors and pipe them to the results stream. This
       // is so a broken transformer doesn't take down the whole graph.
       phase.cascade.reportError(_wrapException(error, stackTrace));
       return true;
-    });
+    }));
   }
 
   /// Handle the results of running [Transformer.apply].
   ///
   /// [controller] should be the controller for the [AggegateTransform] passed
   /// to [AggregateTransformer.apply].
   void _handleApplyResults(AggregateTransformController controller) {
     _consumedPrimaries = controller.consumedPrimaries;
 
     var newOutputs = controller.outputs;
@@ skipping 175 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;
 }