Fix HTTP sample implementation to actually wait for connections before attempting to write.

samples/chat/http_impl.dart

 // Copyright (c) 2011, 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.
 
 // Global constants.
 class Const {
   // Bytes for "HTTP/1.0".
   static final HTTP10 = const [72, 84, 84, 80, 47, 49, 46, 48];
   // Bytes for "HTTP/1.1".
   static final HTTP11 = const [72, 84, 84, 80, 47, 49, 46, 49];
@@ skipping 1368 matching lines @@
   Socket _socket;
   Date _returnTime;
 }
 
 
 class HTTPClientImplementation implements HTTPClient{
   static final int DEFAULT_EVICTION_TIMEOUT = 60000;
 
   HTTPClientImplementation() : _openSockets = new Map(), _shutdown = false;
 
-  HTTPClientRequest open(String method,
-                         String host,
-                         int port,
-                         String path) {
-    // TODO(sgjesse): Throw exception.
-    if (_shutdown) return null;
-    SocketConnection socketConn = _getSocketConnection(host, port);
-    HTTPClientConnection connection =
-        new HTTPClientConnection(this, socketConn);
-    HTTPClientRequest request = connection.open(method, path);
-    return request;
+  void open(String method, String host, int port, String path) {
+    if (_shutdown && _openHandler) {
+      _openHandler(null);
+      return;
+    }
+    _getSocketConnection(host, port, method, path);
   }
 
   void shutdown() {
      _openSockets.forEach(
          void _(String key, Queue<SocketConnection> connections) {
            while (!connections.isEmpty()) {
              var socketConn = connections.removeFirst();
              socketConn._socket.close();
            }
          });
      if (_evictionTimer != null) {
        _evictionTimer.cancel();
      }
      _shutdown = true;
   }
 
   String _connectionKey(String host, int port) {
     return "$host:$port";
   }
 
-  SocketConnection _getSocketConnection(String host, int port) {
-    SocketConnection entry;
+  void _getSocketConnection(String host, int port, String method, String path) {
+
+    void _connectionOpened(SocketConnection socketConn) {
+      HTTPClientConnection connection =
+          new HTTPClientConnection(this, socketConn);
+      HTTPClientRequest request = connection.open(method, path);
+      if (_openHandler != null) {
+        _openHandler(request);
+      }
+    }
 
     // If there are active connections for this key get the first one
     // otherwise create a new one.
     Queue socketConnections = _openSockets[_connectionKey(host, port)];
     if (socketConnections == null || socketConnections.isEmpty()) {
       Socket socket = new Socket(host, port);
-      entry = new SocketConnection(host, port, socket);
+      socket.connectHandler = () {
+        SocketConnection socketConn = new SocketConnection(host, port, socket);
+        _connectionOpened(socketConn);
+      };
     } else {
-      entry = socketConnections.removeFirst();
+      SocketConnection socketConn = socketConnections.removeFirst();
+      _connectionOpened(socketConn);
 
       // Get rid of eviction timer if there are no more active connections.
       if (socketConnections.isEmpty()) {
         _evictionTimer.cancel();
         _evictionTimer = null;
       }
     }
-
-    return entry;
   }
 
   void _returnSocketConnection(SocketConnection socketConn) {
     // If the HTTP client is beeing shutdown don't return the connection.
     if (_shutdown) {
       socketConn._socket.close();
       return;
     };
 
     String key = _connectionKey(socketConn._host, socketConn._port);
@@ skipping 25 matching lines @@
             });
       }
       _evictionTimer = new Timer(_handleEviction, 10000, true);
     }
 
     // Return connection.
     sockets.addFirst(socketConn);
     socketConn._markReturned();
   }
 
+  void set openHandler(void callback(HTTPClientRequest request)) {
+    _openHandler = callback;
+  }
+
+  var _openHandler;
   Map<String, Queue<SocketConnection>> _openSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }