Add a "when" parameter to Chain.capture().

lib/src/chain.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.chain;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 
@@ skipping 31 matching lines @@
   ///
   /// Like the frames in a stack trace, the traces are ordered from most local
   /// to least local. The first one is the trace where the actual exception was
   /// raised, the second one is where that callback was scheduled, and so on.
   final List<Trace> traces;
 
   /// The [StackZoneSpecification] for the current zone.
   static StackZoneSpecification get _currentSpec =>
     Zone.current[#stack_trace.stack_zone.spec];
 
-  /// Runs [callback] in a [Zone] in which the current stack chain is tracked
-  /// and automatically associated with (most) errors.
+  /// If [when] is `true`, runs [callback] in a [Zone] in which the current
+  /// stack chain is tracked and automatically associated with (most) errors.
+  ///
+  /// If [when] is `false`, this does not track stack chains. Instead, it's
+  /// identical to [runZoned], except that it wraps any errors in [new
+  /// Chain.forTrace]—which will only wrap the trace unless there's a different
+  /// [Chain.capture] active. This makes it easy for the caller to only capture
+  /// stack chains in debug mode or during development.
   ///
   /// If [onError] is passed, any error in the zone that would otherwise go
   /// unhandled is passed to it, along with the [Chain] associated with that
   /// error. Note that if [callback] produces multiple unhandled errors,
   /// [onError] may be called more than once. If [onError] isn't passed, the
   /// parent Zone's `unhandledErrorHandler` will be called with the error and
   /// its chain.
   ///
   /// Note that even if [onError] isn't passed, this zone will still be an error
   /// zone. This means that any errors that would cross the zone boundary are
   /// considered unhandled.
   ///
   /// If [callback] returns a value, it will be returned by [capture] as well.
-  static capture(callback(), {void onError(error, Chain chain)}) {
+  static capture(callback(), {void onError(error, Chain chain),
+      bool when: true}) {
+    if (!when) {
+      var newOnError;
+      if (onError != null) {
+        newOnError = (error, stackTrace) {
+          onError(error, new Chain.forTrace(stackTrace));
+        };
+      }
+
+      return runZoned(callback, onError: newOnError);
+    }
+
     var spec = new StackZoneSpecification(onError);
     return runZoned(() {
       try {
         return callback();
       } catch (error, stackTrace) {
         // TODO(nweiz): Don't special-case this when issue 19566 is fixed.
         return Zone.current.handleUncaughtError(error, stackTrace);
       }
     }, zoneSpecification: spec.toSpec(), zoneValues: {
       #stack_trace.stack_zone.spec: spec
@@ skipping 110 matching lines @@
 
     // Don't call out to [Trace.toString] here because that doesn't ensure that
     // padding is consistent across all traces.
     return traces.map((trace) {
       return trace.frames.map((frame) {
         return '${padRight(frame.location, longest)}  ${frame.member}\n';
       }).join();
     }).join(chainGap);
   }
 }