Stop working around dart-lang/sdk#23497.

lib/src/backend/invoker.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
 import '../backend/group.dart';
 import '../frontend/expect.dart';
@@ skipping 160 matching lines @@
   ///
   /// If the test times out, the *most recent* call to
   /// [waitForOutstandingCallbacks] will treat that error as occurring within
   /// [fn]—that is, it will complete immediately.
   Future waitForOutstandingCallbacks(fn()) {
     heartbeat();
 
     var zone;
     var counter = new OutstandingCallbackCounter();
     runZoned(() {
-      // TODO(nweiz): Use async/await here once issue 23497 has been fixed in
-      // two stable versions.
-      runZoned(() {
+      runZoned(() async {
         zone = Zone.current;
         _outstandingCallbackZones.add(zone);
-        new Future.sync(fn).then((_) => counter.removeOutstandingCallback());
+        await fn();
+        counter.removeOutstandingCallback();
       }, onError: _handleError);
     }, zoneValues: {
       _counterKey: counter
     });
 
     return counter.noOutstandingCallbacks.whenComplete(() {
       _outstandingCallbackZones.remove(zone);
     });
   }
 
@@ skipping 56 matching lines @@
         "or the [completes] matcher when testing async code.",
         stackTrace);
   }
 
   /// The method that's run when the test is started.
   void _onRun() {
     _controller.setState(const State(Status.running, Result.success));
 
     var outstandingCallbacksForBody = new OutstandingCallbackCounter();
 
-    // TODO(nweiz): Use async/await here once issue 23497 has been fixed in two
-    // stable versions.
     Chain.capture(() {
-      runZonedWithValues(() {
+      runZonedWithValues(() async {
         _invokerZone = Zone.current;
         _outstandingCallbackZones.add(Zone.current);
 
         // Run the test asynchronously so that the "running" state change has
         // a chance to hit its event handler(s) before the test produces an
         // error. If an error is emitted before the first state change is
         // handled, we can end up with [onError] callbacks firing before the
         // corresponding [onStateChange], which violates the timing
         // guarantees.
         new Future(_test._body)
             .then((_) => removeOutstandingCallback());
 
-        _outstandingCallbacks.noOutstandingCallbacks.then((_) {
-          if (_timeoutTimer != null) _timeoutTimer.cancel();
-          _controller.setState(
-              new State(Status.complete, liveTest.state.result));
+        await _outstandingCallbacks.noOutstandingCallbacks;
+        if (_timeoutTimer != null) _timeoutTimer.cancel();
 
-          // Use [Timer.run] here to avoid starving the DOM or other
-          // non-microtask events.
-          Timer.run(_controller.completer.complete);
-        });
+        _controller.setState(
+            new State(Status.complete, liveTest.state.result));
+
+        // Use [Timer.run] here to avoid starving the DOM or other
+        // non-microtask events.
+        Timer.run(_controller.completer.complete);
       }, zoneValues: {
         #test.invoker: this,
         // Use the invoker as a key so that multiple invokers can have different
         // outstanding callback counters at once.
         _counterKey: outstandingCallbacksForBody,
         _closableKey: true
       },
           zoneSpecification: new ZoneSpecification(
               print: (self, parent, zone, line) => _controller.print(line)),
           onError: _handleError);
     });
   }
 }