Use the Zone API for registerException.

lib/src/frontend/expect_async.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.frontend.expect_async;
 
+import 'dart:async';
+
 import '../backend/invoker.dart';
 import '../backend/state.dart';
 import 'expect.dart';
 
 /// An object used to detect unpassed arguments.
 const _PLACEHOLDER = const Object();
 
 // Functions used to check how many arguments a callback takes.
 typedef _Func0();
 typedef _Func1(a);
@@ skipping 42 matching lines @@
 
   /// An optional description of why the function is expected to be called.
   ///
   /// If not passed, this will be an empty string.
   final String _reason;
 
   /// The number of times the function has been called.
   int _actualCalls = 0;
 
   /// The test invoker in which this function was wrapped.
-  final Invoker _invoker;
+  Invoker get _invoker => _zone[#test.invoker];
+
+  /// The zone in which this function was wrapped.
+  final Zone _zone;
 
   /// Whether this function has been called the requisite number of times.
   bool _complete;
 
   /// Wraps [callback] in a function that asserts that it's called at least
   /// [minExpected] times and no more than [maxExpected] times.
   ///
   /// If passed, [id] is used as a descriptive name fo the function and [reason]
   /// as a reason it's expected to be called. If [isDone] is passed, the test
   /// won't be allowed to complete until it returns `true`.
   _ExpectedFunction(Function callback, int minExpected, int maxExpected,
       {String id, String reason, bool isDone()})
       : this._callback = callback,
         _minExpectedCalls = minExpected,
         _maxExpectedCalls = (maxExpected == 0 && minExpected > 0)
             ? minExpected
             : maxExpected,
         this._isDone = isDone,
         this._reason = reason == null ? '' : '\n$reason',
-        this._invoker = Invoker.current,
+        this._zone = Zone.current,
         this._id = _makeCallbackId(id, callback) {
     if (_invoker == null) {
       throw new StateError("[expectAsync] was called outside of a test.");
     } else if (maxExpected > 0 && minExpected > maxExpected) {
       throw new ArgumentError("max ($maxExpected) may not be less than count "
           "($minExpected).");
     }
 
     if (isDone != null || minExpected > 0) {
       _invoker.addOutstandingCallback();
@@ skipping 71 matching lines @@
           _invoker.liveTest.state.result == Result.success) {
         throw 'Callback ${_id}called ($_actualCalls) after test case '
               '${_invoker.liveTest.test.name} had already completed.$_reason';
       } else if (_maxExpectedCalls >= 0 && _actualCalls > _maxExpectedCalls) {
         throw new TestFailure('Callback ${_id}called more times than expected '
                               '($_maxExpectedCalls).$_reason');
       }
 
       return Function.apply(_callback, args.toList());
     } catch (error, stackTrace) {
-      _invoker.handleError(error, stackTrace);
+      _zone.handleUncaughtError(error, stackTrace);
       return null;
     } finally {
       _afterRun();
     }
   }
 
   /// After each time the function is run, check to see if it's complete.
   void _afterRun() {
     if (_complete) return;
     if (_minExpectedCalls > 0 && _actualCalls < _minExpectedCalls) return;
@@ skipping 33 matching lines @@
 /// true will the callback be considered complete. [callback] may take up to six
 /// optional or required positional arguments; named arguments are not
 /// supported.
 ///
 /// Both [id] and [reason] are optional and provide extra information about the
 /// callback when debugging. [id] should be the name of the callback, while
 /// [reason] should be the reason the callback is expected to be called.
 Function expectAsyncUntil(Function callback, bool isDone(),
     {String id, String reason}) => new _ExpectedFunction(callback, 0, -1,
         id: id, reason: reason, isDone: isDone).func;