- Add assertions in MutexLocker/MonitorLocker to ensure that the code enclosed

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 158 matching lines @@
   return message;
 }
 
 
 void MessageHandler::ClearOOBQueue() {
   oob_queue_->Clear();
 }
 
 
 MessageHandler::MessageStatus MessageHandler::HandleMessages(
+    MonitorLocker* ml,
     bool allow_normal_messages,
     bool allow_multiple_normal_messages) {
   // TODO(turnidge): Add assert that monitor_ is held here.
 
   // If isolate() returns NULL StartIsolateScope does nothing.
   StartIsolateScope start_isolate(isolate());
 
   MessageStatus max_status = kOK;
   Message::Priority min_priority = ((allow_normal_messages && !paused())
                                     ? Message::kNormalPriority
                                     : Message::kOOBPriority);
   Message* message = DequeueMessage(min_priority);
   while (message != NULL) {
     intptr_t message_len = message->len();
     if (FLAG_trace_isolates) {
       OS::Print("[<] Handling message:\n"
                 "\tlen:        %" Pd "\n"
                 "\thandler:    %s\n"
                 "\tport:       %" Pd64 "\n",
                 message_len, name(), message->dest_port());
     }
 
     // Release the monitor_ temporarily while we handle the message.
     // The monitor was acquired in MessageHandler::TaskCallback().
-    monitor_.Exit();
+    ml->Exit();
     Message::Priority saved_priority = message->priority();
     Dart_Port saved_dest_port = message->dest_port();
     MessageStatus status = HandleMessage(message);
     if (status > max_status) {
       max_status = status;
     }
     message = NULL;  // May be deleted by now.
-    monitor_.Enter();
+    ml->Enter();
     if (FLAG_trace_isolates) {
       OS::Print("[.] Message handled (%s):\n"
                 "\tlen:        %" Pd "\n"
                 "\thandler:    %s\n"
                 "\tport:       %" Pd64 "\n",
                 MessageStatusString(status),
                 message_len, name(), saved_dest_port);
     }
     // If we are shutting down, do not process any more messages.
     if (status == kShutdown) {
@@ skipping 25 matching lines @@
 
 
 MessageHandler::MessageStatus MessageHandler::HandleNextMessage() {
   // We can only call HandleNextMessage when this handler is not
   // assigned to a thread pool.
   MonitorLocker ml(&monitor_);
   ASSERT(pool_ == NULL);
 #if defined(DEBUG)
   CheckAccess();
 #endif
-  return HandleMessages(true, false);
+  return HandleMessages(&ml, 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);
+  return HandleMessages(&ml, 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);
+  return HandleMessages(&ml, false, false);
 }
 
 
 bool MessageHandler::ShouldPauseOnStart(MessageStatus status) const {
   Isolate* owning_isolate = isolate();
   if (owning_isolate == NULL) {
     return false;
   }
   // If we are restarting or shutting down, we do not want to honor
   // should_pause_on_start or should_pause_on_exit.
@@ skipping 28 matching lines @@
     // 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 (ShouldPauseOnStart(kOK)) {
       if (!is_paused_on_start()) {
         PausedOnStartLocked(true);
       }
       // More messages may have come in before we (re)acquired the monitor.
-      status = HandleMessages(false, false);
+      status = HandleMessages(&ml, false, false);
       if (ShouldPauseOnStart(status)) {
         // Still paused.
         ASSERT(oob_queue_->IsEmpty());
         task_ = NULL;  // No task in queue.
         return;
       } else {
         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();
+        ml.Exit();
         status = start_callback_(callback_data_);
         ASSERT(Isolate::Current() == NULL);
         start_callback_ = NULL;
-        monitor_.Enter();
+        ml.Enter();
       }
 
       // Handle any pending messages for this message handler.
       if (status != kShutdown) {
-        status = HandleMessages((status == kOK), true);
+        status = HandleMessages(&ml, (status == kOK), true);
       }
     }
 
     // The isolate exits when it encounters an error or when it no
     // longer has live ports.
     if (status != kOK || !HasLivePorts()) {
       if (ShouldPauseOnExit(status)) {
         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());
           }
           PausedOnExitLocked(true);
           // More messages may have come in while we released the monitor.
-          status = HandleMessages(false, false);
+          status = HandleMessages(&ml, false, false);
         }
         if (ShouldPauseOnExit(status)) {
           // Still paused.
           ASSERT(oob_queue_->IsEmpty());
           task_ = NULL;  // No task in queue.
           return;
         } else {
           PausedOnExitLocked(false);
         }
       }
@@ skipping 164 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