- Implement Isolate.pause and Isolate.resume.

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/port.h"
 #include "vm/dart.h"
 
 namespace dart {
 
@@ skipping 16 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MessageHandlerTask);
 };
 
 
 MessageHandler::MessageHandler()
     : queue_(new MessageQueue()),
       oob_queue_(new MessageQueue()),
       control_ports_(0),
       live_ports_(0),
+      paused_(0),
       pause_on_start_(false),
       pause_on_exit_(false),
       paused_on_exit_(false),
       pool_(NULL),
       task_(NULL),
       start_callback_(NULL),
       end_callback_(NULL),
       callback_data_(0) {
   ASSERT(queue_ != NULL);
   ASSERT(oob_queue_ != NULL);
@@ skipping 72 matching lines @@
   }
 
   // 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();
-  if (message == NULL && min_priority < Message::kOOBPriority) {
+  if ((message == NULL) && (min_priority < Message::kOOBPriority)) {
     message = queue_->Dequeue();
   }
   return message;
 }
 
 
 bool MessageHandler::HandleMessages(bool allow_normal_messages,
                                     bool allow_multiple_normal_messages) {
   // TODO(turnidge): Add assert that monitor_ is held here.
   bool result = true;
-  Message::Priority min_priority = (allow_normal_messages
-                                    ? Message::kNormalPriority
-                                    : Message::kOOBPriority);
+  Message::Priority min_priority = (allow_normal_messages && !paused()) ?
+      Message::kNormalPriority : Message::kOOBPriority;
   Message* message = DequeueMessage(min_priority);
   while (message != NULL) {
     if (FLAG_trace_isolates) {
       OS::Print("[<] Handling message:\n"
                 "\thandler:    %s\n"
                 "\tport:       %" Pd64 "\n",
                 name(), message->dest_port());
     }
 
     // Release the monitor_ temporarily while we handle the message.
     // The monitor was acquired in MessageHandler::TaskCallback().
     monitor_.Exit();
     Message::Priority saved_priority = message->priority();
     result = HandleMessage(message);
     monitor_.Enter();
     if (FLAG_trace_isolates) {
       OS::Print("[.] Message handled:\n"
                 "\thandler:    %s\n"
                 "\tport:       %" Pd64 "\n",
                 name(), message->dest_port());
     }
     if (!result) {
       // If we hit an error, we're done processing messages.
       break;
     }
-    if (!allow_multiple_normal_messages &&
-        saved_priority == Message::kNormalPriority) {
-      // Some callers want to process only one normal message and then quit.
+    // 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) {
       break;
     }
+
+    // Reevaluate the minimum allowable priority as the paused state might
+    // have changed as part of handling the message.
+    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.
   MonitorLocker ml(&monitor_);
@@ skipping 26 matching lines @@
     if (pause_on_start()) {
       HandleMessages(false, false);
       if (pause_on_start()) {
         // Still paused.
         task_ = NULL;  // No task in queue.
         return;
       }
     }
 
     if (start_callback_) {
+      // Release the monitor_ temporarily while we call the start callback.
+      // The monitor was acquired with the MonitorLocker above.
       monitor_.Exit();
       ok = start_callback_(callback_data_);
       ASSERT(Isolate::Current() == NULL);
       start_callback_ = NULL;
       monitor_.Enter();
     }
 
     // Handle any pending messages for this message handler.
     if (ok) {
       ok = HandleMessages(true, true);
@@ skipping 80 matching lines @@
 
 void MessageHandler::decrement_control_ports() {
   MonitorLocker ml(&monitor_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   control_ports_--;
 }
 
 }  // namespace dart