Make service protocol respect isolate lifecycle

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 499 matching lines @@
 }
 
 void MessageHandler::PausedOnStart(bool paused) {
   MonitorLocker ml(&monitor_);
   PausedOnStartLocked(&ml, paused);
 }
 
 void MessageHandler::PausedOnStartLocked(MonitorLocker* ml, bool paused) {
   if (paused) {
     ASSERT(!is_paused_on_start_);
-    is_paused_on_start_ = true;
+    ASSERT(paused_timestamp_ == -1);
     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.
     ml->Exit();
     NotifyPauseOnStart();
     ml->Enter();
+    is_paused_on_start_ = true;
   } else {
+    ASSERT(is_paused_on_start_);
+    ASSERT(paused_timestamp_ != -1);
+    paused_timestamp_ = -1;
     // Resumed. Clear the resume request of the owning isolate.
     Isolate* owning_isolate = isolate();
     if (owning_isolate != NULL) {
       owning_isolate->GetAndClearResumeRequest();
     }
+    is_paused_on_start_ = false;
   }
 }
 
 void MessageHandler::PausedOnExit(bool paused) {
   MonitorLocker ml(&monitor_);
   PausedOnExitLocked(&ml, paused);
 }
 
 void MessageHandler::PausedOnExitLocked(MonitorLocker* ml, bool paused) {
   if (paused) {
     ASSERT(!is_paused_on_exit_);
-    is_paused_on_exit_ = true;
+    ASSERT(paused_timestamp_ == -1);
     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.
     ml->Exit();
     NotifyPauseOnExit();
     ml->Enter();
+    is_paused_on_exit_ = true;
   } else {
+    ASSERT(is_paused_on_exit_);
+    ASSERT(paused_timestamp_ != -1);
+    paused_timestamp_ = -1;
     // Resumed. Clear the resume request of the owning isolate.
     Isolate* owning_isolate = isolate();
     if (owning_isolate != NULL) {
       owning_isolate->GetAndClearResumeRequest();
     }
+    is_paused_on_exit_ = false;
   }
 }
 #endif  // !defined(PRODUCT)
 
 MessageHandler::AcquiredQueues::AcquiredQueues(MessageHandler* handler)
     : handler_(handler), ml_(&handler->monitor_) {
   ASSERT(handler != NULL);
   handler_->oob_message_handling_allowed_ = false;
 }
 
 MessageHandler::AcquiredQueues::~AcquiredQueues() {
   ASSERT(handler_ != NULL);
   handler_->oob_message_handling_allowed_ = true;
 }
 
 }  // namespace dart