Make browser tests all run from a server instead of the local filesystem.

tools/testing/dart/http_server.dart

 // Copyright (c) 2012, 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 http_server;
 
 import 'dart:io';
 import 'dart:isolate';
 import 'test_suite.dart';  // For TestUtils.
+import '../../../pkg/args/lib/args.dart';

[ahe, 2013/01/16 13:30:37]

This breaks test.dart in a subtle, but severe way.

test.dart is supposed to test the Dart platform, so it must be self-contained,
otherwise you'll be unable to test the platform. Before this CL, test.dart was
self-contained as all the libraries it uses are compiled into the binary VM in
tools/testing/bin/.

Let's say I'm working on a CL to change how you specify named parameters.

I find all the uses of named parameters in sdk/lib and pkg and update them. Then
I run the tests. This happens:

'file:///Users/ahe/Dart/all/dart/pkg/args/lib/args.dart': Error: line 356 pos
41: '=' expected
      this.negatable, this.allowMultiple: false]);
                                        ^
'file:///Users/ahe/Dart/all/dart/tools/testing/dart/http_server.dart': Error:
line 10 pos 1: library handler failed
import '../../../pkg/args/lib/args.dart';
^
'file:///Users/ahe/Dart/all/dart/tools/testing/dart/test_runner.dart': Error:
line 20 pos 1: library handler failed
import "http_server.dart" as http_server;
^
'file:///Users/ahe/Dart/all/dart/tools/test.dart': Error: line 28 pos 1: library
handler failed
import "testing/dart/test_runner.dart";
^

 
-HttpServer _httpServer;
+main() {
+  /** 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.addOption('mode', abbr: 'm', help: 'Testing mode.',
+      defaultsTo: 'release');
+  parser.addOption('arch', abbr: 'a', help: 'Testing architecture.',
+      defaultsTo: 'ia32');
+  parser.addFlag('help', abbr: 'h', negatable: false,
+      help: 'Print this usage information.');
+  var args = parser.parse(new Options().arguments);
+  if (args['help']) {
+    print(parser.getUsage());
+  } else {
+    // Pretend we're running test.dart so that TestUtils doesn't get confused
+    // about the "current directory." This is only used if we're trying to run
+    // this file independently for local testing.
+    TestUtils.testScriptPath = new Path.fromNative(
+        new Options().script).directoryPath.join(
+        new Path('../../test.dart')).canonicalize().toNativePath();
+    TestingServerRunner.setPackageRootDir({'mode': args['mode'],
+        'arch': args['arch'], 'system': Platform.operatingSystem,
+        'build_directory': ''});
 
-void startHttpServer(String host, int port) {
-  var basePath = TestUtils.dartDir();
-  _httpServer = new HttpServer();
-  _httpServer.onError = (e) {
-    // Consider errors in the builtin http server fatal.
-    // Intead of just throwing the exception we print
-    // a message that makes it clearer what happened.
-    print('Test http server error: $e');
-    exit(1);
-  };
-  _httpServer.defaultRequestHandler = (request, resp) {
-    var requestPath = new Path(request.path).canonicalize();
-    if (!requestPath.isAbsolute) {
-      resp.statusCode = HttpStatus.NOT_FOUND;
-      resp.outputStream.close();
-    } else {
-      var path = basePath;
-      requestPath.segments().forEach((s) => path = path.append(s));
+    TestingServerRunner.startHttpServer('127.0.0.1',
+        port: int.parse(args['port']));
+    print('Server listening on port '
+          '${TestingServerRunner.serverList[0].port}.');
+    TestingServerRunner.startHttpServer('127.0.0.1',
+        allowedPort: TestingServerRunner.serverList[0].port, port:
+        int.parse(args['crossOriginPort']));
+    print(
+        'Server listening on port ${TestingServerRunner.serverList[1].port}.');
+  }
+}
+/**
+ * Runs a set of servers that are initialized specifically for the needs of our
+ * test framework, such as dealing with package-root.
+ */
+class TestingServerRunner {
+  static List serverList = [];
+  static Path _packageRootDir = null;
+
+  // Added as a getter so that the function will be called again each time the
+  // default request handler closure is executed.
+  static Path get packageRootDir => _packageRootDir;
+
+  static setPackageRootDir(Map configuration) {
+    _packageRootDir = TestUtils.currentWorkingDirectory.join(
+        new Path(TestUtils.buildDir(configuration)));
+  }
+
+  static startHttpServer(String host, {int allowedPort:-1, int port: 0}) {
+    var basePath = TestUtils.dartDir();
+    var httpServer = new HttpServer();
+    var packagesDirName = 'packages';
+    httpServer.onError = (e) {
+      // Consider errors in the builtin http server fatal.
+      // Intead of just throwing the exception we print
+      // a message that makes it clearer what happened.
+      print('Test http server error: $e');
+      exit(1);
+    };
+    httpServer.defaultRequestHandler = (request, resp) {
+      var requestPath = new Path(request.path.substring(1)).canonicalize();
+      var path = basePath.join(requestPath);
       var file = new File(path.toNativePath());
+
+      if (requestPath.segments().contains(packagesDirName)) {
+        // Essentially implement the packages path rewriting, so we don't have
+        // to pass environment variables to the browsers.
+        var requestPathStr = requestPath.toNativePath().substring(
+            requestPath.toNativePath().indexOf(packagesDirName));
+        path = packageRootDir.append(requestPathStr);
+        file = new File(path.toNativePath());
+      }
       file.exists().then((exists) {
         if (exists) {
-          // Allow loading from localhost in browsers.
-          resp.headers.set("Access-Control-Allow-Origin", "*");
+          if (allowedPort != -1) {
+            // Allow loading from localhost:$allowedPort in browsers.
+            resp.headers.set("Access-Control-Allow-Origin",
+                "http://127.0.0.1:${allowedPort+1}");
+            resp.headers.set('Access-Control-Allow-Credentials', 'true');
+          } else {
+            // No allowedPort specified. Allow from anywhere (but cross-origin
+            // requests *with credentials* will fail because you can't use "*").
+            resp.headers.set("Access-Control-Allow-Origin", "*");
+          }
+          if (path.toNativePath().endsWith('.html')) {
+            resp.headers.set('Content-Type', 'text/html');
+          } else if (path.toNativePath().endsWith('.js')) {
+            resp.headers.set('Content-Type', 'application/javascript');
+          } else if (path.toNativePath().endsWith('.dart')) {
+            resp.headers.set('Content-Type', 'application/dart');
+          }
           file.openInputStream().pipe(resp.outputStream);
         } else {
           resp.statusCode = HttpStatus.NOT_FOUND;
-          resp.outputStream.close();
+          try {
+            resp.outputStream.close();
+          } catch (e) {
+            if (e is StreamException) {
+              print('Test http_server error closing the response stream: $e');
+            } else {
+              throw e;
+            }
+          }
         }
       });
-    }
-  };
 
-  // Echos back the contents of the request as the response data.
-  _httpServer.addRequestHandler((req) => req.path == "/echo", (request, resp) {
-    resp.headers.set("Access-Control-Allow-Origin", "*");
+    };
 
-    request.inputStream.pipe(resp.outputStream);
-  });
+    // Echos back the contents of the request as the response data.
+    httpServer.addRequestHandler((req) => req.path == "/echo", (request, resp) {
+      resp.headers.set("Access-Control-Allow-Origin", "*");
 
-  _httpServer.listen(host, port);
+      request.inputStream.pipe(resp.outputStream);
+    });
+
+    httpServer.listen(host, port);
+    serverList.add(httpServer);
+  }
+
+  static terminateHttpServers() {
+    for (var server in serverList) server.close();
+  }
 }
-
-terminateHttpServer() {
-  if (_httpServer != null) _httpServer.close();
-}