Reapply "Fixes to eventhandler and HTTP""

runtime/bin/eventhandler_win.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/eventhandler.h"
 
 #include <process.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <mswsock.h>
@@ skipping 240 matching lines @@
     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);
 
-    if (GetLastError() != ERROR_BROKEN_PIPE) {
-      Log::PrintErr("ReadFile failed: %d\n", GetLastError());
+    if (GetLastError() == ERROR_BROKEN_PIPE) {
+      event_handler_->HandleClosed(this);
+    } else {
+      event_handler_->HandleError(this);
     }
-    event_handler_->HandleClosed(this);
-    IOBuffer::DisposeBuffer(buffer);
     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");
     }
@@ skipping 13 matching lines @@
   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);
 
-  if (GetLastError() != ERROR_BROKEN_PIPE) {
-    Log::PrintErr("WriteFile failed: %d\n", GetLastError());
+  if (GetLastError() == ERROR_BROKEN_PIPE) {
+    event_handler_->HandleClosed(this);
+  } else {
+    event_handler_->HandleError(this);
   }
-  event_handler_->HandleClosed(this);
-  IOBuffer::DisposeBuffer(buffer);
   return false;
 }
 
 
 void FileHandle::EnsureInitialized(EventHandlerImplementation* event_handler) {
   ScopedLock lock(this);
   event_handler_ = event_handler;
   if (SupportsOverlappedIO() && completion_port_ == INVALID_HANDLE_VALUE) {
     CreateCompletionPort(event_handler_->completion_port());
   }
@@ skipping 235 matching lines @@
                    buffer->GetWASBUF(),
                    1,
                    NULL,
                    &flags,
                    buffer->GetCleanOverlapped(),
                    NULL);
   if (rc == NO_ERROR || WSAGetLastError() == WSA_IO_PENDING) {
     pending_read_ = buffer;
     return true;
   }
+  IOBuffer::DisposeBuffer(buffer);
+  pending_read_ = NULL;
 
-  if (WSAGetLastError() != WSAECONNRESET) {
-    Log::PrintErr("WSARecv failed: %d\n", WSAGetLastError());
+  if (WSAGetLastError() == WSAECONNRESET) {
+    event_handler_->HandleClosed(this);
+  } else {
+    event_handler_->HandleError(this);
   }
-  event_handler_->HandleClosed(this);
-  IOBuffer::DisposeBuffer(buffer);
   return false;
 }
 
 
 bool ClientSocket::IssueWrite() {
   ScopedLock lock(this);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_write_ != NULL);
   ASSERT(pending_write_->operation() == IOBuffer::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;
   }
-
-  Log::PrintErr("WSASend failed: %d\n", WSAGetLastError());
   IOBuffer::DisposeBuffer(pending_write_);
   pending_write_ = NULL;
+
+  if (WSAGetLastError() == WSAECONNRESET) {
+    event_handler_->HandleClosed(this);
+  } else {
+    event_handler_->HandleError(this);
+  }
   return false;
 }
 
 
 void ClientSocket::EnsureInitialized(
     EventHandlerImplementation* event_handler) {
   ScopedLock lock(this);
   if (completion_port_ == INVALID_HANDLE_VALUE) {
     ASSERT(event_handler_ == NULL);
     event_handler_ = event_handler;
@@ skipping 49 matching lines @@
         if (listen_socket->IsClosed()) {
           delete_handle = true;
         }
       }
     } else {
       handle->SetPortAndMask(msg->dart_port, msg->data);
       handle->EnsureInitialized(this);
 
       Handle::ScopedLock lock(handle);
 
-      // If the data available callback has been requested and data are
-      // available post it immediately. Otherwise make sure that a pending
-      // read is issued unless the socket is already closed for read.
-      if ((msg->data & (1 << kInEvent)) != 0) {
-        if (handle->Available() > 0) {
-          int event_mask = (1 << kInEvent);
-          DartUtils::PostInt32(handle->port(), event_mask);
-        } else if (!handle->HasPendingRead() &&
-                   !handle->IsClosedRead()) {
-          handle->IssueRead();
+      if (!handle->IsError()) {
+        // If in events (data available events) have been requested, and data
+        // is available, post an in event immediately. Otherwise make sure
+        // that a pending read is issued, unless the socket is already closed
+        // for read.
+        if ((msg->data & (1 << kInEvent)) != 0) {
+          if (handle->Available() > 0) {
+            int event_mask = (1 << kInEvent);
+            handle->set_mask(handle->mask() & ~event_mask);
+            DartUtils::PostInt32(handle->port(), event_mask);
+          } else if (!handle->HasPendingRead() &&
+                     !handle->IsClosedRead()) {
+            handle->IssueRead();
+          }
+        }
+
+        // If out events (can write events) have been requested, and there
+        // are no pending writes, post an out event immediately.
+        if ((msg->data & (1 << kOutEvent)) != 0) {
+          if (!handle->HasPendingWrite()) {
+            int event_mask = (1 << kOutEvent);
+            handle->set_mask(handle->mask() & ~event_mask);
+            DartUtils::PostInt32(handle->port(), event_mask);
+          }
+        }
+
+        if (handle->is_client_socket()) {
+          ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(handle);
+          if ((msg->data & (1 << kShutdownReadCommand)) != 0) {
+            client_socket->Shutdown(SD_RECEIVE);
+          }
+
+          if ((msg->data & (1 << kShutdownWriteCommand)) != 0) {
+            client_socket->Shutdown(SD_SEND);
+          }
         }
       }
 
-      // If can send callback had been requested and there is no pending
-      // send post it immediately.
-      if ((msg->data & (1 << kOutEvent)) != 0) {
-        if (!handle->HasPendingWrite()) {
-          int event_mask = (1 << kOutEvent);
-          DartUtils::PostInt32(handle->port(), event_mask);
-        }
-      }
-
-      if (handle->is_client_socket()) {
-        ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(handle);
-        if ((msg->data & (1 << kShutdownReadCommand)) != 0) {
-          client_socket->Shutdown(SD_RECEIVE);
-        }
-
-        if ((msg->data & (1 << kShutdownWriteCommand)) != 0) {
-          client_socket->Shutdown(SD_SEND);
-        }
-      }
-
       if ((msg->data & (1 << kCloseCommand)) != 0) {
         handle->close();
         if (handle->IsClosed()) {
           delete_handle = true;
         }
       }
     }
     if (delete_handle) {
       delete handle;
     }
@@ skipping 21 matching lines @@
 void EventHandlerImplementation::HandleClosed(Handle* handle) {
   if (!handle->IsClosing()) {
     int event_mask = 1 << kCloseEvent;
     DartUtils::PostInt32(handle->port(), event_mask);
   }
 }
 
 
 void EventHandlerImplementation::HandleError(Handle* handle) {
   handle->set_last_error(WSAGetLastError());
+  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) {
@@ skipping 20 matching lines @@
   }
 }
 
 
 void EventHandlerImplementation::HandleWrite(Handle* handle,
                                              int bytes,
                                              IOBuffer* buffer) {
   handle->WriteComplete(buffer);
 
   if (bytes > 0) {
-    if (!handle->IsClosing()) {
+    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);
   }
@@ skipping 137 matching lines @@
   // Initialize Winsock32
   if (!Socket::Initialize()) {
     FATAL("Failed to initialized Windows sockets");
   }
 }
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }