Remove non-fatal prints from windows eventhandler.

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 <winsock2.h>  // NOLINT
@@ skipping 142 matching lines @@
   LeaveCriticalSection(&cs_);
 }
 
 
 bool Handle::CreateCompletionPort(HANDLE completion_port) {
   completion_port_ = CreateIoCompletionPort(handle_,
                                             completion_port,
                                             reinterpret_cast<ULONG_PTR>(this),
                                             0);
   if (completion_port_ == NULL) {
-    Log::PrintErr("Error CreateIoCompletionPort: %d\n", GetLastError());
     return false;
   }
   return true;
 }
 
 
 void Handle::Close() {
   ScopedLock lock(this);
   if (!IsClosing()) {
     // Close the socket and set the closing state. This close method can be
@@ skipping 66 matching lines @@
   if (GetFileType(handle_) == FILE_TYPE_CHAR) {
     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");
   }
@@ skipping 153 matching lines @@
   int status = WSAIoctl(socket(),
                         SIO_GET_EXTENSION_FUNCTION_POINTER,
                         &guid_accept_ex,
                         sizeof(guid_accept_ex),
                         &AcceptEx_,
                         sizeof(AcceptEx_),
                         &bytes,
                         NULL,
                         NULL);
   if (status == SOCKET_ERROR) {
-    Log::PrintErr("Error WSAIoctl failed: %d\n", WSAGetLastError());
     return false;
   }
   return true;
 }
 
 
 bool ListenSocket::IssueAccept() {
   ScopedLock lock(this);
   // For AcceptEx there needs to be buffer storage for address
   // information for two addresses (local and remote address). The
@@ skipping 47 matching lines @@
       client_socket->CreateCompletionPort(completion_port);
       if (accepted_head_ == NULL) {
         accepted_head_ = client_socket;
         accepted_tail_ = client_socket;
       } else {
         ASSERT(accepted_tail_ != NULL);
         accepted_tail_->set_next(client_socket);
         accepted_tail_ = client_socket;
       }
     } 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_--;
   OverlappedBuffer::DisposeBuffer(buffer);
 }
@@ skipping 155 matching lines @@
 void StdHandle::WriteSyncCompleteAsync() {
   ASSERT(pending_write_ != NULL);
 
   DWORD bytes_written = -1;
   BOOL ok = WriteFile(handle_,
                       pending_write_->GetBufferStart(),
                       pending_write_->GetBufferSize(),
                       &bytes_written,
                       NULL);
   if (!ok) {
-    if (GetLastError() != ERROR_BROKEN_PIPE) {
-      Log::PrintErr("WriteFile failed %d\n", GetLastError());
-    }
     bytes_written = 0;
   }
   thread_wrote_ += bytes_written;
   OVERLAPPED* overlapped = pending_write_->GetCleanOverlapped();
   ok = PostQueuedCompletionStatus(event_handler_->completion_port(),
                                   bytes_written,
                                   reinterpret_cast<ULONG_PTR>(this),
                                   overlapped);
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
@@ skipping 55 matching lines @@
   int status = WSAIoctl(socket(),
                         SIO_GET_EXTENSION_FUNCTION_POINTER,
                         &guid_disconnect_ex,
                         sizeof(guid_disconnect_ex),
                         &DisconnectEx_,
                         sizeof(DisconnectEx_),
                         &bytes,
                         NULL,
                         NULL);
   if (status == SOCKET_ERROR) {
-    Log::PrintErr("Error WSAIoctl failed: %d\n", WSAGetLastError());
     return false;
   }
   return true;
 }
 
 
 void ClientSocket::Shutdown(int how) {
   int rc = shutdown(socket(), how);
   if (how == SD_RECEIVE) MarkClosedRead();
   if (how == SD_SEND) MarkClosedWrite();
@@ skipping 540 matching lines @@
 
 
 void EventHandlerImplementation::Shutdown() {
   Notify(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)