Use the package_resolver package.

lib/src/runner/browser/platform.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:async/async.dart';
 import 'package:http_multi_server/http_multi_server.dart';
+import 'package:package_resolver/package_resolver.dart';
 import 'package:path/path.dart' as p;
 import 'package:pool/pool.dart';
 import 'package:shelf/shelf.dart' as shelf;
 import 'package:shelf/shelf_io.dart' as shelf_io;
 import 'package:shelf_static/shelf_static.dart';
 import 'package:shelf_web_socket/shelf_web_socket.dart';
+import 'package:shelf_packages_handler/shelf_packages_handler.dart';
 import 'package:stream_channel/stream_channel.dart';
 import 'package:web_socket_channel/web_socket_channel.dart';
 
 import '../../backend/metadata.dart';
 import '../../backend/test_platform.dart';
 import '../../util/io.dart';
 import '../../util/one_off_handler.dart';
 import '../../util/path_handler.dart';
 import '../../util/stack_trace_mapper.dart';
 import '../../utils.dart';
@@ skipping 86 matching lines @@
       : _root = root == null ? p.current : root,
         _config = config,
         _compiledDir = config.pubServeUrl == null ? createTempDir() : null,
         _http = config.pubServeUrl == null ? null : new HttpClient(),
         _compilers = new CompilerPool(config) {
     var cascade = new shelf.Cascade()
         .add(_webSocketHandler.handler);
 
     if (_config.pubServeUrl == null) {
       cascade = cascade
-          .add(_createPackagesHandler())
+          .add(packagesDirHandler())
           .add(_jsHandler.handler)
           .add(createStaticHandler(_root))
           .add(_wrapperHandler);
 
       if (config.precompiledPath != null) {
         cascade = cascade.add(createStaticHandler(config.precompiledPath));
       }
     }
 
     var pipeline = new shelf.Pipeline()
-      .addMiddleware(nestingMiddleware(_secret))
-      .addHandler(cascade.handler);
+        .addMiddleware(nestingMiddleware(_secret))
+        .addHandler(cascade.handler);
 
     _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);
-
-    return (request) {
-      var segments = p.url.split(request.url.path);
-
-      for (var i = 0; i < segments.length; i++) {
-        if (segments[i] != "packages") continue;
-        return staticHandler(
-            request.change(path: p.url.joinAll(segments.take(i + 1))));
-      }
-
-      return new shelf.Response.notFound("Not found.");
-    };
-  }
-
   /// A handler that serves wrapper files used to bootstrap tests.
   shelf.Response _wrapperHandler(shelf.Request request) {
     var path = p.fromUri(request.url);
 
     if (path.endsWith(".browser_test.dart")) {
       var testPath = p.basename(p.withoutExtension(p.withoutExtension(path)));
       return new shelf.Response.ok('''
         import "package:stream_channel/stream_channel.dart";
 
         import "package:test/src/runner/plugin/remote_platform_helpers.dart";
@@ skipping 139 matching lines @@
           throw new LoadException(path,
               "Error getting $url: ${response.statusCode} "
                   "${response.reasonPhrase}\n"
               'Make sure "pub serve" is serving the test/ directory.');
         }
 
         if (getSourceMap && !_config.jsTrace) {
           _mappers[path] = new StackTraceMapper(
               await UTF8.decodeStream(response),
               mapUrl: url,
-              packageRoot: _config.pubServeUrl.resolve('packages'),
+              packageResolver: new SyncPackageResolver.root(
+                  _config.pubServeUrl.resolve('packages')),
               sdkRoot: _config.pubServeUrl.resolve('packages/\$sdk'));
           return;
         }
 
         // Drain the response stream.
         response.listen((_) {});
       } on IOException catch (error) {
         var message = getErrorMessage(error);
         if (error is SocketException) {
           message = "${error.osError.message} "
@@ skipping 11 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, () async {
       var dir = new Directory(_compiledDir).createTempSync('test_').path;
       var jsPath = p.join(dir, p.basename(dartPath) + ".browser_test.dart.js");
 
-      await _compilers.compile(dartPath, jsPath,
-          packageRoot: _config.packageRoot);
+      await _compilers.compile(dartPath, jsPath);
       if (_closed) return;
 
       var jsUrl = p.toUri(p.relative(dartPath, from: _root)).path +
           '.browser_test.dart.js';
       _jsHandler.add(jsUrl, (request) {
         return new shelf.Response.ok(new File(jsPath).readAsStringSync(),
             headers: {'Content-Type': 'application/javascript'});
       });
 
       var mapUrl = p.toUri(p.relative(dartPath, from: _root)).path +
           '.browser_test.dart.js.map';
       _jsHandler.add(mapUrl, (request) {
         return new shelf.Response.ok(
             new File(jsPath + '.map').readAsStringSync(),
             headers: {'Content-Type': 'application/json'});
       });
 
       if (_config.jsTrace) return;
       var mapPath = jsPath + '.map';
       _mappers[dartPath] = new StackTraceMapper(
           new File(mapPath).readAsStringSync(),
           mapUrl: p.toUri(mapPath),
-          packageRoot: p.toUri(_config.packageRoot),
+          packageResolver: await PackageResolver.current.asSync,
           sdkRoot: p.toUri(sdkDir));
     });
   }
 
   /// Returns the [BrowserManager] for [platform], which should be a browser.
   ///
   /// If no browser manager is running yet, starts one.
   Future<BrowserManager> _browserManagerFor(TestPlatform platform) {
     var manager = _browserManagers[platform];
     if (manager != null) return Result.release(manager);
@@ skipping 50 matching lines @@
     await Future.wait(futures);
 
     if (_config.pubServeUrl == null) {
       new Directory(_compiledDir).deleteSync(recursive: true);
     } else {
       _http.close();
     }
   });
   final _closeMemo = new AsyncMemoizer();
 }