Changed the debugger API to allow only one debug event listener to be registe...

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 591 matching lines @@
     return;
   }
 
   // Clear debugger context global handle.
   GlobalHandles::Destroy(reinterpret_cast<Object**>(debug_context_.location()));
   debug_context_ = Handle<Context>();
 }
 
 
 void Debug::Iterate(ObjectVisitor* v) {
-#define VISIT(field) v->VisitPointer(bit_cast<Object**, Code**>(&(field)));
-  VISIT(debug_break_return_entry_);
-  VISIT(debug_break_return_);
-#undef VISIT
+  v->VisitPointer(bit_cast<Object**, Code**>(&(debug_break_return_entry_)));
+  v->VisitPointer(bit_cast<Object**, Code**>(&(debug_break_return_)));
 }
 
 
 Object* Debug::Break(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 0);
 
   // Get the top-most JavaScript frame.
   JavaScriptFrameIterator it;
   JavaScriptFrame* frame = it.frame();
@@ skipping 686 matching lines @@
   Handle<Object> fun(Top::global()->GetProperty(*function_name));
   ASSERT(fun->IsJSFunction());
   bool caught_exception;
   Handle<Object> js_object = Execution::TryCall(
       Handle<JSFunction>::cast(fun),
       Handle<JSObject>(Debug::debug_context()->global()),
       0, NULL, &caught_exception);
 }
 
 
+Handle<Object> Debugger::event_listener_ = Handle<Object>();
+Handle<Object> Debugger::event_listener_data_ = Handle<Object>();
 bool Debugger::debugger_active_ = false;
 bool Debugger::compiling_natives_ = false;
 bool Debugger::is_loading_debugger_ = false;
 DebugMessageThread* Debugger::message_thread_ = NULL;
 v8::DebugMessageHandler Debugger::debug_message_handler_ = NULL;
 void* Debugger::debug_message_handler_data_ = NULL;
 
 
 Handle<Object> Debugger::MakeJSObject(Vector<const char> constructor_name,
                                       int argc, Object*** argv,
@@ skipping 270 matching lines @@
   // Create the execution state.
   bool caught_exception = false;
   Handle<Object> exec_state = MakeExecutionState(&caught_exception);
   if (caught_exception) {
     return;
   }
   // First notify the builtin debugger.
   if (message_thread_ != NULL) {
     message_thread_->DebugEvent(event, exec_state, event_data);
   }
-  // Notify registered debug event listeners. The list can contain both C and
-  // JavaScript functions.
-  v8::NeanderArray listeners(Factory::debug_event_listeners());
-  int length = listeners.length();
-  for (int i = 0; i < length; i++) {
-    if (listeners.get(i)->IsUndefined()) continue;   // Skip deleted ones.
-    v8::NeanderObject listener(JSObject::cast(listeners.get(i)));
-    Handle<Object> callback_data(listener.get(1));
-    if (listener.get(0)->IsProxy()) {
+  // Notify registered debug event listener. This can be either a C or a
+  // JavaScript function.
+  if (!event_listener_.is_null()) {
+    if (event_listener_->IsProxy()) {
       // C debug event listener.
-      Handle<Proxy> callback_obj(Proxy::cast(listener.get(0)));
+      Handle<Proxy> callback_obj(Handle<Proxy>::cast(event_listener_));
       v8::DebugEventCallback callback =
             FUNCTION_CAST<v8::DebugEventCallback>(callback_obj->proxy());
       callback(event,
                v8::Utils::ToLocal(Handle<JSObject>::cast(exec_state)),
                v8::Utils::ToLocal(Handle<JSObject>::cast(event_data)),
-               v8::Utils::ToLocal(callback_data));
+               v8::Utils::ToLocal(Handle<Object>::cast(event_listener_data_)));
     } else {
       // JavaScript debug event listener.
-      ASSERT(listener.get(0)->IsJSFunction());
-      Handle<JSFunction> fun(JSFunction::cast(listener.get(0)));
+      ASSERT(event_listener_->IsJSFunction());
+      Handle<JSFunction> fun(Handle<JSFunction>::cast(event_listener_));
 
       // Invoke the JavaScript debug event listener.
       const int argc = 4;
       Object** argv[argc] = { Handle<Object>(Smi::FromInt(event)).location(),
                               exec_state.location(),
                               event_data.location(),
-                              callback_data.location() };
+                              event_listener_data_.location() };
       Handle<Object> result = Execution::TryCall(fun, Top::global(),
                                                  argc, argv, &caught_exception);
       if (caught_exception) {
         // Silently ignore exceptions from debug event listeners.
       }
     }
   }
 
   // Clear the mirror cache.
   Debug::ClearMirrorCache();
 }
 
 
+void Debugger::SetEventListener(Handle<Object> callback,
+                                Handle<Object> data) {
+  HandleScope scope;
+
+  // Clear the global handles for the event listener and the event listener data
+  // object.
+  if (!event_listener_.is_null()) {
+    GlobalHandles::Destroy(
+        reinterpret_cast<Object**>(event_listener_.location()));
+    event_listener_ = Handle<Object>();
+  }
+  if (!event_listener_data_.is_null()) {
+    GlobalHandles::Destroy(
+        reinterpret_cast<Object**>(event_listener_data_.location()));
+    event_listener_data_ = Handle<Object>();
+  }
+
+  // If there is a new debug event listener register it together with its data
+  // object.
+  if (!callback->IsUndefined() && !callback->IsNull()) {
+    event_listener_ = Handle<Object>::cast(GlobalHandles::Create(*callback));
+    if (data.is_null()) {
+      data = Factory::undefined_value();
+    }
+    event_listener_data_ = Handle<Object>::cast(GlobalHandles::Create(*data));
+  }
+
+  UpdateActiveDebugger();
+}
+
+
 void Debugger::SetMessageHandler(v8::DebugMessageHandler handler, void* data) {
   debug_message_handler_ = handler;
   debug_message_handler_data_ = data;
   if (!message_thread_) {
-    message_thread_  = new DebugMessageThread();
+    message_thread_ = new DebugMessageThread();
     message_thread_->Start();
   }
   UpdateActiveDebugger();
 }
 
 
 // Posts an output message from the debugger to the debug_message_handler
 // callback.  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::SendMessage(Vector< uint16_t> message) {
   if (debug_message_handler_ != NULL) {
     debug_message_handler_(message.start(), message.length(),
                            debug_message_handler_data_);
   }
 }
 
 
 void Debugger::ProcessCommand(Vector<const uint16_t> command) {
   if (message_thread_ != NULL) {
     message_thread_->ProcessCommand(
         Vector<uint16_t>(const_cast<uint16_t *>(command.start()),
                          command.length()));
   }
 }
 
 
 void Debugger::UpdateActiveDebugger() {
-  v8::NeanderArray listeners(Factory::debug_event_listeners());
-  int length = listeners.length();
-  bool active_listener = false;
-  for (int i = 0; i < length && !active_listener; i++) {
-    active_listener = !listeners.get(i)->IsUndefined();
+  set_debugger_active((message_thread_ != NULL &&
+                       debug_message_handler_ != NULL) ||
+                       !event_listener_.is_null());
+  if (!debugger_active() && message_thread_) {
+    message_thread_->OnDebuggerInactive();
   }
-  set_debugger_active((Debugger::message_thread_ != NULL &&
-                       Debugger::debug_message_handler_ != NULL) ||
-                       active_listener);
-  if (!debugger_active() && message_thread_)
-    message_thread_->OnDebuggerInactive();
 }
 
 
 Handle<Object> Debugger::Call(Handle<JSFunction> fun,
                               Handle<Object> data,
                               bool* pending_exception) {
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter() || !debugger.HasJavaScriptFrames()) {
     return Factory::undefined_value();
@@ skipping 305 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal