Some Linux and Mac OS event handler refactoring

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 13 matching lines @@
 }
 
 
 static const int kInitialPortMapSize = 128;
 static const int kPortMapGrowingFactor = 2;
 static const int kInterruptMessageSize = sizeof(InterruptMessage);
 static const int kInfinityTimeout = -1;
 static const int kTimerId = -1;
 
 
+
+void SocketData::FillPollEvents(struct pollfd* pollfds) {
+  // 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;
+  }
+}
+
+
 EventHandlerImplementation::EventHandlerImplementation() {
   intptr_t result;
   port_map_entries_ = 0;
   port_map_size_ = kInitialPortMapSize;
-  port_map_ = reinterpret_cast<PortData*>(calloc(port_map_size_,
-                                                 sizeof(PortData)));
+  port_map_ = reinterpret_cast<SocketData*>(calloc(port_map_size_,
+                                                 sizeof(SocketData)));
   ASSERT(port_map_ != NULL);
   result = pipe(interrupt_fds_);
   if (result != 0) {
     FATAL("Pipe creation failed");
   }
   FDUtils::SetNonBlocking(interrupt_fds_[0]);
   FDUtils::SetNonBlocking(interrupt_fds_[1]);
   timeout_ = kInfinityTimeout;
   timeout_port_ = 0;
 }
 
 
 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) {
+SocketData* EventHandlerImplementation::GetSocketData(intptr_t fd) {
   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));
+    size_t new_port_map_bytes = new_port_map_size * sizeof(SocketData);
+    port_map_ = reinterpret_cast<SocketData*>(realloc(port_map_,
+                                                      new_port_map_bytes));
     ASSERT(port_map_ != NULL);
-    size_t port_map_bytes = port_map_size_ * sizeof(PortData);
+    size_t port_map_bytes = port_map_size_ * sizeof(SocketData);
     memset(port_map_ + port_map_size_,
            0,
            new_port_map_bytes - port_map_bytes);
     port_map_size_ = new_port_map_size;
   }
 
-  /*
-   * Only change the port map entries count if SetPort changes
-   * the port map state.
-   */
-  if (dart_port == 0 && PortFor(fd) != 0) {
-    port_map_entries_--;
-  } else if (dart_port != 0 && PortFor(fd) == 0) {
-    port_map_entries_++;
-  }
-  port_map_[fd].dart_port = dart_port;
-  port_map_[fd].mask = mask;
+  return port_map_ + fd;
 }
 
 
-Dart_Port EventHandlerImplementation::PortFor(intptr_t fd) {
-  return port_map_[fd].dart_port;
+void EventHandlerImplementation::SetPort(intptr_t fd,
+                                         Dart_Port dart_port,
+                                         intptr_t mask) {
+  SocketData* sd = GetSocketData(fd);
+
+  // Only change the port map entries count if SetPort changes the
+  // port map state.
+  if (dart_port == 0 && sd->port() != 0) {
+    port_map_entries_--;
+  } else if (dart_port != 0 && sd->port() == 0) {
+    port_map_entries_++;
+  }
+
+  sd->set_port(dart_port);
+  sd->set_mask(mask);
 }
 
 
-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 18 matching lines @@
   msg.dart_port = dart_port;
   msg.data = data;
   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) {
-  // 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) {
   struct pollfd* pollfds;
 
   intptr_t numPollfds = 1 + port_map_entries_;
   pollfds = reinterpret_cast<struct pollfd*>(calloc(sizeof(struct pollfd),
                                                     numPollfds));
   pollfds[0].fd = interrupt_fds_[0];
   pollfds[0].events |= POLLIN;
 
   // TODO(hpayer): optimize the following iteration over the hash map
   int j = 1;
   for (int i = 0; i < port_map_size_; i++) {
-    if (port_map_[i].dart_port != 0) {
+    SocketData* sd = &port_map_[i];
+    if (sd->port() != 0) {
       // Fd is added to the poll set.
       pollfds[j].fd = i;
-      SetPollEvents(&pollfds[j], port_map_[i].mask);
+      sd->FillPollEvents(&pollfds[j]);
       j++;
     }
   }
   *pollfds_size = numPollfds;
   return pollfds;
 }
 
 
 bool EventHandlerImplementation::GetInterruptMessage(InterruptMessage* msg) {
   int total_read = 0;
@@ skipping 27 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;
-  if (IsListeningSocket(pollfd->fd)) {
+  SocketData* sd = GetSocketData(pollfd->fd);
+  if (sd->IsListeningSocket()) {
     // 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.
@@ skipping 22 matching lines @@
   }
   if (result_size > 0) {
     for (int i = 1; i < pollfds_size; i++) {
      /*
       * The fd is unregistered. It gets re-registered when the request
       * was handled by dart.
       */
       intptr_t event_mask = GetPollEvents(&pollfds[i]);
       if (event_mask != 0) {
         intptr_t fd = pollfds[i].fd;
-        Dart_Port port = PortFor(fd);
+        Dart_Port port = GetSocketData(fd)->port();
         ASSERT(port != 0);
         UnregisterFd(fd);
         Dart_PostIntArray(port, 1, &event_mask);
       }
     }
   }
   HandleInterruptFd();
 }
 
 
@@ skipping 49 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);
 }