Add an error callback to StackZoneSpecification.

pkg/stack_trace/lib/src/stack_zone_specification.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.
 
 library stack_trace.stack_zone_specification;
 
 import 'dart:async';
 
 import 'trace.dart';
 import 'chain.dart';
@@ skipping 38 matching lines @@
   _Node _currentNode;
 
   StackZoneSpecification([this._onError]);
 
   /// Converts [this] to a real [ZoneSpecification].
   ZoneSpecification toSpec() {
     return new ZoneSpecification(
         handleUncaughtError: handleUncaughtError,
         registerCallback: registerCallback,
         registerUnaryCallback: registerUnaryCallback,
-        registerBinaryCallback: registerBinaryCallback);
+        registerBinaryCallback: registerBinaryCallback,
+        errorCallback: errorCallback);
   }
 
   /// Returns the current stack chain.
   ///
   /// By default, the first frame of the first trace will be the line where
   /// [currentChain] is called. If [level] is passed, the first trace will start
   /// that many frames up instead.
   Chain currentChain([int level=0]) => _createNode(level + 1).toChain();
 
   /// Returns the stack chain associated with [trace], if one exists.
@@ skipping 11 matching lines @@
   /// information associated with it.
   ///
   /// By default, the first frame of the first trace will be the line where
   /// [trackFuture] is called. If [level] is passed, the first trace will start
   /// that many frames up instead.
   Future trackFuture(Future future, [int level=0]) {
     var completer = new Completer.sync();
     var node = _createNode(level + 1);
     future.then(completer.complete).catchError((e, stackTrace) {
       if (stackTrace == null) stackTrace = new Trace.current();
-      if (_chains[stackTrace] == null) _chains[stackTrace] = node;
+      if (stackTrace is! Chain && _chains[stackTrace] == null) {
+        _chains[stackTrace] = node;
+      }
       completer.completeError(e, stackTrace);
     });
     return completer.future;
   }
 
   /// Ensures that any errors emitted by [stream] have the correct stack
   /// information associated with them.
   ///
   /// By default, the first frame of the first trace will be the line where
   /// [trackStream] is called. If [level] is passed, the first trace will start
   /// that many frames up instead.
   Stream trackStream(Stream stream, [int level=0]) {
     var node = _createNode(level + 1);
     return stream.transform(new StreamTransformer.fromHandlers(
         handleError: (error, stackTrace, sink) {
       if (stackTrace == null) stackTrace = new Trace.current();
-      if (_chains[stackTrace] == null) _chains[stackTrace] = node;
+      if (stackTrace is! Chain && _chains[stackTrace] == null) {
+        _chains[stackTrace] = node;
+      }
       sink.addError(error, stackTrace);
     }));
   }
 
   /// Tracks the current stack chain so it can be set to [_currentChain] when
   /// [f] is run.
   ZoneCallback registerCallback(Zone self, ZoneDelegate parent, Zone zone,
       Function f) {
     if (f == null) return parent.registerCallback(zone, null);
     var node = _createNode(1);
@@ skipping 37 matching lines @@
       return parent.runBinary(zone, _onError, error, stackChain);
     } catch (newError, newStackTrace) {
       if (identical(newError, error)) {
         return parent.handleUncaughtError(zone, error, stackChain);
       } else {
         return parent.handleUncaughtError(zone, newError, newStackTrace);
       }
     }
   }
 
+  /// Attaches the current stack chain to [stackTrace], replacing it if
+  /// necessary.
+  AsyncError errorCallback(Zone self, ZoneDelegate parent, Zone zone,
+      Object error, StackTrace stackTrace) {
+    var asyncError = parent.errorCallback(zone, error, stackTrace);
+    if (asyncError != null) {
+      error = asyncError.error;
+      stackTrace = asyncError.stackTrace;
+    }
+
+    // Go up two levels to get through [_CustomZone.errorCallback].
+    if (stackTrace == null) {
+      stackTrace = _createNode(2).toChain();
+    } else {
+      if (_chains[stackTrace] == null) _chains[stackTrace] = _createNode(2);
+    }
+
+    return new AsyncError(error, stackTrace);
+  }
+
   /// Creates a [_Node] with the current stack trace and linked to
   /// [_currentNode].
   ///
   /// By default, the first frame of the first trace will be the line where
   /// [_createNode] is called. If [level] is passed, the first trace will start
   /// that many frames up instead.
   _Node _createNode([int level=0]) =>
     new _Node(new Trace.current(level + 1), _currentNode);
 
   // TODO(nweiz): use a more robust way of detecting and tracking errors when
@@ skipping 31 matching lines @@
   Chain toChain() {
     var nodes = <Trace>[];
     var node = this;
     while (node != null) {
       nodes.add(node.trace);
       node = node.previous;
     }
     return new Chain(nodes);
   }
 }