Let completers complete in the zone they were constructed in.

sdk/lib/async/future_impl.dart

 // Copyright (c) 2012, 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.
 
 part of dart.async;
 
 deprecatedFutureValue(_FutureImpl future) =>
   future._isComplete ? future._resultOrListeners : null;
 
 abstract class _Completer<T> implements Completer<T> {
   final Future<T> future;
   bool _isComplete = false;
 
   _Completer() : future = new _FutureImpl<T>() {
     _FutureImpl futureImpl = future;
     futureImpl._zone.expectCallback();
   }
 
   void _setFutureValue(T value);
   void _setFutureError(error);
 
   void complete([T value]) {
     if (_isComplete) throw new StateError("Future already completed");
     _isComplete = true;
     _FutureImpl futureImpl = future;
+    _setFutureValue(value);
     futureImpl._zone.cancelCallbackExpectation();
-    _setFutureValue(value);
   }
 
   void completeError(Object error, [Object stackTrace = null]) {
     if (_isComplete) throw new StateError("Future already completed");
     _isComplete = true;
     if (stackTrace != null) {
       // Force the stack trace onto the error, even if it already had one.
       _attachStackTrace(error, stackTrace);
     }
     _FutureImpl futureImpl = future;
-    if (futureImpl._inSameErrorZone(_Zone.current)) {
-      futureImpl._zone.cancelCallbackExpectation();
-      _setFutureError(error);
-    } else {
-      _Zone.current.handleUncaughtError(error);
-    }
+    _setFutureError(error);
+    futureImpl._zone.cancelCallbackExpectation();

[Lasse Reichstein Nielsen, 2013/07/05 19:00:07]

Is this too early if _setFutureError is async? We don't want the zone to go away
before the future is completed.

Should the future be the one to decide when it has received its callback,
instead of the controller doing it?

[floitsch, 2013/07/08 10:45:51]

Moved it down to _setFutureValue and _setFutureError.
Ideally it would be the future that decides, but that would require some
refactoring.

   }
 
   bool get isCompleted => _isComplete;
 }
 
 class _AsyncCompleter<T> extends _Completer<T> {
   void _setFutureValue(T value) {
     _FutureImpl future = this.future;
     runAsync(() { future._setValue(value); });
   }
@@ skipping 599 matching lines @@
           _setError(error);
         }, onError: _setError);
         return;
       }
     } catch (e, s) {
       error = _asyncError(e, s);
     }
     _setError(error);
   }
 }