DevTools: Support eventless host message dispatching.

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 1406 matching lines @@
 Mutex* Debugger::debugger_access_ = OS::CreateMutex();
 Handle<Object> Debugger::event_listener_ = Handle<Object>();
 Handle<Object> Debugger::event_listener_data_ = Handle<Object>();
 bool Debugger::compiling_natives_ = false;
 bool Debugger::is_loading_debugger_ = false;
 bool Debugger::never_unload_debugger_ = false;
 DebugMessageThread* Debugger::message_thread_ = NULL;
 v8::Debug::MessageHandler Debugger::message_handler_ = NULL;
 bool Debugger::message_handler_cleared_ = false;
 v8::Debug::HostDispatchHandler Debugger::host_dispatch_handler_ = NULL;
+int Debugger::host_dispatch_micros_ = 100 * 1000;
 DebuggerAgent* Debugger::agent_ = NULL;
 LockingMessageQueue Debugger::command_queue_(kQueueInitialSize);
 LockingMessageQueue Debugger::message_queue_(kQueueInitialSize);
 Semaphore* Debugger::command_received_ = OS::CreateSemaphore(0);
 Semaphore* Debugger::message_received_ = OS::CreateSemaphore(0);
 
 
 Handle<Object> Debugger::MakeJSObject(Vector<const char> constructor_name,
                                       int argc, Object*** argv,
                                       bool* caught_exception) {
@@ skipping 383 matching lines @@
     bool success = SendEventMessage(event_data);
     if (!success) {
       // If failed to notify debugger just continue running.
       return;
     }
   }
 
   // Process requests from the debugger.
   while (true) {
     // Wait for new command in the queue.
-    command_received_->Wait();
+    if (Debugger::host_dispatch_handler_) {
+      // In case there is a host dispatch - do periodic dispatches.
+      if (!command_received_->Wait(host_dispatch_micros_)) {
+        // Timout expired, do the dispatch.
+        Debugger::host_dispatch_handler_();
+        continue;
+      }
+    } else {
+      // In case there is no host dispatch - just wait.
+      command_received_->Wait();
+    }
 
     // The debug command interrupt flag might have been set when the command was
     // added.
     StackGuard::Continue(DEBUGCOMMAND);
 
     // Get the command from the queue.
     Message command = command_queue_.Get();
     Logger::DebugTag("Got request from command queue, in interactive loop.");
     if (!Debugger::IsDebuggerActive()) {
       // Delete command text and user data.
       command.Dispose();
       return;
     }
 
-    // Check if the command is a host dispatch.
-    if (command.IsHostDispatch()) {
-      if (Debugger::host_dispatch_handler_) {
-        Debugger::host_dispatch_handler_(command.client_data());
-        // Delete the dispatch.
-        command.Dispose();
-      }
-      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));
 
     request = v8::String::New(command.text().start(),
                               command.text().length());
@@ skipping 96 matching lines @@
 
     // Send an empty command to the debugger if in a break to make JavaScript
     // run again if the debugger is closed.
     if (Debug::InDebugger()) {
       ProcessCommand(Vector<const uint16_t>::empty());
     }
   }
 }
 
 
-void Debugger::SetHostDispatchHandler(v8::Debug::HostDispatchHandler handler) {
+void Debugger::SetHostDispatchHandler(v8::Debug::HostDispatchHandler handler,
+                                      int period) {
   host_dispatch_handler_ = handler;
+  host_dispatch_micros_ = period * 1000;
 }
 
 
 // Calls the registered debug message handler. This callback is part of the
 // public API. Messages are kept internally as Vector<uint16_t> strings, which
 // are allocated in various places and deallocated by the calling function
 // sometime after this call.
 void Debugger::InvokeMessageHandler(Message message) {
   ScopedLock with(debugger_access_);
 
@@ skipping 74 matching lines @@
     StackGuard::DebugCommand();
   }
 }
 
 
 bool Debugger::HasCommands() {
   return !command_queue_.IsEmpty();
 }
 
 
-void Debugger::ProcessHostDispatch(v8::Debug::ClientData* dispatch) {
-  // Puts a host dispatch comming from the public API on the queue.
-  Logger::DebugTag("Put dispatch on command_queue.");
-  command_queue_.Put(Message::NewHostDispatch(dispatch));
-  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();
 }
 
 
 Handle<Object> Debugger::Call(Handle<JSFunction> fun,
                               Handle<Object> data,
                               bool* pending_exception) {
@@ skipping 68 matching lines @@
 
 
 void DebugMessageThread::Stop() {
   keep_running_ = false;
   Debugger::SendMessage(Message::NewEmptyMessage());
   Join();
 }
 
 
 Message::Message() : text_(Vector<uint16_t>::empty()),
-                     client_data_(NULL),
-                     is_host_dispatch_(false) {
+                     client_data_(NULL) {
 }
 
 
 Message::Message(const Vector<uint16_t>& text,
-                 v8::Debug::ClientData* data,
-                 bool is_host_dispatch)
+                 v8::Debug::ClientData* data)
     : text_(text),
-      client_data_(data),
-      is_host_dispatch_(is_host_dispatch) {
+      client_data_(data) {
 }
 
 
 Message::~Message() {
 }
 
 
 void Message::Dispose() {
   text_.Dispose();
   delete client_data_;
   client_data_ = NULL;
 }
 
 
-bool Message::IsHostDispatch() const {
-  return is_host_dispatch_;
-}
-
-
 Message Message::NewCommand(const Vector<uint16_t>& command,
                             v8::Debug::ClientData* data) {
-  return Message(command.Clone(), data, false);
+  return Message(command.Clone(), data);
 }
 
 
-Message Message::NewHostDispatch(v8::Debug::ClientData* dispatch) {
-  return Message(Vector<uint16_t>::empty(), dispatch, true);
-}
-
-
 Message Message::NewOutput(v8::Handle<v8::String> output,
                            v8::Debug::ClientData* data) {
   Vector<uint16_t> text;
   if (!output.IsEmpty()) {
     // Do not include trailing '\0'.
     text = Vector<uint16_t>::New(output->Length());
     output->Write(text.start(), 0, output->Length());
   }
-  return Message(text, data, false);
+  return Message(text, data);
 }
 
 
 Message Message::NewEmptyMessage() {
   return Message();
 }
 
 
 MessageQueue::MessageQueue(int size) : start_(0), end_(0), size_(size) {
   messages_ = NewArray<Message>(size);
@@ skipping 72 matching lines @@
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal