Explicitly handle listen sockets and connection sockets differently in Linux and Mac OS eventhandler

runtime/bin/eventhandler_macos.cc

 // Copyright (c) 2011, 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 <errno.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/time.h>
@@ skipping 40 matching lines @@
 
 EventHandlerImplementation::~EventHandlerImplementation() {
   free(port_map_);
   close(interrupt_fds_[0]);
   close(interrupt_fds_[1]);
 }
 
 
 // TODO(hpayer): Use hash table instead of array.
 void EventHandlerImplementation::SetPort(intptr_t fd,
-                                 Dart_Port dart_port,
-                                 intptr_t mask) {
+                                         Dart_Port dart_port,
+                                         intptr_t mask) {
   ASSERT(fd >= 0);
   if (fd >= port_map_size_) {
     intptr_t new_port_map_size = port_map_size_;
     do {
       new_port_map_size = new_port_map_size * kPortMapGrowingFactor;
     } while (fd >= new_port_map_size);
     size_t new_port_map_bytes = new_port_map_size * sizeof(PortData);
     port_map_ = reinterpret_cast<PortData*>(realloc(port_map_,
                                                     new_port_map_bytes));
     ASSERT(port_map_ != NULL);
@@ skipping 16 matching lines @@
   port_map_[fd].dart_port = dart_port;
   port_map_[fd].mask = mask;
 }
 
 
 Dart_Port EventHandlerImplementation::PortFor(intptr_t fd) {
   return port_map_[fd].dart_port;
 }
 
 
+bool EventHandlerImplementation::IsListeningSocket(intptr_t fd) {
+  return (port_map_[fd].mask & (1 << kListeningSocket)) != 0;
+}
+
+
 void EventHandlerImplementation::RegisterFdWakeup(intptr_t id,
                                                   Dart_Port dart_port,
                                                   intptr_t data) {
   WakeupHandler(id, dart_port, data);
 }
 
 
 void EventHandlerImplementation::CloseFd(intptr_t id) {
   SetPort(id, 0, 0);
   close(id);
@@ skipping 20 matching lines @@
   intptr_t result =
     write(interrupt_fds_[1], &msg, kInterruptMessageSize);
   if (result != kInterruptMessageSize) {
     perror("Interrupt message failure");
   }
 }
 
 
 void EventHandlerImplementation::SetPollEvents(struct pollfd* pollfds,
                                                intptr_t mask) {
-  /*
-   * We do not set POLLERR and POLLHUP explicitly since they are triggered
-   * anyway.
-   */
+  // Do not ask for POLLERR and POLLHUP explicitly as they are
+  // triggered anyway.
   if ((mask & (1 << kInEvent)) != 0) {
     pollfds->events |= POLLIN;
   }
   if ((mask & (1 << kOutEvent)) != 0) {
     pollfds->events |= POLLOUT;
   }
 }
 
 
 struct pollfd* EventHandlerImplementation::GetPollFds(intptr_t* pollfds_size) {
@@ skipping 52 matching lines @@
       CloseFd(msg.id);
     } else {
       SetPort(msg.id, msg.dart_port, msg.data);
     }
   }
 }
 
 
 intptr_t EventHandlerImplementation::GetPollEvents(struct pollfd* pollfd) {
   intptr_t event_mask = 0;
-  /*
-   * We prioritize the events in the following order.
-   */
-  if ((pollfd->revents & POLLIN) != 0) {
-    if (FDUtils::AvailableBytes(pollfd->fd) != 0) {
-      event_mask = (1 << kInEvent);
-    } else if ((pollfd->revents & POLLHUP) != 0) {
-      event_mask = (1 << kCloseEvent);
-    } else if ((pollfd->revents & POLLERR) != 0) {
-      event_mask = (1 << kErrorEvent);
-    } else {
-      /*
-       * Accept event.
-       */
-      event_mask = (1 << kInEvent);
+  if (IsListeningSocket(pollfd->fd)) {
+    // For listening sockets the POLLIN event indicate that there are
+    // connections ready for accept unless accompanied with one of the
+    // other flags.
+    if ((pollfd->revents & POLLIN) != 0) {
+      if ((pollfd->revents & POLLHUP) != 0) event_mask |= (1 << kCloseEvent);
+      if ((pollfd->revents & POLLERR) != 0) event_mask |= (1 << kErrorEvent);
+      if (event_mask == 0) event_mask |= (1 << kInEvent);
     }
-  }
+  } else {
+    // Prioritize data events over close and error events.
+    if ((pollfd->revents & POLLIN) != 0) {
+      if (FDUtils::AvailableBytes(pollfd->fd) != 0) {
+        event_mask = (1 << kInEvent);
+      } else if ((pollfd->revents & POLLHUP) != 0) {
+        event_mask = (1 << kCloseEvent);
+      } else if ((pollfd->revents & POLLERR) != 0) {
+        event_mask = (1 << kErrorEvent);
+      }
+    }
 
-  if ((pollfd->revents & POLLOUT) != 0) {
-    event_mask |= (1 << kOutEvent);
+    if ((pollfd->revents & POLLOUT) != 0) event_mask |= (1 << kOutEvent);
   }
 
   return event_mask;
 }
 
 
 void EventHandlerImplementation::HandleEvents(struct pollfd* pollfds,
                                               int pollfds_size,
                                               int result_size) {
   if ((pollfds[0].revents & POLLIN) != 0) {
@@ skipping 71 matching lines @@
     FATAL("Create start event handler thread");
   }
 }
 
 
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           intptr_t data) {
   RegisterFdWakeup(id, dart_port, data);
 }