Change handling of debugger unloading

test/cctest/test-debug.cc

 // Copyright 2007-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 372 matching lines @@
   return debugged_functions;
 }
 
 
 static Handle<Code> ComputeCallDebugBreak(int argc) {
   CALL_HEAP_FUNCTION(v8::internal::StubCache::ComputeCallDebugBreak(argc),
                      Code);
 }
 
 
-// Check that the debugger is loaded.
-static void CheckDebuggerLoaded() {
-  CHECK(Debug::debug_context().is_null());
-}
-
-
 // Check that the debugger has been fully unloaded.
 void CheckDebuggerUnloaded(bool check_functions) {
   // Check that the debugger context is cleared and that there is no debug
   // information stored for the debugger.
   CHECK(Debug::debug_context().is_null());
   CHECK_EQ(NULL, Debug::debug_info_list_);
 
   // Collect garbage to ensure weak handles are cleared.
   Heap::CollectAllGarbage();
   Heap::CollectAllGarbage();
@@ skipping 21 matching lines @@
         }
       }
     }
   }
 }
 
 
 } }  // namespace v8::internal
 
 
-// Check that the debugger is loaded.
-static void CheckDebuggerLoaded() {
-  v8::internal::CheckDebuggerLoaded();
-}
-
-
 // Check that the debugger has been fully unloaded.
 static void CheckDebuggerUnloaded(bool check_functions = false) {
   v8::internal::CheckDebuggerUnloaded(check_functions);
 }
 
 
 // Inherit from BreakLocationIterator to get access to protected parts for
 // testing.
 class TestBreakLocationIterator: public v8::internal::BreakLocationIterator {
  public:
@@ skipping 3277 matching lines @@
 TEST(DebuggerUnload) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Check debugger is unloaded before it is used.
   CheckDebuggerUnloaded();
 
   // Add debug event listener.
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
-  CheckDebuggerLoaded();
-
   // Create a couple of functions for the test.
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){x=1}", "foo");
   v8::Local<v8::Function> bar =
       CompileFunction(&env, "function bar(){y=2}", "bar");
 
   // Set some break points.
   SetBreakPoint(foo, 0);
   SetBreakPoint(foo, 4);
   SetBreakPoint(bar, 0);
   SetBreakPoint(bar, 4);
 
   // Make sure that the break points are there.
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
   bar->Call(env->Global(), 0, NULL);
   CHECK_EQ(4, break_point_hit_count);
 
   // Remove the debug event listener without clearing breakpoints.
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded(true);
 
   // Set a new debug event listener.
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
-  CheckDebuggerLoaded();
-
   // Check that the break points was actually cleared.
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Set break points and run again.
   SetBreakPoint(foo, 0);
   SetBreakPoint(foo, 4);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Remove the debug event listener without clearing breakpoints again.
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded(true);
 }
 
 
+// Debugger message handler which counts the number of times it is called.
+static int message_handler_hit_count = 0;
+static void MessageHandlerHitCount(const uint16_t* message,
+                                   int length, void* data) {
+  message_handler_hit_count++;
+
+  const int kBufferSize = 1000;
+  uint16_t buffer[kBufferSize];
+  const char* command_continue =
+    "{\"seq\":0,"
+     "\"type\":\"request\","
+     "\"command\":\"continue\"}";
+
+  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_continue, buffer));
+}
+
+
+// Test clearing the debug message handler.
+TEST(DebuggerClearMessageHandler) {
+  v8::HandleScope scope;
+  DebugLocalContext env;
+
+  // Check debugger is unloaded before it is used.
+  CheckDebuggerUnloaded();
+
+  // Set a debug message handler.
+  v8::Debug::SetMessageHandler(MessageHandlerHitCount);
+
+  // Run code to throw a unhandled exception. This should end up in the message
+  // handler.
+  CompileRun("throw 1");
+
+  // The message handler should be called.
+  CHECK_GT(message_handler_hit_count, 0);
+
+  // Clear debug message handler.
+  message_handler_hit_count = 0;
+  v8::Debug::SetMessageHandler(NULL);
+
+  // Run code to throw a unhandled exception. This should end up in the message
+  // handler.
+  CompileRun("throw 1");
+
+  // The message handler should not be called more.
+  CHECK_EQ(0, message_handler_hit_count);
+
+  CheckDebuggerUnloaded(true);
+}
+
+
+// Debugger message handler which clears the message handler while active.
+static void MessageHandlerClearingMessageHandler(const uint16_t* message,
+                                                 int length,
+                                                 void* data) {
+  message_handler_hit_count++;
+
+  // Clear debug message handler.
+  v8::Debug::SetMessageHandler(NULL);
+}
+
+
+// Test clearing the debug message handler while processing a debug event.
+TEST(DebuggerClearMessageHandlerWhileActive) {
+  v8::HandleScope scope;
+  DebugLocalContext env;
+
+  // Check debugger is unloaded before it is used.
+  CheckDebuggerUnloaded();
+
+  // Set a debug message handler.
+  v8::Debug::SetMessageHandler(MessageHandlerClearingMessageHandler);
+
+  // Run code to throw a unhandled exception. This should end up in the message
+  // handler.
+  CompileRun("throw 1");
+
+  // The message handler should be called.
+  CHECK_EQ(1, message_handler_hit_count);
+
+  CheckDebuggerUnloaded(true);
+}
+
+
 int host_dispatch_hit_count = 0;
 static void HostDispatchHandlerHitCount(void* dispatch, void *data) {
   host_dispatch_hit_count++;
 }
 
 
 // Test that clearing the debug event listener actually clears all break points
 // and related information.
 TEST(DebuggerHostDispatch) {
   i::FLAG_debugger_auto_break = true;
@@ skipping 211 matching lines @@
   bool allow_natives_syntax = i::FLAG_allow_natives_syntax;
   i::FLAG_allow_natives_syntax = true;
   CompileRun(
       "var scripts = %DebugGetLoadedScripts();"
       "for (var i = 0; i < scripts.length; ++i) {"
       "    scripts[i].line_ends;"
       "}");
   // Must not crash while accessing line_ends.
   i::FLAG_allow_natives_syntax = allow_natives_syntax;
 }