Cleanup in //runtime/bin

runtime/bin/eventhandler_macos.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 "platform/globals.h"
 #if defined(TARGET_OS_MACOS)
 
 #include "bin/eventhandler.h"
 #include "bin/eventhandler_macos.h"
 
 #include <errno.h>  // NOLINT
+#include <fcntl.h>  // NOLINT
 #include <pthread.h>  // NOLINT
 #include <stdio.h>  // NOLINT
 #include <string.h>  // NOLINT
 #include <sys/event.h>  // NOLINT
 #include <unistd.h>  // NOLINT
-#include <fcntl.h>  // NOLINT
 
 #include "bin/dartutils.h"
 #include "bin/fdutils.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "platform/hashmap.h"
 #include "platform/utils.h"
 
-
 namespace dart {
 namespace bin {
 
-
 bool DescriptorInfo::HasReadEvent() {
   return (Mask() & (1 << kInEvent)) != 0;
 }
 
 
 bool DescriptorInfo::HasWriteEvent() {
   return (Mask() & (1 << kOutEvent)) != 0;
 }
 
 
 // Unregister the file descriptor for a SocketData structure with kqueue.
 static void RemoveFromKqueue(intptr_t kqueue_fd_, DescriptorInfo* di) {
-  if (!di->tracked_by_kqueue()) return;
+  if (!di->tracked_by_kqueue()) {
+    return;
+  }
   static const intptr_t kMaxChanges = 2;
   struct kevent events[kMaxChanges];
   EV_SET(events, di->fd(), EVFILT_READ, EV_DELETE, 0, 0, NULL);
   VOID_NO_RETRY_EXPECTED(kevent(kqueue_fd_, events, 1, NULL, 0, NULL));
   EV_SET(events, di->fd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
   VOID_NO_RETRY_EXPECTED(kevent(kqueue_fd_, events, 1, NULL, 0, NULL));
   di->set_tracked_by_kqueue(false);
 }
 
 
@@ skipping 86 matching lines @@
   VOID_TEMP_FAILURE_RETRY(close(interrupt_fds_[0]));
   VOID_TEMP_FAILURE_RETRY(close(interrupt_fds_[1]));
 }
 
 
 void EventHandlerImplementation::UpdateKQueueInstance(intptr_t old_mask,
                                                       DescriptorInfo *di) {
   intptr_t new_mask = di->Mask();
   if (old_mask != 0 && new_mask == 0) {
     RemoveFromKqueue(kqueue_fd_, di);
-  } else if (old_mask == 0 && new_mask != 0) {
+  } else if ((old_mask == 0) && (new_mask != 0)) {
     AddToKqueue(kqueue_fd_, di);
-  } else if (old_mask != 0 && new_mask != 0 && old_mask != new_mask) {
+  } else if ((old_mask != 0) && (new_mask != 0) && (old_mask != new_mask)) {
     ASSERT(!di->IsListeningSocket());
     RemoveFromKqueue(kqueue_fd_, di);
     AddToKqueue(kqueue_fd_, di);
   }
 }
 
 
 DescriptorInfo* EventHandlerImplementation::GetDescriptorInfo(
     intptr_t fd, bool is_listening) {
   ASSERT(fd >= 0);
@@ skipping 108 matching lines @@
         intptr_t old_mask = di->Mask();
         di->SetPortAndMask(msg[i].dart_port, msg[i].data & EVENT_MASK);
         UpdateKQueueInstance(old_mask, di);
       } else {
         UNREACHABLE();
       }
     }
   }
 }
 
+
 #ifdef DEBUG_KQUEUE
 static void PrintEventMask(intptr_t fd, struct kevent* event) {
   Log::Print("%d ", static_cast<int>(fd));
+
   Log::Print("filter=0x%x:", event->filter);
-  if (event->filter == EVFILT_READ) Log::Print("EVFILT_READ ");
-  if (event->filter == EVFILT_WRITE) Log::Print("EVFILT_WRITE ");
+  if (event->filter == EVFILT_READ) {
+    Log::Print("EVFILT_READ ");
+  }
+  if (event->filter == EVFILT_WRITE) {
+    Log::Print("EVFILT_WRITE ");
+  }
+
   Log::Print("flags: %x: ", event->flags);
-  if ((event->flags & EV_EOF) != 0) Log::Print("EV_EOF ");
-  if ((event->flags & EV_ERROR) != 0) Log::Print("EV_ERROR ");
-  if ((event->flags & EV_CLEAR) != 0) Log::Print("EV_CLEAR ");
-  if ((event->flags & EV_ADD) != 0) Log::Print("EV_ADD ");
-  if ((event->flags & EV_DELETE) != 0) Log::Print("EV_DELETE ");
+  if ((event->flags & EV_EOF) != 0) {
+    Log::Print("EV_EOF ");
+  }
+  if ((event->flags & EV_ERROR) != 0) {
+    Log::Print("EV_ERROR ");
+  }
+  if ((event->flags & EV_CLEAR) != 0) {
+    Log::Print("EV_CLEAR ");
+  }
+  if ((event->flags & EV_ADD) != 0) {
+    Log::Print("EV_ADD ");
+  }
+  if ((event->flags & EV_DELETE) != 0) {
+    Log::Print("EV_DELETE ");
+  }
+
   Log::Print("- fflags: %d ", event->fflags);
   Log::Print("- data: %ld ", event->data);
-  Log::Print("(available %d) ",
-      static_cast<int>(FDUtils::AvailableBytes(fd)));
+  Log::Print("(available %d) ", static_cast<int>(FDUtils::AvailableBytes(fd)));
   Log::Print("\n");
 }
 #endif
 
 
 intptr_t EventHandlerImplementation::GetEvents(struct kevent* event,
                                                DescriptorInfo* di) {
 #ifdef DEBUG_KQUEUE
   PrintEventMask(di->fd(), event);
 #endif
   intptr_t event_mask = 0;
   if (di->IsListeningSocket()) {
     // On a listening socket the READ event means that there are
     // connections ready to be accepted.
     if (event->filter == EVFILT_READ) {
       if ((event->flags & EV_EOF) != 0) {
         if (event->fflags != 0) {
           event_mask |= (1 << kErrorEvent);
         } else {
           event_mask |= (1 << kCloseEvent);
         }
       }
-      if (event_mask == 0) event_mask |= (1 << kInEvent);
+      if (event_mask == 0) {
+        event_mask |= (1 << kInEvent);
+      }
     } else {
       UNREACHABLE();
     }
   } else {
     // Prioritize data events over close and error events.
     if (event->filter == EVFILT_READ) {
       event_mask = (1 << kInEvent);
       if ((event->flags & EV_EOF) != 0) {
         if (event->fflags != 0) {
           event_mask = (1 << kErrorEvent);
@@ skipping 81 matching lines @@
 void EventHandlerImplementation::EventHandlerEntry(uword args) {
   static const intptr_t kMaxEvents = 16;
   struct kevent events[kMaxEvents];
   EventHandler* handler = reinterpret_cast<EventHandler*>(args);
   EventHandlerImplementation* handler_impl = &handler->delegate_;
   ASSERT(handler_impl != NULL);
 
   while (!handler_impl->shutdown_) {
     int64_t millis = handler_impl->GetTimeout();
     ASSERT(millis == kInfinityTimeout || millis >= 0);
-    if (millis > kMaxInt32) millis = kMaxInt32;
+    if (millis > kMaxInt32) {
+      millis = kMaxInt32;
+    }
     // NULL pointer timespec for infinite timeout.
     ASSERT(kInfinityTimeout < 0);
     struct timespec* timeout = NULL;
     struct timespec ts;
     if (millis >= 0) {
       int32_t millis32 = static_cast<int32_t>(millis);
       int32_t secs = millis32 / 1000;
       ts.tv_sec = secs;
       ts.tv_nsec = (millis32 - (secs * 1000)) * 1000000;
       timeout = &ts;
@@ skipping 46 matching lines @@
 
 uint32_t EventHandlerImplementation::GetHashmapHashFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_MACOS)