clang-format runtime/bin

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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/eventhandler.h"
 #include "bin/eventhandler_win.h"
 
-#include <fcntl.h>  // NOLINT
-#include <io.h>  // NOLINT
-#include <mswsock.h>  // NOLINT
+#include <fcntl.h>     // NOLINT
+#include <io.h>        // NOLINT
+#include <mswsock.h>   // NOLINT
 #include <winsock2.h>  // NOLINT
 #include <ws2tcpip.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
 #include "platform/utils.h"
 
 namespace dart {
 namespace bin {
 
 static const int kBufferSize = 64 * 1024;
 static const int kStdOverlappedBufferSize = 16 * 1024;
 static const int kMaxUDPPackageLength = 64 * 1024;
 
 OverlappedBuffer* OverlappedBuffer::AllocateBuffer(int buffer_size,
                                                    Operation operation) {
   OverlappedBuffer* buffer =
-      new(buffer_size) OverlappedBuffer(buffer_size, operation);
+      new (buffer_size) OverlappedBuffer(buffer_size, operation);
   return buffer;
 }
 
 
 OverlappedBuffer* OverlappedBuffer::AllocateAcceptBuffer(int buffer_size) {
   OverlappedBuffer* buffer = AllocateBuffer(buffer_size, kAccept);
   return buffer;
 }
 
 
@@ skipping 72 matching lines @@
       event_handler_(NULL),
       data_ready_(NULL),
       pending_read_(NULL),
       pending_write_(NULL),
       last_error_(NOERROR),
       flags_(0),
       read_thread_id_(Thread::kInvalidThreadId),
       read_thread_handle_(NULL),
       read_thread_starting_(false),
       read_thread_finished_(false),
-      monitor_(new Monitor()) {
-}
+      monitor_(new Monitor()) {}
 
 
 Handle::~Handle() {
   delete monitor_;
 }
 
 
 bool Handle::CreateCompletionPort(HANDLE completion_port) {
-  completion_port_ = CreateIoCompletionPort(handle(),
-                                            completion_port,
-                                            reinterpret_cast<ULONG_PTR>(this),
-                                            0);
+  completion_port_ = CreateIoCompletionPort(
+      handle(), completion_port, reinterpret_cast<ULONG_PTR>(this), 0);
   return (completion_port_ != NULL);
 }
 
 
 void Handle::Close() {
   MonitorLocker ml(monitor_);
   if (!IsClosing()) {
     // Close the socket and set the closing state. This close method can be
     // called again if this socket has pending IO operations in flight.
     MarkClosing();
@@ skipping 117 matching lines @@
   NotifyReadThreadStarted();
   ASSERT(pending_read_ != NULL);
   ASSERT(pending_read_->GetBufferSize() >= kStdOverlappedBufferSize);
 
   DWORD buffer_size = pending_read_->GetBufferSize();
   if (GetFileType(handle_) == FILE_TYPE_CHAR) {
     buffer_size = kStdOverlappedBufferSize;
   }
   char* buffer_start = pending_read_->GetBufferStart();
   DWORD bytes_read = 0;
-  BOOL ok = ReadFile(handle_,
-                     buffer_start,
-                     buffer_size,
-                     &bytes_read,
-                     NULL);
+  BOOL ok = ReadFile(handle_, buffer_start, buffer_size, &bytes_read, NULL);
   if (!ok) {
     bytes_read = 0;
   }
   OVERLAPPED* overlapped = pending_read_->GetCleanOverlapped();
-  ok = PostQueuedCompletionStatus(event_handler_->completion_port(),
-                                  bytes_read,
-                                  reinterpret_cast<ULONG_PTR>(this),
-                                  overlapped);
+  ok =
+      PostQueuedCompletionStatus(event_handler_->completion_port(), bytes_read,
+                                 reinterpret_cast<ULONG_PTR>(this), overlapped);
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
   }
   NotifyReadThreadFinished();
 }
 
 
 bool Handle::IssueRead() {
   ASSERT(type_ != kListenSocket);
   ASSERT(pending_read_ == NULL);
   OverlappedBuffer* buffer = OverlappedBuffer::AllocateReadBuffer(kBufferSize);
   if (SupportsOverlappedIO()) {
     ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
 
-    BOOL ok = ReadFile(handle_,
-                       buffer->GetBufferStart(),
-                       buffer->GetBufferSize(),
-                       NULL,
-                       buffer->GetCleanOverlapped());
+    BOOL ok =
+        ReadFile(handle_, buffer->GetBufferStart(), buffer->GetBufferSize(),
+                 NULL, buffer->GetCleanOverlapped());
     if (ok || (GetLastError() == ERROR_IO_PENDING)) {
       // Completing asynchronously.
       pending_read_ = buffer;
       return true;
     }
     OverlappedBuffer::DisposeBuffer(buffer);
     HandleIssueError();
     return false;
   } else {
     // Completing asynchronously through thread.
     pending_read_ = buffer;
     read_thread_starting_ = true;
-    int result = Thread::Start(ReadFileThread,
-                               reinterpret_cast<uword>(this));
+    int result = Thread::Start(ReadFileThread, reinterpret_cast<uword>(this));
     if (result != 0) {
       FATAL1("Failed to start read file thread %d", result);
     }
     return true;
   }
 }
 
 
 bool Handle::IssueRecvFrom() {
   return false;
 }
 
 
 bool Handle::IssueWrite() {
   MonitorLocker ml(monitor_);
   ASSERT(type_ != kListenSocket);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_write_ != NULL);
   ASSERT(pending_write_->operation() == OverlappedBuffer::kWrite);
 
   OverlappedBuffer* buffer = pending_write_;
-  BOOL ok = WriteFile(handle_,
-                      buffer->GetBufferStart(),
-                      buffer->GetBufferSize(),
-                      NULL,
-                      buffer->GetCleanOverlapped());
+  BOOL ok =
+      WriteFile(handle_, buffer->GetBufferStart(), buffer->GetBufferSize(),
+                NULL, buffer->GetCleanOverlapped());
   if (ok || (GetLastError() == ERROR_IO_PENDING)) {
     // Completing asynchronously.
     pending_write_ = buffer;
     return true;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   HandleIssueError();
   return false;
 }
 
@@ skipping 61 matching lines @@
 
 
 bool DirectoryWatchHandle::IssueRead() {
   // It may have been started before, as we start the directory-handler when
   // we create it.
   if ((pending_read_ != NULL) || (data_ready_ != NULL)) {
     return true;
   }
   OverlappedBuffer* buffer = OverlappedBuffer::AllocateReadBuffer(kBufferSize);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
-  BOOL ok = ReadDirectoryChangesW(handle_,
-                                  buffer->GetBufferStart(),
-                                  buffer->GetBufferSize(),
-                                  recursive_,
-                                  events_,
-                                  NULL,
-                                  buffer->GetCleanOverlapped(),
-                                  NULL);
+  BOOL ok = ReadDirectoryChangesW(handle_, buffer->GetBufferStart(),
+                                  buffer->GetBufferSize(), recursive_, events_,
+                                  NULL, buffer->GetCleanOverlapped(), NULL);
   if (ok || (GetLastError() == ERROR_IO_PENDING)) {
     // Completing asynchronously.
     pending_read_ = buffer;
     return true;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   return false;
 }
 
 
@@ skipping 18 matching lines @@
     HandleError(this);
   }
   WSASetLastError(error);
 }
 
 
 bool ListenSocket::LoadAcceptEx() {
   // Load the AcceptEx function into memory using WSAIoctl.
   GUID guid_accept_ex = WSAID_ACCEPTEX;
   DWORD bytes;
-  int status = WSAIoctl(socket(),
-                        SIO_GET_EXTENSION_FUNCTION_POINTER,
-                        &guid_accept_ex,
-                        sizeof(guid_accept_ex),
-                        &AcceptEx_,
-                        sizeof(AcceptEx_),
-                        &bytes,
-                        NULL,
-                        NULL);
+  int status = WSAIoctl(socket(), SIO_GET_EXTENSION_FUNCTION_POINTER,
+                        &guid_accept_ex, sizeof(guid_accept_ex), &AcceptEx_,
+                        sizeof(AcceptEx_), &bytes, NULL, NULL);
   return (status != SOCKET_ERROR);
 }
 
 
 bool ListenSocket::IssueAccept() {
   MonitorLocker ml(monitor_);
 
   // 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;
   OverlappedBuffer* buffer =
       OverlappedBuffer::AllocateAcceptBuffer(2 * kAcceptExAddressStorageSize);
   DWORD received;
   BOOL ok;
-  ok = AcceptEx_(socket(),
-                 buffer->client(),
-                 buffer->GetBufferStart(),
+  ok = AcceptEx_(socket(), buffer->client(), buffer->GetBufferStart(),
                  0,  // For now don't receive data with accept.
-                 kAcceptExAddressStorageSize,
-                 kAcceptExAddressStorageSize,
-                 &received,
-                 buffer->GetCleanOverlapped());
+                 kAcceptExAddressStorageSize, kAcceptExAddressStorageSize,
+                 &received, buffer->GetCleanOverlapped());
   if (!ok) {
     if (WSAGetLastError() != WSA_IO_PENDING) {
       int error = WSAGetLastError();
       closesocket(buffer->client());
       OverlappedBuffer::DisposeBuffer(buffer);
       WSASetLastError(error);
       return false;
     }
   }
 
   pending_accept_count_++;
 
   return true;
 }
 
 
 void ListenSocket::AcceptComplete(OverlappedBuffer* buffer,
                                   HANDLE completion_port) {
   MonitorLocker ml(monitor_);
   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,
+    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.
       ClientSocket* client_socket = new ClientSocket(buffer->client());
       client_socket->mark_connected();
       client_socket->CreateCompletionPort(completion_port);
       if (accepted_head_ == NULL) {
         accepted_head_ = client_socket;
         accepted_tail_ = client_socket;
       } else {
@@ skipping 22 matching lines @@
     delete handle;
   }
 }
 
 
 void ListenSocket::DoClose() {
   closesocket(socket());
   handle_ = INVALID_HANDLE_VALUE;
   while (CanAccept()) {
     // Get rid of connections already accepted.
-    ClientSocket *client = Accept();
+    ClientSocket* client = Accept();
     if (client != NULL) {
       client->Close();
       DeleteIfClosed(client);
     } else {
       break;
     }
   }
 }
 
 
 bool ListenSocket::CanAccept() {
   MonitorLocker ml(monitor_);
   return accepted_head_ != NULL;
 }
 
 
 ClientSocket* ListenSocket::Accept() {
   MonitorLocker ml(monitor_);
 
-  ClientSocket *result = NULL;
+  ClientSocket* result = NULL;
 
   if (accepted_head_ != NULL) {
     result = accepted_head_;
     accepted_head_ = accepted_head_->next();
     if (accepted_head_ == NULL) {
       accepted_tail_ = NULL;
     }
     result->set_next(NULL);
     accepted_count_--;
   }
@@ skipping 37 matching lines @@
   ASSERT(!data_ready_->IsEmpty());
   return data_ready_->GetRemainingLength();
 }
 
 
 intptr_t Handle::Read(void* buffer, intptr_t num_bytes) {
   MonitorLocker ml(monitor_);
   if (data_ready_ == NULL) {
     return 0;
   }
-  num_bytes = data_ready_->Read(
-      buffer, Utils::Minimum<intptr_t>(num_bytes, INT_MAX));
+  num_bytes =
+      data_ready_->Read(buffer, Utils::Minimum<intptr_t>(num_bytes, INT_MAX));
   if (data_ready_->IsEmpty()) {
     OverlappedBuffer::DisposeBuffer(data_ready_);
     data_ready_ = NULL;
     if (!IsClosing() && !IsClosedRead()) {
       IssueRead();
     }
   }
   return num_bytes;
 }
 
 
-intptr_t Handle::RecvFrom(
-    void* buffer, intptr_t num_bytes, struct sockaddr* sa, socklen_t sa_len) {
+intptr_t Handle::RecvFrom(void* buffer,
+                          intptr_t num_bytes,
+                          struct sockaddr* sa,
+                          socklen_t sa_len) {
   MonitorLocker ml(monitor_);
   if (data_ready_ == NULL) {
     return 0;
   }
-  num_bytes = data_ready_->Read(
-      buffer, Utils::Minimum<intptr_t>(num_bytes, INT_MAX));
+  num_bytes =
+      data_ready_->Read(buffer, Utils::Minimum<intptr_t>(num_bytes, INT_MAX));
   if (data_ready_->from()->sa_family == AF_INET) {
     ASSERT(sa_len >= sizeof(struct sockaddr_in));
     memmove(sa, data_ready_->from(), sizeof(struct sockaddr_in));
   } else {
     ASSERT(data_ready_->from()->sa_family == AF_INET6);
     ASSERT(sa_len >= sizeof(struct sockaddr_in6));
     memmove(sa, data_ready_->from(), sizeof(struct sockaddr_in6));
   }
   // Always dispose of the buffer, as UDP messages must be read in their
   // entirety to match how recvfrom works in a socket.
@@ skipping 76 matching lines @@
 
   write_thread_exists_ = false;
   ml.Notify();
 }
 
 
 void StdHandle::WriteSyncCompleteAsync() {
   ASSERT(pending_write_ != NULL);
 
   DWORD bytes_written = -1;
-  BOOL ok = WriteFile(handle_,
-                      pending_write_->GetBufferStart(),
-                      pending_write_->GetBufferSize(),
-                      &bytes_written,
-                      NULL);
+  BOOL ok = WriteFile(handle_, pending_write_->GetBufferStart(),
+                      pending_write_->GetBufferSize(), &bytes_written, NULL);
   if (!ok) {
     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);
+  ok = PostQueuedCompletionStatus(
+      event_handler_->completion_port(), bytes_written,
+      reinterpret_cast<ULONG_PTR>(this), overlapped);
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
   }
 }
 
 intptr_t StdHandle::Write(const void* buffer, intptr_t num_bytes) {
   MonitorLocker ml(monitor_);
   if (pending_write_ != NULL) {
     return 0;
   }
   if (num_bytes > kBufferSize) {
     num_bytes = kBufferSize;
   }
   // In the case of stdout and stderr, OverlappedIO is not supported.
   // Here we'll instead use a thread, to make it async.
   // This code is actually never exposed to the user, as stdout and stderr is
   // not available as a RawSocket, but only wrapped in a Socket.
   // Note that we return '0', unless a thread have already completed a write.
   if (thread_wrote_ > 0) {
     if (num_bytes > thread_wrote_) {
       num_bytes = thread_wrote_;
     }
     thread_wrote_ -= num_bytes;
     return num_bytes;
   }
   if (!write_thread_exists_) {
     write_thread_exists_ = true;
-    int result = Thread::Start(
-        WriteFileThread, reinterpret_cast<uword>(this));
+    int result = Thread::Start(WriteFileThread, reinterpret_cast<uword>(this));
     if (result != 0) {
       FATAL1("Failed to start write file thread %d", result);
     }
     while (!write_thread_running_) {
       // Wait until we the thread is running.
       ml.Wait(Monitor::kNoTimeout);
     }
   }
   // Only queue up to INT_MAX bytes.
   int truncated_bytes = Utils::Minimum<intptr_t>(num_bytes, INT_MAX);
@@ skipping 19 matching lines @@
     ASSERT(res == WAIT_OBJECT_0);
   }
   Handle::DoClose();
 }
 
 
 bool ClientSocket::LoadDisconnectEx() {
   // Load the DisconnectEx function into memory using WSAIoctl.
   GUID guid_disconnect_ex = WSAID_DISCONNECTEX;
   DWORD bytes;
-  int status = WSAIoctl(socket(),
-                        SIO_GET_EXTENSION_FUNCTION_POINTER,
-                        &guid_disconnect_ex,
-                        sizeof(guid_disconnect_ex),
-                        &DisconnectEx_,
-                        sizeof(DisconnectEx_),
-                        &bytes,
-                        NULL,
-                        NULL);
+  int status =
+      WSAIoctl(socket(), SIO_GET_EXTENSION_FUNCTION_POINTER,
+               &guid_disconnect_ex, sizeof(guid_disconnect_ex), &DisconnectEx_,
+               sizeof(DisconnectEx_), &bytes, NULL, NULL);
   return (status != SOCKET_ERROR);
 }
 
 
 void ClientSocket::Shutdown(int how) {
   int rc = shutdown(socket(), how);
   if (how == SD_RECEIVE) {
     MarkClosedRead();
   }
   if (how == SD_SEND) {
@@ skipping 18 matching lines @@
   MonitorLocker ml(monitor_);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_read_ == NULL);
 
   // TODO(sgjesse): Use a MTU value here. Only the loopback adapter can
   // handle 64k datagrams.
   OverlappedBuffer* buffer = OverlappedBuffer::AllocateReadBuffer(65536);
 
   DWORD flags;
   flags = 0;
-  int rc = WSARecv(socket(),
-                   buffer->GetWASBUF(),
-                   1,
-                   NULL,
-                   &flags,
-                   buffer->GetCleanOverlapped(),
-                   NULL);
+  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;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   pending_read_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 bool ClientSocket::IssueWrite() {
   MonitorLocker ml(monitor_);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_write_ != NULL);
   ASSERT(pending_write_->operation() == OverlappedBuffer::kWrite);
 
-  int rc = WSASend(socket(),
-                   pending_write_->GetWASBUF(),
-                   1,
-                   NULL,
-                   0,
-                   pending_write_->GetCleanOverlapped(),
-                   NULL);
+  int rc = WSASend(socket(), pending_write_->GetWASBUF(), 1, NULL, 0,
+                   pending_write_->GetCleanOverlapped(), NULL);
   if ((rc == NO_ERROR) || (WSAGetLastError() == WSA_IO_PENDING)) {
     return true;
   }
   OverlappedBuffer::DisposeBuffer(pending_write_);
   pending_write_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 void ClientSocket::IssueDisconnect() {
   OverlappedBuffer* buffer = OverlappedBuffer::AllocateDisconnectBuffer();
-  BOOL ok = DisconnectEx_(
-    socket(), buffer->GetCleanOverlapped(), TF_REUSE_SOCKET, 0);
+  BOOL ok =
+      DisconnectEx_(socket(), buffer->GetCleanOverlapped(), TF_REUSE_SOCKET, 0);
   // DisconnectEx works like other OverlappedIO APIs, where we can get either an
   // immediate success or delayed operation by WSA_IO_PENDING being set.
   if (ok || (WSAGetLastError() != WSA_IO_PENDING)) {
     DisconnectComplete(buffer);
   }
   NotifyAllDartPorts(1 << kDestroyedEvent);
   RemoveAllPorts();
 }
 
 
@@ skipping 38 matching lines @@
   return connected_ && closed_;
 }
 
 
 bool DatagramSocket::IssueSendTo(struct sockaddr* sa, socklen_t sa_len) {
   MonitorLocker ml(monitor_);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_write_ != NULL);
   ASSERT(pending_write_->operation() == OverlappedBuffer::kSendTo);
 
-  int rc = WSASendTo(socket(),
-                     pending_write_->GetWASBUF(),
-                     1,
-                     NULL,
-                     0,
-                     sa,
-                     sa_len,
-                     pending_write_->GetCleanOverlapped(),
-                     NULL);
+  int rc = WSASendTo(socket(), pending_write_->GetWASBUF(), 1, NULL, 0, sa,
+                     sa_len, pending_write_->GetCleanOverlapped(), NULL);
   if ((rc == NO_ERROR) || (WSAGetLastError() == WSA_IO_PENDING)) {
     return true;
   }
   OverlappedBuffer::DisposeBuffer(pending_write_);
   pending_write_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 bool DatagramSocket::IssueRecvFrom() {
   MonitorLocker ml(monitor_);
   ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
   ASSERT(pending_read_ == NULL);
 
   OverlappedBuffer* buffer =
       OverlappedBuffer::AllocateRecvFromBuffer(kMaxUDPPackageLength);
 
   DWORD flags;
   flags = 0;
-  int rc = WSARecvFrom(socket(),
-                       buffer->GetWASBUF(),
-                       1,
-                       NULL,
-                       &flags,
-                       buffer->from(),
-                       buffer->from_len_addr(),
-                       buffer->GetCleanOverlapped(),
-                       NULL);
+  int rc = WSARecvFrom(socket(), buffer->GetWASBUF(), 1, NULL, &flags,
+                       buffer->from(), buffer->from_len_addr(),
+                       buffer->GetCleanOverlapped(), NULL);
   if ((rc == NO_ERROR) || (WSAGetLastError() == WSA_IO_PENDING)) {
     pending_read_ = buffer;
     return true;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   pending_read_ = NULL;
   HandleIssueError();
   return false;
 }
 
@@ skipping 29 matching lines @@
     // Change of timeout request. Just set the new timeout and port as the
     // completion thread will use the new timeout value for its next wait.
     timeout_queue_.UpdateTimeout(msg->dart_port, msg->data);
   } else if (msg->id == kShutdownId) {
     shutdown_ = true;
   } else {
     Handle* handle = reinterpret_cast<Handle*>(msg->id);
     ASSERT(handle != NULL);
 
     if (handle->is_listen_socket()) {
-      ListenSocket* listen_socket =
-          reinterpret_cast<ListenSocket*>(handle);
+      ListenSocket* listen_socket = reinterpret_cast<ListenSocket*>(handle);
       listen_socket->EnsureInitialized(this);
 
       MonitorLocker ml(listen_socket->monitor_);
 
       if (IS_COMMAND(msg->data, kReturnTokenCommand)) {
         listen_socket->ReturnTokens(msg->dart_port, TOKEN_COUNT(msg->data));
       } else if (IS_COMMAND(msg->data, kSetEventMaskCommand)) {
         // `events` can only have kInEvent/kOutEvent flags set.
         intptr_t events = msg->data & EVENT_MASK;
         ASSERT(0 == (events & ~(1 << kInEvent | 1 << kOutEvent)));
         listen_socket->SetPortAndMask(msg->dart_port, events);
         TryDispatchingPendingAccepts(listen_socket);
       } else if (IS_COMMAND(msg->data, kCloseCommand)) {
         listen_socket->RemovePort(msg->dart_port);
 
         // We only close the socket file descriptor from the operating
         // system if there are no other dart socket objects which
         // are listening on the same (address, port) combination.
-        ListeningSocketRegistry *registry =
-            ListeningSocketRegistry::Instance();
+        ListeningSocketRegistry* registry = ListeningSocketRegistry::Instance();
         MutexLocker locker(registry->mutex());
         if (registry->CloseSafe(reinterpret_cast<intptr_t>(listen_socket))) {
           ASSERT(listen_socket->Mask() == 0);
           listen_socket->Close();
         }
 
         DartUtils::PostInt32(msg->dart_port, 1 << kDestroyedEvent);
       } else {
         UNREACHABLE();
       }
@@ skipping 75 matching lines @@
   {
     MonitorLocker ml(listen_socket->monitor_);
     TryDispatchingPendingAccepts(listen_socket);
   }
 
   DeleteIfClosed(listen_socket);
 }
 
 
 void EventHandlerImplementation::TryDispatchingPendingAccepts(
-    ListenSocket *listen_socket) {
+    ListenSocket* listen_socket) {
   if (!listen_socket->IsClosing() && listen_socket->CanAccept()) {
     intptr_t event_mask = 1 << kInEvent;
-    for (int i = 0;
-         (i < listen_socket->accepted_count()) &&
-         (listen_socket->Mask() == event_mask);
+    for (int i = 0; (i < listen_socket->accepted_count()) &&
+                    (listen_socket->Mask() == event_mask);
          i++) {
       Dart_Port port = listen_socket->NextNotifyDartPort(event_mask);
       DartUtils::PostInt32(port, event_mask);
     }
   }
 }
 
 
 void EventHandlerImplementation::HandleRead(Handle* handle,
                                             int bytes,
@@ skipping 59 matching lines @@
       }
     }
   } else {
     HandleError(handle);
   }
 
   DeleteIfClosed(handle);
 }
 
 
-void EventHandlerImplementation::HandleDisconnect(
-    ClientSocket* client_socket,
-    int bytes,
-    OverlappedBuffer* buffer) {
+void EventHandlerImplementation::HandleDisconnect(ClientSocket* client_socket,
+                                                  int bytes,
+                                                  OverlappedBuffer* buffer) {
   client_socket->DisconnectComplete(buffer);
   DeleteIfClosed(client_socket);
 }
 
 
-void EventHandlerImplementation::HandleConnect(
-    ClientSocket* client_socket,
-    int bytes,
-    OverlappedBuffer* buffer) {
+void EventHandlerImplementation::HandleConnect(ClientSocket* client_socket,
+                                               int bytes,
+                                               OverlappedBuffer* buffer) {
   if (bytes < 0) {
     HandleError(client_socket);
     OverlappedBuffer::DisposeBuffer(buffer);
   } else {
     client_socket->ConnectComplete(buffer);
   }
   client_socket->mark_connected();
   DeleteIfClosed(client_socket);
 }
 
@@ skipping 69 matching lines @@
   ASSERT(res == WAIT_OBJECT_0);
   delete startup_monitor_;
   CloseHandle(completion_port_);
 }
 
 
 int64_t EventHandlerImplementation::GetTimeout() {
   if (!timeout_queue_.HasTimeout()) {
     return kInfinityTimeout;
   }
-  int64_t millis = timeout_queue_.CurrentTimeout() -
-      TimerUtils::GetCurrentMonotonicMillis();
+  int64_t millis =
+      timeout_queue_.CurrentTimeout() - TimerUtils::GetCurrentMonotonicMillis();
   return (millis < 0) ? 0 : millis;
 }
 
 
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           int64_t data) {
   InterruptMessage* msg = new InterruptMessage;
   msg->id = id;
   msg->dart_port = dart_port;
   msg->data = data;
-  BOOL ok = PostQueuedCompletionStatus(
-      completion_port_, 0, NULL, reinterpret_cast<OVERLAPPED*>(msg));
+  BOOL ok = PostQueuedCompletionStatus(completion_port_, 0, NULL,
+                                       reinterpret_cast<OVERLAPPED*>(msg));
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
   }
 }
 
 
 void EventHandlerImplementation::EventHandlerEntry(uword args) {
   EventHandler* handler = reinterpret_cast<EventHandler*>(args);
   EventHandlerImplementation* handler_impl = &handler->delegate_;
   ASSERT(handler_impl != NULL);
 
   {
     MonitorLocker ml(handler_impl->startup_monitor_);
     handler_impl->handler_thread_id_ = Thread::GetCurrentThreadId();
     handler_impl->handler_thread_handle_ =
         OpenThread(SYNCHRONIZE, false, handler_impl->handler_thread_id_);
     ml.Notify();
   }
 
   while (!handler_impl->shutdown_) {
     DWORD bytes;
     ULONG_PTR key;
     OVERLAPPED* overlapped;
     int64_t millis = handler_impl->GetTimeout();
     ASSERT(millis == kInfinityTimeout || millis >= 0);
     if (millis > kMaxInt32) {
       millis = kMaxInt32;
     }
     ASSERT(sizeof(int32_t) == sizeof(DWORD));
-    BOOL ok = GetQueuedCompletionStatus(handler_impl->completion_port(),
-                                        &bytes,
-                                        &key,
-                                        &overlapped,
-                                        static_cast<DWORD>(millis));
+    BOOL ok =
+        GetQueuedCompletionStatus(handler_impl->completion_port(), &bytes, &key,
+                                  &overlapped, static_cast<DWORD>(millis));
 
     if (!ok && (overlapped == NULL)) {
       if (GetLastError() == ERROR_ABANDONED_WAIT_0) {
         // The completion port should never be closed.
         Log::Print("Completion port closed\n");
         UNREACHABLE();
       } else {
         // Timeout is signalled by false result and NULL in overlapped.
         handler_impl->HandleTimeout();
       }
@@ skipping 26 matching lines @@
       delete msg;
     } else {
       handler_impl->HandleIOCompletion(bytes, key, overlapped);
     }
   }
   handler->NotifyShutdownDone();
 }
 
 
 void EventHandlerImplementation::Start(EventHandler* handler) {
-  int result = Thread::Start(EventHandlerEntry,
-                             reinterpret_cast<uword>(handler));
+  int result =
+      Thread::Start(EventHandlerEntry, reinterpret_cast<uword>(handler));
   if (result != 0) {
     FATAL1("Failed to start event handler thread %d", result);
   }
 
   {
     MonitorLocker ml(startup_monitor_);
     while (handler_thread_id_ == Thread::kInvalidThreadId) {
       ml.Wait();
     }
   }
 
   // Initialize Winsock32
   if (!Socket::Initialize()) {
     FATAL("Failed to initialized Windows sockets");
   }
 }
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)