clang-format runtime/vm

runtime/vm/message_handler.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 "vm/message_handler.h"
 
 #include "vm/dart.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/port.h"
 #include "vm/thread_interrupter.h"
 
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_service_pause_events);
 
 class MessageHandlerTask : public ThreadPool::Task {
  public:
-  explicit MessageHandlerTask(MessageHandler* handler)
-      : handler_(handler) {
+  explicit MessageHandlerTask(MessageHandler* handler) : handler_(handler) {
     ASSERT(handler != NULL);
   }
 
   virtual void Run() {
     ASSERT(handler_ != NULL);
     handler_->TaskCallback();
   }
 
  private:
   MessageHandler* handler_;
@@ skipping 69 matching lines @@
 }
 
 
 void MessageHandler::Run(ThreadPool* pool,
                          StartCallback start_callback,
                          EndCallback end_callback,
                          CallbackData data) {
   bool task_running;
   MonitorLocker ml(&monitor_);
   if (FLAG_trace_isolates) {
-    OS::Print("[+] Starting message handler:\n"
-              "\thandler:    %s\n",
-              name());
+    OS::Print(
+        "[+] Starting message handler:\n"
+        "\thandler:    %s\n",
+        name());
   }
   ASSERT(pool_ == NULL);
   ASSERT(!delete_me_);
   pool_ = pool;
   start_callback_ = start_callback;
   end_callback_ = end_callback;
   callback_data_ = data;
   task_ = new MessageHandlerTask(this);
   task_running = pool_->Run(task_);
   ASSERT(task_running);
 }
 
 
 void MessageHandler::PostMessage(Message* message, bool before_events) {
   Message::Priority saved_priority;
   bool task_running = true;
   {
     MonitorLocker ml(&monitor_);
     if (FLAG_trace_isolates) {
       const char* source_name = "<native code>";
       Isolate* source_isolate = Isolate::Current();
       if (source_isolate) {
         source_name = source_isolate->name();
       }
-      OS::Print("[>] Posting message:\n"
-                "\tlen:        %" Pd "\n"
-                "\tsource:     %s\n"
-                "\tdest:       %s\n"
-                "\tdest_port:  %" Pd64 "\n",
-                message->len(), source_name, name(), message->dest_port());
+      OS::Print(
+          "[>] Posting message:\n"
+          "\tlen:        %" Pd
+          "\n"
+          "\tsource:     %s\n"
+          "\tdest:       %s\n"
+          "\tdest_port:  %" Pd64 "\n",
+          message->len(), source_name, name(), message->dest_port());
     }
 
     saved_priority = message->priority();
     if (message->IsOOB()) {
       oob_queue_->Enqueue(message, before_events);
     } else {
       queue_->Enqueue(message, before_events);
     }
     message = NULL;  // Do not access message.  May have been deleted.
 
@@ skipping 28 matching lines @@
 MessageHandler::MessageStatus MessageHandler::HandleMessages(
     MonitorLocker* ml,
     bool allow_normal_messages,
     bool allow_multiple_normal_messages) {
   // TODO(turnidge): Add assert that monitor_ is held here.
 
   // If isolate() returns NULL StartIsolateScope does nothing.
   StartIsolateScope start_isolate(isolate());
 
   MessageStatus max_status = kOK;
-  Message::Priority min_priority = ((allow_normal_messages && !paused())
-                                    ? Message::kNormalPriority
-                                    : Message::kOOBPriority);
+  Message::Priority min_priority =
+      ((allow_normal_messages && !paused()) ? Message::kNormalPriority
+                                            : Message::kOOBPriority);
   Message* message = DequeueMessage(min_priority);
   while (message != NULL) {
     intptr_t message_len = message->len();
     if (FLAG_trace_isolates) {
-      OS::Print("[<] Handling message:\n"
-                "\tlen:        %" Pd "\n"
-                "\thandler:    %s\n"
-                "\tport:       %" Pd64 "\n",
-                message_len, name(), message->dest_port());
+      OS::Print(
+          "[<] Handling message:\n"
+          "\tlen:        %" Pd
+          "\n"
+          "\thandler:    %s\n"
+          "\tport:       %" Pd64 "\n",
+          message_len, name(), message->dest_port());
     }
 
     // Release the monitor_ temporarily while we handle the message.
     // The monitor was acquired in MessageHandler::TaskCallback().
     ml->Exit();
     Message::Priority saved_priority = message->priority();
     Dart_Port saved_dest_port = message->dest_port();
     MessageStatus status = HandleMessage(message);
     if (status > max_status) {
       max_status = status;
     }
     message = NULL;  // May be deleted by now.
     ml->Enter();
     if (FLAG_trace_isolates) {
-      OS::Print("[.] Message handled (%s):\n"
-                "\tlen:        %" Pd "\n"
-                "\thandler:    %s\n"
-                "\tport:       %" Pd64 "\n",
-                MessageStatusString(status),
-                message_len, name(), saved_dest_port);
+      OS::Print(
+          "[.] Message handled (%s):\n"
+          "\tlen:        %" Pd
+          "\n"
+          "\thandler:    %s\n"
+          "\tport:       %" Pd64 "\n",
+          MessageStatusString(status), message_len, name(), saved_dest_port);
     }
     // If we are shutting down, do not process any more messages.
     if (status == kShutdown) {
       ClearOOBQueue();
       break;
     }
 
     // Some callers want to process only one normal message and then quit. At
     // the same time it is OK to process multiple OOB messages.
     if ((saved_priority == Message::kNormalPriority) &&
         !allow_multiple_normal_messages) {
       // We processed one normal message.  Allow no more.
       allow_normal_messages = false;
     }
 
     // Reevaluate the minimum allowable priority.  The paused state
     // may have changed as part of handling the message.  We may also
     // have encountered an error during message processsing.
     //
     // Even if we encounter an error, we still process pending OOB
     // messages so that we don't lose the message notification.
     min_priority = (((max_status == kOK) && allow_normal_messages && !paused())
-                    ? Message::kNormalPriority
-                    : Message::kOOBPriority);
+                        ? Message::kNormalPriority
+                        : Message::kOOBPriority);
     message = DequeueMessage(min_priority);
   }
   return max_status;
 }
 
 
 MessageHandler::MessageStatus MessageHandler::HandleNextMessage() {
   // We can only call HandleNextMessage when this handler is not
   // assigned to a thread pool.
   MonitorLocker ml(&monitor_);
@@ skipping 108 matching lines @@
         status = HandleMessages(&ml, (status == kOK), true);
       }
     }
 
     // The isolate exits when it encounters an error or when it no
     // longer has live ports.
     if (status != kOK || !HasLivePorts()) {
       if (ShouldPauseOnExit(status)) {
         if (!is_paused_on_exit()) {
           if (FLAG_trace_service_pause_events) {
-            OS::PrintErr("Isolate %s paused before exiting. "
-                         "Use the Observatory to release it.\n", name());
+            OS::PrintErr(
+                "Isolate %s paused before exiting. "
+                "Use the Observatory to release it.\n",
+                name());
           }
           PausedOnExitLocked(&ml, true);
           // More messages may have come in while we released the monitor.
           status = HandleMessages(&ml, false, false);
         }
         if (ShouldPauseOnExit(status)) {
           // Still paused.
           ASSERT(oob_queue_->IsEmpty());
           task_ = NULL;  // No task in queue.
           return;
         } else {
           PausedOnExitLocked(&ml, false);
         }
       }
       if (FLAG_trace_isolates) {
         if (status != kOK && thread() != NULL) {
           const Error& error = Error::Handle(thread()->sticky_error());
-          OS::Print("[-] Stopping message handler (%s):\n"
-                    "\thandler:    %s\n"
-                    "\terror:    %s\n",
-                    MessageStatusString(status), name(), error.ToCString());
+          OS::Print(
+              "[-] Stopping message handler (%s):\n"
+              "\thandler:    %s\n"
+              "\terror:    %s\n",
+              MessageStatusString(status), name(), error.ToCString());
         } else {
-          OS::Print("[-] Stopping message handler (%s):\n"
-                    "\thandler:    %s\n",
-                    MessageStatusString(status), name());
+          OS::Print(
+              "[-] Stopping message handler (%s):\n"
+              "\thandler:    %s\n",
+              MessageStatusString(status), name());
         }
       }
       pool_ = NULL;
       run_end_callback = true;
       delete_me = delete_me_;
     }
 
     // Clear the task_ last.  This allows other tasks to potentially start
     // for this message handler.
     ASSERT(oob_queue_->IsEmpty());
     task_ = NULL;
   }
 
   // Message handlers either use delete_me or end_callback but not both.
   ASSERT(!delete_me || end_callback_ == NULL);
 
   if (run_end_callback && end_callback_ != NULL) {
     end_callback_(callback_data_);
     // The handler may have been deleted after this point.
   }
   if (delete_me) {
     delete this;
   }
 }
 
 
 void MessageHandler::ClosePort(Dart_Port port) {
   MonitorLocker ml(&monitor_);
   if (FLAG_trace_isolates) {
-    OS::Print("[-] Closing port:\n"
-              "\thandler:    %s\n"
-              "\tport:       %" Pd64 "\n"
-              "\tports:      live(%" Pd ")\n",
-              name(), port, live_ports_);
+    OS::Print(
+        "[-] Closing port:\n"
+        "\thandler:    %s\n"
+        "\tport:       %" Pd64
+        "\n"
+        "\tports:      live(%" Pd ")\n",
+        name(), port, live_ports_);
   }
 }
 
 
 void MessageHandler::CloseAllPorts() {
   MonitorLocker ml(&monitor_);
   if (FLAG_trace_isolates) {
-    OS::Print("[-] Closing all ports:\n"
-              "\thandler:    %s\n",
-              name());
+    OS::Print(
+        "[-] Closing all ports:\n"
+        "\thandler:    %s\n",
+        name());
   }
   queue_->Clear();
   oob_queue_->Clear();
 }
 
 
 void MessageHandler::RequestDeletion() {
   ASSERT(OwnedByPortMap());
   {
     MonitorLocker ml(&monitor_);
@@ skipping 106 matching lines @@
   handler_->oob_message_handling_allowed_ = false;
 }
 
 
 MessageHandler::AcquiredQueues::~AcquiredQueues() {
   ASSERT(handler_ != NULL);
   handler_->oob_message_handling_allowed_ = true;
 }
 
 }  // namespace dart