Refactor outstdanding callbacks in invoker.dart.

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.
 
 library test.backend.invoker;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
@@ skipping 102 matching lines @@
   void addOutstandingCallback() {
     if (closed) throw new ClosedException();
     _outstandingCallbacks.addOutstandingCallback();
   }
 
   /// Tells the invoker that a callback declared with [addOutstandingCallback]
   /// is no longer running.
   void removeOutstandingCallback() =>
       _outstandingCallbacks.removeOutstandingCallback();
 
+  /// Runs [fn] and returns once all (registered) outstanding callbacks it
+  /// transitively invokes have completed.
+  ///
+  /// If [fn] itself returns a future, this will automatically wait until that
+  /// future completes as well.
+  ///
+  /// Note that outstanding callbacks registered within [fn] will *not* be
+  /// registered as outstanding callback outside of [fn].
+  Future waitForOutstandingCallbacks(fn()) {
+    var counter = new OutstandingCallbackCounter();
+    runZoned(() {
+      // TODO(nweiz): Use async/await here once issue 23497 has been fixed in
+      // two stable versions.
+      new Future.sync(fn).then((_) => counter.removeOutstandingCallback());
+    }, zoneValues: {
+      // Use the invoker as a key so that multiple invokers can have different
+      // outstanding callback counters at once.
+      this: counter
+    });
+
+    return counter.noOutstandingCallbacks;
+  }
+
   /// Notifies the invoker of an asynchronous error.
   ///
   /// Note that calling this explicitly is rarely necessary, since any
   /// otherwise-uncaught errors will be forwarded to the invoker anyway.
   void handleError(error, [StackTrace stackTrace]) {
     if (stackTrace == null) stackTrace = new Chain.current();
 
     var afterSuccess = liveTest.isComplete &&
         liveTest.state.result == Result.success;
 
@@ skipping 43 matching lines @@
         // corresponding [onStateChange], which violates the timing
         // guarantees.
         new Future(_test._body)
             .then((_) => removeOutstandingCallback());
 
         _outstandingCallbacks.noOutstandingCallbacks.then((_) {
           if (_test._tearDown == null) return null;
 
           // Reset the outstanding callback counter to wait for callbacks from
           // the test's `tearDown` to complete.
-          var outstandingCallbacksForTearDown = new OutstandingCallbackCounter();
-          runZonedWithValues(() {
-            new Future.sync(_test._tearDown)
-              .then((_) => removeOutstandingCallback());
-          }, onError: handleError, zoneValues: {
-            this: outstandingCallbacksForTearDown
-          });
-
-          return outstandingCallbacksForTearDown.noOutstandingCallbacks;
+          return waitForOutstandingCallbacks(() =>
+              runZoned(_test._tearDown, onError: handleError));
         }).then((_) {
           timer.cancel();
           _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.
         this: outstandingCallbacksForBody
       },
           zoneSpecification: new ZoneSpecification(
               print: (self, parent, zone, line) => _controller.print(line)),
           onError: handleError);
     });
   }
 }