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

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"
@@ skipping 240 matching lines @@
   // assigned to a thread pool.
   MonitorLocker ml(&monitor_);
   ASSERT(pool_ == NULL);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   return HandleMessages(true, false);
 }
 
 
+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;
   }
   MonitorLocker ml(&monitor_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   return HandleMessages(false, false);
 }
@@ skipping 22 matching lines @@
     // function. Whenever we reacquire the monitor we *must* process
     // all pending OOB messages, or we may miss a request for vm
     // shutdown.
     MonitorLocker ml(&monitor_);
     if (pause_on_start()) {
       if (!paused_on_start_) {
         // Temporarily release the monitor when calling out to
         // 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();
       }
       // More messages may have come in before we (re)acquired the monitor.
       status = HandleMessages(false, false);
       if (ShouldPause(status) && pause_on_start()) {
         // Still paused.
         ASSERT(oob_queue_->IsEmpty());
         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);
       }
     }
 
     if (status == kOK) {
       if (start_callback_) {
         // Initialize the message handler by running its start function,
         // if we have one.  For an isolate, this will run the isolate's
         // main() function.
         //
         // Release the monitor_ temporarily while we call the start callback.
@@ skipping 16 matching lines @@
       if (ShouldPause(status) && pause_on_exit()) {
         if (!paused_on_exit_) {
           if (FLAG_trace_service_pause_events) {
             OS::PrintErr("Isolate %s paused before exiting. "
                          "Use the Observatory to release it.\n", name());
           }
           // Temporarily release the monitor when calling out to
           // 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();
 
           // More messages may have come in while we released the monitor.
           HandleMessages(false, false);
         }
         if (ShouldPause(status) && pause_on_exit()) {
           // Still paused.
           ASSERT(oob_queue_->IsEmpty());
           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) {
         if (status != kOK && isolate() != NULL) {
           const Error& error =
               Error::Handle(isolate()->object_store()->sticky_error());
           OS::Print("[-] Stopping message handler (%s):\n"
                     "\thandler:    %s\n"
                     "\terror:    %s\n",
                     MessageStatusString(status), name(), error.ToCString());
@@ skipping 54 matching lines @@
 
 void MessageHandler::decrement_live_ports() {
   MonitorLocker ml(&monitor_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   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) {
 }
 
 
 MessageHandler::AcquiredQueues::~AcquiredQueues() {
   Reset(NULL);
 }
 
 
@@ skipping 15 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