Make the lock/unlock and Enter/Exit methods in Mutex and Monitor private so taht we always use the …

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 307 matching lines @@
   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 (ShouldPauseOnStart(kOK)) {
       if (!is_paused_on_start()) {
-        PausedOnStartLocked(true);
+        PausedOnStartLocked(&ml, true);
       }
       // More messages may have come in before we (re)acquired the monitor.
       status = HandleMessages(&ml, false, false);
       if (ShouldPauseOnStart(status)) {
         // Still paused.
         ASSERT(oob_queue_->IsEmpty());
         task_ = NULL;  // No task in queue.
         return;
       } else {
-        PausedOnStartLocked(false);
+        PausedOnStartLocked(&ml, 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 12 matching lines @@
 
     // 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);
+          PausedOnExitLocked(&ml, true);
           // More messages may have come in while we released the monitor.
           status = HandleMessages(&ml, false, false);
         }
         if (ShouldPauseOnExit(status)) {
           // Still paused.
           ASSERT(oob_queue_->IsEmpty());
           task_ = NULL;  // No task in queue.
           return;
         } else {
-          PausedOnExitLocked(false);
+          PausedOnExitLocked(&ml, false);
         }
       }
       if (FLAG_trace_isolates) {
         if (status != kOK && isolate() != NULL) {
           const Error& error = Error::Handle(thread()->sticky_error());
           OS::Print("[-] Stopping message handler (%s):\n"
                     "\thandler:    %s\n"
                     "\terror:    %s\n",
                     MessageStatusString(status), name(), error.ToCString());
         } else {
@@ skipping 55 matching lines @@
   MonitorLocker ml(&monitor_);
 #if defined(DEBUG)
   CheckAccess();
 #endif
   live_ports_--;
 }
 
 
 void MessageHandler::PausedOnStart(bool paused) {
   MonitorLocker ml(&monitor_);
-  PausedOnStartLocked(paused);
+  PausedOnStartLocked(&ml, paused);
 }
 
 
-void MessageHandler::PausedOnStartLocked(bool paused) {
+void MessageHandler::PausedOnStartLocked(MonitorLocker* ml, bool paused) {
   if (paused) {
     ASSERT(!is_paused_on_start_);
     is_paused_on_start_ = true;
     paused_timestamp_ = OS::GetCurrentTimeMillis();
   } else {
     ASSERT(is_paused_on_start_);
     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();
+    ml->Exit();
     NotifyPauseOnStart();
-    monitor_.Enter();
+    ml->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);
+  PausedOnExitLocked(&ml, paused);
 }
 
 
-void MessageHandler::PausedOnExitLocked(bool paused) {
+void MessageHandler::PausedOnExitLocked(MonitorLocker* ml, bool paused) {
   if (paused) {
     ASSERT(!is_paused_on_exit_);
     is_paused_on_exit_ = true;
     paused_timestamp_ = OS::GetCurrentTimeMillis();
   } else {
     ASSERT(is_paused_on_exit_);
     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();
+    ml->Exit();
     NotifyPauseOnExit();
-    monitor_.Enter();
+    ml->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(MessageHandler* handler)
+    : handler_(handler), ml_(&handler->monitor_) {
+  ASSERT(handler != NULL);
+  handler_->oob_message_handling_allowed_ = false;
 }
 
 
 MessageHandler::AcquiredQueues::~AcquiredQueues() {
-  Reset(NULL);
-}
-
-
-void MessageHandler::AcquiredQueues::Reset(MessageHandler* handler) {
-  if (handler_ != NULL) {
-    // Release ownership. The OOB flag is set without holding the monitor.
-    handler_->monitor_.Exit();
-    handler_->oob_message_handling_allowed_ = true;
-  }
-  handler_ = handler;
-  if (handler_ == NULL) {
-    return;
-  }
   ASSERT(handler_ != NULL);
-  // Take ownership. The OOB flag is set without holding the monitor.
-  handler_->oob_message_handling_allowed_ = false;
-  handler_->monitor_.Enter();
-}
-
-
-void MessageHandler::AcquireQueues(AcquiredQueues* acquired_queues) {
-  ASSERT(acquired_queues != NULL);
-  // No double dipping.
-  ASSERT(acquired_queues->handler_ == NULL);
-  acquired_queues->Reset(this);
+  handler_->oob_message_handling_allowed_ = true;
 }
 
 }  // namespace dart