Don't wait for asynchronous error handlers.

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> {
@@ skipping 163 matching lines @@
   /// forwarded directly to the other future.
   static const int _CHAINED = 2;
   /// The future has been chained to another future, but there hasn't been
   /// any listeners added to this future yet. If it is completed with an
   /// error, the error will be considered unhandled.
   static const int _CHAINED_UNLISTENED = 6;
   /// The future has been completed with a value result.
   static const int _VALUE = 8;
   /// The future has been completed with an error result.
   static const int _ERROR = 12;
-  /// Extra bit set when the future has been completed with an error result.
-  /// but no listener has been scheduled to receive the error.
-  /// If the bit is still set when a [runAsync] call triggers, the error will
-  /// be reported to the top-level handler.
-  /// Assigning a listener before that time will clear the bit.
-  static const int _UNHANDLED_ERROR = 16;
 
   /** Whether the future is complete, and as what. */
   int _state = _INCOMPLETE;
 
   final _Zone _zone = _Zone.current.fork();
 
   bool get _isChained => (_state & _CHAINED) != 0;
   bool get _hasChainedListener => _state == _CHAINED;
   bool get _isComplete => _state >= _VALUE;
   bool get _mayComplete => _state == _INCOMPLETE;
   bool get _hasValue => _state == _VALUE;
   bool get _hasError => _state >= _ERROR;
-  bool get _hasUnhandledError => _state >= _UNHANDLED_ERROR;
-
-  void _clearUnhandledError() {
-    _state &= ~_UNHANDLED_ERROR;
-  }
 
   /**
    * Either the result, a list of listeners or another future.
    *
    * The result of the future is either a value or an error.
    * A result is only stored when the future has completed.
    *
    * The listeners is an internally linked list of [_FutureListener]s.
    * Listeners are only remembered while the future is not yet complete,
    * and it is not chained to another future.
@@ skipping 14 matching lines @@
   _FutureImpl.immediate(T value) {
     _state = _VALUE;
     _resultOrListeners = value;
   }
 
   _FutureImpl.immediateError(var error, [Object stackTrace]) {
     if (stackTrace != null) {
       // Force stack trace onto error, even if it had already one.
       _attachStackTrace(error, stackTrace);
     }
-    _setError(error);
+    _asyncSetError(error);
   }
 
   factory _FutureImpl.wait(Iterable<Future> futures) {
     Completer completer;
     // List collecting values from the futures.
     // Set to null if an error occurs.
     List values;
     void handleError(error) {
       if (values != null) {
         values = null;
@@ skipping 73 matching lines @@
       hasListeners = (_state == _CHAINED);  // and not _CHAINED_UNLISTENED.
     } else {
       listeners = _removeListeners();
       hasListeners = (listeners != null);
     }
 
     _state = _ERROR;
     _resultOrListeners = error;
 
     if (!hasListeners) {
-      _scheduleUnhandledError();
+      // TODO(floitsch): Hook this into unhandled error handling.
+      var error = _resultOrListeners;

[Lasse Reichstein Nielsen, 2013/09/05 09:17:25]

Why the alias for error here? Just remove the "var error ..." line.

+      _zone.handleUncaughtError(error);
       return;
     }
     while (listeners != null) {
       _FutureListener listener = listeners;
       listeners = listener._nextListener;
       listener._nextListener = null;
       listener._sendError(error);
     }
   }
 
   void _asyncSetValue(T value) {
     if (!_mayComplete) throw new StateError("Future already completed");
     _state = _PENDING_COMPLETE;
     runAsync(() { _setValueUnchecked(value); });
   }
 
   void _asyncSetError(Object error) {
     if (!_mayComplete) throw new StateError("Future already completed");
     _state = _PENDING_COMPLETE;
     runAsync(() { _setErrorUnchecked(error); });
   }
 
-  void _scheduleUnhandledError() {
-    assert(_state == _ERROR);
-    _state = _ERROR | _UNHANDLED_ERROR;
-    // Wait for the rest of the current event's duration to see
-    // if a subscriber is added to handle the error.
-    runAsync(() {
-      if (_hasUnhandledError) {
-        // No error handler has been added since the error was set.
-        _clearUnhandledError();
-        // TODO(floitsch): Hook this into unhandled error handling.
-        var error = _resultOrListeners;
-        _zone.handleUncaughtError(error);
-      }
-    });
-  }
-
   void _addListener(_FutureListener listener) {
     assert(listener._nextListener == null);
     if (!listener._inSameErrorZone(_zone)) {
       listener = new _ErrorZoneBoundaryListener(listener);
     }
     if (_isChained) {
       _state = _CHAINED;  // In case it was _CHAINED_UNLISTENED.
       _FutureImpl resultSource = _chainSource;
       resultSource._addListener(listener);
       return;
     }
     if (_isComplete) {
-      _clearUnhandledError();
       // Handle late listeners asynchronously.
       runAsync(() {
         if (_hasValue) {
           T value = _resultOrListeners;
           listener._sendValue(value);
         } else {
           assert(_hasError);
           listener._sendError(_resultOrListeners);
         }
       });
@@ skipping 27 matching lines @@
    * immediately. This function is only called during event resolution
    * where it's acceptable to send an event.
    */
   void _chain(_FutureImpl future) {
     if (!_isComplete) {
       future._chainFromFuture(this);
     } else if (_hasValue) {
       future._setValue(_resultOrListeners);
     } else {
       assert(_hasError);
-      _clearUnhandledError();
       future._setError(_resultOrListeners);
     }
   }
 
   /**
    * Returns the future that this future is chained to.
    *
    * If that future is itself chained to something else,
    * get the [_chainSource] of that future instead, and make this
    * future chain directly to the earliest source.
@@ skipping 233 matching lines @@
           _setError(error);
         }, onError: _setError);
         return;
       }
     } catch (e, s) {
       error = _asyncError(e, s);
     }
     _setError(error);
   }
 }