Use shelf's Server API in browser/server.

lib/src/runner/browser/server.dart

 // Copyright (c) 2015, 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 test.runner.browser.server;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ skipping 23 matching lines @@
 /// A server that serves JS-compiled tests to browsers.
 ///
 /// A test suite may be loaded for a given file using [loadSuite].
 class BrowserServer {
   /// Starts the server.
   ///
   /// [root] is the root directory that the server should serve. It defaults to
   /// the working directory.
   static Future<BrowserServer> start(Configuration config, {String root})
       async {
-    var server = new BrowserServer._(root, config);
-    await server._load();
-    return server;
+    var server = new shelf_io.IOServer(await HttpMultiServer.loopback(0));
+    return new BrowserServer(server, config, root: root);
   }
 
-  /// The underlying HTTP server.
-  HttpServer _server;
+  /// The underlying server.
+  final shelf.Server _server;
 
   /// A randomly-generated secret.
   ///
   /// This is used to ensure that other users on the same system can't snoop
   /// on data being served through this server.
   final _secret = randomBase64(24, urlSafe: true);
 
   /// The URL for this server.
-  Uri get url => baseUrlForAddress(_server.address, _server.port)
-      .resolve(_secret + "/");
+  Uri get url => _server.url.resolve(_secret + "/");
 
   /// The test runner configuration.
   Configuration _config;
 
   /// A [OneOffHandler] for servicing WebSocket connections for
   /// [BrowserManager]s.
   ///
   /// This is one-off because each [BrowserManager] can only connect to a single
   /// WebSocket,
   final _webSocketHandler = new OneOffHandler();
@@ skipping 37 matching lines @@
 
   /// A map from test suite paths to Futures that will complete once those
   /// suites are finished compiling.
   ///
   /// This is used to make sure that a given test suite is only compiled once
   /// per run, rather than once per browser per run.
   final _compileFutures = new Map<String, Future>();
 
   final _mappers = new Map<String, StackTraceMapper>();
 
-  BrowserServer._(String root, Configuration config)
+  BrowserServer(this._server, Configuration config, {String root})
       : _root = root == null ? p.current : root,
         _config = config,
         _compiledDir = config.pubServeUrl == null ? createTempDir() : null,
         _http = config.pubServeUrl == null ? null : new HttpClient(),
-        _compilers = new CompilerPool(color: config.color);
-
-  /// Starts the underlying server.
-  Future _load() async {
+        _compilers = new CompilerPool(color: config.color) {
     var cascade = new shelf.Cascade()
         .add(_webSocketHandler.handler);
 
     if (_config.pubServeUrl == null) {
       cascade = cascade
           .add(_createPackagesHandler())
           .add(_jsHandler.handler)
           .add(createStaticHandler(_root))
           .add(_wrapperHandler);
     }
 
     var pipeline = new shelf.Pipeline()
       .addMiddleware(nestingMiddleware(_secret))
       .addHandler(cascade.handler);
 
-    _server = await HttpMultiServer.loopback(0);
-    shelf_io.serveRequests(_server, pipeline);
+    _server.mount(pipeline);
   }
 
   /// Returns a handler that serves the contents of the "packages/" directory
   /// for any URL that contains "packages/".
   ///
   /// This is a factory so it can wrap a static handler.
   shelf.Handler _createPackagesHandler() {
     var staticHandler =
       createStaticHandler(_config.packageRoot, serveFilesOutsidePath: true);
 
@@ skipping 258 matching lines @@
       await Future.wait(futures);
 
       if (_config.pubServeUrl == null) {
         new Directory(_compiledDir).deleteSync(recursive: true);
       } else {
         _http.close();
       }
     });
   }
 }