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

sdk/lib/async/zone.dart

 // Copyright (c) 2013, 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;
 
 typedef dynamic ZoneCallback();
 typedef dynamic ZoneUnaryCallback(arg);
 typedef dynamic ZoneBinaryCallback(arg1, arg2);
 
 typedef dynamic HandleUncaughtErrorHandler(
     Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace);
 typedef dynamic RunHandler(Zone self, ZoneDelegate parent, Zone zone, f());
 typedef dynamic RunUnaryHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg), arg);
 typedef dynamic RunBinaryHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2), arg1, arg2);
 typedef ZoneCallback RegisterCallbackHandler(
     Zone self, ZoneDelegate parent, Zone zone, f());
 typedef ZoneUnaryCallback RegisterUnaryCallbackHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg));
 typedef ZoneBinaryCallback RegisterBinaryCallbackHandler(
     Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2));
+typedef AsyncError ErrorCallbackHandler(Zone self, ZoneDelegate parent,
+    Zone zone, Object error, StackTrace stackTrace);
 typedef void ScheduleMicrotaskHandler(
     Zone self, ZoneDelegate parent, Zone zone, f());
 typedef Timer CreateTimerHandler(
     Zone self, ZoneDelegate parent, Zone zone, Duration duration, void f());
 typedef Timer CreatePeriodicTimerHandler(
     Zone self, ZoneDelegate parent, Zone zone,
     Duration period, void f(Timer timer));
 typedef void PrintHandler(
     Zone self, ZoneDelegate parent, Zone zone, String line);
 typedef Zone ForkHandler(Zone self, ZoneDelegate parent, Zone zone,
                          ZoneSpecification specification,
                          Map zoneValues);
 
+/// Pair of error and stack trace. Returned by [Zone.errorCallback].
+class AsyncError implements Error {
+  final error;
+  final StackTrace stackTrace;
+
+  AsyncError(this.error, this.stackTrace);
+  String toString() => error.toString();
+}
+
+
 class _ZoneFunction {
   final _Zone zone;
   final Function function;
   const _ZoneFunction(this.zone, this.function);
 }
 
 /**
  * This class provides the specification for a forked zone.
  *
  * When forking a new zone (see [Zone.fork]) one can override the default
@@ skipping 23 matching lines @@
     dynamic runUnary(
         Zone self, ZoneDelegate parent, Zone zone, f(arg), arg),
     dynamic runBinary(Zone self, ZoneDelegate parent, Zone zone,
                       f(arg1, arg2), arg1, arg2),
     ZoneCallback registerCallback(
         Zone self, ZoneDelegate parent, Zone zone, f()),
     ZoneUnaryCallback registerUnaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg)),
     ZoneBinaryCallback registerBinaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)),
+    AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone,
+                             Object error, StackTrace stackTrace),
     void scheduleMicrotask(
         Zone self, ZoneDelegate parent, Zone zone, f()),
     Timer createTimer(Zone self, ZoneDelegate parent, Zone zone,
                       Duration duration, void f()),
     Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
                               Duration period, void f(Timer timer)),
     void print(Zone self, ZoneDelegate parent, Zone zone, String line),
     Zone fork(Zone self, ZoneDelegate parent, Zone zone,
               ZoneSpecification specification, Map zoneValues)
   }) = _ZoneSpecification;
 
   /**
    * Creates a specification from [other] with the provided handlers overriding
    * the ones in [other].
    */
   factory ZoneSpecification.from(ZoneSpecification other, {
     dynamic handleUncaughtError(Zone self, ZoneDelegate parent, Zone zone,
                                 error, StackTrace stackTrace): null,
     dynamic run(Zone self, ZoneDelegate parent, Zone zone, f()): null,
     dynamic runUnary(
         Zone self, ZoneDelegate parent, Zone zone, f(arg), arg): null,
     dynamic runBinary(Zone self, ZoneDelegate parent, Zone zone,
                       f(arg1, arg2), arg1, arg2): null,
     ZoneCallback registerCallback(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
     ZoneUnaryCallback registerUnaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg)): null,
     ZoneBinaryCallback registerBinaryCallback(
         Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)): null,
+    AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone,
+                             Object error, StackTrace stackTrace),
     void scheduleMicrotask(
         Zone self, ZoneDelegate parent, Zone zone, f()): null,
     Timer createTimer(Zone self, ZoneDelegate parent, Zone zone,
                       Duration duration, void f()): null,
     Timer createPeriodicTimer(Zone self, ZoneDelegate parent, Zone zone,
                               Duration period, void f(Timer timer)): null,
     void print(Zone self, ZoneDelegate parent, Zone zone, String line): null,
     Zone fork(Zone self, ZoneDelegate parent, Zone zone,
               ZoneSpecification specification,
               Map zoneValues): null
   }) {
     return new ZoneSpecification(
       handleUncaughtError: handleUncaughtError != null
                            ? handleUncaughtError
                            : other.handleUncaughtError,
       run: run != null ? run : other.run,
       runUnary: runUnary != null ? runUnary : other.runUnary,
       runBinary: runBinary != null ? runBinary : other.runBinary,
       registerCallback: registerCallback != null
                         ? registerCallback
                         : other.registerCallback,
       registerUnaryCallback: registerUnaryCallback != null
                          ? registerUnaryCallback
                          : other.registerUnaryCallback,
       registerBinaryCallback: registerBinaryCallback != null
                          ? registerBinaryCallback
                          : other.registerBinaryCallback,
+      errorCallback: errorCallback != null
+                         ? errorCallback
+                         : other.errorCallback,
       scheduleMicrotask: scheduleMicrotask != null
                          ? scheduleMicrotask
                          : other.scheduleMicrotask,
       createTimer : createTimer != null ? createTimer : other.createTimer,
       createPeriodicTimer: createPeriodicTimer != null
                            ? createPeriodicTimer
                            : other.createPeriodicTimer,
       print : print != null ? print : other.print,
       fork: fork != null ? fork : other.fork);
   }
 
   HandleUncaughtErrorHandler get handleUncaughtError;
   RunHandler get run;
   RunUnaryHandler get runUnary;
   RunBinaryHandler get runBinary;
   RegisterCallbackHandler get registerCallback;
   RegisterUnaryCallbackHandler get registerUnaryCallback;
   RegisterBinaryCallbackHandler get registerBinaryCallback;
+  ErrorCallbackHandler get errorCallback;
   ScheduleMicrotaskHandler get scheduleMicrotask;
   CreateTimerHandler get createTimer;
   CreatePeriodicTimerHandler get createPeriodicTimer;
   PrintHandler get print;
   ForkHandler get fork;
 }
 
 /**
  * Internal [ZoneSpecification] class.
  *
  * The implementation wants to rely on the fact that the getters cannot change
  * dynamically. We thus require users to go through the redirecting
  * [ZoneSpecification] constructor which instantiates this class.
  */
 class _ZoneSpecification implements ZoneSpecification {
   const _ZoneSpecification({
     this.handleUncaughtError: null,
     this.run: null,
     this.runUnary: null,
     this.runBinary: null,
     this.registerCallback: null,
     this.registerUnaryCallback: null,
     this.registerBinaryCallback: null,
+    this.errorCallback: null,
     this.scheduleMicrotask: null,
     this.createTimer: null,
     this.createPeriodicTimer: null,
     this.print: null,
     this.fork: null
   });
 
   // TODO(13406): Enable types when dart2js supports it.
   final /*HandleUncaughtErrorHandler*/ handleUncaughtError;
   final /*RunHandler*/ run;
   final /*RunUnaryHandler*/ runUnary;
   final /*RunBinaryHandler*/ runBinary;
   final /*RegisterCallbackHandler*/ registerCallback;
   final /*RegisterUnaryCallbackHandler*/ registerUnaryCallback;
   final /*RegisterBinaryCallbackHandler*/ registerBinaryCallback;
+  final /*ErrorCallbackHandler*/ errorCallback;
   final /*ScheduleMicrotaskHandler*/ scheduleMicrotask;
   final /*CreateTimerHandler*/ createTimer;
   final /*CreatePeriodicTimerHandler*/ createPeriodicTimer;
   final /*PrintHandler*/ print;
   final /*ForkHandler*/ fork;
 }
 
 /**
  * This class wraps zones for delegation.
  *
  * When forwarding to parent zones one can't just invoke the parent zone's
  * exposed functions (like [Zone.run]), but one needs to provide more
  * information (like the zone the `run` was initiated). Zone callbacks thus
  * receive more information including this [ZoneDelegate] class. When delegating
  * to the parent zone one should go through the given instance instead of
  * directly invoking the parent zone.
  */
 abstract class ZoneDelegate {
   dynamic handleUncaughtError(Zone zone, error, StackTrace stackTrace);
   dynamic run(Zone zone, f());
   dynamic runUnary(Zone zone, f(arg), arg);
   dynamic runBinary(Zone zone, f(arg1, arg2), arg1, arg2);
   ZoneCallback registerCallback(Zone zone, f());
   ZoneUnaryCallback registerUnaryCallback(Zone zone, f(arg));
   ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2));
+  AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace);
   void scheduleMicrotask(Zone zone, f());
   Timer createTimer(Zone zone, Duration duration, void f());
   Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer));
   void print(Zone zone, String line);
   Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues);
 }
 
 /**
  * A Zone represents the asynchronous version of a dynamic extent. Asynchronous
  * callbacks are executed in the zone they have been queued in. For example,
@@ skipping 146 matching lines @@
    *      ZoneCallback registered = registerBinaryCallback(f);
    *      if (runGuarded) {
    *        return (arg1, arg2) => this.runBinaryGuarded(registered, arg);
    *      }
    *      return (arg1, arg2) => thin.runBinary(registered, arg1, arg2);
    */
   ZoneBinaryCallback bindBinaryCallback(
       f(arg1, arg2), { bool runGuarded: true });
 
   /**
+   * Intercepts errors when added programmtically to a `Future` or `Stream`.
+   *
+   * When caling [Completer.completeError], [Stream.addError],
+   * or [Future] constructors that take an error or a callback that may throw,
+   * the current zone is allowed to intercept and replace the error.
+   *
+   * When other libraries use intermediate controllers or completers, such
+   * calls may contain errors that have already been processed.
+   *
+   * Return `null` if no replacement is desired.
+   * The original error is used unchanged in that case.
+   * Otherwise return an instance of [AsyncError] holding
+   * the new pair of error and stack trace.
+   */
+  AsyncError errorCallback(Object error, StackTrace stackTrace);
+
+  /**
    * Runs [f] asynchronously in this zone.
    */
   void scheduleMicrotask(void f());
 
   /**
    * Creates a Timer where the callback is executed in this zone.
    */
   Timer createTimer(Duration duration, void callback());
 
   /**
@@ skipping 95 matching lines @@
         implZone, _parentDelegate(implZone), zone, f);
   }
 
   ZoneBinaryCallback registerBinaryCallback(Zone zone, f(arg1, arg2)) {
     _ZoneFunction implementation = _delegationTarget._registerBinaryCallback;
     _Zone implZone = implementation.zone;
     return (implementation.function)(
         implZone, _parentDelegate(implZone), zone, f);
   }
 
+  AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace) {
+    _ZoneFunction implementation = _delegationTarget._errorCallback;
+    _Zone implZone = implementation.zone;
+    if (identical(implZone, _ROOT_ZONE)) return null;
+    return (implementation.function)(implZone, _parentDelegate(implZone), zone,
+                                     error, stackTrace);
+  }
+
   void scheduleMicrotask(Zone zone, f()) {
     _ZoneFunction implementation = _delegationTarget._scheduleMicrotask;
     _Zone implZone = implementation.zone;
     (implementation.function)(
         implZone, _parentDelegate(implZone), zone, f);
   }
 
   Timer createTimer(Zone zone, Duration duration, void f()) {
     _ZoneFunction implementation = _delegationTarget._createTimer;
     _Zone implZone = implementation.zone;
@@ skipping 30 matching lines @@
  */
 abstract class _Zone implements Zone {
   const _Zone();
 
   _ZoneFunction get _runUnary;
   _ZoneFunction get _run;
   _ZoneFunction get _runBinary;
   _ZoneFunction get _registerCallback;
   _ZoneFunction get _registerUnaryCallback;
   _ZoneFunction get _registerBinaryCallback;
+  _ZoneFunction get _errorCallback;
   _ZoneFunction get _scheduleMicrotask;
   _ZoneFunction get _createTimer;
   _ZoneFunction get _createPeriodicTimer;
   _ZoneFunction get _print;
   _ZoneFunction get _fork;
   _ZoneFunction get _handleUncaughtError;
   _Zone get parent;
   _ZoneDelegate get _delegate;
   Map get _map;
 
   bool inSameErrorZone(Zone otherZone) {
     return identical(errorZone, otherZone.errorZone);
   }
 }
 
 class _CustomZone extends _Zone {
   // The actual zone and implementation of each of these
   // inheritable zone functions.
   _ZoneFunction _runUnary;
   _ZoneFunction _run;
   _ZoneFunction _runBinary;
   _ZoneFunction _registerCallback;
   _ZoneFunction _registerUnaryCallback;
   _ZoneFunction _registerBinaryCallback;
+  _ZoneFunction _errorCallback;
   _ZoneFunction _scheduleMicrotask;
   _ZoneFunction _createTimer;
   _ZoneFunction _createPeriodicTimer;
   _ZoneFunction _print;
   _ZoneFunction _fork;
   _ZoneFunction _handleUncaughtError;
 
   // A cached delegate to this zone.
   ZoneDelegate _delegateCache;
 
@@ skipping 26 matching lines @@
         : parent._runBinary;
     _registerCallback = (specification.registerCallback != null)
         ? new _ZoneFunction(this, specification.registerCallback)
         : parent._registerCallback;
     _registerUnaryCallback = (specification.registerUnaryCallback != null)
         ? new _ZoneFunction(this, specification.registerUnaryCallback)
         : parent._registerUnaryCallback;
     _registerBinaryCallback = (specification.registerBinaryCallback != null)
         ? new _ZoneFunction(this, specification.registerBinaryCallback)
         : parent._registerBinaryCallback;
+    _errorCallback = (specification.errorCallback != null)
+        ? new _ZoneFunction(this, specification.errorCallback)
+        : parent._errorCallback;
     _scheduleMicrotask = (specification.scheduleMicrotask != null)
         ? new _ZoneFunction(this, specification.scheduleMicrotask)
         : parent._scheduleMicrotask;
     _createTimer = (specification.createTimer != null)
         ? new _ZoneFunction(this, specification.createTimer)
         : parent._createTimer;
     _createPeriodicTimer = (specification.createPeriodicTimer != null)
         ? new _ZoneFunction(this, specification.createPeriodicTimer)
         : parent._createPeriodicTimer;
     _print = (specification.print != null)
@@ skipping 146 matching lines @@
   }
 
   ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) {
     _ZoneFunction implementation = this._registerBinaryCallback;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     return (implementation.function)(
         implementation.zone, parentDelegate, this, f);
   }
 
+  AsyncError errorCallback(Object error, StackTrace stackTrace) {
+    final _ZoneFunction implementation = this._errorCallback;
+    assert(implementation != null);
+    final Zone implementationZone = implementation.zone;
+    if (identical(implementationZone, _ROOT_ZONE)) return null;
+    final ZoneDelegate parentDelegate = _parentDelegate(implementationZone);
+    return (implementation.function)(
+        implementationZone, parentDelegate, this, error, stackTrace);
+  }
+
   void scheduleMicrotask(void f()) {
     _ZoneFunction implementation = this._scheduleMicrotask;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     return (implementation.function)(
         implementation.zone, parentDelegate, this, f);
   }
 
   Timer createTimer(Duration duration, void f()) {
     _ZoneFunction implementation = this._createTimer;
@@ skipping 69 matching lines @@
 ZoneUnaryCallback _rootRegisterUnaryCallback(
     Zone self, ZoneDelegate parent, Zone zone, f(arg)) {
   return f;
 }
 
 ZoneBinaryCallback _rootRegisterBinaryCallback(
     Zone self, ZoneDelegate parent, Zone zone, f(arg1, arg2)) {
   return f;
 }
 
+AsyncError _rootErrorCallback(Zone self, ZoneDelegate parent, Zone zone,
+                              Object error, StackTrace stackTrace) => null;
+
 void _rootScheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) {
   if (!identical(_ROOT_ZONE, zone)) {
     f = zone.bindCallback(f);
   }
   _scheduleAsyncCallback(f);
 }
 
 Timer _rootCreateTimer(Zone self, ZoneDelegate parent, Zone zone,
                        Duration duration, void callback()) {
   if (!identical(_ROOT_ZONE, zone)) {
@@ skipping 50 matching lines @@
   HandleUncaughtErrorHandler get handleUncaughtError =>
       _rootHandleUncaughtError;
   RunHandler get run => _rootRun;
   RunUnaryHandler get runUnary => _rootRunUnary;
   RunBinaryHandler get runBinary => _rootRunBinary;
   RegisterCallbackHandler get registerCallback => _rootRegisterCallback;
   RegisterUnaryCallbackHandler get registerUnaryCallback =>
       _rootRegisterUnaryCallback;
   RegisterBinaryCallbackHandler get registerBinaryCallback =>
       _rootRegisterBinaryCallback;
+  ErrorCallbackHandler get errorCallback => _rootErrorCallback;
   ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask;
   CreateTimerHandler get createTimer => _rootCreateTimer;
   CreatePeriodicTimerHandler get createPeriodicTimer =>
       _rootCreatePeriodicTimer;
   PrintHandler get print => _rootPrint;
   ForkHandler get fork => _rootFork;
 }
 
 class _RootZone extends _Zone {
   const _RootZone();
 
   _ZoneFunction get _run =>
       const _ZoneFunction(_ROOT_ZONE, _rootRun);
   _ZoneFunction get _runUnary =>
       const _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
   _ZoneFunction get _runBinary =>
       const _ZoneFunction(_ROOT_ZONE, _rootRunBinary);
   _ZoneFunction get _registerCallback =>
       const _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback);
   _ZoneFunction get _registerUnaryCallback =>
       const _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback);
   _ZoneFunction get _registerBinaryCallback =>
       const _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback);
+  _ZoneFunction get _errorCallback =>
+      const _ZoneFunction(_ROOT_ZONE, _rootErrorCallback);
   _ZoneFunction get _scheduleMicrotask =>
       const _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask);
   _ZoneFunction get _createTimer =>
       const _ZoneFunction(_ROOT_ZONE, _rootCreateTimer);
   _ZoneFunction get _createPeriodicTimer =>
       const _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer);
   _ZoneFunction get _print =>
       const _ZoneFunction(_ROOT_ZONE, _rootPrint);
   _ZoneFunction get _fork =>
       const _ZoneFunction(_ROOT_ZONE, _rootFork);
@@ skipping 111 matching lines @@
     if (identical(Zone._current, _ROOT_ZONE)) return f(arg1, arg2);
     return _rootRunBinary(null, null, this, f, arg1, arg2);
   }
 
   ZoneCallback registerCallback(f()) => f;
 
   ZoneUnaryCallback registerUnaryCallback(f(arg)) => f;
 
   ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) => f;
 
+  AsyncError errorCallback(Object error, StackTrace stackTrace) => null;
+
   void scheduleMicrotask(void f()) {
     _rootScheduleMicrotask(null, null, this, f);
   }
 
   Timer createTimer(Duration duration, void f()) {
     return Timer._createTimer(duration, f);
   }
 
   Timer createPeriodicTimer(Duration duration, void f(Timer timer)) {
     return Timer._createPeriodicTimer(duration, f);
@@ skipping 62 matching lines @@
                                    handleUncaughtError: errorHandler);
   }
   Zone zone = Zone.current.fork(specification: zoneSpecification,
                                 zoneValues: zoneValues);
   if (onError != null) {
     return zone.runGuarded(body);
   } else {
     return zone.run(body);
   }
 }