Implement debugger connection on Windows.

runtime/bin/dbg_connection.cc

 // 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.
 
 #include "bin/dbg_connection.h"
 #include "bin/dbg_message.h"
 #include "bin/dartutils.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
@@ skipping 90 matching lines @@
     // TODO(hausner):
     // Buffer is full. What should we do if there is no valid message
     // in the buffer? This might be possible if the client sends a message
     // that's larger than the buffer, of if the client sends malformed
     // messages that keep piling up.
     ASSERT(IsValidMessage());
     return;
   }
   // TODO(hausner): Handle error conditions returned by Read. We may
   // want to close the debugger connection if we get any errors.
-  int bytes_read = Socket::Read(fd_, buf_ + data_length_, max_read);
+  int bytes_read =
+      DebuggerConnectionImpl::Receive(fd_, buf_ + data_length_, max_read);
   if (bytes_read == 0) {
     connection_is_alive_ = false;
     return;
   }
   ASSERT(bytes_read > 0);
   data_length_ += bytes_read;
   ASSERT(data_length_ < buf_length_);
   buf_[data_length_] = '\0';
 }
 
@@ skipping 155 matching lines @@
 void DebuggerConnectionHandler::StartHandler(const char* address,
                                              int port_number) {
   MonitorLocker ml(&handler_lock_);
   if (listener_fd_ != -1) {
     return;  // The debugger connection handler was already started.
   }
 
   // First setup breakpoint, exception and delayed breakpoint handlers.
   DbgMsgQueueList::Initialize();
 
+  // Initialize the socket implementation.
+  if (!Socket::Initialize()) {
+    FATAL("Failed initializing socket implementation.");
+  }
+
   // Now setup a listener socket and start a thread which will
   // listen, accept connections from debuggers, read and handle/dispatch
   // debugger commands received on these connections.
   ASSERT(listener_fd_ == -1);
   listener_fd_ = ServerSocket::CreateBindListen(address, port_number, 1);
   DebuggerConnectionImpl::StartHandler(port_number);
 }
 
 
 void DebuggerConnectionHandler::WaitForConnection() {
@@ skipping 31 matching lines @@
     intptr_t remaining = msg->length();
     intptr_t sent = 0;
     const intptr_t max_piece_len = 122;  // Pretty arbitrary, not a power of 2.
     dart::Monitor sleep;
     while (remaining > 0) {
       intptr_t piece_len = remaining;
       if (piece_len > max_piece_len) {
         piece_len = max_piece_len;
       }
       intptr_t written =
-        Socket::Write(debug_fd, msg->buf() + sent, piece_len);
+          DebuggerConnectionImpl::Send(debug_fd, msg->buf() + sent, piece_len);
       ASSERT(written == piece_len);
       sent += written;
       remaining -= written;
       // Wait briefly so the OS does not coalesce message fragments.
       {
         MonitorLocker ml(&sleep);
         ml.Wait(10);
       }
     }
     return;
   }
-  intptr_t bytes_written = Socket::Write(debug_fd, msg->buf(), msg->length());
+  intptr_t bytes_written =
+      DebuggerConnectionImpl::Send(debug_fd, msg->buf(), msg->length());
   ASSERT(msg->length() == bytes_written);
   // TODO(hausner): Error checking. Probably just shut down the debugger
   // session if we there is an error while writing.
 }
 
 
 void DebuggerConnectionHandler::AcceptDbgConnection(int debug_fd) {
   AddNewDebuggerConnection(debug_fd);
   {
     MonitorLocker ml(&handler_lock_);
@@ skipping 63 matching lines @@
   ASSERT(singleton_handler != NULL);
   return singleton_handler;
 }
 
 
 bool DebuggerConnectionHandler::IsConnected() {
   // TODO(asiva): Support multiple debugger connections.
   // Return true if a connection has been established.
   return singleton_handler != NULL;
 }