Add HTTP handler registration to the HTTP server

runtime/bin/http_impl.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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 775 matching lines @@
   HttpRequest _request;
   HttpResponse _response;
 
   // Callbacks.
   Function onRequestReceived;
   Function onClosed;
   Function onError;
 }
 
 
+class _RequestHandlerRegistration {
+  _RequestHandlerRegistration(Function this._matcher, Object this._handler);
+  Function _matcher;
+  RequestHandler _handler;
+}
+
+
+class _RequestHandlerImpl implements RequestHandler {
+  _RequestHandlerImpl(Function this._handler);
+  void onRequest(HttpRequest request, HttpResponse response) =>
+    _handler(request, response);
+  Function _handler;
+}
+
+
 // HTTP server waiting for socket connections. The connections are
 // managed by the server and as requests are received the request.
 class _HttpServer implements HttpServer {
-  _HttpServer() : _connections = new Set<_HttpConnection>();
+  _HttpServer() : _connections = new Set<_HttpConnection>(),
+                  _handlers = new List<_RequestHandlerRegistration>();
 
   void listen(String host, int port, [int backlog = 5]) {
     listenOn(new ServerSocket(host, port, backlog));
     _closeServer = true;
   }
 
   void listenOn(ServerSocket serverSocket) {
     void onConnection(Socket socket) {
       // Accept the client connection.
       _HttpConnection connection = new _HttpConnection(this);
       connection._connectionEstablished(socket);
-      connection.onRequestReceived = _onRequest;
+      connection.onRequestReceived = _handleRequest;
       connection.onClosed = () => _connections.remove(connection);
       connection.onError = (e) {
         _connections.remove(connection);
         if (_onError != null) _onError(e);
       };
       connection._connectionEstablished(socket);
       _connections.add(connection);
     }
     serverSocket.onConnection = onConnection;
     _server = serverSocket;
     _closeServer = false;
   }
 
+  addRequestHandler(bool matcher(String path), Object handler) {
+    if (handler is Function) {
+      handler = new _RequestHandlerImpl(handler);
+    }
+    _handlers.add(new _RequestHandlerRegistration(matcher, handler));
+  }
+
+  void set defaultRequestHandler(Object handler) {
+    _defaultHandler = handler;
+  }
+
   void close() {
     if (_server !== null && _closeServer) {
       _server.close();
     }
     _server = null;
     for (_HttpConnection connection in _connections) {
       connection._close();
     }
     _connections.clear();
   }
 
   int get port() {
     if (_server === null) {
       throw new HttpException("The HttpServer is not listening on a port.");
     }
     return _server.port;
   }
 
   void set onError(void callback(Exception e)) {
     _onError = callback;
   }
 
-  void set onRequest(void callback(HttpRequest, HttpResponse)) {
-    _onRequest = callback;
+  void _handleRequest(HttpRequest request, HttpResponse response) {
+    for (int i = 0; i < _handlers.length; i++) {
+      if (_handlers[i]._matcher(request)) {
+        var handler = _handlers[i]._handler;
+        try {
+          handler.onRequest(request, response);
+        } catch (var e) {
+          if (_onError != null) {
+            _onError(e);
+          }
+        }
+        return;
+      }
+    }
+
+    if (_defaultHandler != null) {
+      if (_defaultHandler is Function) {
+        _defaultHandler(request, response);
+      } else {
+        _defaultHandler.onRequest(request, response);
+      }
+    } else {
+      response.statusCode = HttpStatus.NOT_FOUND;
+      response.outputStream.close();
+    }
   }
 
+
   ServerSocket _server;  // The server listen socket.
   bool _closeServer = false;
   Set<_HttpConnection> _connections;  // Set of currently connected clients.
-  Function _onRequest;
+  List<_RequestHandlerRegistration> _handlers;
+  Object _defaultHandler;
   Function _onError;
 }
 
 
 class _HttpClientRequest
     extends _HttpRequestResponseBase implements HttpClientRequest {
   static final int START = 0;
   static final int HEADERS_SENT = 1;
   static final int DONE = 2;
 
@@ skipping 473 matching lines @@
     sockets.addFirst(socketConn);
     socketConn._markReturned();
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }