Add necessary support functions so that embedders can implemented pause on start and exit

runtime/vm/message_handler.cc

Index: runtime/vm/message_handler.cc
diff --git a/runtime/vm/message_handler.cc b/runtime/vm/message_handler.cc
index 30194cd5b4ec4a3074f690712f8bca1c2679a0b3..de5fae8b758821218cdbe4f84ee94b5c9abde1f2 100644
--- a/runtime/vm/message_handler.cc
+++ b/runtime/vm/message_handler.cc
@@ -258,6 +258,18 @@ MessageHandler::MessageStatus MessageHandler::HandleNextMessage() {
 }
 
 
+MessageHandler::MessageStatus MessageHandler::HandleNormalMessages() {
+  // We can only call HandleNormalMessages when this handler is not
+  // assigned to a thread pool.
+  MonitorLocker ml(&monitor_);
+  ASSERT(pool_ == NULL);
+#if defined(DEBUG)
+  CheckAccess();
+#endif
+  return HandleMessages(true, true);
+}
+
+
 MessageHandler::MessageStatus MessageHandler::HandleOOBMessages() {
   if (!oob_message_handling_allowed_) {
     return kOK;
@@ -300,8 +312,7 @@ void MessageHandler::TaskCallback() {
         // NotifyPauseOnStart.  This avoids a dead lock that can occur
         // when this message handler tries to post a message while a
         // message is being posted to it.
-        paused_on_start_ = true;
-        paused_timestamp_ = OS::GetCurrentTimeMillis();
+        PausedOnStartLocked(true);
         monitor_.Exit();
         NotifyPauseOnStart();
         monitor_.Enter();
@@ -314,8 +325,12 @@ void MessageHandler::TaskCallback() {
         task_ = NULL;  // No task in queue.
         return;
       } else {
-        paused_on_start_ = false;
-        paused_timestamp_ = -1;
+        // Resumed. Clear the resume request of the owning isolate.
+        Isolate* owning_isolate = isolate();
+        if (owning_isolate != NULL) {
+          owning_isolate->GetAndClearResumeRequest();
+        }

[turnidge, 2016/02/03 21:33:37]

I'm guessing it doesn't work to move this into SetPausedOnStart(false) (the new
combo of PausedOnStart/NotifyPauseOnStart)... but if it did, it would be nice to
get this code tucked away.

+        PausedOnStartLocked(false);
       }
     }
 
@@ -352,8 +367,7 @@ void MessageHandler::TaskCallback() {
           // NotifyPauseOnExit.  This avoids a dead lock that can
           // occur when this message handler tries to post a message
           // while a message is being posted to it.
-          paused_on_exit_ = true;
-          paused_timestamp_ = OS::GetCurrentTimeMillis();
+          PausedOnExitLocked(true);
           monitor_.Exit();
           NotifyPauseOnExit();
           monitor_.Enter();
@@ -367,8 +381,12 @@ void MessageHandler::TaskCallback() {
           task_ = NULL;  // No task in queue.
           return;
         } else {
-          paused_on_exit_ = false;
-          paused_timestamp_ = -1;
+          // Resumed. Clear the resume request of the owning isolate.
+          Isolate* owning_isolate = isolate();
+          if (owning_isolate != NULL) {
+            owning_isolate->GetAndClearResumeRequest();
+          }
+          PausedOnExitLocked(false);
         }
       }
       if (FLAG_trace_isolates) {
@@ -443,6 +461,40 @@ void MessageHandler::decrement_live_ports() {
 }
 
 
+void MessageHandler::PausedOnStart(bool v) {
+  MonitorLocker ml(&monitor_);
+  PausedOnStartLocked(v);
+}
+
+
+void MessageHandler::PausedOnStartLocked(bool v) {
+  if (v) {
+    paused_on_start_ = true;
+    paused_timestamp_ = OS::GetCurrentTimeMillis();
+  } else {
+    paused_on_start_ = false;
+    paused_timestamp_ = -1;
+  }
+}
+
+
+void MessageHandler::PausedOnExit(bool v) {
+  MonitorLocker ml(&monitor_);
+  PausedOnExitLocked(v);
+}
+
+
+void MessageHandler::PausedOnExitLocked(bool v) {
+  if (v) {
+    paused_on_exit_ = true;
+    paused_timestamp_ = OS::GetCurrentTimeMillis();
+  } else {
+    paused_on_exit_ = false;
+    paused_timestamp_ = -1;
+  }
+}
+
+
 MessageHandler::AcquiredQueues::AcquiredQueues()
     : handler_(NULL) {
 }