Add error-intercept for Completer.completeError and StreamController.addError.

sdk/lib/async/future.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;
 
 /**
  * An object representing a delayed computation.
  *
  * A [Future] is used to represent a potential value, or error,
@@ skipping 99 matching lines @@
    *
    * If a non-future value is returned, the returned future is completed
    * with that value.
    */
   factory Future(computation()) {
     _Future result = new _Future<T>();
     Timer.run(() {
       try {
         result._complete(computation());
       } catch (e, s) {
-        result._completeError(e, s);
+        _completeWithErrorCallback(result, e, s);
       }
     });
     return result;
   }
 
   /**
    * Creates a future containing the result of calling [computation]
    * asynchronously with [scheduleMicrotask].
    *
    * If executing [computation] throws,
    * the returned future is completed with the thrown error.
    *
    * If calling [computation] returns a [Future], completion of
    * the created future will wait until the returned future completes,
    * and will then complete with the same result.
    *
    * If calling [computation] returns a non-future value,
    * the returned future is completed with that value.
    */
   factory Future.microtask(computation()) {
     _Future result = new _Future<T>();
     scheduleMicrotask(() {
       try {
         result._complete(computation());
       } catch (e, s) {
-        result._completeError(e, s);
+        _completeWithErrorCallback(result, e, s);
       }
     });
     return result;
   }
 
   /**
    * Creates a future containing the result of immediately calling
    * [computation].
    *
    * If calling [computation] throws, the returned future is completed with the
@@ skipping 26 matching lines @@
   factory Future.value([value]) {
     return new _Future<T>.immediate(value);
   }
 
   /**
    * A future that completes with an error in the next event-loop iteration.
    *
    * Use [Completer] to create a Future and complete it later.
    */
   factory Future.error(Object error, [StackTrace stackTrace]) {
+    if (!identical(Zone.current, _ROOT_ZONE)) {
+      AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
+      if (replacement != null) {
+        error = replacement.error;
+        stackTrace = replacement.stackTrace;
+      }
+    }
     return new _Future<T>.immediateError(error, stackTrace);
   }
 
   /**
    * Creates a future that runs its computation after a delay.
    *
    * The [computation] will be executed after the given [duration] has passed,
    * and the future is completed with the result.
    * If the duration is 0 or less,
    * it completes no sooner than in the next event-loop iteration.
    *
    * If [computation] is omitted,
    * it will be treated as if [computation] was set to `() => null`,
    * and the future will eventually complete with the `null` value.
    *
    * If calling [computation] throws, the created future will complete with the
    * error.
    *
    * See also [Completer] for a way to create and complete a future at a
    * later time that isn't necessarily after a known fixed duration.
    */
   factory Future.delayed(Duration duration, [T computation()]) {
-    Completer completer = new Completer.sync();
-    Future result = completer.future;
-    if (computation != null) {
-      result = result.then((ignored) => computation());
-    }
-    new Timer(duration, completer.complete);
+    _Future result = new _Future<T>();
+    new Timer(duration, () {
+      try {
+        result._complete(computation == null ? null : computation());
+      } catch (e, s) {
+        _completeWithErrorCallback(result, e, s);
+      }
+    });
     return result;
   }
 
   /**
    * Wait for all the given futures to complete and collect their values.
    *
    * Returns a future which will complete once all the futures in a list are
    * complete. If any of the futures in the list completes with an error,
    * the resulting future also completes with an error. Otherwise the value
    * of the returned future will be a list of all the values that were produced.
    *
    * If `eagerError` is true, the future completes with an error immediately on
    * the first error from one of the futures. Otherwise all futures must
    * complete before the returned future is completed (still with the first
    * error to occur, the remaining errors are silently dropped).
    */
   static Future<List> wait(Iterable<Future> futures, {bool eagerError: false}) {
-    Completer completer;  // Completer for the returned future.
+    final _Future<List> result = new _Future<List>();
     List values;  // Collects the values. Set to null on error.
     int remaining = 0;  // How many futures are we waiting for.
     var error;   // The first error from a future.
     StackTrace stackTrace;  // The stackTrace that came with the error.
 
     // Handle an error from any of the futures.
     handleError(theError, theStackTrace) {
-      bool isFirstError = values != null;
+      final bool isFirstError = (values != null);
       values = null;
       remaining--;
       if (isFirstError) {
         if (remaining == 0 || eagerError) {
-          completer.completeError(theError, theStackTrace);
+          result._completeError(theError, theStackTrace);
         } else {
           error = theError;
           stackTrace = theStackTrace;
         }
       } else if (remaining == 0 && !eagerError) {
-        completer.completeError(error, stackTrace);
+        result._completeError(error, stackTrace);
       }
     }
 
     // As each future completes, put its value into the corresponding
     // position in the list of values.
     for (Future future in futures) {
       int pos = remaining++;
       future.then((Object value) {
         remaining--;
         if (values != null) {
           values[pos] = value;
           if (remaining == 0) {
-            completer.complete(values);
+            result._completeWithValue(values);
           }
         } else if (remaining == 0 && !eagerError) {
-          completer.completeError(error, stackTrace);
+          result._completeError(error, stackTrace);
         }
       }, onError: handleError);
     }
     if (remaining == 0) {
       return new Future.value(const []);
     }
     values = new List(remaining);
-    completer = new Completer<List>();
-    return completer.future;
+    return result;
   }
 
   /**
    * Perform an async operation for each element of the iterable, in turn.
    *
    * Runs [f] for each element in [input] in order, moving to the next element
    * only when the [Future] returned by [f] completes. Returns a [Future] that
    * completes when all elements have been processed.
    *
    * The return values of all [Future]s are discarded. Any errors will cause the
@@ skipping 350 matching lines @@
    *     theFuture.catchError(thisCompleter.completeError);
    *
    */
   void completeError(Object error, [StackTrace stackTrace]);
 
   /**
    * Whether the future has been completed.
    */
   bool get isCompleted;
 }
+
+// Helper function completing a _Future with error, but checking the zone
+// for error replacement first.
+void _completeWithErrorCallback(_Future result, error, stackTrace) {
+  AsyncError replacement = Zone.current.errorCallback(error, stackTrace);
+  if (replacement == null) {
+    result._completeError(error, stackTrace);
+  } else {
+    result._completeError(replacement.error, replacement.stackTrace);
+  }
+}
+