Make pkg/stack_trace use stack chains.

pkg/scheduled_test/lib/scheduled_process.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 scheduled_test.scheduled_process;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
+import 'package:stack_trace/stack_trace.dart';
+
 import 'scheduled_test.dart';
 import 'src/utils.dart';
 import 'src/value_future.dart';
 
 /// A class representing a [Process] that is scheduled to run in the course of
 /// the test. This class allows actions on the process to be scheduled
 /// synchronously. All operations on this class are scheduled.
 ///
 /// Before running the test, either [shouldExit] or [kill] must be called on
 /// this to ensure that the process terminates when expected. Note that [kill]
@@ skipping 69 matching lines @@
         _description = description {
     assert(currentSchedule.state == ScheduleState.SET_UP);
 
     _updateDescription(executable, arguments);
 
     _scheduleStartProcess(executable, arguments, workingDirectory, environment);
 
     _scheduleExceptionCleanup();
 
     var stdoutWithCanceller = _lineStreamWithCanceller(
-        _process.then((p) => p.stdout));
+        _process.then((p) => Chain.track(p.stdout)));
     _stdoutCanceller = stdoutWithCanceller.last;
     _stdoutLog = stdoutWithCanceller.first;
 
     var stderrWithCanceller = _lineStreamWithCanceller(
-        _process.then((p) => p.stderr));
+        _process.then((p) => Chain.track(p.stderr)));
     _stderrCanceller = stderrWithCanceller.last;
     _stderrLog = stderrWithCanceller.first;
 
     _stdout = new StreamIterator<String>(stdoutStream());
     _stderr = new StreamIterator<String>(stderrStream());
   }
 
   /// Updates [_description] to reflect [executable] and [arguments], which are
   /// the same values as in [start].
   void _updateDescription(executable, arguments) {
@@ skipping 27 matching lines @@
         new Future.sync(() => executable),
         awaitObject(arguments),
         new Future.sync(() => workingDirectory),
         new Future.sync(() => environment)
       ]).then((results) {
         executable = results[0];
         arguments = results[1];
         workingDirectory = results[2];
         environment = results[3];
         _updateDescription(executable, arguments);
-        return Process.start(executable,
-                             arguments,
-                             workingDirectory: workingDirectory,
-                             environment: environment).then((process) {
+        return Chain.track(
+            Process.start(executable,
+                          arguments,
+                          workingDirectory: workingDirectory,
+                          environment: environment)).then((process) {
           process.stdin.encoding = UTF8;
           return process;
         });
       });
     }, "starting process '$description'"));
   }
 
   /// Listens for [_process] to exit and passes the exit code to
   /// [exitCodeCompleter]. If the process completes earlier than expected, an
   /// exception will be signaled to the schedule.
   void _handleExit(Completer exitCodeCompleter) {
     // We purposefully avoid using wrapFuture here. If an error occurs while a
     // process is running, we want the schedule to move to the onException
     // queue where the process will be killed, rather than blocking the tasks
     // queue waiting for the process to exit.
-    _process.then((p) => p.exitCode).then((exitCode) {
+    _process.then((p) => Chain.track(p.exitCode)).then((exitCode) {
       if (_endExpected) {
         exitCodeCompleter.complete(exitCode);
         return;
       }
 
       wrapFuture(pumpEventQueue().then((_) {
         if (currentSchedule.currentTask != _taskBeforeEnd) return null;
         // If we're one task before the end was scheduled, wait for that task
         // to complete and pump the event queue so that _endExpected will be
         // set.
@@ skipping 165 matching lines @@
     schedule(() {
       _endExpected = true;
       return _exitCode.then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     }, "waiting for process '$description' to exit");
   }
 }