Add debug command break flag for debugger host dispatch

src/debug.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1807 matching lines @@
       return;
     }
 
     // Check if the command is a host dispatch.
     if (command[0] == 0) {
       if (Debugger::host_dispatch_handler_) {
         int32_t dispatch = (command[1] << 16) | command[2];
         Debugger::host_dispatch_handler_(reinterpret_cast<void*>(dispatch),
                                          Debugger::host_dispatch_handler_data_);
       }
+      if (auto_continue && !HasCommands()) {
+        return;
+      }
       continue;
     }
 
     // Invoke JavaScript to process the debug request.
     v8::Local<v8::String> fun_name;
     v8::Local<v8::Function> fun;
     v8::Local<v8::Value> request;
     v8::TryCatch try_catch;
     fun_name = v8::String::New("processDebugRequest");
     fun = v8::Function::Cast(*cmd_processor->Get(fun_name));
@@ skipping 185 matching lines @@
 // processing of the command to the DebugMessageThread thread.
 // The new copy of the command is destroyed in HandleCommand().
 void Debugger::ProcessCommand(Vector<const uint16_t> command) {
   // Make a copy of the command. Need to cast away const for Clone to work.
   Vector<uint16_t> command_copy =
       Vector<uint16_t>(const_cast<uint16_t*>(command.start()),
                        command.length()).Clone();
   Logger::DebugTag("Put command on command_queue.");
   command_queue_.Put(command_copy);
   command_received_->Signal();
+
+  // Set the debug command break flag to have the command processed.
   if (!Debug::InDebugger()) {
     StackGuard::DebugCommand();
   }
 }
 
 
 bool Debugger::HasCommands() {
   return !command_queue_.IsEmpty();
 }
 
 
 void Debugger::ProcessHostDispatch(void* dispatch) {
-// Puts a host dispatch comming from the public API on the queue.
+  // Puts a host dispatch comming from the public API on the queue.
   uint16_t hack[3];
   hack[0] = 0;
   hack[1] = reinterpret_cast<uint32_t>(dispatch) >> 16;
   hack[2] = reinterpret_cast<uint32_t>(dispatch) & 0xFFFF;
   Logger::DebugTag("Put dispatch on command_queue.");
   command_queue_.Put(Vector<uint16_t>(hack, 3).Clone());
   command_received_->Signal();
+
+  // Set the debug command break flag to have the host dispatch processed.
+  if (!Debug::InDebugger()) {
+    StackGuard::DebugCommand();
+  }
 }
 
 
 bool Debugger::IsDebuggerActive() {
   ScopedLock with(debugger_access_);
 
   return message_handler_ != NULL || !event_listener_.is_null();
 }
 
 
@@ skipping 145 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal