Support tasks injection into a running VM.

src/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 3085 matching lines @@
 
 void Debug::EnqueueDebugCommand(v8::Debug::ClientData* client_data) {
   CommandMessage message = CommandMessage::New(Vector<uint16_t>(), client_data);
   event_command_queue_.Put(message);
 
   // Set the debug command break flag to have the command processed.
   if (!in_debug_scope()) isolate_->stack_guard()->RequestDebugCommand();
 }
 
 
+void Debug::EnqueueEmbedderTask(v8::Task* task) {
+  embedder_task_queue_.Enqueue(task);
+
+  // Set the debug command break flag to have the command processed.
+  if (!in_debug_scope()) {
+    isolate_->stack_guard()->RequestDebugCommand();
+  }
+}
+
+
+bool Debug::ProcessEmbedderTasks() {
+  bool did_process_task = false;
+  while (v8::Task* task = embedder_task_queue_.Dequeue()) {
+    did_process_task = true;
+    task->Run();
+    delete task;
+  }
+  return did_process_task;
+}
+
+
 MaybeHandle<Object> Debug::Call(Handle<JSFunction> fun, Handle<Object> data) {
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return isolate_->factory()->undefined_value();
 
   // Create the execution state.
   Handle<Object> exec_state;
   if (!MakeExecutionState().ToHandle(&exec_state)) {
     return isolate_->factory()->undefined_value();
   }
 
   Handle<Object> argv[] = { exec_state, data };
   return Execution::Call(
       isolate_,
       fun,
       Handle<Object>(debug_context()->global_proxy(), isolate_),
       arraysize(argv),
       argv);
 }
 
 
 void Debug::HandleDebugBreak() {
   // Ignore debug break during bootstrapping.
   if (isolate_->bootstrapper()->IsActive()) return;
   // Just continue if breaks are disabled.
   if (break_disabled()) return;
+  if (ProcessEmbedderTasks()) {
+    isolate_->stack_guard()->ClearDebugCommand();
+  }
   // Ignore debug break if debugger is not active.
   if (!is_active()) return;
 
   StackLimitCheck check(isolate_);
   if (check.HasOverflowed()) return;
 
   { JavaScriptFrameIterator it(isolate_);
     DCHECK(!it.done());
     Object* fun = it.frame()->function();
     if (fun && fun->IsJSFunction()) {
@@ skipping 332 matching lines @@
   queue_.Put(message);
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
+
+LockingTaskQueue::LockingTaskQueue() {}
+
+
+LockingTaskQueue::~LockingTaskQueue() { Clear(); }
+
+
+void LockingTaskQueue::Enqueue(v8::Task* task) {
+  base::LockGuard<base::Mutex> lock_guard(&mutex_);
+  queue_.push(task);
+}
+
+
+v8::Task* LockingTaskQueue::Dequeue() {
+  base::LockGuard<base::Mutex> lock_guard(&mutex_);
+  if (queue_.empty()) return NULL;
+  v8::Task* task = queue_.front();
+  queue_.pop();
+  return task;
+}
+
+
+void LockingTaskQueue::Clear() {
+  base::LockGuard<base::Mutex> lock_guard(&mutex_);
+  while (!queue_.empty()) {
+    delete queue_.front();
+    queue_.pop();
+  }
+}
 } }  // namespace v8::internal