Make pkg/stack_trace use stack chains.

pkg/scheduled_test/lib/scheduled_server.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_server;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
+import 'package:stack_trace/stack_trace.dart';
+
 import 'scheduled_test.dart';
 import 'src/scheduled_server/handler.dart';
 import 'src/scheduled_server/safe_http_server.dart';
+import 'src/utils.dart';
 
 typedef Future ScheduledHandler(HttpRequest request);
 
 /// A class representing an [HttpServer] that's scheduled to run in the course
 /// of the test. This class allows the server's request handling to be scheduled
 /// synchronously.
 ///
 /// The server expects requests to be received in the order [handle] is called,
 /// and expects that no additional requests will be received.
 class ScheduledServer {
@@ skipping 15 matching lines @@
 
   /// Creates a new server listening on an automatically-allocated port on
   /// 127.0.0.1. [description] is used to refer to the server in debugging
   /// messages.
   factory ScheduledServer([String description]) {
     var id = _count++;
     if (description == null) description = 'scheduled server $id';
 
     var scheduledServer;
     scheduledServer = new ScheduledServer._(schedule(() {
-      return SafeHttpServer.bind("127.0.0.1", 0).then((server) {
-        server.listen(scheduledServer._handleRequest,
+      return Chain.track(SafeHttpServer.bind("127.0.0.1", 0)).then((server) {
+        Chain.track(server).listen(scheduledServer._handleRequest,
             onError: currentSchedule.signalError);
         currentSchedule.onComplete.schedule(server.close);
         return server;
       });
     }, "starting '$description'"), description);
     return scheduledServer;
   }
 
   /// The port on which the server is listening.
   Future<int> get port => _server.then((s) => s.port);
@@ skipping 21 matching lines @@
         throw e;
       });
     }, "'$description' waiting for $method $path");
   }
 
   /// The handler for incoming [HttpRequest]s to this server. This dispatches
   /// the request to the first handler in the queue. It's that handler's
   /// responsibility to check that the method/path are correct and that it's
   /// being run at the correct time.
   void _handleRequest(HttpRequest request) {
-    wrapFuture(new Future.sync(() {
+    wrapFuture(syncFuture(() {
       if (_handlers.isEmpty) {
         fail("'$description' received ${request.method} ${request.uri.path} "
              "when no more requests were expected.");
       }
       return _handlers.removeFirst().fn(request);
     }).catchError((e) {
       // Close the server so that we don't leave a dangling request.
       _server.then((s) => s.close(force: true));
       throw e;
     }), 'receiving ${request.method} ${request.uri}');
   }
 }