Handle vmservice messages while at breakpoint.

runtime/bin/dbg_message.cc

 // Copyright (c) 2012, 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 "bin/dbg_connection.h"
 #include "bin/dbg_message.h"
 #include "bin/dartutils.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 
@@ skipping 999 matching lines @@
       ml.Notify();
     } else {
       ASSERT(msglist_tail_ != NULL);
       msglist_tail_->set_next(msg);
       msglist_tail_ = msg;
     }
   }
 }
 
 
-void DbgMsgQueue::HandleMessages() {
+void DbgMsgQueue::Notify() {
+  MonitorLocker ml(&msg_queue_lock_);
+  ml.Notify();
+}
+
+
+bool DbgMsgQueue::HandlePendingMessages() {
+  // Handle all available debug messages, up to a resume request.
   bool resume_requested = false;
-  MonitorLocker ml(&msg_queue_lock_);
-  is_running_ = false;
-  while (!resume_requested) {
-    while (msglist_head_ == NULL) {
-      ASSERT(msglist_tail_ == NULL);
-      dart::Monitor::WaitResult res = ml.Wait();  // Wait for debugger commands.
-      ASSERT(res == dart::Monitor::kNotified);
-    }
-    while (msglist_head_ != NULL && !resume_requested) {
-      ASSERT(msglist_tail_ != NULL);
-      DbgMessage* msg = msglist_head_;
-      msglist_head_ = msglist_head_->next();
-      resume_requested = msg->HandleMessage();
-      delete msg;
-    }
+  while (msglist_head_ != NULL && !resume_requested) {
+    ASSERT(msglist_tail_ != NULL);
+    DbgMessage* msg = msglist_head_;
+    msglist_head_ = msglist_head_->next();
     if (msglist_head_ == NULL) {
       msglist_tail_ = NULL;
     }
+    resume_requested = msg->HandleMessage();
+    delete msg;
   }
+  return resume_requested;
+}
+
+
+void DbgMsgQueue::MessageLoop() {
+  MonitorLocker ml(&msg_queue_lock_);
+  is_running_ = false;
+
+  // Request notification on isolate messages.  This allows us to
+  // respond to vm service messages while at breakpoint.
+  Dart_SetMessageNotifyCallback(DbgMsgQueueList::NotifyIsolate);
+
+  while (true) {
+    // Handle all available vm service messages, up to a resume
+    // request.
+    if (Dart_HandleServiceMessages()) {
+      break;
+    }
+
+    // Handle all available debug messages, up to a resume request.
+    if (HandlePendingMessages()) {
+      break;
+    }
+
+    // Wait for more debug or vm service messages.
+    dart::Monitor::WaitResult res = ml.Wait();
+    ASSERT(res == dart::Monitor::kNotified);
+  }
+  Dart_SetMessageNotifyCallback(NULL);
   is_interrupted_ = false;
   is_running_ = true;
 }
 
 
 void DbgMsgQueue::InterruptIsolate() {
   Dart_Isolate isolate = Dart_GetIsolate(isolate_id_);
   MonitorLocker ml(&msg_queue_lock_);
   if (is_running_ && !is_interrupted_) {
     is_interrupted_ = true;
@@ skipping 119 matching lines @@
   MutexLocker ml(msg_queue_list_lock_);
   DbgMsgQueue* queue = DbgMsgQueueList::GetIsolateMsgQueueLocked(isolate_id);
   if (queue != NULL) {
     queue->AddMessage(cmd_idx, start, end, debug_fd);
     return true;
   }
   return false;
 }
 
 
+void DbgMsgQueueList::NotifyIsolate(Dart_Isolate isolate) {
+  MutexLocker ml(msg_queue_list_lock_);
+  Dart_IsolateId isolate_id = Dart_GetIsolateId(isolate);
+  DbgMsgQueue* queue = DbgMsgQueueList::GetIsolateMsgQueueLocked(isolate_id);
+  if (queue != NULL) {
+    queue->Notify();
+  }
+}
+
+
 bool DbgMsgQueueList::InterruptIsolate(Dart_IsolateId isolate_id) {
   MutexLocker ml(msg_queue_list_lock_);
   DbgMsgQueue* queue = DbgMsgQueueList::GetIsolateMsgQueueLocked(isolate_id);
   if (queue != NULL) {
     queue->InterruptIsolate();
     return true;
   }
   return false;
 }
 
@@ skipping 96 matching lines @@
 
 void DbgMsgQueueList::PausedEventHandler(Dart_IsolateId isolate_id,
                                          intptr_t bp_id,
                                          const Dart_CodeLocation& loc) {
   DebuggerConnectionHandler::WaitForConnection();
   Dart_EnterScope();
   DbgMsgQueue* msg_queue = GetIsolateMsgQueue(isolate_id);
   ASSERT(msg_queue != NULL);
   msg_queue->SendQueuedMsgs();
   msg_queue->SendBreakpointEvent(bp_id, loc);
-  msg_queue->HandleMessages();
+  msg_queue->MessageLoop();
   Dart_ExitScope();
 }
 
 
 void DbgMsgQueueList::ExceptionThrownHandler(Dart_IsolateId isolate_id,
                                              Dart_Handle exception,
                                              Dart_StackTrace stack_trace) {
   DebuggerConnectionHandler::WaitForConnection();
   Dart_EnterScope();
   DbgMsgQueue* msg_queue = GetIsolateMsgQueue(isolate_id);
   ASSERT(msg_queue != NULL);
   msg_queue->SendQueuedMsgs();
   msg_queue->SendExceptionEvent(exception, stack_trace);
-  msg_queue->HandleMessages();
+  msg_queue->MessageLoop();
   Dart_ExitScope();
 }
 
 
 void DbgMsgQueueList::IsolateEventHandler(Dart_IsolateId isolate_id,
                                           Dart_IsolateEvent kind) {
   DebuggerConnectionHandler::WaitForConnection();
   Dart_EnterScope();
   if (kind == kCreated) {
     DbgMsgQueue* msg_queue = AddIsolateMsgQueue(isolate_id);
     msg_queue->SendIsolateEvent(isolate_id, kind);
   } else {
     DbgMsgQueue* msg_queue = GetIsolateMsgQueue(isolate_id);
     ASSERT(msg_queue != NULL);
     msg_queue->SendQueuedMsgs();
     msg_queue->SendIsolateEvent(isolate_id, kind);
     if (kind == kInterrupted) {
-      msg_queue->HandleMessages();
+      msg_queue->MessageLoop();
     } else {
       ASSERT(kind == kShutdown);
       RemoveIsolateMsgQueue(isolate_id);
     }
   }
   Dart_ExitScope();
 }
 
 }  // namespace bin
 }  // namespace dart