Enables clean VM shutdown.

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/port.h"
 #include "vm/thread_interrupter.h"
@@ skipping 24 matching lines @@
 MessageHandler::MessageHandler()
     : queue_(new MessageQueue()),
       oob_queue_(new MessageQueue()),
       oob_message_handling_allowed_(true),
       live_ports_(0),
       paused_(0),
       pause_on_start_(false),
       pause_on_exit_(false),
       paused_on_start_(false),
       paused_on_exit_(false),
-      pool_(NULL),
+      running_(false),
       task_(NULL),
       start_callback_(NULL),
       end_callback_(NULL),
       callback_data_(0) {
   ASSERT(queue_ != NULL);
   ASSERT(oob_queue_ != NULL);
 }
 
 
 MessageHandler::~MessageHandler() {
@@ skipping 12 matching lines @@
   // By default there is no checking.
 }
 #endif
 
 
 void MessageHandler::MessageNotify(Message::Priority priority) {
   // By default, there is no custom message notification.
 }
 
 
-void MessageHandler::Run(ThreadPool* pool,
-                         StartCallback start_callback,
+void MessageHandler::Run(StartCallback start_callback,
                          EndCallback end_callback,
                          CallbackData data) {
   MonitorLocker ml(&monitor_);
   if (FLAG_trace_isolates) {
     OS::Print("[+] Starting message handler:\n"
               "\thandler:    %s\n",
               name());
   }
-  ASSERT(pool_ == NULL);
-  pool_ = pool;
+  ASSERT(!running_);
+  running_ = true;

[turnidge, 2015/06/30 22:15:46]

I think that "running_" is a bit confusing as a name.  I would be happier with a
name like "running_on_thread_pool_".   This would distinguish from those message
handlers that run, for example, in dartium's event loop.

[zra, 2015/07/20 22:23:39]

Done.

   start_callback_ = start_callback;
   end_callback_ = end_callback;
   callback_data_ = data;
   task_ = new MessageHandlerTask(this);
-  pool_->Run(task_);
+  ThreadPool::Run(task_);
 }
 
 
 void MessageHandler::PostMessage(Message* message, bool before_events) {
   Message::Priority saved_priority;
   {
     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());
     }
 
     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.
 
-    if (pool_ != NULL && task_ == NULL) {
+    if (running_ && task_ == NULL) {
       task_ = new MessageHandlerTask(this);
-      pool_->Run(task_);
+      ThreadPool::Run(task_);
     }
   }
   // Invoke any custom message notification.
   MessageNotify(saved_priority);
 }
 
 
 Message* MessageHandler::DequeueMessage(Message::Priority min_priority) {
   // TODO(turnidge): Add assert that monitor_ is held here.
   Message* message = oob_queue_->Dequeue();
@@ skipping 59 matching lines @@
     min_priority = (allow_normal_messages && !paused()) ?
         Message::kNormalPriority : Message::kOOBPriority;
     message = DequeueMessage(min_priority);
   }
   return result;
 }
 
 
 bool MessageHandler::HandleNextMessage() {
   // We can only call HandleNextMessage when this handler is not
   // assigned to a thread pool.

[turnidge, 2015/06/30 22:15:46]

Update comment.

[zra, 2015/07/20 22:23:39]

Done.

   MonitorLocker ml(&monitor_);
-  ASSERT(pool_ == NULL);
+  ASSERT(!running_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   return HandleMessages(true, false);
 }
 
 
 bool MessageHandler::HandleOOBMessages() {
   if (!oob_message_handling_allowed_) {
     return true;
@@ skipping 62 matching lines @@
           NotifyPauseOnExit();
           paused_on_exit_ = true;
         }
       } else {
         if (FLAG_trace_isolates) {
         OS::Print("[-] Stopping message handler (%s):\n"
                   "\thandler:    %s\n",
                   (ok ? "no live ports" : "error"),
                   name());
         }
-        pool_ = NULL;
+        running_ = false;
         run_end_callback = true;
         paused_on_exit_ = false;
       }
     }
   }
   if (run_end_callback && end_callback_ != NULL) {
     end_callback_(callback_data_);
     // The handler may have been deleted after this point.
   }
 }
@@ skipping 69 matching lines @@
 
 
 void MessageHandler::AcquireQueues(AcquiredQueues* acquired_queues) {
   ASSERT(acquired_queues != NULL);
   // No double dipping.
   ASSERT(acquired_queues->handler_ == NULL);
   acquired_queues->Reset(this);
 }
 
 }  // namespace dart