Debugger: remove debug command API.

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 16 matching lines @@
 namespace v8 {
 namespace internal {
 
 Debug::Debug(Isolate* isolate)
     : debug_context_(Handle<Context>()),
       event_listener_(Handle<Object>()),
       event_listener_data_(Handle<Object>()),
       message_handler_(NULL),
       command_received_(0),
       command_queue_(isolate->logger(), kQueueInitialSize),
-      event_command_queue_(isolate->logger(), kQueueInitialSize),
       is_active_(false),
       is_suppressed_(false),
       live_edit_enabled_(true),  // TODO(yangguo): set to false by default.
       has_break_points_(false),
       break_disabled_(false),
       in_debug_event_listener_(false),
       break_on_exception_(false),
       break_on_uncaught_exception_(false),
       script_cache_(NULL),
       debug_info_list_(NULL),
@@ skipping 2691 matching lines @@
                          Handle<JSObject>::cast(exec_state),
                          event_data,
                          auto_continue);
   }
   // Notify registered debug event listener. This can be either a C or
   // a JavaScript function. Don't call event listener for v8::Break
   // here, if it's only a debug command -- they will be processed later.
   if ((event != v8::Break || !auto_continue) && !event_listener_.is_null()) {
     CallEventCallback(event, exec_state, event_data, NULL);
   }
-  // Process pending debug commands.
-  if (event == v8::Break) {
-    while (!event_command_queue_.IsEmpty()) {
-      CommandMessage command = event_command_queue_.Get();
-      if (!event_listener_.is_null()) {
-        CallEventCallback(v8::BreakForCommand,
-                          exec_state,
-                          event_data,
-                          command.client_data());
-      }
-      command.Dispose();
-    }
-  }
 }
 
 
 void Debug::CallEventCallback(v8::DebugEvent event,
                               Handle<Object> exec_state,
                               Handle<Object> event_data,
                               v8::Debug::ClientData* client_data) {
   bool previous = in_debug_event_listener_;
   in_debug_event_listener_ = true;
   if (event_listener_->IsForeign()) {
@@ skipping 254 matching lines @@
       client_data);
   isolate_->logger()->DebugTag("Put command on command_queue.");
   command_queue_.Put(message);
   command_received_.Signal();
 
   // Set the debug command break flag to have the command processed.
   if (!in_debug_scope()) isolate_->stack_guard()->RequestDebugCommand();
 }
 
 
-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();
-}
-
-
 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();
   }
 
@@ skipping 369 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal