Normalize handling of the package root in the runner.

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.
   ///
   /// If [packageRoot] is passed, it's used for all package imports when
-  /// compiling tests to JS. Otherwise, the package root is inferred from the
-  /// location of the source file.
+  /// compiling tests to JS. Otherwise, the package root is inferred from
+  /// [root].
   ///
   /// If [pubServeUrl] is passed, tests will be loaded from the `pub serve`
   /// instance at that URL rather than from the filesystem.
   ///
   /// If [color] is true, console colors will be used when compiling Dart.
+  ///
+  /// If the package root doesn't exist, throws an [ApplicationException].
   static Future<BrowserServer> start({String root, String packageRoot,
       Uri pubServeUrl, bool color: false}) {
     var server = new BrowserServer._(root, packageRoot, pubServeUrl, color);
     return server._load().then((_) => server);
   }
 
   /// The underlying HTTP server.
   HttpServer _server;
 
   /// A randomly-generated secret.
@@ skipping 20 matching lines @@
   ///
   /// This is `null` if tests are loaded from `pub serve`.
   final CompilerPool _compilers;
 
   /// The temporary directory in which compiled JS is emitted.
   final String _compiledDir;
 
   /// The root directory served statically by this server.
   final String _root;
 
-  /// The package root which is passed to `dart2js`.
+  /// The package root.
   final String _packageRoot;
 
   /// The URL for the `pub serve` instance to use to load tests.
   ///
   /// This is `null` if tests should be compiled manually.
   final Uri _pubServeUrl;
 
   /// The pool of active `pub serve` compilations.
   ///
   /// Pub itself ensures that only one compilation runs at a time; we just use
@@ skipping 20 matching lines @@
   /// This should only be accessed through [_browserManagerFor].
   final _browserManagers = new Map<TestPlatform, Future<BrowserManager>>();
 
   /// 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 one per browser per run.
   final _compileFutures = new Map<String, Future>();
 
-  BrowserServer._(String root, this._packageRoot, Uri pubServeUrl, bool color)
+  BrowserServer._(String root, String packageRoot, Uri pubServeUrl, bool color)
       : _root = root == null ? p.current : root,
+        _packageRoot = packageRootFor(root, packageRoot),
         _pubServeUrl = pubServeUrl,
         _compiledDir = pubServeUrl == null ? createTempDir() : null,
         _http = pubServeUrl == null ? null : new HttpClient(),
         _compilers = new CompilerPool(color: color);
 
   /// Starts the underlying server.
   Future _load() {
     var cascade = new shelf.Cascade()
         .add(_webSocketHandler.handler);
 
@@ skipping 12 matching lines @@
     return shelf_io.serve(pipeline, 'localhost', 0).then((server) {
       _server = server;
     });
   }
 
   /// 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 packageRoot = _packageRoot == null
-        ? p.join(_root, 'packages')
-        : _packageRoot;
     var staticHandler =
-      createStaticHandler(packageRoot, serveFilesOutsidePath: true);
+      createStaticHandler(_packageRoot, serveFilesOutsidePath: true);
 
     return (request) {
       var segments = p.url.split(shelfUrl(request).path);
 
       for (var i = 0; i < segments.length; i++) {
         if (segments[i] != "packages") continue;
         return staticHandler(
             shelfChange(request, path: p.url.joinAll(segments.take(i + 1))));
       }
 
@@ skipping 111 matching lines @@
 
   /// Compile the test suite at [dartPath] to JavaScript.
   ///
   /// Once the suite has been compiled, it's added to [_jsHandler] so it can be
   /// served.
   Future _compileSuite(String dartPath) {
     return _compileFutures.putIfAbsent(dartPath, () {
       var dir = new Directory(_compiledDir).createTempSync('test_').path;
       var jsPath = p.join(dir, p.basename(dartPath) + ".js");
 
-      return _compilers.compile(dartPath, jsPath,
-              packageRoot: packageRootFor(dartPath, _packageRoot))
+      return _compilers.compile(dartPath, jsPath, packageRoot: _packageRoot)
           .then((_) {
         if (_closed) return;
 
         _jsHandler.add(
             p.relative(dartPath, from: _root) + '.browser_test.dart.js',
             (request) {
           return new shelf.Response.ok(new File(jsPath).readAsStringSync(),
               headers: {'Content-Type': 'application/javascript'});
         });
       });
@@ skipping 67 matching lines @@
       if (_pubServeUrl == null) {
         new Directory(_compiledDir).deleteSync(recursive: true);
       } else {
         _http.close();
       }
 
       _closeCompleter.complete();
     }).catchError(_closeCompleter.completeError);
   }
 }