Add flag to disable capturing stack traces.

pkg/scheduled_test/lib/src/schedule.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 schedule;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:stack_trace/stack_trace.dart';
@@ skipping 92 matching lines @@
   Duration get timeout => _timeout;
   Duration _timeout = new Duration(seconds: 5);
   set timeout(Duration duration) {
     _timeout = duration;
     heartbeat();
   }
 
   /// The timer for keeping track of task timeouts. This may be null.
   Timer _timeoutTimer;
 
+  /// If `true`, then new [Task]s will capture the current stack trace before
+  /// running. This can be set to `false` to speed up running tests since
+  /// capturing stack traces is currently quite slow. Even when set to `false`,
+  /// stack traces from *thrown* exceptions will be caught. This only disables
+  /// the eager collection of stack traces *before* an error occurs. Defaults
+  /// to `true`.
+  bool captureStackTraces = true;
+
   /// Creates a new schedule with empty task queues.
   Schedule() {
     _tasks = new TaskQueue._("tasks", this);
     _onComplete = new TaskQueue._("onComplete", this);
     _onException = new TaskQueue._("onException", this);
     _currentQueue = _tasks;
 
     heartbeat();
   }
 
@@ skipping 179 matching lines @@
         currentQueue._signalTimeout(new ScheduleError.from(this, "The schedule "
             "timed out after $_timeout of inactivity."));
       });
     }
   }
 
   /// Register an error in the schedule's error list. This ensures that there
   /// are no duplicate errors, and that all errors are wrapped in
   /// [ScheduleError].
   void _addError(error) {
-    if (errors.contains(error)) return;
+    if (error is ScheduleError && errors.contains(error)) return;
     errors.add(new ScheduleError.from(this, error));
   }
 }
 
 /// An enum of states for a [Schedule].
 class ScheduleState {
   /// The schedule can have tasks added to its queue, but is not yet running
   /// them.
   static const SET_UP = const ScheduleState._("SET_UP");
 
@@ skipping 16 matching lines @@
 /// A queue of asynchronous tasks to execute in order.
 class TaskQueue {
   // TODO(nweiz): make this a read-only view when issue 8321 is fixed.
   /// The tasks in the queue.
   Collection<Task> get contents => _contents;
   final _contents = new Queue<Task>();
 
   /// The name of the queue, for debugging purposes.
   final String name;
 
+  /// If `true`, then new [Task]s in this queue will capture the current stack
+  /// trace before running.
+  bool get captureStackTraces => _schedule.captureStackTraces;
+
   /// The [Schedule] that created this queue.
   final Schedule _schedule;
 
   /// An out-of-band error signaled by [_schedule]. If this is non-null, it
   /// indicates that the queue should stop as soon as possible and re-throw this
   /// error.
   ScheduleError _error;
 
   /// The [SubstituteFuture] for the currently-running task in the queue, or
   /// null if no task is currently running.
@@ skipping 130 matching lines @@
   Function _wrapAsync(fn(arg), String description) {
     assert(_schedule.state == ScheduleState.SET_UP || isRunning);
 
     // It's possible that the queue timed out before [fn] finished.
     bool _timedOut() =>
       _schedule.currentQueue != this || pendingCallbacks.isEmpty;
 
     if (description == null) {
       description = "Out-of-band operation #${_totalCallbacks}";
     }
-    var stackString = prefixLines(terseTraceString(new Trace.current()));
-    description = "$description\n\nStack trace:\n$stackString";
+
+    if (captureStackTraces) {
+      var stackString = prefixLines(terseTraceString(new Trace.current()));
+      description += "\n\nStack trace:\n$stackString";
+    }
+
     _totalCallbacks++;
 
     _pendingCallbacks.add(description);
     return (arg) {
       try {
         return fn(arg);
       } catch (e, stackTrace) {
         var error = new ScheduleError.from(
             _schedule, e, stackTrace: stackTrace);
         if (_timedOut()) {
@@ skipping 71 matching lines @@
           return prefixLines(childString,
               firstPrefix: "  $prefix ", prefix: "  | ");
         }).join('\n');
         taskString = '$taskString\n$childrenString';
       }
 
       return taskString;
     }).join("\n");
   }
 }