Unload debugger when message handler is cleared

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 4675 matching lines @@
   {
     v8::Context::Scope context_scope(context_2);
     expected_context = context_2;
     expected_context_data = data_2;
     v8::Local<v8::Function> f = CompileFunction(source, "f");
     f->Call(context_2->Global(), 0, NULL);
   }
 
   // Two times compile event and two times break event.
   CHECK_GT(message_handler_hit_count, 4);
+
+  v8::Debug::SetMessageHandler2(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Common part of EvalContextData and NestedBreakEventContextData tests.
 static void ExecuteScriptForContextCheck() {
   // Create a context.
   v8::Persistent<v8::Context> context_1;
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::Handle<v8::ObjectTemplate>();
   v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>();
@@ skipping 26 matching lines @@
 // break event in an eval statement the expected context is the one returned by
 // Message.GetEventContext.
 TEST(EvalContextData) {
   v8::HandleScope scope;
   v8::Debug::SetMessageHandler2(ContextCheckMessageHandler);
 
   ExecuteScriptForContextCheck();
 
   // One time compile event and one time break event.
   CHECK_GT(message_handler_hit_count, 2);
+  v8::Debug::SetMessageHandler2(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 static bool sent_eval = false;
 static int break_count = 0;
+static int continue_command_send_count = 0;
 // Check that the expected context is the one generating the debug event
 // including the case of nested break event.
 static void DebugEvalContextCheckMessageHandler(
     const v8::Debug::Message& message) {
   CHECK(message.GetEventContext() == expected_context);
   CHECK(message.GetEventContext()->GetData()->StrictEquals(
       expected_context_data));
   message_handler_hit_count++;
 
   if (message.IsEvent() && message.GetEvent() == v8::Break) {
     break_count++;
     if (!sent_eval) {
       sent_eval = true;
 
       const int kBufferSize = 1000;
       uint16_t buffer[kBufferSize];
       const char* eval_command =
         "{\"seq\":0,"
          "\"type\":\"request\","
          "\"command\":\"evaluate\","
          "arguments:{\"expression\":\"debugger;\","
          "\"global\":true,\"disable_break\":false}}";
 
       // Send evaluate command.
       v8::Debug::SendCommand(buffer, AsciiToUtf16(eval_command, buffer));
       return;
     } else {
       // It's a break event caused by the evaluation request above.
       SendContinueCommand();
+      continue_command_send_count++;
     }
-  } else if (message.IsResponse()) {
+  } else if (message.IsResponse() && continue_command_send_count < 2) {
     // Response to the evaluation request. We're still on the breakpoint so
     // send continue.
     SendContinueCommand();
+    continue_command_send_count++;
   }
 }
 
 
 // Tests that context returned for break event is correct when the event occurs
 // in 'evaluate' debugger request.
 TEST(NestedBreakEventContextData) {
   v8::HandleScope scope;
+  break_count = 0;
+  message_handler_hit_count = 0;
   v8::Debug::SetMessageHandler2(DebugEvalContextCheckMessageHandler);
 
   ExecuteScriptForContextCheck();
 
   // One time compile event and two times break event.
   CHECK_GT(message_handler_hit_count, 3);
 
   // One break from the source and another from the evaluate request.
   CHECK_EQ(break_count, 2);
+  v8::Debug::SetMessageHandler2(NULL);
+  CheckDebuggerUnloaded();
 }
 
 
 // Debug event listener which counts the script collected events.
 int script_collected_count = 0;
 static void DebugEventScriptCollectedEvent(v8::DebugEvent event,
                                            v8::Handle<v8::Object> exec_state,
                                            v8::Handle<v8::Object> event_data,
                                            v8::Handle<v8::Value> data) {
   // Count the number of breaks.
   if (event == v8::ScriptCollected) {
     script_collected_count++;
   }
 }
 
 
 // Test that scripts collected are reported through the debug event listener.
 TEST(ScriptCollectedEvent) {
   break_point_hit_count = 0;
+  script_collected_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Request the loaded scripts to initialize the debugger script cache.
   Debug::GetLoadedScripts();
 
   // Do garbage collection to ensure that only the script in this test will be
   // collected afterwards.
   Heap::CollectAllGarbage();
 
@@ skipping 24 matching lines @@
     script_collected_message_count++;
     v8::Handle<v8::Context> context = message.GetEventContext();
     CHECK(context.IsEmpty());
   }
 }
 
 
 // Test that GetEventContext doesn't fail and return empty handle for
 // ScriptCollected events.
 TEST(ScriptCollectedEventContext) {
-  break_point_hit_count = 0;
+  script_collected_message_count = 0;
   v8::HandleScope scope;
 
   { // Scope for the DebugLocalContext.
     DebugLocalContext env;
 
     // Request the loaded scripts to initialize the debugger script cache.
     Debug::GetLoadedScripts();
 
     // Do garbage collection to ensure that only the script in this test will be
     // collected afterwards.
     Heap::CollectAllGarbage();
 
-    script_collected_count = 0;
     v8::Debug::SetMessageHandler2(ScriptCollectedMessageHandler);
     {
       v8::Script::Compile(v8::String::New("eval('a=1')"))->Run();
       v8::Script::Compile(v8::String::New("eval('a=2')"))->Run();
     }
   }
 
   // Do garbage collection to collect the script above which is no longer
   // referenced.
   Heap::CollectAllGarbage();
 
   CHECK_EQ(2, script_collected_message_count);
 
   v8::Debug::SetMessageHandler2(NULL);
 }
+
+
+// Debug event listener which counts the after compile events.
+int after_compile_message_count = 0;
+static void AfterCompileMessageHandler(const v8::Debug::Message& message) {
+  // Count the number of scripts collected.
+  if (message.IsEvent()) {
+    if (message.GetEvent() == v8::AfterCompile) {
+      after_compile_message_count++;
+    } else if (message.GetEvent() == v8::Break) {
+      SendContinueCommand();
+    }
+  }
+}
+
+
+// Tests that after compile event is sent as many times as there are scripts
+// compiled.
+TEST(AfterCompileMessageWhenMessageHandlerIsReset) {
+  v8::HandleScope scope;
+  DebugLocalContext env;
+  after_compile_message_count = 0;
+  const char* script = "var a=1";
+
+  v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
+  v8::Script::Compile(v8::String::New(script))->Run();
+  v8::Debug::SetMessageHandler2(NULL);
+
+  v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
+  v8::Debug::DebugBreak();
+  v8::Script::Compile(v8::String::New(script))->Run();
+
+  // Setting listener to NULL should cause debugger unload.
+  v8::Debug::SetMessageHandler2(NULL);
+  CheckDebuggerUnloaded();
+
+  // Compilation cache should be disabled when debugger is active.
+  CHECK_EQ(2, after_compile_message_count);
+}
+
+
+// Tests that break event is sent when message handler is reset.
+TEST(BreakMessageWhenMessageHandlerIsReset) {
+  v8::HandleScope scope;
+  DebugLocalContext env;
+  after_compile_message_count = 0;
+  const char* script = "function f() {};";
+
+  v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
+  v8::Script::Compile(v8::String::New(script))->Run();
+  v8::Debug::SetMessageHandler2(NULL);
+
+  v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
+  v8::Debug::DebugBreak();
+  v8::Local<v8::Function> f =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f->Call(env->Global(), 0, NULL);
+
+  // Setting message handler to NULL should cause debugger unload.
+  v8::Debug::SetMessageHandler2(NULL);
+  CheckDebuggerUnloaded();
+
+  // Compilation cache should be disabled when debugger is active.
+  CHECK_EQ(1, after_compile_message_count);
+}
+
+
+static int exception_event_count = 0;
+static void ExceptionMessageHandler(const v8::Debug::Message& message) {
+  if (message.IsEvent() && message.GetEvent() == v8::Exception) {
+    exception_event_count++;
+    SendContinueCommand();
+  }
+}
+
+
+// Tests that exception event is sent when message handler is reset.
+TEST(ExceptionMessageWhenMessageHandlerIsReset) {
+  v8::HandleScope scope;
+  DebugLocalContext env;
+  exception_event_count = 0;
+  const char* script = "function f() {throw new Error()};";
+
+  v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
+  v8::Script::Compile(v8::String::New(script))->Run();
+  v8::Debug::SetMessageHandler2(NULL);
+
+  v8::Debug::SetMessageHandler2(ExceptionMessageHandler);
+  v8::Local<v8::Function> f =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
+  f->Call(env->Global(), 0, NULL);
+
+  // Setting message handler to NULL should cause debugger unload.
+  v8::Debug::SetMessageHandler2(NULL);
+  CheckDebuggerUnloaded();
+
+  CHECK_EQ(1, exception_event_count);
+}