Revised CL for customisable logging (replacing printfs).

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>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/log.h"
 #include "bin/socket.h"
 #include "platform/thread.h"
 
 
 static const int kInfinityTimeout = -1;
 static const int kTimeoutId = -1;
 static const int kShutdownId = -2;
 
 
 int64_t GetCurrentTimeMilliseconds() {
@@ skipping 112 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) {
-    fprintf(stderr, "Error CreateIoCompletionPort: %d\n", GetLastError());
+    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 60 matching lines @@
 void Handle::ReadSyncCompleteAsync() {
   ASSERT(pending_read_ != NULL);
   DWORD bytes_read = 0;
   BOOL ok = ReadFile(handle_,
                      pending_read_->GetBufferStart(),
                      pending_read_->GetBufferSize(),
                      &bytes_read,
                      NULL);
   if (!ok) {
     if (GetLastError() != ERROR_BROKEN_PIPE) {
-      fprintf(stderr, "ReadFile failed %d\n", GetLastError());
+      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 14 matching lines @@
                        buffer->GetBufferSize(),
                        NULL,
                        buffer->GetCleanOverlapped());
     if (ok || GetLastError() == ERROR_IO_PENDING) {
       // Completing asynchronously.
       pending_read_ = buffer;
       return true;
     }
 
     if (GetLastError() != ERROR_BROKEN_PIPE) {
-      fprintf(stderr, "ReadFile failed: %d\n", GetLastError());
+      Log::PrintErr("ReadFile failed: %d\n", GetLastError());
     }
     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);
@@ skipping 18 matching lines @@
                       buffer->GetBufferSize(),
                       NULL,
                       buffer->GetCleanOverlapped());
   if (ok || GetLastError() == ERROR_IO_PENDING) {
     // Completing asynchronously.
     pending_write_ = buffer;
     return true;
   }
 
   if (GetLastError() != ERROR_BROKEN_PIPE) {
-    fprintf(stderr, "WriteFile failed: %d\n", GetLastError());
+    Log::PrintErr("WriteFile failed: %d\n", GetLastError());
   }
   event_handler_->HandleClosed(this);
   IOBuffer::DisposeBuffer(buffer);
   return false;
 }
 
 
 void FileHandle::EnsureInitialized(EventHandlerImplementation* event_handler) {
   ScopedLock lock(this);
   event_handler_ = event_handler;
@@ skipping 25 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) {
-    fprintf(stderr, "Error WSAIoctl failed: %d\n", WSAGetLastError());
+    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
@@ skipping 11 matching lines @@
   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) {
-      fprintf(stderr, "AcceptEx failed: %d\n", WSAGetLastError());
+      Log::PrintErr("AcceptEx failed: %d\n", WSAGetLastError());
       closesocket(buffer->client());
       IOBuffer::DisposeBuffer(buffer);
       return false;
     }
   }
 
   pending_accept_count_++;
 
   return true;
 }
@@ skipping 25 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 {
-      fprintf(stderr, "setsockopt failed: %d\n", WSAGetLastError());
+      Log::PrintErr("setsockopt failed: %d\n", WSAGetLastError());
       closesocket(buffer->client());
     }
   }
 
   pending_accept_count_--;
   IOBuffer::DisposeBuffer(buffer);
 }
 
 
 ClientSocket* ListenSocket::Accept() {
@@ skipping 71 matching lines @@
     return num_bytes;
   } else {
     DWORD bytes_written = -1;
     BOOL ok = WriteFile(handle_,
                         buffer,
                         num_bytes,
                         &bytes_written,
                         NULL);
     if (!ok) {
       if (GetLastError() != ERROR_BROKEN_PIPE) {
-        fprintf(stderr, "WriteFile failed: %d\n", GetLastError());
+        Log::PrintErr("WriteFile failed: %d\n", GetLastError());
       }
       event_handler_->HandleClosed(this);
     }
     return bytes_written;
   }
 }
 
 
 void ClientSocket::Shutdown(int how) {
   int rc = shutdown(socket(), how);
   if (rc == SOCKET_ERROR) {
-    fprintf(stderr, "shutdown failed: %d %d\n", socket(), WSAGetLastError());
+    Log::PrintErr("shutdown failed: %d %d\n", socket(), WSAGetLastError());
   }
   if (how == SD_RECEIVE) MarkClosedRead();
   if (how == SD_SEND) MarkClosedWrite();
   if (how == SD_BOTH) {
     MarkClosedRead();
     MarkClosedWrite();
   }
 }
 
 
@@ skipping 12 matching lines @@
                    NULL,
                    &flags,
                    buffer->GetCleanOverlapped(),
                    NULL);
   if (rc == NO_ERROR || WSAGetLastError() == WSA_IO_PENDING) {
     pending_read_ = buffer;
     return true;
   }
 
   if (WSAGetLastError() != WSAECONNRESET) {
-    fprintf(stderr, "WSARecv failed: %d\n", WSAGetLastError());
+    Log::PrintErr("WSARecv failed: %d\n", WSAGetLastError());
   }
   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;
   }
 
-  fprintf(stderr, "WSASend failed: %d\n", WSAGetLastError());
+  Log::PrintErr("WSASend failed: %d\n", WSAGetLastError());
   IOBuffer::DisposeBuffer(pending_write_);
   pending_write_ = NULL;
   return false;
 }
 
 
 void ClientSocket::EnsureInitialized(
     EventHandlerImplementation* event_handler) {
   ScopedLock lock(this);
   if (completion_port_ == INVALID_HANDLE_VALUE) {
@@ skipping 271 matching lines @@
     OVERLAPPED* overlapped;
     intptr_t millis = handler->GetTimeout();
     BOOL ok = GetQueuedCompletionStatus(handler->completion_port(),
                                         &bytes,
                                         &key,
                                         &overlapped,
                                         millis);
     if (!ok && overlapped == NULL) {
       if (GetLastError() == ERROR_ABANDONED_WAIT_0) {
         // The completion port should never be closed.
-        printf("Completion port closed\n");
+        Log::Print("Completion port closed\n");
         UNREACHABLE();
       } else {
         // Timeout is signalled by false result and NULL in overlapped.
         handler->HandleTimeout();
       }
     } else if (!ok) {
       // 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
@@ skipping 31 matching lines @@
   // Initialize Winsock32
   if (!Socket::Initialize()) {
     FATAL("Failed to initialized Windows sockets");
   }
 }
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }