Use ConnectEx on Windows, to do async connect of sockets.

runtime/bin/eventhandler_win.h

 // 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.
 
 #ifndef BIN_EVENTHANDLER_WIN_H_
 #define BIN_EVENTHANDLER_WIN_H_
 
 #if !defined(BIN_EVENTHANDLER_H_)
 #error Do not include eventhandler_win.h directly; use eventhandler.h instead.
 #endif
@@ skipping 23 matching lines @@
   Dart_Port dart_port;
   int64_t data;
 };
 
 
 // An OverlappedBuffer encapsulates the OVERLAPPED structure and the
 // associated data buffer. For accept it also contains the pre-created
 // socket for the client.
 class OverlappedBuffer {
  public:
-  enum Operation { kAccept, kRead, kRecvFrom, kWrite, kSendTo, kDisconnect };
+  enum Operation {
+    kAccept, kRead, kRecvFrom, kWrite, kSendTo, kDisconnect, kConnect
+  };
 
   static OverlappedBuffer* AllocateAcceptBuffer(int buffer_size);
   static OverlappedBuffer* AllocateReadBuffer(int buffer_size);
   static OverlappedBuffer* AllocateRecvFromBuffer(int buffer_size);
   static OverlappedBuffer* AllocateWriteBuffer(int buffer_size);
   static OverlappedBuffer* AllocateSendToBuffer(int buffer_size);
   static OverlappedBuffer* AllocateDisconnectBuffer();
+  static OverlappedBuffer* AllocateConnectBuffer();
   static void DisposeBuffer(OverlappedBuffer* buffer);
 
   // Find the IO buffer from the OVERLAPPED address.
   static OverlappedBuffer* GetFromOverlapped(OVERLAPPED* overlapped);
 
   // Read data from a buffer which has been received. It will read up
   // to num_bytes bytes of data returning the actual number of bytes
   // read. This will update the index of the next byte in the buffer
   // so calling Read several times will keep returning new data from
   // the buffer until all data have been read.
@@ skipping 346 matching lines @@
   ClientSocket* accepted_head_;
   ClientSocket* accepted_tail_;
 };
 
 
 // Information on connected sockets.
 class ClientSocket : public SocketHandle {
  public:
   explicit ClientSocket(SOCKET s) : SocketHandle(s),
                                     DisconnectEx_(NULL),
-                                    next_(NULL) {
+                                    next_(NULL),
+                                    connected_(false),
+                                    closed_(false) {
     LoadDisconnectEx();
     type_ = kClientSocket;
   }
 
   ClientSocket(SOCKET s, Dart_Port port) : SocketHandle(s, port),
                                            DisconnectEx_(NULL),
-                                           next_(NULL) {
+                                           next_(NULL),
+                                           connected_(false),
+                                           closed_(false) {
     LoadDisconnectEx();
     type_ = kClientSocket;
   }
 
   virtual ~ClientSocket() {
     // Don't delete this object until all pending requests have been handled.
     ASSERT(!HasPendingRead());
     ASSERT(!HasPendingWrite());
     ASSERT(next_ == NULL);
   };
 
   void Shutdown(int how);
 
   // Internal interface used by the event handler.
   virtual bool IssueRead();
   virtual bool IssueWrite();
   void IssueDisconnect();
   void DisconnectComplete(OverlappedBuffer* buffer);
 
+  void ConnectComplete(OverlappedBuffer* buffer);
+
   virtual void EnsureInitialized(
     EventHandlerImplementation* event_handler);
   virtual void DoClose();
   virtual bool IsClosed();
 
   ClientSocket* next() { return next_; }
   void set_next(ClientSocket* next) { next_ = next; }
 
+  void mark_connected() {
+    connected_ = true;
+  }
+  bool is_connected() const { return connected_; }
+
  private:
   bool LoadDisconnectEx();
 
   LPFN_DISCONNECTEX DisconnectEx_;
   ClientSocket* next_;
+  bool connected_;
+  bool closed_;
 };
 
 
 class DatagramSocket : public SocketHandle {
  public:
   explicit DatagramSocket(SOCKET s) : SocketHandle(s) {
     type_ = kDatagramSocket;
   }
 
   virtual ~DatagramSocket() {
@@ skipping 28 matching lines @@
   void HandleTimeout();
   void HandleAccept(ListenSocket* listen_socket, OverlappedBuffer* buffer);
   void HandleClosed(Handle* handle);
   void HandleError(Handle* handle);
   void HandleRead(Handle* handle, int bytes, OverlappedBuffer* buffer);
   void HandleRecvFrom(Handle* handle, int bytes, OverlappedBuffer* buffer);
   void HandleWrite(Handle* handle, int bytes, OverlappedBuffer* buffer);
   void HandleDisconnect(ClientSocket* client_socket,
                         int bytes,
                         OverlappedBuffer* buffer);
+  void HandleConnect(ClientSocket* client_socket,
+                     int bytes,
+                     OverlappedBuffer* buffer);
   void HandleIOCompletion(DWORD bytes, ULONG_PTR key, OVERLAPPED* overlapped);
 
   HANDLE completion_port() { return completion_port_; }
 
  private:
   ClientSocket* client_sockets_head_;
 
   TimeoutQueue timeout_queue_;  // Time for next timeout.
   bool shutdown_;
   HANDLE completion_port_;
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_EVENTHANDLER_WIN_H_