Implement the full process interface for Windows

bin/eventhandler_win.cc

 // 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.
 
 #include <process.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <mswsock.h>
 
 #include "bin/builtin.h"
@@ skipping 200 matching lines @@
                      buffer->GetBufferStart(),
                      buffer->GetBufferSize(),
                      NULL,
                      buffer->GetCleanOverlapped());
   if (ok || GetLastError() == ERROR_IO_PENDING) {
     // Completing asynchronously.
     pending_read_ = buffer;
     return true;
   }
 
-  fprintf(stderr, "ReadFile failed: %d\n", GetLastError());
+  if (GetLastError() != ERROR_BROKEN_PIPE) {
+    fprintf(stderr, "ReadFile failed: %d\n", GetLastError());
+  }
   event_handler_->HandleClosed(this);
   IOBuffer::DisposeBuffer(buffer);
   return false;
 }
 
 
 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);
 
   IOBuffer* 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;
   }
 
-  fprintf(stderr, "WriteFile failed: %d\n", GetLastError());
+  if (GetLastError() != ERROR_BROKEN_PIPE) {
+    fprintf(stderr, "WriteFile failed: %d\n", GetLastError());
+  }
   event_handler_->HandleClosed(this);
   IOBuffer::DisposeBuffer(buffer);
   return false;
 }
 
 
+void FileHandle::EnsureInitialized(EventHandlerImplementation* event_handler) {
+  ScopedLock lock(this);
+  if (completion_port_ == INVALID_HANDLE_VALUE) {
+    ASSERT(event_handler_ == NULL);
+    event_handler_ = event_handler;
+    CreateCompletionPort(event_handler_->completion_port());
+  }
+}
+
+
+bool FileHandle::IsClosed() {
+  return false;
+}
+
+
+void FileHandle::AfterClose() {
+}
+
+
 bool ListenSocket::LoadAcceptEx() {
   // Load the AcceptEx function into memory using WSAIoctl.
   // The WSAIoctl function is an extension of the ioctlsocket()
   // function that can use overlapped I/O. The function's 3rd
   // through 6th parameters are input and output buffers where
   // we pass the pointer to our AcceptEx function. This is used
   // so that we can call the AcceptEx function directly, rather
   // than refer to the Mswsock.lib library.
   GUID guid_accept_ex = WSAID_ACCEPTEX;
   DWORD bytes;
@@ skipping 108 matching lines @@
     }
   }
 }
 
 
 bool ListenSocket::IsClosed() {
   return closing_ && !HasPendingAccept();
 }
 
 
-int ClientSocket::Available() {
+int Handle::Available() {
   ScopedLock lock(this);
   if (data_ready_ == NULL) return 0;
   ASSERT(!data_ready_->IsEmpty());
   return data_ready_->GetRemainingLength();
 }
 
 
-int ClientSocket::Read(void* buffer, int num_bytes) {
+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_);
     data_ready_ = NULL;
   }
   return num_bytes;
 }
 
 
-int ClientSocket::Write(const void* buffer, int num_bytes) {
+int Handle::Write(const void* buffer, int num_bytes) {
   ScopedLock lock(this);
   if (pending_write_ != NULL) return 0;
   if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
   if (num_bytes > 4096) num_bytes = 4096;
   pending_write_ = IOBuffer::AllocateWriteBuffer(num_bytes);
   pending_write_->Write(buffer, num_bytes);
   IssueWrite();
   return num_bytes;
 }
 
@@ skipping 324 matching lines @@
       // not NULL then it did dequeue a request which failed.
 
       // Treat ERROR_CONNECTION_ABORTED as connection closed.
       // The error ERROR_OPERATION_ABORTED is set for pending
       // accept requests for a listen socket which is closed.
       // ERROR_NETNAME_DELETED occurs when the client closes
       // the socket it is reading from.
       DWORD last_error = GetLastError();
       if (last_error == ERROR_CONNECTION_ABORTED ||
           last_error == ERROR_OPERATION_ABORTED ||
-          last_error == ERROR_NETNAME_DELETED) {
+          last_error == ERROR_NETNAME_DELETED ||
+          last_error == ERROR_BROKEN_PIPE) {
         ASSERT(bytes == 0);
         handler->HandleIOCompletion(bytes, key, overlapped);
       } else {
-        printf("After GetQueuedCompletionStatus %d\n", GetLastError());
         UNREACHABLE();
      }
     } else if (key == NULL) {
       // A key of NULL signals an interrupt message.
       InterruptMessage* msg = reinterpret_cast<InterruptMessage*>(overlapped);
       handler->HandleInterrupt(msg);
       delete msg;
     } else {
       handler->HandleIOCompletion(bytes, key, overlapped);
     }
   }
 }
 
 
 void EventHandlerImplementation::StartEventHandler() {
   uint32_t tid;
   uintptr_t thread_handle =
       _beginthreadex(NULL, 32 * 1024, EventHandlerThread, this, 0, &tid);
   if (thread_handle == -1) {
     FATAL("Failed to start event handler thread");
   }
 
   // Initialize Winsock32
   if (!Socket::Initialize()) {
     FATAL("Failed to initialized Windows sockets");
   }
 }