Revert "Update the test runner to use the new dart:io API" again

tools/testing/dart/http_server.dart

-// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
+// 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:async';
 import 'dart:io';
 import 'dart:isolate';
 import 'dart:uri';
 import 'test_suite.dart';  // For TestUtils.
@@ skipping 82 matching lines @@
   int get crossOriginPort => _serverList[1].port;
 
   /**
    * [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}) {
-    return _startHttpServer(host, port: port).then((_) {
-      _startHttpServer(host,
-                       port: crossOriginPort,
-                       allowedPort:_serverList[0].port);
-    });
+  void startServers(String host, {int port: 0, int crossOriginPort: 0}) {
+    _startHttpServer(host, port: port);
+    _startHttpServer(host,
+                     port: crossOriginPort,
+                     allowedPort:_serverList[0].port);
   }
 
   String httpServerCommandline() {
     var dart = TestUtils.dartTestExecutable.toNativePath();
     var dartDir = TestUtils.dartDir();
     var script = dartDir.join(new Path("tools/testing/dart/http_server.dart"));
     var buildDirectory = _buildDirectory.toNativePath();
     var csp = useContentSecurityPolicy ? '--csp ' : '';
 
     return '$dart $script -p $port -c $crossOriginPort $csp'
            '--build-directory=$buildDirectory';
   }
 
   void stopServers() {
     for (var server in _serverList) {
       server.close();
     }
   }
 
-  Future _startHttpServer(String host, {int port: 0, int allowedPort: -1}) {
-    return HttpServer.bind(host, port).then((HttpServer httpServer) {
-      httpServer.listen((HttpRequest request) {
-        if (request.uri.path == "/echo") {
-          _handleEchoRequest(request, request.response);
-        } else {
-          _handleFileOrDirectoryRequest(
-              request, request.response, allowedPort);
-        }
-      },
-      onError: (e) {
-        DebugLogger.error('HttpServer: an error occured: $e');
-      });
-      _serverList.add(httpServer);
-    });
+  void _startHttpServer(String host, {int port: 0, int allowedPort: -1}) {
+    var httpServer = new HttpServer();
+    httpServer.onError = (e) {
+      DebugLogger.error('HttpServer: an error occured: $e');
+    };
+    httpServer.defaultRequestHandler = (request, response) {
+      _handleFileOrDirectoryRequest(request, response, allowedPort);
+    };
+    httpServer.addRequestHandler(
+        (req) => req.path == "/echo", _handleEchoRequest);
+
+    httpServer.listen(host, port);
+    _serverList.add(httpServer);
   }
 
   void _handleFileOrDirectoryRequest(HttpRequest request,
                                      HttpResponse response,
                                      int allowedPort) {
-    var path = _getFilePathFromRequestPath(request.uri.path);
+    var path = _getFilePathFromRequestPath(request.path);
     if (path != null) {
       var file = new File.fromPath(path);
       file.exists().then((exists) {
         if (exists) {
           _sendFileContent(request, response, allowedPort, path, file);
         } else {
           var directory = new Directory.fromPath(path);
           directory.exists().then((exists) {
             if (exists) {
               _listDirectory(directory).then((entries) {
                 _sendDirectoryListing(entries, request, response);
               });
             } else {
               _sendNotFound(request, response);
             }
           });
         }
       });
     } else {
-      if (request.uri.path == '/') {
+      if (request.path == '/') {
         var entries = [new _Entry('root_dart', 'root_dart/'),
                        new _Entry('root_build', 'root_build/'),
                        new _Entry('echo', 'echo')];
         _sendDirectoryListing(entries, request, response);
       } else {
         _sendNotFound(request, response);
       }
     }
   }
 
   void _handleEchoRequest(HttpRequest request, HttpResponse response) {
     response.headers.set("Access-Control-Allow-Origin", "*");
-    request.pipe(response);
-    response.done.catchError((e) {
-      DebugLogger.warning(
-          'HttpServer: error while closing the response stream: $e');
-    });
+    request.inputStream.pipe(response.outputStream);
   }
 
   Path _getFilePathFromRequestPath(String urlRequestPath) {
     // Go to the top of the file to see an explanation of the URL path scheme.
     var requestPath = new Path(urlRequestPath.substring(1)).canonicalize();
     var pathSegments = requestPath.segments();
     if (pathSegments.length > 0) {
       var basePath;
       var relativePath;
       if (pathSegments[0] == PREFIX_BUILDDIR) {
@@ skipping 18 matching lines @@
         return basePath.join(relativePath);
       }
     }
     return null;
   }
 
   Future<List<_Entry>> _listDirectory(Directory directory) {
     var completer = new Completer();
     var entries = [];
 
-    directory.list().listen(
-      (FileSystemEntity fse) {
-        var filename = new Path(fse.path).filename;
-        if (fse is File) {
-          entries.add(new _Entry(filename, filename));
-        } else if (fse is Directory) {
-          entries.add(new _Entry(filename, '$filename/'));
-        }
-      },
-      onDone: () {
+    directory.list()
+      ..onFile = (filepath) {
+        var filename = new Path(filepath).filename;
+        entries.add(new _Entry(filename, filename));
+      }
+      ..onDir = (dirpath) {
+        var filename = new Path(dirpath).filename;
+        entries.add(new _Entry(filename, '$filename/'));
+      }
+      ..onDone = (_) {
         completer.complete(entries);
-      });
+      };
     return completer.future;
   }
 
   void _sendDirectoryListing(List<_Entry> entries,
                              HttpRequest request,
                              HttpResponse response) {
     response.headers.set('Content-Type', 'text/html');
     var header = '''<!DOCTYPE html>
     <html>
     <head>
-      <title>${request.uri.path}</title>
+      <title>${request.path}</title>
     </head>
     <body>
       <code>
-        <div>${request.uri.path}</div>
+        <div>${request.path}</div>
         <hr/>
         <ul>''';
     var footer = '''
         </ul>
       </code>
     </body>
     </html>''';
 
 
     entries.sort();
-    response.write(header);
+    response.outputStream.writeString(header);
     for (var entry in entries) {
-      response.write(
-          '<li><a href="${new Path(request.uri.path).append(entry.name)}">'
+      response.outputStream.writeString(
+          '<li><a href="${new Path(request.path).append(entry.name)}">'
           '${entry.displayName}</a></li>');
     }
-    response.write(footer);
-    response.close();
-    response.done.catchError((e) {
-      DebugLogger.warning(
-          'HttpServer: error while closing the response stream: $e');
-    });
+    response.outputStream.writeString(footer);
+    response.outputStream.close();
   }
 
   void _sendFileContent(HttpRequest request,
                         HttpResponse response,
                         int allowedPort,
                         Path path,
                         File file) {
     if (allowedPort != -1) {
       var origin = new Uri(request.headers.value('Origin'));
       // Allow loading from http://*:$allowedPort in browsers.
@@ skipping 16 matching lines @@
         response.headers.set(header, "script-src 'self'; object-src 'self'");
       }
     }
     if (path.filename.endsWith('.html')) {
       response.headers.set('Content-Type', 'text/html');
     } else if (path.filename.endsWith('.js')) {
       response.headers.set('Content-Type', 'application/javascript');
     } else if (path.filename.endsWith('.dart')) {
       response.headers.set('Content-Type', 'application/dart');
     }
-    file.openRead().pipe(response);
-    response.done.catchError((e) {
-      DebugLogger.warning(
-          'HttpServer: error while closing the response stream: $e');
-    });
+    file.openInputStream().pipe(response.outputStream);
   }
 
   void _sendNotFound(HttpRequest request, HttpResponse response) {
     // NOTE: Since some tests deliberately try to access non-existent files.
     // We might want to remove this warning (otherwise it will show
     // up in the debug.log every time).
-    if (request.uri.path != "/favicon.ico") {
-      DebugLogger.warning('HttpServer: could not find file for request path: '
-                          '"${request.uri.path}"');
+    DebugLogger.warning('HttpServer: could not find file for request path: '
+                        '"${request.path}"');
+    response.statusCode = HttpStatus.NOT_FOUND;
+    try {
+      response.outputStream.close();
+    } catch (e) {
+      if (e is StreamException) {
+        DebugLogger.warning('HttpServer: error while closing the response '
+                            'stream: $e');
+      } else {
+        throw e;
+      }
     }
-    response.statusCode = HttpStatus.NOT_FOUND;
-    response.close();
-    response.done.catchError((e) {
-      DebugLogger.warning(
-          'HttpServer: error while closing the response stream: $e');
-    });
   }
 }
 
 // Helper class for displaying directory listings.
 class _Entry {
   final String name;
   final String displayName;
 
   _Entry(this.name, this.displayName);
 
   int compareTo(_Entry other) {
     return name.compareTo(other.name);
   }
 }