Add a new attachTo method to HttpServer, for using an existing ServerSocket.

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 _HttpRequestResponseBase {
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _contentLength = -1,
         _keepAlive = false,
         _headers = new Map();
 
@@ skipping 336 matching lines @@
       case HttpStatus.SERVICE_UNAVAILABLE: return "Service Unavailable";
       case HttpStatus.GATEWAY_TIMEOUT: return "Gateway Time-out";
       case HttpStatus.HTTP_VERSION_NOT_SUPPORTED:
         return "Http Version not supported";
       default: return "Status $statusCode";
     }
   }
 
   bool _writeHeader() {
     List<int> data;
-    OutputStream stream = _httpConnection.outputStream;
 
     // Write status line.
-    stream.write(_Const.HTTP11);
+    _httpConnection.outputStream.write(_Const.HTTP11);
     _writeSP();
     data = _statusCode.toString().charCodes();
-    stream.write(data);
+    _httpConnection.outputStream.write(data);
     _writeSP();
     data = reasonPhrase.charCodes();
-    stream.write(data);
+    _httpConnection.outputStream.write(data);
     _writeCRLF();
 
     // Determine the value of the "Connection" header
     // based on the keep alive state.
     setHeader("Connection", keepAlive ? "keep-alive" : "close");
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
       setHeader("Content-Length", _contentLength.toString());
     } else {
@@ skipping 83 matching lines @@
   void set onClosed(void callback()) {
     _requestOrResponse._streamSetCloseHandler(callback);
   }
 
   void set onError(void callback(Exception e)) {
     _requestOrResponse._streamSetErrorHandler(callback);
   }
 
   _HttpRequestResponseBase _requestOrResponse;
 }
 

[Søren Gjesse, 2012/04/02 07:32:41]

Looks as if this change is mixed with the previous change of handling closed
sockets. It should not be part of this change.

[Anders Johnsen, 2012/04/02 07:36:52]

Removed :)

+class _EmptyOutputStream implements OutputStream {
+  void close() {}
+  void destroy() {}
+
+  void set onVlosed(void callback()) {}
+  void set onError(void callback()) {}
+  void set onNoPendingWrites(void callback()) {}
+
+  bool write(List buffer, [bool copybuffer]) => true;
+  bool writeFrom(List buffer, [int offset, int len]) => true;
+  bool writeString(String string, [Encoding encoding]) => true;
+}
 
 class _HttpConnectionBase implements Hashable {
   static final int PHASE_IDLE = 0;
   static final int PHASE_REQUEST = 1;
   static final int PHASE_RESPONSE = 2;
 
   _HttpConnectionBase() : _phase = PHASE_IDLE,
                           _sendBuffers = new Queue(),
                           _httpParser = new _HttpParser();
 
   void _connectionEstablished(Socket socket) {
     _socket = socket;
     // Register handler for socket events.
     _socket.onData = _onData;
     _socket.onClosed = _onClosed;
     _socket.onError = _onError;
   }
 
   OutputStream get outputStream() {
+    if (_closing) return new _EmptyOutputStream();
     return _socket.outputStream;
   }
 
   void _onData() {
     int available = _socket.available();
     if (available == 0) {
       return;
     }
 
     ByteArray buffer = new ByteArray(available);
     int bytesRead = _socket.readList(buffer, 0, available);
     if (bytesRead > 0) {
       int parsed = _httpParser.writeList(buffer, 0, bytesRead);
       if (parsed != bytesRead) {
         // TODO(sgjesse): Error handling.
         _socket.close();
       }
     }
   }
 
   void _onClosed() {
+    _closing = true;
     if (_phase != PHASE_IDLE) {
       // Client closed socket for writing. Socket should still be open
       // for writing the response.
-      _closing = true;
     } else {
       // The connection is currently not used by any request just close it.
       _socket.close();
     }
     if (_onDisconnectCallback != null) _onDisconnectCallback();
   }
 
   void _onError(Exception e) {
+    _closing = true;
     // If an error occurs, make sure to close the socket if one is associated.
     if (_socket != null) {
       _socket.close();
     }
     if (_onErrorCallback != null) {
       _onErrorCallback(e);
     }
     _propagateError(e);
   }
 
@@ skipping 89 matching lines @@
   HttpResponse _response;
 
   // Callbacks.
   var requestReceived;
 }
 
 
 // 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>();
+
   void listen(String host, int port, [int backlog = 5]) {
+    _server = new ServerSocket(host, port, backlog);
+    attachTo(_server);
+  }
 
+  void attachTo(ServerSocket serverSocket) {
     void onConnection(Socket socket) {
       // Accept the client connection.
       _HttpConnection connection = new _HttpConnection(this);
-      connection._connectionEstablished(socket);
       connection.requestReceived = _onRequest;
-      _connections.add(connection);
       connection.onDisconnect = () => _connections.remove(connection);
       connection.onError = (e) {
         if (_onError != null) _onError(e);
       };
+      connection._connectionEstablished(socket);
+      _connections.add(connection);
     }
 
-    _connections = new Set<_HttpConnection>();
-    _server = new ServerSocket(host, port, backlog);
-    _server.onConnection = onConnection;
+    serverSocket.onConnection = onConnection;
   }
 
   void close() {
-    _server.close();
+    if (_server !== null) {
+      _server.close();
+      _server = null;
+    }
     for (_HttpConnection connection in _connections) {
       connection._socket.close();
     }
+    _connections.clear();
   }
 
   int get port() => _server.port;
 
   void set onError(void callback(Exception e)) {
     _onError = callback;
   }
 
   void set onRequest(void callback(HttpRequest, HttpResponse)) {
     _onRequest = callback;
   }
 
-  ServerSocket _server;  // The server listen socket.
+  ServerSocket _server;  // The server listen socket, if created internally.
   Set<_HttpConnection> _connections;  // Set of currently connected clients.
   Function _onRequest;
   Function _onError;
 }
 
 
 class _HttpClientRequest
     extends _HttpRequestResponseBase implements HttpClientRequest {
   static final int START = 0;
   static final int HEADERS_SENT = 1;
@@ skipping 95 matching lines @@
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
 
   void _streamSetErrorHandler(callback(Exception e)) {
     _streamErrorHandler = callback;
   }
 
   void _writeHeader() {
     List<int> data;
-    OutputStream stream = _httpConnection.outputStream;
 
     // Write request line.
     data = _method.toString().charCodes();
-    stream.write(data);
+    _httpConnection.outputStream.write(data);
     _writeSP();
     data = _uri.toString().charCodes();
-    stream.write(data);
+    _httpConnection.outputStream.write(data);
     _writeSP();
-    stream.write(_Const.HTTP11);
+    _httpConnection.outputStream.write(_Const.HTTP11);
     _writeCRLF();
 
     // Determine the value of the "Connection" header
     // based on the keep alive state.
     setHeader("Connection", keepAlive ? "keep-alive" : "close");
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
       setHeader("Content-Length", _contentLength.toString());
     } else {
@@ skipping 390 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?
 }