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 43 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),
+      should_pause_on_start_(false),
+      should_pause_on_exit_(false),
+      is_paused_on_start_(false),
+      is_paused_on_exit_(false),
       paused_timestamp_(-1),
       pool_(NULL),
       task_(NULL),
       start_callback_(NULL),
       end_callback_(NULL),
       callback_data_(0) {
   ASSERT(queue_ != NULL);
   ASSERT(oob_queue_ != NULL);
 }
 
@@ skipping 173 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::HandleAllMessages() {
+  // We can only call HandleAllMessages 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);
 }
 
 
+bool MessageHandler::ShouldPauseOnStart() const {
+  Isolate* owning_isolate = isolate();
+  if (owning_isolate == NULL) {
+    return false;
+  }
+  return should_pause_on_start() && owning_isolate->is_runnable();
+}
+
+
+bool MessageHandler::ShouldPauseOnExit() const {
+  Isolate* owning_isolate = isolate();
+  if (owning_isolate == NULL) {
+    return false;
+  }
+  return should_pause_on_exit() && owning_isolate->is_runnable();
+}
+
+
 bool MessageHandler::HasOOBMessages() {
   MonitorLocker ml(&monitor_);
   return !oob_queue_->IsEmpty();
 }
 
 
 static bool ShouldPause(MessageHandler::MessageStatus status) {
   // If we are restarting or shutting down, we do not want to honor
-  // pause_on_start or pause_on_exit.
+  // should_pause_on_start or should_pause_on_exit.
   return (status != MessageHandler::kRestart &&
           status != MessageHandler::kShutdown);

[turnidge, 2016/02/03 23:17:56]

I wonder if we can fold ShouldPause() into ShoudlPauseOnStart() and
ShouldPauseOnExit.

[Cutch, 2016/02/03 23:25:07]

Done.

 }
 
 
 void MessageHandler::TaskCallback() {
   ASSERT(Isolate::Current() == NULL);
   MessageStatus status = kOK;
   bool run_end_callback = false;
   {
     // We will occasionally release and reacquire this monitor in this
     // 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();
-        monitor_.Exit();
-        NotifyPauseOnStart();
-        monitor_.Enter();
+    if (ShouldPauseOnStart()) {
+      if (!is_paused_on_start_) {
+        PausedOnStartLocked(true);
       }
       // More messages may have come in before we (re)acquired the monitor.
       status = HandleMessages(false, false);
-      if (ShouldPause(status) && pause_on_start()) {
+      if (ShouldPause(status) && ShouldPauseOnStart()) {
         // Still paused.
         ASSERT(oob_queue_->IsEmpty());
         task_ = NULL;  // No task in queue.
         return;
       } else {
-        paused_on_start_ = false;
-        paused_timestamp_ = -1;
+        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.
         monitor_.Exit();
         status = start_callback_(callback_data_);
         ASSERT(Isolate::Current() == NULL);
         start_callback_ = NULL;
         monitor_.Enter();
       }
 
       // Handle any pending messages for this message handler.
       if (status != kShutdown) {
         status = HandleMessages((status == kOK), true);
       }
     }
 
     // The isolate exits when it encounters an error or when it no
     // longer has live ports.
     if (status != kOK || !HasLivePorts()) {
-      if (ShouldPause(status) && pause_on_exit()) {
-        if (!paused_on_exit_) {
+      if (ShouldPause(status) && ShouldPauseOnExit()) {
+        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());
           }
-          // 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();
-          monitor_.Exit();
-          NotifyPauseOnExit();
-          monitor_.Enter();
-
+          PausedOnExitLocked(true);
           // More messages may have come in while we released the monitor.
           HandleMessages(false, false);
         }
-        if (ShouldPause(status) && pause_on_exit()) {
+        if (ShouldPause(status) && ShouldPauseOnExit()) {
           // Still paused.
           ASSERT(oob_queue_->IsEmpty());
           task_ = NULL;  // No task in queue.
           return;
         } else {
-          paused_on_exit_ = false;
-          paused_timestamp_ = -1;
+          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 paused) {
+  MonitorLocker ml(&monitor_);
+  PausedOnStartLocked(paused);
+}
+
+
+void MessageHandler::PausedOnStartLocked(bool paused) {
+  if (paused) {

[turnidge, 2016/02/03 23:17:57]

Do we want to ASSERT(!is_paused_on_start_)?

Similarly for the false case and for the cases in PausedOnExitLocked?

[Cutch, 2016/02/03 23:25:07]

Done.

+    is_paused_on_start_ = true;
+    paused_timestamp_ = OS::GetCurrentTimeMillis();
+  } else {
+    is_paused_on_start_ = false;
+    paused_timestamp_ = -1;
+  }
+  if (is_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.
+    monitor_.Exit();
+    NotifyPauseOnStart();
+    monitor_.Enter();
+  } else {
+    // Resumed. Clear the resume request of the owning isolate.
+    Isolate* owning_isolate = isolate();
+    if (owning_isolate != NULL) {
+      owning_isolate->GetAndClearResumeRequest();
+    }
+  }
+}
+
+
+void MessageHandler::PausedOnExit(bool paused) {
+  MonitorLocker ml(&monitor_);
+  PausedOnExitLocked(paused);
+}
+
+
+void MessageHandler::PausedOnExitLocked(bool paused) {
+  if (paused) {
+    is_paused_on_exit_ = true;
+    paused_timestamp_ = OS::GetCurrentTimeMillis();
+  } else {
+    is_paused_on_exit_ = false;
+    paused_timestamp_ = -1;
+  }
+  if (is_paused_on_exit_) {
+    // 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.
+    monitor_.Exit();
+    NotifyPauseOnExit();
+    monitor_.Enter();
+  } else {
+    // Resumed. Clear the resume request of the owning isolate.
+    Isolate* owning_isolate = isolate();
+    if (owning_isolate != NULL) {
+      owning_isolate->GetAndClearResumeRequest();
+    }
+  }
+}
+
+
 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