clang-format runtime/bin

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 11 matching lines @@
 #define LOG_INFO(msg, ...) Log::Print(msg, ##__VA_ARGS__)
 #else
 #define LOG_ERR(msg, ...)
 #define LOG_INFO(msg, ...)
 #endif  // defined(EVENTHANDLER_LOGGING)
 
 namespace dart {
 namespace bin {
 
 MagentaWaitManyInfo::MagentaWaitManyInfo()
-    : capacity_(kInitialCapacity),
-      size_(0) {
+    : 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");
   }
-  items_ = static_cast<mx_wait_item_t*>(
-      malloc(kInitialCapacity * sizeof(*items_)));
+  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(items_);
 }
@@ skipping 52 matching lines @@
       realloc(descriptor_infos_, new_capacity * sizeof(*descriptor_infos_)));
   if (descriptor_infos_ == NULL) {
     FATAL("Failed to grow descriptor_infos 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_);
+  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]);
+  mx_status_t status =
+      mx_channel_create(0, &interrupt_handles_[0], &interrupt_handles_[1]);
   if (status != NO_ERROR) {
     FATAL1("mx_channel_create failed: %s\n", mx_status_get_string(status));
   }
   shutdown_ = false;
   info_.AddHandle(interrupt_handles_[0],
-                  MX_SIGNAL_READABLE | MX_SIGNAL_PEER_CLOSED,
-                  NULL);
+                  MX_SIGNAL_READABLE | MX_SIGNAL_PEER_CLOSED, NULL);
   LOG_INFO("EventHandlerImplementation initialized\n");
 }
 
 
 EventHandlerImplementation::~EventHandlerImplementation() {
   mx_status_t status = mx_handle_close(interrupt_handles_[0]);
   if (status != NO_ERROR) {
     FATAL1("mx_handle_close failed: %s\n", mx_status_get_string(status));
   }
   status = mx_handle_close(interrupt_handles_[1]);
   if (status != NO_ERROR) {
     FATAL1("mx_handle_close failed: %s\n", mx_status_get_string(status));
   }
   LOG_INFO("EventHandlerImplementation destroyed\n");
 }
 
 
 void EventHandlerImplementation::WakeupHandler(intptr_t id,
                                                Dart_Port dart_port,
                                                int64_t data) {
   InterruptMessage msg;
   msg.id = id;
   msg.dart_port = dart_port;
   msg.data = data;
 
   mx_status_t status =
-    mx_channel_write(interrupt_handles_[1], 0, &msg, sizeof(msg), NULL, 0);
+      mx_channel_write(interrupt_handles_[1], 0, &msg, sizeof(msg), NULL, 0);
   if (status != NO_ERROR) {
     FATAL1("mx_channel_write failed: %s\n", mx_status_get_string(status));
   }
   LOG_INFO("WakeupHandler(%ld, %ld, %lld)\n", id, dart_port, data);
 }
 
 
 void EventHandlerImplementation::HandleInterruptFd() {
   LOG_INFO("HandleInterruptFd entry\n");
   InterruptMessage msg;
   uint32_t bytes = kInterruptMessageSize;
   mx_status_t status;
   while (true) {
-    status = mx_channel_read(
-        interrupt_handles_[0], 0, &msg, bytes, &bytes, NULL, 0, NULL);
+    status = mx_channel_read(interrupt_handles_[0], 0, &msg, bytes, &bytes,
+                             NULL, 0, NULL);
     if (status != NO_ERROR) {
       break;
     }
     ASSERT(bytes == kInterruptMessageSize);
     if (msg.id == kTimerId) {
       LOG_INFO("HandleInterruptFd read timer update\n");
       timeout_queue_.UpdateTimeout(msg.dart_port, msg.data);
     } else if (msg.id == kShutdownId) {
       LOG_INFO("HandleInterruptFd read shutdown\n");
       shutdown_ = true;
@@ skipping 35 matching lines @@
   } else {
     LOG_INFO("HandleEvents interrupt_handles_[0] not readable\n");
   }
 }
 
 
 int64_t EventHandlerImplementation::GetTimeout() const {
   if (!timeout_queue_.HasTimeout()) {
     return kInfinityTimeout;
   }
-  int64_t millis = timeout_queue_.CurrentTimeout() -
-      TimerUtils::GetCurrentMonotonicMillis();
+  int64_t millis =
+      timeout_queue_.CurrentTimeout() - TimerUtils::GetCurrentMonotonicMillis();
   return (millis < 0) ? 0 : millis;
 }
 
 
 void EventHandlerImplementation::HandleTimeout() {
   if (timeout_queue_.HasTimeout()) {
     int64_t millis = timeout_queue_.CurrentTimeout() -
-        TimerUtils::GetCurrentMonotonicMillis();
+                     TimerUtils::GetCurrentMonotonicMillis();
     if (millis <= 0) {
       DartUtils::PostNull(timeout_queue_.CurrentPort());
       timeout_queue_.RemoveCurrent();
     }
   }
 }
 
 
 void EventHandlerImplementation::Poll(uword args) {
   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();
-    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(),
-        timeout);
+    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(), 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)