Change handling of debugger unloading

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 589 matching lines @@
   return true;
 }
 
 
 void Debug::Unload() {
   // Return debugger is not loaded.
   if (!IsLoaded()) {
     return;
   }
 
-  // Get rid of all break points and related information.
-  ClearAllBreakPoints();
-
   // Clear debugger context global handle.
   GlobalHandles::Destroy(reinterpret_cast<Object**>(debug_context_.location()));
   debug_context_ = Handle<Context>();
 }
 
 
 // Set the flag indicating that preemption happened during debugging.
 void Debug::PreemptionWhileInDebugger() {
   ASSERT(InDebugger());
   Debug::set_preemption_pending(true);
@@ skipping 739 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);
 }
 
 
+Mutex* Debugger::debugger_access_ = OS::CreateMutex();
 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;
+bool Debugger::never_unload_debugger_ = false;
 DebugMessageThread* Debugger::message_thread_ = NULL;
 v8::DebugMessageHandler Debugger::message_handler_ = NULL;
+bool Debugger::message_handler_cleared_ = false;
 void* Debugger::message_handler_data_ = NULL;
 v8::DebugHostDispatchHandler Debugger::host_dispatch_handler_ = NULL;
 void* Debugger::host_dispatch_handler_data_ = NULL;
 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);
 
 
@@ skipping 185 matching lines @@
 
 
 // Handle debugger actions when a new script is compiled.
 void Debugger::OnAfterCompile(Handle<Script> script, Handle<JSFunction> fun) {
   HandleScope scope;
 
   // No compile events while compiling natives.
   if (compiling_natives()) return;
 
   // No more to do if not debugging.
-  if (!debugger_active()) return;
+  if (!IsDebuggerActive()) return;
 
   // Store whether in debugger before entering debugger.
   bool in_debugger = Debug::InDebugger();
 
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // If debugging there might be script break points registered for this
   // script. Make sure that these break points are set.
@@ skipping 108 matching lines @@
         // Silently ignore exceptions from debug event listeners.
       }
     }
   }
 
   // Clear the mirror cache.
   Debug::ClearMirrorCache();
 }
 
 
+void Debugger::UnloadDebugger() {
+  // Make sure that there are no breakpoints left.
+  Debug::ClearAllBreakPoints();
+
+  // Unload the debugger if feasible.
+  if (!never_unload_debugger_) {
+    Debug::Unload();
+  }
+
+  // Clear the flag indicating that the message handler was recently cleared.
+  message_handler_cleared_ = false;
+}
+
+
 void Debugger::NotifyMessageHandler(v8::DebugEvent event,
                                     Handle<Object> exec_state,
                                     Handle<Object> event_data,
                                     bool auto_continue) {
   HandleScope scope;
 
   if (!Debug::Load()) return;
 
   // Process the individual events.
   bool interactive = false;
@@ skipping 47 matching lines @@
     // Wait for new command in the queue.
     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.
     Vector<uint16_t> command = command_queue_.Get();
     Logger::DebugTag("Got request from command queue, in interactive loop.");
-    if (!Debugger::debugger_active()) {
+    if (!Debugger::IsDebuggerActive()) {
       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_);
       }
@@ skipping 82 matching lines @@
   // 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();
+  // Unload the debugger if event listener cleared.
+  if (callback->IsUndefined()) {
+    UnloadDebugger();
+  }
 }
 
 
 void Debugger::SetMessageHandler(v8::DebugMessageHandler handler, void* data,
                                  bool message_handler_thread) {
+  ScopedLock with(debugger_access_);
+
   message_handler_ = handler;
   message_handler_data_ = data;
-  if (!message_thread_ && message_handler_thread) {
-    message_thread_ = new DebugMessageThread();
-    message_thread_->Start();
+  if (handler != NULL) {
+    if (!message_thread_ && message_handler_thread) {
+      message_thread_ = new DebugMessageThread();
+      message_thread_->Start();
+    }
+  } else {
+    // Indicate that the message handler was recently cleared.
+    message_handler_cleared_ = true;
+
+    // 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());
+    }
   }
-  UpdateActiveDebugger();
 }
 
 
 void Debugger::SetHostDispatchHandler(v8::DebugHostDispatchHandler handler,
                                       void* data) {
   host_dispatch_handler_ = handler;
   host_dispatch_handler_data_ = data;
 }
 
 
 // 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(Vector<uint16_t> message) {
+  ScopedLock with(debugger_access_);
+
   if (message_handler_ != NULL) {
     message_handler_(message.start(), message.length(), message_handler_data_);
   }
 }
 
 
 void Debugger::SendMessage(Vector<uint16_t> message) {
   if (message_thread_ == NULL) {
     // If there is no message thread just invoke the message handler from the
     // V8 thread.
@@ skipping 71 matching lines @@
   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();
 }
 
 
-void Debugger::UpdateActiveDebugger() {
-  set_debugger_active(message_handler_ != NULL || !event_listener_.is_null());
-  if (!debugger_active() && message_thread_) {
-    // Send an empty command to the debugger if in a break to make JavaScript
-    // run again if the debugger is closed.
-    ProcessCommand(Vector<const uint16_t>::empty());
-  }
-  if (!debugger_active()) {
-    Debug::Unload();
-  }
+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) {
+  // When calling functions in the debugger prevent it from beeing unloaded.
+  Debugger::never_unload_debugger_ = true;
+
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter() || !debugger.HasJavaScriptFrames()) {
     return Factory::undefined_value();
   }
 
   // Create the execution state.
   bool caught_exception = false;
   Handle<Object> exec_state = MakeExecutionState(&caught_exception);
   if (caught_exception) {
@@ skipping 129 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal