Added synchronous socket implementation to dart:io.

runtime/bin/eventhandler_win.cc

 // Copyright (c) 2013, 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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(HOST_OS_WINDOWS)
 
 #include "bin/eventhandler.h"
@@ skipping 919 matching lines @@
   MonitorLocker ml(monitor_);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_read_ == NULL);
 
   // TODO(sgjesse): Use a MTU value here. Only the loopback adapter can
   // handle 64k datagrams.
   OverlappedBuffer* buffer = OverlappedBuffer::AllocateReadBuffer(65536);
 
   DWORD flags;
   flags = 0;
+  OVERLAPPED* overlap_buffer = (sync ? NULL : buffer->GetCleanOverlapped());
   int rc = WSARecv(socket(), buffer->GetWASBUF(), 1, NULL, &flags,
-                   buffer->GetCleanOverlapped(), NULL);
+                   overlap_buffer, NULL);
   if ((rc == NO_ERROR) || (WSAGetLastError() == WSA_IO_PENDING)) {
     pending_read_ = buffer;
     return true;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   pending_read_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 bool ClientSocket::IssueWrite() {
   MonitorLocker ml(monitor_);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_write_ != NULL);
   ASSERT(pending_write_->operation() == OverlappedBuffer::kWrite);
 
+  OVERLAPPED* overlap_buffer =
+      (sync ? NULL : pending_write->GetCleanOverlapped());
   int rc = WSASend(socket(), pending_write_->GetWASBUF(), 1, NULL, 0,
-                   pending_write_->GetCleanOverlapped(), NULL);
+                   overlap_buffer, NULL);
   if ((rc == NO_ERROR) || (WSAGetLastError() == WSA_IO_PENDING)) {
     return true;
   }
   OverlappedBuffer::DisposeBuffer(pending_write_);
   pending_write_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 void ClientSocket::IssueDisconnect() {
   OverlappedBuffer* buffer = OverlappedBuffer::AllocateDisconnectBuffer();
-  BOOL ok =
-      DisconnectEx_(socket(), buffer->GetCleanOverlapped(), TF_REUSE_SOCKET, 0);
+  OVERLAPPED* overlap_buffer = (sync ? NULL : buffer->GetCleanOverlapped());
+  BOOL ok = DisconnectEx_(socket(), overlap_buffer, TF_REUSE_SOCKET, 0);
   // DisconnectEx works like other OverlappedIO APIs, where we can get either an
   // immediate success or delayed operation by WSA_IO_PENDING being set.
   if (ok || (WSAGetLastError() != WSA_IO_PENDING)) {
     DisconnectComplete(buffer);
   }
   // When the Dart side receives this event, it may decide to close its Dart
   // ports. When all ports are closed, the VM will shut down. The EventHandler
   // will then shut down. If the EventHandler shuts down before this
   // asynchronous disconnect finishes, this ClientSocket will be leaked.
   // TODO(dart:io): Retain a list of client sockets that are in the process of
@@ skipping 594 matching lines @@
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)