Add Process.runSync for running processe synchronously.

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.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/eventhandler.h"
 
 #include <process.h>  // NOLINT
 #include <winsock2.h>  // NOLINT
 #include <ws2tcpip.h>  // NOLINT
 #include <mswsock.h>  // NOLINT
 #include <io.h>  // NOLINT
 #include <fcntl.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/utils.h"
 #include "platform/thread.h"
 
 
 namespace dart {
 namespace bin {
 
 static const int kBufferSize = 64 * 1024;
-static const int kStdioBufferSize = 16 * 1024;
+static const int kStdOverlappedBufferSize = 16 * 1024;
 
 static const int kInfinityTimeout = -1;
 static const int kTimeoutId = -1;
 static const int kShutdownId = -2;
 
-IOBuffer* IOBuffer::AllocateBuffer(int buffer_size, Operation operation) {
-  IOBuffer* buffer = new(buffer_size) IOBuffer(buffer_size, operation);
+OverlappedBuffer* OverlappedBuffer::AllocateBuffer(int buffer_size,
+                                                   Operation operation) {
+  OverlappedBuffer* buffer =
+      new(buffer_size) OverlappedBuffer(buffer_size, operation);
   return buffer;
 }
 
 
-IOBuffer* IOBuffer::AllocateAcceptBuffer(int buffer_size) {
-  IOBuffer* buffer = AllocateBuffer(buffer_size, kAccept);
+OverlappedBuffer* OverlappedBuffer::AllocateAcceptBuffer(int buffer_size) {
+  OverlappedBuffer* buffer = AllocateBuffer(buffer_size, kAccept);
   return buffer;
 }
 
 
-IOBuffer* IOBuffer::AllocateReadBuffer(int buffer_size) {
+OverlappedBuffer* OverlappedBuffer::AllocateReadBuffer(int buffer_size) {
   return AllocateBuffer(buffer_size, kRead);
 }
 
 
-IOBuffer* IOBuffer::AllocateWriteBuffer(int buffer_size) {
+OverlappedBuffer* OverlappedBuffer::AllocateWriteBuffer(int buffer_size) {
   return AllocateBuffer(buffer_size, kWrite);
 }
 
 
-IOBuffer* IOBuffer::AllocateDisconnectBuffer() {
+OverlappedBuffer* OverlappedBuffer::AllocateDisconnectBuffer() {
   return AllocateBuffer(0, kDisconnect);
 }
 
 
-void IOBuffer::DisposeBuffer(IOBuffer* buffer) {
+void OverlappedBuffer::DisposeBuffer(OverlappedBuffer* buffer) {
   delete buffer;
 }
 
 
-IOBuffer* IOBuffer::GetFromOverlapped(OVERLAPPED* overlapped) {
-  IOBuffer* buffer = CONTAINING_RECORD(overlapped, IOBuffer, overlapped_);
+OverlappedBuffer* OverlappedBuffer::GetFromOverlapped(OVERLAPPED* overlapped) {
+  OverlappedBuffer* buffer =
+      CONTAINING_RECORD(overlapped, OverlappedBuffer, overlapped_);
   return buffer;
 }
 
 
-int IOBuffer::Read(void* buffer, int num_bytes) {
+int OverlappedBuffer::Read(void* buffer, int num_bytes) {
   if (num_bytes > GetRemainingLength()) {
     num_bytes = GetRemainingLength();
   }
   memcpy(buffer, GetBufferStart() + index_, num_bytes);
   index_ += num_bytes;
   return num_bytes;
 }
 
 
-int IOBuffer::Write(const void* buffer, int num_bytes) {
+int OverlappedBuffer::Write(const void* buffer, int num_bytes) {
   ASSERT(num_bytes == buflen_);
   memcpy(GetBufferStart(), buffer, num_bytes);
   data_length_ = num_bytes;
   return num_bytes;
 }
 
 
-int IOBuffer::GetRemainingLength() {
+int OverlappedBuffer::GetRemainingLength() {
   ASSERT(operation_ == kRead);
   return data_length_ - index_;
 }
 
 
 Handle::Handle(HANDLE handle)
     : handle_(reinterpret_cast<HANDLE>(handle)),
       port_(0),
       mask_(0),
       completion_port_(INVALID_HANDLE_VALUE),
@@ skipping 74 matching lines @@
   return pending_read_ != NULL;
 }
 
 
 bool Handle::HasPendingWrite() {
   ScopedLock lock(this);
   return pending_write_ != NULL;
 }
 
 
-void Handle::ReadComplete(IOBuffer* buffer) {
+void Handle::ReadComplete(OverlappedBuffer* buffer) {
   ScopedLock lock(this);
   // Currently only one outstanding read at the time.
   ASSERT(pending_read_ == buffer);
   ASSERT(data_ready_ == NULL);
   if (!IsClosing() && !buffer->IsEmpty()) {
     data_ready_ = pending_read_;
   } else {
-    IOBuffer::DisposeBuffer(buffer);
+    OverlappedBuffer::DisposeBuffer(buffer);
   }
   pending_read_ = NULL;
 }
 
 
-void Handle::WriteComplete(IOBuffer* buffer) {
+void Handle::WriteComplete(OverlappedBuffer* buffer) {
   ScopedLock lock(this);
   // Currently only one outstanding write at the time.
   ASSERT(pending_write_ == buffer);
-  IOBuffer::DisposeBuffer(buffer);
+  OverlappedBuffer::DisposeBuffer(buffer);
   pending_write_ = NULL;
 }
 
 
 static unsigned int __stdcall ReadFileThread(void* args) {
   Handle* handle = reinterpret_cast<Handle*>(args);
   handle->ReadSyncCompleteAsync();
   return 0;
 }
 
 
 void Handle::ReadSyncCompleteAsync() {
   ASSERT(pending_read_ != NULL);
-  ASSERT(pending_read_->GetBufferSize() >= kStdioBufferSize);
+  ASSERT(pending_read_->GetBufferSize() >= kStdOverlappedBufferSize);
 
   DWORD buffer_size = pending_read_->GetBufferSize();
   if (GetFileType(handle_) == FILE_TYPE_CHAR) {
-    buffer_size = kStdioBufferSize;
+    buffer_size = kStdOverlappedBufferSize;
   }
   DWORD bytes_read = 0;
   BOOL ok = ReadFile(handle_,
                      pending_read_->GetBufferStart(),
                      buffer_size,
                      &bytes_read,
                      NULL);
   if (!ok) {
     if (GetLastError() != ERROR_BROKEN_PIPE) {
       Log::PrintErr("ReadFile failed %d\n", GetLastError());
     }
     bytes_read = 0;
   }
   OVERLAPPED* overlapped = pending_read_->GetCleanOverlapped();
   ok = PostQueuedCompletionStatus(event_handler_->completion_port(),
                                   bytes_read,
                                   reinterpret_cast<ULONG_PTR>(this),
                                   overlapped);
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
   }
 }
 
 
 bool Handle::IssueRead() {
   ScopedLock lock(this);
   ASSERT(type_ != kListenSocket);
   ASSERT(pending_read_ == NULL);
-  IOBuffer* buffer = IOBuffer::AllocateReadBuffer(kBufferSize);
+  OverlappedBuffer* buffer = OverlappedBuffer::AllocateReadBuffer(kBufferSize);
   if (SupportsOverlappedIO()) {
     ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
 
     BOOL ok = ReadFile(handle_,
                        buffer->GetBufferStart(),
                        buffer->GetBufferSize(),
                        NULL,
                        buffer->GetCleanOverlapped());
     if (ok || GetLastError() == ERROR_IO_PENDING) {
       // Completing asynchronously.
       pending_read_ = buffer;
       return true;
     }
-    IOBuffer::DisposeBuffer(buffer);
+    OverlappedBuffer::DisposeBuffer(buffer);
     HandleIssueError();
     return false;
   } else {
     // Completing asynchronously through thread.
     pending_read_ = buffer;
     uint32_t tid;
     uintptr_t thread_handle =
         _beginthreadex(NULL, 32 * 1024, ReadFileThread, this, 0, &tid);
     if (thread_handle == -1) {
       FATAL("Failed to start read file thread");
     }
     return true;
   }
 }
 
 
 bool Handle::IssueWrite() {
   ScopedLock lock(this);
   ASSERT(type_ != kListenSocket);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_write_ != NULL);
-  ASSERT(pending_write_->operation() == IOBuffer::kWrite);
+  ASSERT(pending_write_->operation() == OverlappedBuffer::kWrite);
 
-  IOBuffer* buffer = pending_write_;
+  OverlappedBuffer* buffer = pending_write_;
   BOOL ok = WriteFile(handle_,
                       buffer->GetBufferStart(),
                       buffer->GetBufferSize(),
                       NULL,
                       buffer->GetCleanOverlapped());
   if (ok || GetLastError() == ERROR_IO_PENDING) {
     // Completing asynchronously.
     pending_write_ = buffer;
     return true;
   }
-  IOBuffer::DisposeBuffer(buffer);
+  OverlappedBuffer::DisposeBuffer(buffer);
   HandleIssueError();
   return false;
 }
 
 
 void Handle::HandleIssueError() {
   DWORD error = GetLastError();
   if (error == ERROR_BROKEN_PIPE) {
     event_handler_->HandleClosed(this);
   } else {
@@ skipping 65 matching lines @@
   ScopedLock lock(this);
 
   // For AcceptEx there needs to be buffer storage for address
   // information for two addresses (local and remote address). The
   // AcceptEx documentation says: "This value must be at least 16
   // bytes more than the maximum address length for the transport
   // protocol in use."
   static const int kAcceptExAddressAdditionalBytes = 16;
   static const int kAcceptExAddressStorageSize =
       sizeof(SOCKADDR_STORAGE) + kAcceptExAddressAdditionalBytes;
-  IOBuffer* buffer =
-      IOBuffer::AllocateAcceptBuffer(2 * kAcceptExAddressStorageSize);
+  OverlappedBuffer* buffer =
+      OverlappedBuffer::AllocateAcceptBuffer(2 * kAcceptExAddressStorageSize);
   DWORD received;
   BOOL ok;
   ok = AcceptEx_(socket(),
                  buffer->client(),
                  buffer->GetBufferStart(),
                  0,  // For now don't receive data with accept.
                  kAcceptExAddressStorageSize,
                  kAcceptExAddressStorageSize,
                  &received,
                  buffer->GetCleanOverlapped());
   if (!ok) {
     if (WSAGetLastError() != WSA_IO_PENDING) {
       Log::PrintErr("AcceptEx failed: %d\n", WSAGetLastError());
       closesocket(buffer->client());
-      IOBuffer::DisposeBuffer(buffer);
+      OverlappedBuffer::DisposeBuffer(buffer);
       return false;
     }
   }
 
   pending_accept_count_++;
 
   return true;
 }
 
 
-void ListenSocket::AcceptComplete(IOBuffer* buffer, HANDLE completion_port) {
+void ListenSocket::AcceptComplete(OverlappedBuffer* buffer,
+                                  HANDLE completion_port) {
   ScopedLock lock(this);
   if (!IsClosing()) {
     // Update the accepted socket to support the full range of API calls.
     SOCKET s = socket();
     int rc = setsockopt(buffer->client(),
                         SOL_SOCKET,
                         SO_UPDATE_ACCEPT_CONTEXT,
                         reinterpret_cast<char*>(&s), sizeof(s));
     if (rc == NO_ERROR) {
       // Insert the accepted socket into the list.
@@ skipping 10 matching lines @@
     } else {
       Log::PrintErr("setsockopt failed: %d\n", WSAGetLastError());
       closesocket(buffer->client());
     }
   } else {
     // Close the socket, as it's already accepted.
     closesocket(buffer->client());
   }
 
   pending_accept_count_--;
-  IOBuffer::DisposeBuffer(buffer);
+  OverlappedBuffer::DisposeBuffer(buffer);
 }
 
 
 void ListenSocket::DoClose() {
   closesocket(socket());
   handle_ = INVALID_HANDLE_VALUE;
   while (CanAccept()) {
     // Get rid of connections already accepted.
     ClientSocket *client = Accept();
     if (client != NULL) {
@@ skipping 46 matching lines @@
   ASSERT(!data_ready_->IsEmpty());
   return data_ready_->GetRemainingLength();
 }
 
 
 int Handle::Read(void* buffer, int num_bytes) {
   ScopedLock lock(this);
   if (data_ready_ == NULL) return 0;
   num_bytes = data_ready_->Read(buffer, num_bytes);
   if (data_ready_->IsEmpty()) {
-    IOBuffer::DisposeBuffer(data_ready_);
+    OverlappedBuffer::DisposeBuffer(data_ready_);
     data_ready_ = NULL;
   }
   return num_bytes;
 }
 
 
 int Handle::Write(const void* buffer, int num_bytes) {
   ScopedLock lock(this);
   if (SupportsOverlappedIO()) {
     if (pending_write_ != NULL) return 0;
     if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
     if (num_bytes > kBufferSize) num_bytes = kBufferSize;
-    pending_write_ = IOBuffer::AllocateWriteBuffer(num_bytes);
+    pending_write_ = OverlappedBuffer::AllocateWriteBuffer(num_bytes);
     pending_write_->Write(buffer, num_bytes);
     if (!IssueWrite()) return -1;
     return num_bytes;
   } else {
     DWORD bytes_written = -1;
     BOOL ok = WriteFile(handle_,
                         buffer,
                         num_bytes,
                         &bytes_written,
                         NULL);
@@ skipping 45 matching lines @@
   shutdown(socket(), SD_BOTH);
   IssueDisconnect();
 }
 
 
 bool ClientSocket::IssueRead() {
   ScopedLock lock(this);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_read_ == NULL);
 
-  IOBuffer* buffer = IOBuffer::AllocateReadBuffer(1024);
+  OverlappedBuffer* buffer = OverlappedBuffer::AllocateReadBuffer(1024);
 
   DWORD flags;
   flags = 0;
   int rc = WSARecv(socket(),
                    buffer->GetWASBUF(),
                    1,
                    NULL,
                    &flags,
                    buffer->GetCleanOverlapped(),
                    NULL);
   if (rc == NO_ERROR || WSAGetLastError() == WSA_IO_PENDING) {
     pending_read_ = buffer;
     return true;
   }
-  IOBuffer::DisposeBuffer(buffer);
+  OverlappedBuffer::DisposeBuffer(buffer);
   pending_read_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 bool ClientSocket::IssueWrite() {
   ScopedLock lock(this);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_write_ != NULL);
-  ASSERT(pending_write_->operation() == IOBuffer::kWrite);
+  ASSERT(pending_write_->operation() == OverlappedBuffer::kWrite);
 
   int rc = WSASend(socket(),
                    pending_write_->GetWASBUF(),
                    1,
                    NULL,
                    0,
                    pending_write_->GetCleanOverlapped(),
                    NULL);
   if (rc == NO_ERROR || WSAGetLastError() == WSA_IO_PENDING) {
     return true;
   }
-  IOBuffer::DisposeBuffer(pending_write_);
+  OverlappedBuffer::DisposeBuffer(pending_write_);
   pending_write_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 void ClientSocket::IssueDisconnect() {
   Dart_Port p = port();
-  IOBuffer* buffer = IOBuffer::AllocateDisconnectBuffer();
+  OverlappedBuffer* buffer = OverlappedBuffer::AllocateDisconnectBuffer();
   BOOL ok = DisconnectEx_(
     socket(), buffer->GetCleanOverlapped(), TF_REUSE_SOCKET, 0);
   if (!ok && WSAGetLastError() != WSA_IO_PENDING) {
     DisconnectComplete(buffer);
   }
   if (p != ILLEGAL_PORT) DartUtils::PostInt32(p, 1 << kDestroyedEvent);
 }
 
 
-void ClientSocket::DisconnectComplete(IOBuffer* buffer) {
-  IOBuffer::DisposeBuffer(buffer);
+void ClientSocket::DisconnectComplete(OverlappedBuffer* buffer) {
+  OverlappedBuffer::DisposeBuffer(buffer);
   closesocket(socket());
   if (data_ready_ != NULL) {
-    IOBuffer::DisposeBuffer(data_ready_);
+    OverlappedBuffer::DisposeBuffer(data_ready_);
   }
   // When disconnect is complete get rid of the object.
   delete this;
 }
 
 
 void ClientSocket::EnsureInitialized(
     EventHandlerImplementation* event_handler) {
   ScopedLock lock(this);
   if (completion_port_ == INVALID_HANDLE_VALUE) {
@@ skipping 107 matching lines @@
         handle->SetPortAndMask(msg->dart_port, msg->data);
         handle->Close();
       }
     }
     DeleteIfClosed(handle);
   }
 }
 
 
 void EventHandlerImplementation::HandleAccept(ListenSocket* listen_socket,
-                                              IOBuffer* buffer) {
+                                              OverlappedBuffer* buffer) {
   listen_socket->AcceptComplete(buffer, completion_port_);
 
   if (!listen_socket->IsClosing()) {
     int event_mask = 1 << kInEvent;
     if ((listen_socket->mask() & event_mask) != 0) {
       DartUtils::PostInt32(listen_socket->port(), event_mask);
     }
   }
 
   DeleteIfClosed(listen_socket);
@@ skipping 13 matching lines @@
   handle->MarkError();
   if (!handle->IsClosing()) {
     int event_mask = 1 << kErrorEvent;
     DartUtils::PostInt32(handle->port(), event_mask);
   }
 }
 
 
 void EventHandlerImplementation::HandleRead(Handle* handle,
                                             int bytes,
-                                            IOBuffer* buffer) {
+                                            OverlappedBuffer* buffer) {
   buffer->set_data_length(bytes);
   handle->ReadComplete(buffer);
   if (bytes > 0) {
     if (!handle->IsClosing()) {
       int event_mask = 1 << kInEvent;
       if ((handle->mask() & event_mask) != 0) {
         DartUtils::PostInt32(handle->port(), event_mask);
       }
     }
   } else {
     handle->MarkClosedRead();
     if (bytes == 0) {
       HandleClosed(handle);
     } else {
       HandleError(handle);
     }
   }
 
   DeleteIfClosed(handle);
 }
 
 
 void EventHandlerImplementation::HandleWrite(Handle* handle,
                                              int bytes,
-                                             IOBuffer* buffer) {
+                                             OverlappedBuffer* buffer) {
   handle->WriteComplete(buffer);
 
   if (bytes > 0) {
     if (!handle->IsError() && !handle->IsClosing()) {
       int event_mask = 1 << kOutEvent;
       if ((handle->mask() & event_mask) != 0) {
         DartUtils::PostInt32(handle->port(), event_mask);
       }
     }
   } else if (bytes == 0) {
     HandleClosed(handle);
   } else {
     HandleError(handle);
   }
 
   DeleteIfClosed(handle);
 }
 
 
 void EventHandlerImplementation::HandleDisconnect(
     ClientSocket* client_socket,
     int bytes,
-    IOBuffer* buffer) {
+    OverlappedBuffer* buffer) {
   client_socket->DisconnectComplete(buffer);
 }
 
 void EventHandlerImplementation::HandleTimeout() {
   if (!timeout_queue_.HasTimeout()) return;
   DartUtils::PostNull(timeout_queue_.CurrentPort());
   timeout_queue_.RemoveCurrent();
 }
 
 
 void EventHandlerImplementation::HandleIOCompletion(DWORD bytes,
                                                     ULONG_PTR key,
                                                     OVERLAPPED* overlapped) {
-  IOBuffer* buffer = IOBuffer::GetFromOverlapped(overlapped);
+  OverlappedBuffer* buffer = OverlappedBuffer::GetFromOverlapped(overlapped);
   switch (buffer->operation()) {
-    case IOBuffer::kAccept: {
+    case OverlappedBuffer::kAccept: {
       ListenSocket* listen_socket = reinterpret_cast<ListenSocket*>(key);
       HandleAccept(listen_socket, buffer);
       break;
     }
-    case IOBuffer::kRead: {
+    case OverlappedBuffer::kRead: {
       Handle* handle = reinterpret_cast<Handle*>(key);
       HandleRead(handle, bytes, buffer);
       break;
     }
-    case IOBuffer::kWrite: {
+    case OverlappedBuffer::kWrite: {
       Handle* handle = reinterpret_cast<Handle*>(key);
       HandleWrite(handle, bytes, buffer);
       break;
     }
-    case IOBuffer::kDisconnect: {
+    case OverlappedBuffer::kDisconnect: {
       ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(key);
       HandleDisconnect(client_socket, bytes, buffer);
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
@@ skipping 109 matching lines @@
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)