Update usage of mx_handle_wait_many() API.

runtime/bin/eventhandler_fuchsia.cc

 // Copyright (c) 2016, 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_FUCHSIA)
 
 #include "bin/eventhandler.h"
@@ skipping 18 matching lines @@
 namespace bin {
 
 MagentaWaitManyInfo::MagentaWaitManyInfo()
     : capacity_(kInitialCapacity),
       size_(0) {
   descriptor_infos_ = static_cast<DescriptorInfo**>(
       malloc(kInitialCapacity * sizeof(*descriptor_infos_)));
   if (descriptor_infos_ == NULL) {
     FATAL("Failed to allocate descriptor_infos array");
   }
-  handles_ = static_cast<mx_handle_t*>(
-      malloc(kInitialCapacity * sizeof(*handles_)));
-  if (handles_ == NULL) {
-    FATAL("Failed to allocate handles array");
-  }
-  signals_ = static_cast<mx_signals_t*>(
-      malloc(kInitialCapacity * sizeof(*signals_)));
-  if (signals_ == NULL) {
-    FATAL("Failed to allocate signals array");
-  }
-  signals_states_ = static_cast<mx_signals_state_t*>(
-      malloc(kInitialCapacity * sizeof(*signals_states_)));
-  if (signals_states_ == NULL) {
-    FATAL("Failed to allocate signals_states array");
+  items_ = static_cast<mx_wait_item_t*>(
+      malloc(kInitialCapacity * sizeof(*items_)));
+  if (items_ == NULL) {
+    FATAL("Failed to allocate items array");
   }
 }
 
 
 MagentaWaitManyInfo::~MagentaWaitManyInfo() {
   free(descriptor_infos_);
-  free(handles_);
-  free(signals_);
-  free(signals_states_);
+  free(items_);
 }
 
 
 void MagentaWaitManyInfo::AddHandle(mx_handle_t handle,
                                     mx_signals_t signals,
                                     DescriptorInfo* di) {
 #if defined(DEBUG)
   // Check that the handle is not already in the list.
   for (intptr_t i = 0; i < size_; i++) {
-    if (handles_[i] == handle) {
+    if (items_[i].handle == handle) {
       FATAL("The handle is already in the list!");
     }
   }
 #endif
   intptr_t new_size = size_ + 1;
   GrowArraysIfNeeded(new_size);
   descriptor_infos_[size_] = di;
-  handles_[size_] = handle;
-  signals_[size_] = signals;
-  signals_states_[size_].satisfied = MX_SIGNAL_NONE;
-  signals_states_[size_].satisfiable = MX_SIGNAL_NONE;
+  items_[size_].handle = handle;
+  items_[size_].waitfor = signals;
+  items_[size_].pending = 0;
   size_ = new_size;
   LOG_INFO("AddHandle(%ld, %ld, %p), size = %ld\n", handle, signals, di, size_);
 }
 
 
 void MagentaWaitManyInfo::RemoveHandle(mx_handle_t handle) {
   intptr_t idx;
   for (idx = 1; idx < size_; idx++) {
-    if (handle == handles_[idx]) {
+    if (handle == items_[idx].handle) {
       break;
     }
   }
   if (idx == size_) {
     FATAL("Handle is not in the list!");
   }
 
   if (idx != (size_ - 1)) {
     descriptor_infos_[idx] = descriptor_infos_[size_ - 1];
-    handles_[idx] = handles_[size_ - 1];
-    signals_[idx] = signals_[size_ - 1];
-    signals_states_[idx] = signals_states_[size_ - 1];
+    items_[idx] = items_[size_ - 1];
   }
   descriptor_infos_[size_ - 1] = NULL;
-  handles_[size_ - 1] = MX_HANDLE_INVALID;
-  signals_[size_ - 1] = MX_SIGNAL_NONE;
-  signals_states_[size_ - 1].satisfied = MX_SIGNAL_NONE;
-  signals_states_[size_ - 1].satisfiable = MX_SIGNAL_NONE;
+  items_[size_ - 1] = {MX_HANDLE_INVALID, 0, 0};
   size_ = size_ - 1;
   LOG_INFO("RemoveHandle(%ld), size = %ld\n", handle, size_);
 }
 
 
 void MagentaWaitManyInfo::GrowArraysIfNeeded(intptr_t desired_size) {
   if (desired_size < capacity_) {
     return;
   }
   intptr_t new_capacity = desired_size + (desired_size >> 1);
   descriptor_infos_ = static_cast<DescriptorInfo**>(
       realloc(descriptor_infos_, new_capacity * sizeof(*descriptor_infos_)));
   if (descriptor_infos_ == NULL) {
     FATAL("Failed to grow descriptor_infos array");
   }
-  handles_ = static_cast<mx_handle_t*>(
-      realloc(handles_, new_capacity * sizeof(*handles_)));
-  if (handles_ == NULL) {
-    FATAL("Failed to grow handles array");
-  }
-  signals_ = static_cast<mx_signals_t*>(
-      realloc(signals_, new_capacity * sizeof(*signals_)));
-  if (signals_ == NULL) {
-    FATAL("Failed to grow signals array");
-  }
-  signals_states_ = static_cast<mx_signals_state_t*>(
-      realloc(signals_states_, new_capacity * sizeof(*signals_states_)));
-  if (signals_states_ == NULL) {
-    FATAL("Failed to grow signals_states array");
+  items_ = static_cast<mx_wait_item_t*>(
+      realloc(items_, new_capacity * sizeof(*items_)));
+  if (items_ == NULL) {
+    FATAL("Failed to grow items array");
   }
   capacity_ = new_capacity;
   LOG_INFO("GrowArraysIfNeeded(%ld), capacity = %ld\n",
            desired_size, capacity_);
 }
 
 
 EventHandlerImplementation::EventHandlerImplementation() {
   mx_status_t status = mx_channel_create(0, &interrupt_handles_[0],
                                          &interrupt_handles_[1]);
@@ skipping 67 matching lines @@
   if (status != ERR_SHOULD_WAIT) {
     FATAL1("mx_channel_read failed: %s\n", mx_status_get_string(status));
   }
   LOG_INFO("HandleInterruptFd exit\n");
 }
 
 
 void EventHandlerImplementation::HandleEvents() {
   LOG_INFO("HandleEvents entry\n");
   for (intptr_t i = 1; i < info_.size(); i++) {
-    if (info_.signals_states()[i].satisfied != MX_SIGNAL_NONE) {
+    const mx_wait_item_t& wait_item = info_.items()[i];
+    if (wait_item.pending & wait_item.waitfor) {
       // Only the control handle has no descriptor info.
       ASSERT(info_.descriptor_infos()[i] != NULL);
       ASSERT(info_.handles()[i] != interrupt_handles_[0]);
       // TODO(zra): Handle events on other handles. At the moment we are
       // only interrupted when there is a message on interrupt_handles_[0].
       UNIMPLEMENTED();
     }
   }
 
-  if ((info_.signals_states()[0].satisfied & MX_SIGNAL_PEER_CLOSED) != 0) {
+  if ((info_.items()[0].pending & MX_SIGNAL_PEER_CLOSED) != 0) {
     FATAL("EventHandlerImplementation::Poll: Unexpected peer closed\n");
   }
-  if ((info_.signals_states()[0].satisfied & MX_SIGNAL_READABLE) != 0) {
+  if ((info_.items()[0].pending & MX_SIGNAL_READABLE) != 0) {
     LOG_INFO("HandleEvents interrupt_handles_[0] readable\n");
     HandleInterruptFd();
   } else {
     LOG_INFO("HandleEvents interrupt_handles_[0] not readable\n");
   }
 }
 
 
 int64_t EventHandlerImplementation::GetTimeout() const {
   if (!timeout_queue_.HasTimeout()) {
@@ skipping 21 matching lines @@
   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));
     mx_time_t timeout =
         millis * kMicrosecondsPerMillisecond * kNanosecondsPerMicrosecond;
     const MagentaWaitManyInfo& info = handler_impl->info();
-    uint32_t result_index;
-    LOG_INFO("mx_handle_wait_many(%ld, %p, %p, %lld, %p, %p)\n",
-        info.size(), info.handles(), info.signals(), timeout, &result_index,
-        info.signals_states());
+    LOG_INFO("mx_handle_wait_many(%p, %ld, %lld)\n",
+        info.items(), info.size(), timeout);
     mx_status_t status = mx_handle_wait_many(
+        info.items(),
         info.size(),
-        info.handles(),
-        info.signals(),
-        timeout,
-        &result_index,
-        info.signals_states());
+        timeout);
     if ((status != NO_ERROR) && (status != ERR_TIMED_OUT)) {
       FATAL1("mx_handle_wait_many failed: %s\n", mx_status_get_string(status));
     } else {
       LOG_INFO("mx_handle_wait_many returned: %ld\n", status);
       handler_impl->HandleTimeout();
       handler_impl->HandleEvents();
     }
   }
   handler->NotifyShutdownDone();
   LOG_INFO("EventHandlerImplementation notifying about shutdown\n");
@@ skipping 19 matching lines @@
                                           int64_t data) {
   WakeupHandler(id, dart_port, data);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_FUCHSIA)
 
 #endif  // !defined(DART_IO_DISABLED)