Add HttpsServer class and test.

sdk/lib/io/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.
 
 // The close queue handles graceful closing of HTTP connections. When
 // a connection is added to the queue it will enter a wait state
 // waiting for all data written and possibly socket shutdown from
 // peer.
 class _CloseQueue {
   _CloseQueue() : _q = new Set<_HttpConnectionBase>();
@@ skipping 907 matching lines @@
 
 
 class _RequestHandlerRegistration {
   _RequestHandlerRegistration(Function this._matcher, Function this._handler);
   Function _matcher;
   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>(),
-                  _handlers = new List<_RequestHandlerRegistration>(),
-                  _closeQueue = new _CloseQueue();
+// HTTPS connections are also supported, if the _HttpServer.httpsServer
+// constructor is used and a certificate name is provided in listen,
+// or a SecureServerSocket is provided to listenOn.
+class _HttpServer implements HttpServer, HttpsServer {

[Mads Ager (google), 2012/11/29 09:45:24]

Similarly here in the implementation. It might be nice to have a base class for
the shared functionality and have separate listen and listenOn methods.

+  _HttpServer() : this._internal(isSecure: false);
 
-  void listen(String host, int port, {int backlog: 128}) {
-    listenOn(new ServerSocket(host, port, backlog));
+  _HttpServer.httpsServer() : this._internal(isSecure: true);
+
+  _HttpServer._internal({ bool isSecure: false })
+      : _secure = isSecure,
+        _connections = new Set<_HttpConnection>(),
+        _handlers = new List<_RequestHandlerRegistration>(),
+        _closeQueue = new _CloseQueue();
+
+  void listen(String host,
+              int port,
+              {int backlog: 128,
+              String certificate_name}) {
+    if (_secure) {
+      listenOn(new SecureServerSocket(host, port, backlog, certificate_name));
+    } else {
+      listenOn(new ServerSocket(host, port, backlog));
+    }
     _closeServer = true;
   }
 
   void listenOn(ServerSocket serverSocket) {
+    if (_secure && serverSocket is! SecureServerSocket) {
+        throw new HttpException(
+            'HttpsServer.listenOn was called with non-secure server socket');
+    } else if (!_secure && serverSocket is SecureServerSocket) {
+        throw new HttpException(
+            'HttpServer.listenOn was called with a secure server socket');
+    }
     void onConnection(Socket socket) {
       // Accept the client connection.
       _HttpConnection connection = new _HttpConnection(this);
       connection._connectionEstablished(socket);
       _connections.add(connection);
       connection.onRequestReceived = _handleRequest;
       connection.onClosed = () => _connections.remove(connection);
       connection.onDetach = () => _connections.remove(connection);
       connection.onError = (e) {
         _connections.remove(connection);
@@ skipping 95 matching lines @@
       } else {
         assert(result._isClosing);
         result.closing++;
       }
     });
     return result;
   }
 
   ServerSocket _server;  // The server listen socket.
   bool _closeServer = false;
+  bool _secure;
   Set<_HttpConnection> _connections;  // Set of currently connected clients.
   List<_RequestHandlerRegistration> _handlers;
   Object _defaultHandler;
   Function _onError;
   _CloseQueue _closeQueue;
   _HttpSessionManager _sessionManagerInstance;
 }
 
 
 class _HttpClientRequest
@@ skipping 1061 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }