Cleanup in //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.
 
 #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 <winsock2.h>  // NOLINT
 #include <ws2tcpip.h>  // NOLINT
-#include <mswsock.h>  // NOLINT
-#include <io.h>  // NOLINT
-#include <fcntl.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"
@@ skipping 107 matching lines @@
 Handle::~Handle() {
   delete monitor_;
 }
 
 
 bool Handle::CreateCompletionPort(HANDLE completion_port) {
   completion_port_ = CreateIoCompletionPort(handle(),
                                             completion_port,
                                             reinterpret_cast<ULONG_PTR>(this),
                                             0);
-  if (completion_port_ == NULL) {
-    return false;
-  }
-  return true;
+  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();
     // Perform handle type specific closing.
@@ skipping 143 matching lines @@
   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());
-    if (ok || GetLastError() == ERROR_IO_PENDING) {
+    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;
@@ skipping 19 matching lines @@
   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());
-  if (ok || GetLastError() == ERROR_IO_PENDING) {
+  if (ok || (GetLastError() == ERROR_IO_PENDING)) {
     // Completing asynchronously.
     pending_write_ = buffer;
     return true;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   HandleIssueError();
   return false;
 }
 
 
@@ skipping 26 matching lines @@
   } else {
     HandleError(this);
   }
   SetLastError(error);
 }
 
 
 void FileHandle::EnsureInitialized(EventHandlerImplementation* event_handler) {
   MonitorLocker ml(monitor_);
   event_handler_ = event_handler;
-  if (SupportsOverlappedIO() && completion_port_ == INVALID_HANDLE_VALUE) {
+  if (SupportsOverlappedIO() && (completion_port_ == INVALID_HANDLE_VALUE)) {
     CreateCompletionPort(event_handler_->completion_port());
   }
 }
 
 
 bool FileHandle::IsClosed() {
   return IsClosing() && !HasPendingRead() && !HasPendingWrite();
 }
 
 
 void DirectoryWatchHandle::EnsureInitialized(
     EventHandlerImplementation* event_handler) {
   MonitorLocker ml(monitor_);
   event_handler_ = event_handler;
   if (completion_port_ == INVALID_HANDLE_VALUE) {
     CreateCompletionPort(event_handler_->completion_port());
   }
 }
 
 
 bool DirectoryWatchHandle::IsClosed() {
-  return IsClosing() && pending_read_ == NULL;
+  return IsClosing() && (pending_read_ == NULL);
 }
 
 
 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;
+  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);
-  if (ok || GetLastError() == ERROR_IO_PENDING) {
+  if (ok || (GetLastError() == ERROR_IO_PENDING)) {
     // Completing asynchronously.
     pending_read_ = buffer;
     return true;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   return false;
 }
 
 
 void DirectoryWatchHandle::Stop() {
@@ skipping 26 matching lines @@
   DWORD bytes;
   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) {
-    return false;
-  }
-  return true;
+  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
@@ skipping 98 matching lines @@
 
 
 ClientSocket* ListenSocket::Accept() {
   MonitorLocker ml(monitor_);
 
   ClientSocket *result = NULL;
 
   if (accepted_head_ != NULL) {
     result = accepted_head_;
     accepted_head_ = accepted_head_->next();
-    if (accepted_head_ == NULL) accepted_tail_ = NULL;
+    if (accepted_head_ == NULL) {
+      accepted_tail_ = NULL;
+    }
     result->set_next(NULL);
     accepted_count_--;
   }
 
   if (pending_accept_count_ < 5) {
     // We have less than 5 pending accepts, queue another.
     if (!IsClosing()) {
       if (!IssueAccept()) {
         HandleError(this);
       }
@@ skipping 17 matching lines @@
 }
 
 
 bool ListenSocket::IsClosed() {
   return IsClosing() && !HasPendingAccept();
 }
 
 
 intptr_t Handle::Available() {
   MonitorLocker ml(monitor_);
-  if (data_ready_ == NULL) return 0;
+  if (data_ready_ == NULL) {
+    return 0;
+  }
   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;
+  if (data_ready_ == NULL) {
+    return 0;
+  }
   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();
+    if (!IsClosing() && !IsClosedRead()) {
+      IssueRead();
+    }
   }
   return num_bytes;
 }
 
 
 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;
+  if (data_ready_ == NULL) {
+    return 0;
+  }
   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.
   OverlappedBuffer::DisposeBuffer(data_ready_);
   data_ready_ = NULL;
-  if (!IsClosing() && !IsClosedRead()) IssueRecvFrom();
+  if (!IsClosing() && !IsClosedRead()) {
+    IssueRecvFrom();
+  }
   return num_bytes;
 }
 
 
 intptr_t Handle::Write(const void* buffer, intptr_t num_bytes) {
   MonitorLocker ml(monitor_);
-  if (pending_write_ != NULL) return 0;
-  if (num_bytes > kBufferSize) num_bytes = kBufferSize;
+  if (pending_write_ != NULL) {
+    return 0;
+  }
+  if (num_bytes > kBufferSize) {
+    num_bytes = kBufferSize;
+  }
   ASSERT(SupportsOverlappedIO());
-  if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
+  if (completion_port_ == INVALID_HANDLE_VALUE) {
+    return 0;
+  }
   int truncated_bytes = Utils::Minimum<intptr_t>(num_bytes, INT_MAX);
   pending_write_ = OverlappedBuffer::AllocateWriteBuffer(truncated_bytes);
   pending_write_->Write(buffer, truncated_bytes);
-  if (!IssueWrite()) return -1;
+  if (!IssueWrite()) {
+    return -1;
+  }
   return truncated_bytes;
 }
 
 
 intptr_t Handle::SendTo(const void* buffer,
                         intptr_t num_bytes,
                         struct sockaddr* sa,
                         socklen_t sa_len) {
   MonitorLocker ml(monitor_);
-  if (pending_write_ != NULL) return 0;
-  if (num_bytes > kBufferSize) num_bytes = kBufferSize;
+  if (pending_write_ != NULL) {
+    return 0;
+  }
+  if (num_bytes > kBufferSize) {
+    num_bytes = kBufferSize;
+  }
   ASSERT(SupportsOverlappedIO());
-  if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
+  if (completion_port_ == INVALID_HANDLE_VALUE) {
+    return 0;
+  }
   pending_write_ = OverlappedBuffer::AllocateSendToBuffer(num_bytes);
   pending_write_->Write(buffer, num_bytes);
-  if (!IssueSendTo(sa, sa_len)) return -1;
+  if (!IssueSendTo(sa, sa_len)) {
+    return -1;
+  }
   return num_bytes;
 }
 
 
 static void WriteFileThread(uword args) {
   StdHandle* handle = reinterpret_cast<StdHandle*>(args);
   handle->RunWriteLoop();
 }
 
 
@@ skipping 35 matching lines @@
                                   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;
+  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_;
+    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));
     if (result != 0) {
       FATAL1("Failed to start write file thread %d", result);
     }
@@ skipping 32 matching lines @@
   DWORD bytes;
   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) {
-    return false;
-  }
-  return true;
+  return (status != SOCKET_ERROR);
 }
 
 
 void ClientSocket::Shutdown(int how) {
   int rc = shutdown(socket(), how);
-  if (how == SD_RECEIVE) MarkClosedRead();
-  if (how == SD_SEND) MarkClosedWrite();
+  if (how == SD_RECEIVE) {
+    MarkClosedRead();
+  }
+  if (how == SD_SEND) {
+    MarkClosedWrite();
+  }
   if (how == SD_BOTH) {
     MarkClosedRead();
     MarkClosedWrite();
   }
 }
 
 
 void ClientSocket::DoClose() {
   // Always do a shutdown before initiating a disconnect.
   shutdown(socket(), SD_BOTH);
@@ skipping 13 matching lines @@
 
   DWORD flags;
   flags = 0;
   int rc = WSARecv(socket(),
                    buffer->GetWASBUF(),
                    1,
                    NULL,
                    &flags,
                    buffer->GetCleanOverlapped(),
                    NULL);
-  if (rc == NO_ERROR || WSAGetLastError() == WSA_IO_PENDING) {
+  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);
-  if (rc == NO_ERROR || WSAGetLastError() == WSA_IO_PENDING) {
+  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);
   // 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) {
+  if (ok || (WSAGetLastError() != WSA_IO_PENDING)) {
     DisconnectComplete(buffer);
   }
   NotifyAllDartPorts(1 << kDestroyedEvent);
   RemoveAllPorts();
 }
 
 
 void ClientSocket::DisconnectComplete(OverlappedBuffer* buffer) {
   OverlappedBuffer::DisposeBuffer(buffer);
   closesocket(socket());
@@ skipping 44 matching lines @@
 
   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) {
+  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);
-  if (rc == NO_ERROR || WSAGetLastError() == WSA_IO_PENDING) {
+  if ((rc == NO_ERROR) || (WSAGetLastError() == WSA_IO_PENDING)) {
     pending_read_ = buffer;
     return true;
   }
   OverlappedBuffer::DisposeBuffer(buffer);
   pending_read_ = NULL;
   HandleIssueError();
   return false;
 }
 
 
 void DatagramSocket::EnsureInitialized(
     EventHandlerImplementation* event_handler) {
   MonitorLocker ml(monitor_);
-  if (completion_port_ == INVALID_HANDLE_VALUE) {
+  if ((completion_port_ == INVALID_HANDLE_VALUE)) {
     ASSERT(event_handler_ == NULL);
     event_handler_ = event_handler;
     CreateCompletionPort(event_handler_->completion_port());
   }
 }
 
 
 bool DatagramSocket::IsClosed() {
   return IsClosing() && !HasPendingRead() && !HasPendingWrite();
 }
@@ skipping 135 matching lines @@
 
   DeleteIfClosed(listen_socket);
 }
 
 
 void EventHandlerImplementation::TryDispatchingPendingAccepts(
     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;
+         (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 84 matching lines @@
     OverlappedBuffer::DisposeBuffer(buffer);
   } else {
     client_socket->ConnectComplete(buffer);
   }
   client_socket->mark_connected();
   DeleteIfClosed(client_socket);
 }
 
 
 void EventHandlerImplementation::HandleTimeout() {
-  if (!timeout_queue_.HasTimeout()) return;
+  if (!timeout_queue_.HasTimeout()) {
+    return;
+  }
   DartUtils::PostNull(timeout_queue_.CurrentPort());
   timeout_queue_.RemoveCurrent();
 }
 
 
 void EventHandlerImplementation::HandleIOCompletion(DWORD bytes,
                                                     ULONG_PTR key,
                                                     OVERLAPPED* overlapped) {
   OverlappedBuffer* buffer = OverlappedBuffer::GetFromOverlapped(overlapped);
   switch (buffer->operation()) {
@@ skipping 88 matching lines @@
     handler_impl->handler_thread_id_ = Thread::GetCurrentThreadId();
     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;
+    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));
 
-    if (!ok && overlapped == NULL) {
+    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();
       }
     } 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
       // 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_BROKEN_PIPE) {
+      if ((last_error == ERROR_CONNECTION_ABORTED) ||
+          (last_error == ERROR_OPERATION_ABORTED) ||
+          (last_error == ERROR_NETNAME_DELETED) ||
+          (last_error == ERROR_BROKEN_PIPE)) {
         ASSERT(bytes == 0);
         handler_impl->HandleIOCompletion(bytes, key, overlapped);
       } else if (last_error == ERROR_MORE_DATA) {
         // Don't ASSERT no bytes in this case. This can happen if the receive
         // buffer for datagram sockets is to small to contain a full datagram,
         // and in this case bytes hold the bytes that was read.
         handler_impl->HandleIOCompletion(-1, key, overlapped);
       } else {
         ASSERT(bytes == 0);
         handler_impl->HandleIOCompletion(-1, key, overlapped);
@@ skipping 33 matching lines @@
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)