Fix a broken scheduled_test test.

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 116 matching lines @@
         setUp();
       } catch (e, stackTrace) {
         // Even though the scheduling failed, we need to run the onException and
         // onComplete queues, so we set the schedule state to RUNNING.
         _state = ScheduleState.RUNNING;
         throw new ScheduleError.from(this, e, stackTrace: stackTrace);
       }
 
       _state = ScheduleState.RUNNING;
       return tasks._run();
-    }).catchError((e) {
-      _addError(e);
-      return onException._run().catchError((innerError) {
+    }).catchError((error, stackTrace) {
+      _addError(error, stackTrace);
+      return onException._run().catchError((innerError, innerTrace) {
         // If an error occurs in a task in the onException queue, make sure it's
         // registered in the error list and re-throw it. We could also re-throw
-        // `e`; ultimately, all the errors will be shown to the user if any
+        // `error`; ultimately, all the errors will be shown to the user if any
         // ScheduleError is thrown.
-        _addError(innerError);
+        _addError(innerError, innerTrace);
         throw innerError;
       }).then((_) {
         // If there are no errors in the onException queue, re-throw the
         // original error that caused it to run.
-        throw e;
+        throw error;
       });
     }).whenComplete(() {
-      return onComplete._run().catchError((e) {
+      return onComplete._run().catchError((error, stackTrace) {
         // If an error occurs in a task in the onComplete queue, make sure it's
         // registered in the error list and re-throw it.
-        _addError(e);
-        throw e;
+        _addError(error, stackTrace);
+        throw error;
       });
     }).whenComplete(() {
       if (_timeoutTimer != null) _timeoutTimer.cancel();
       _state = ScheduleState.DONE;
     });
   }
 
   /// Stop the current [TaskQueue] after the current task and any out-of-band
   /// tasks stop executing. If this is called before [this] has started running,
   /// no tasks in the [tasks] queue will be run.
@@ skipping 81 matching lines @@
   /// The returned [Future] completes to the same value or error as [future].
   ///
   /// [description] provides an optional description of the future, which is
   /// used when generating error messages.
   ///
   /// The top-level `wrapFuture` function should usually be used in preference
   /// to this in test code.
   Future wrapFuture(Future future, [String description]) {
     var done = wrapAsync((fn) => fn(), description);
 
-    future = future.then((result) => done(() => result)).catchError((e) {
+    future = future.then((result) => done(() => result))
+        .catchError((error, stackTrace) {
       done(() {
-        throw e;
+        throw new ScheduleError.from(this, error, stackTrace: stackTrace);
       });
       // wrapAsync will catch the first throw, so we throw [e] again so it
       // propagates through the Future chain.
-      throw e;
+      throw error;
     });
 
     // Don't top-level the error, since it's already been signaled to the
     // schedule.
     future.catchError((_) => null);
 
     return future;
   }
 
   /// Returns a string representation of all errors registered on this schedule.
@@ skipping 25 matching lines @@
         _timeoutTimer = null;
         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 (error is ScheduleError && errors.contains(error)) return;
-    _errors.add(new ScheduleError.from(this, error));
+  void _addError(error, [StackTrace stackTrace]) {
+    error = new ScheduleError.from(this, error, stackTrace: stackTrace);
+    if (errors.contains(error)) return;
+    _errors.add(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");
 
   /// The schedule is actively running tasks. This includes running tasks in
@@ skipping 94 matching lines @@
   Future schedule(fn(), [String description]) {
     if (isRunning) {
       var task = _schedule.currentTask;
       var wrappedFn = () => _schedule.wrapFuture(
           new Future.value().then((_) => fn()));
       if (task == null) return wrappedFn();
       return task.runChild(wrappedFn, description);
     }
 
     var task = new Task(() {
-      return new Future.sync(fn).catchError((e) {
-        throw new ScheduleError.from(_schedule, e);
+      return new Future.sync(fn).catchError((e, stackTrace) {
+        throw new ScheduleError.from(_schedule, e, stackTrace: stackTrace);
       });
     }, description, this);
     _contents.add(task);
     return task.result;
   }
 
   /// Runs all the tasks in this queue in order.
   Future _run() {
     _schedule._currentQueue = this;
     _schedule.heartbeat();
@@ skipping 100 matching lines @@
 
   /// Notifies the queue that it has timed out and it needs to terminate
   /// immediately with a timeout error.
   void _signalTimeout(ScheduleError error) {
     _pendingCallbacks.clear();
     if (!isRunningTasks) {
       _noPendingCallbacksCompleter.completeError(error);
     } else if (_taskFuture != null) {
       // Catch errors coming off the old task future, in case it completes after
       // timing out.
-      _taskFuture.substitute(new Future.error(error)).catchError((e) {
-        _schedule._signalPostTimeoutError(e);
+      _taskFuture.substitute(new Future.error(error))
+          .catchError((e, stackTrace) {
+        _schedule._signalPostTimeoutError(e, stackTrace);
       });
     } else {
       // This branch probably won't be reached, but it's conceivable that the
       // event loop might get pumped when _taskFuture is null but we haven't yet
       // finished running all the tasks.
       _signalError(error);
     }
   }
 
   String toString() => name;
@@ skipping 45 matching lines @@
   /// The string description of the callback.
   String get description {
     if (_description == null) _description = _thunk();
     return _description;
   }
 
   String toString() => description;
 
   PendingCallback._(this._thunk);
 }