Revert "Remove support for "packages" URL from testing server."

tools/testing/dart/http_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.
 
 import 'dart:async';
 import 'dart:convert' show HtmlEscape;
 import 'dart:io';
 
+import 'package:package_resolver/package_resolver.dart';
+
 import 'configuration.dart';
 import 'vendored_pkg/args/args.dart';
 import 'utils.dart';
 
 class DispatchingServer {
   HttpServer server;
   Map<String, Function> _handlers = new Map<String, Function>();
   Function _notFound;
 
   DispatchingServer(
@@ skipping 19 matching lines @@
 }
 
 /// Interface of the HTTP server:
 ///
 /// /echo: This will stream the data received in the request stream back
 ///        to the client.
 /// /root_dart/X: This will serve the corresponding file from the dart
 ///               directory (i.e. '$DartDirectory/X').
 /// /root_build/X: This will serve the corresponding file from the build
 ///                directory (i.e. '$BuildDirectory/X').
+/// /FOO/packages/PAZ/BAR: This will serve files from the packages listed in
+///      the package spec .packages.  Supports a package
+///      root or custom package spec, and uses [dart_dir]/.packages
+///      as the default. This will serve file lib/BAR from the package PAZ.
 /// /ws: This will upgrade the connection to a WebSocket connection and echo
 ///      all data back to the client.
 ///
 /// In case a path does not refer to a file but rather to a directory, a
 /// directory listing will be displayed.
 
 const PREFIX_BUILDDIR = 'root_build';
 const PREFIX_DARTDIR = 'root_dart';
 
 void main(List<String> arguments) {
   // This script is in [dart]/tools/testing/dart.
   TestUtils.setDartDirUri(Platform.script.resolve('../../..'));
   /** Convenience method for local testing. */
   var parser = new ArgParser();
   parser.addOption('port',
       abbr: 'p',
       help: 'The main server port we wish to respond to requests.',
       defaultsTo: '0');
   parser.addOption('crossOriginPort',
       abbr: 'c',
       help: 'A different port that accepts request from the main server port.',
       defaultsTo: '0');
   parser.addFlag('help',
       abbr: 'h', negatable: false, help: 'Print this usage information.');
   parser.addOption('build-directory', help: 'The build directory to use.');
-  parser.addOption('package-root', help: 'Obsolete unsupported option');
-  parser.addOption('packages', help: 'Obsolete unsupported option');
+  parser.addOption('package-root', help: 'The package root to use.');
+  parser.addOption('packages', help: 'The package spec file to use.');
   parser.addOption('network',
       help: 'The network interface to use.', defaultsTo: '0.0.0.0');
   parser.addFlag('csp',
       help: 'Use Content Security Policy restrictions.', defaultsTo: false);
   parser.addOption('runtime',
       help: 'The runtime we are using (for csp flags).', defaultsTo: 'none');
 
   var args = parser.parse(arguments);
   if (args['help'] as bool) {
     print(parser.getUsage());
   } else {
-    var servers = new TestingServers(args['build-directory'] as String,
-        args['csp'] as bool, Runtime.find(args['runtime'] as String), null);
+    var servers = new TestingServers(
+        args['build-directory'] as String,
+        args['csp'] as bool,
+        Runtime.find(args['runtime'] as String),
+        null,
+        args['package-root'] as String,
+        args['packages'] as String);
     var port = int.parse(args['port'] as String);
     var crossOriginPort = int.parse(args['crossOriginPort'] as String);
     servers
         .startServers(args['network'] as String,
             port: port, crossOriginPort: crossOriginPort)
         .then((_) {
       DebugLogger.info('Server listening on port ${servers.port}');
       DebugLogger.info('Server listening on port ${servers.crossOriginPort}');
     });
   }
 }
 
 /**
  * Runs a set of servers that are initialized specifically for the needs of our
- * test framework.
+ * test framework, such as dealing with package-root.
  */
 class TestingServers {
   static final _CACHE_EXPIRATION_IN_SECONDS = 30;
   static final _HARMLESS_REQUEST_PATH_ENDINGS = [
     "/apple-touch-icon.png",
     "/apple-touch-icon-precomposed.png",
     "/favicon.ico",
     "/foo",
     "/bar",
     "/NonExistingFile",
     "IntentionallyMissingFile",
   ];
 
   final List<HttpServer> _serverList = [];
   Uri _buildDirectory;
   Uri _dartDirectory;
+  Uri _packageRoot;
+  Uri _packages;
   final bool useContentSecurityPolicy;
   final Runtime runtime;
   DispatchingServer _server;
+  SyncPackageResolver _resolver;
 
   TestingServers(String buildDirectory, this.useContentSecurityPolicy,
-      [this.runtime = Runtime.none, String dartDirectory]) {
+      [this.runtime = Runtime.none,
+      String dartDirectory,
+      String packageRoot,
+      String packages]) {
     _buildDirectory = Uri.base.resolveUri(new Uri.directory(buildDirectory));
     if (dartDirectory == null) {
       _dartDirectory = TestUtils.dartDirUri;
     } else {
       _dartDirectory = Uri.base.resolveUri(new Uri.directory(dartDirectory));
     }
+    if (packageRoot == null) {
+      if (packages == null) {
+        _packages = _dartDirectory.resolve('.packages');
+      } else {
+        _packages = new Uri.file(packages);
+      }
+    } else {
+      _packageRoot = new Uri.directory(packageRoot);
+    }
   }
 
   int get port => _serverList[0].port;
   int get crossOriginPort => _serverList[1].port;
   DispatchingServer get server => _server;
 
   /**
    * [startServers] will start two Http servers.
    * The first server listens on [port] and sets
    *   "Access-Control-Allow-Origin: *"
    * The second server listens on [crossOriginPort] and sets
    *   "Access-Control-Allow-Origin: client:port1
    *   "Access-Control-Allow-Credentials: true"
    */
   Future startServers(String host,
       {int port: 0, int crossOriginPort: 0}) async {
+    if (_packages != null) {
+      _resolver = await SyncPackageResolver.loadConfig(_packages);
+    } else {
+      _resolver = new SyncPackageResolver.root(_packageRoot);
+    }
     _server = await _startHttpServer(host, port: port);
     await _startHttpServer(host,
         port: crossOriginPort, allowedPort: _serverList[0].port);
   }
 
   String httpServerCommandLine() {
     var dart = Platform.resolvedExecutable;
     var script = _dartDirectory.resolve('tools/testing/dart/http_server.dart');
     var buildDirectory = _buildDirectory.toFilePath();
     var command = [
       dart,
       script.toFilePath(),
       '-p',
       port,
       '-c',
       crossOriginPort,
       '--build-directory=$buildDirectory',
       '--runtime=${runtime.name}'
     ];
     if (useContentSecurityPolicy) {
       command.add('--csp');
     }
+    if (_packages != null) {
+      command.add('--packages=${_packages.toFilePath()}');
+    } else if (_packageRoot != null) {
+      command.add('--package-root=${_packageRoot.toFilePath()}');
+    }
     return command.join(' ');
   }
 
   void stopServers() {
     for (var server in _serverList) {
       server.close();
     }
   }
 
   void _onError(e) {
     DebugLogger.error('HttpServer: an error occured', e);
   }
 
   Future<DispatchingServer> _startHttpServer(String host,
       {int port: 0, int allowedPort: -1}) {
     return HttpServer.bind(host, port).then((HttpServer httpServer) {
       var server = new DispatchingServer(httpServer, _onError, _sendNotFound);
       server.addHandler('/echo', _handleEchoRequest);
       server.addHandler('/ws', _handleWebSocketRequest);
       fileHandler(HttpRequest request) {
         _handleFileOrDirectoryRequest(request, allowedPort);
       }
 
       server.addHandler('/$PREFIX_BUILDDIR', fileHandler);
       server.addHandler('/$PREFIX_DARTDIR', fileHandler);
+      server.addHandler('/packages', fileHandler);
       _serverList.add(httpServer);
       return server;
     });
   }
 
   Future _handleFileOrDirectoryRequest(
       HttpRequest request, int allowedPort) async {
     // Enable browsers to cache file/directory responses.
     var response = request.response;
     response.headers
@@ skipping 52 matching lines @@
     }).catchError((e) {
       DebugLogger.warning(
           'HttpServer: error while transforming to WebSocket', e);
     });
   }
 
   Uri _getFileUriFromRequestUri(Uri request) {
     // Go to the top of the file to see an explanation of the URL path scheme.
     List<String> pathSegments = request.normalizePath().pathSegments;
     if (pathSegments.length == 0) return null;
+    int packagesIndex = pathSegments.indexOf('packages');
+    if (packagesIndex != -1) {
+      var packageUri = new Uri(
+          scheme: 'package',
+          pathSegments: pathSegments.skip(packagesIndex + 1));
+      return _resolver.resolveUri(packageUri);
+    }
     if (pathSegments[0] == PREFIX_BUILDDIR) {
       return _buildDirectory.resolve(pathSegments.skip(1).join('/'));
     }
     if (pathSegments[0] == PREFIX_DARTDIR) {
       return _dartDirectory.resolve(pathSegments.skip(1).join('/'));
     }
     return null;
   }
 
   Future<List<_Entry>> _listDirectory(Directory directory) {
@@ skipping 148 matching lines @@
 class _Entry implements Comparable<_Entry> {
   final String name;
   final String displayName;
 
   _Entry(this.name, this.displayName);
 
   int compareTo(_Entry other) {
     return name.compareTo(other.name);
   }
 }