Added automatic debug break for processing debugger commands

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 3226 matching lines @@
   // Post 6 commands, filling the command queue and making it expand.
   // These calls return immediately, but the commands stay on the queue
   // until the execution of source_2.
   // Note: AsciiToUtf16 executes before SendCommand, so command is copied
   // to buffer before buffer is sent to SendCommand.
   v8::Debug::SendCommand(buffer_1, AsciiToUtf16(command_1, buffer_1));
   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_2, buffer_2));
   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_3, buffer_2));
   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_3, buffer_2));
   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_3, buffer_2));
-  v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_continue, buffer_2));
   message_queue_barriers.barrier_2.Wait();
   // Main thread compiles and runs source_2.
   // Queued commands are executed at the start of compilation of source_2.
   message_queue_barriers.barrier_3.Wait();
   // Free the message handler to process all the messages from the queue.
   for (int i = 0; i < 20 ; ++i) {
     message_queue_barriers.semaphore_1->Signal();
   }
   // Main thread compiles and runs source_3.
   // source_3 includes a debugger statement, which causes a break event.
@@ skipping 21 matching lines @@
 
   const char* source_1 = "a = 3; b = 4; c = new Object(); c.d = 5;";
   const char* source_2 = "e = 17;";
   const char* source_3 = "a = 4; debugger; a = 5; a = 6; a = 7;";
 
   // See MessageQueueDebuggerThread::Run for interleaved sequence of
   // API calls and events in the two threads.
   CompileRun(source_1);
   message_queue_barriers.barrier_1.Wait();
   message_queue_barriers.barrier_2.Wait();
-  v8::Debug::DebugBreak();
   CompileRun(source_2);
   message_queue_barriers.barrier_3.Wait();
   CompileRun(source_3);
   message_queue_debugger_thread.Join();
   fflush(stdout);
 }
 
 /* Test ThreadedDebugging */
 /* This test interrupts a running infinite loop that is
  * occupying the v8 thread by a break command from the
@@ skipping 157 matching lines @@
   uint16_t buffer[kBufSize];
 
   const char* command_1 = "{\"seq\":101,"
       "\"type\":\"request\","
       "\"command\":\"setbreakpoint\","
       "\"arguments\":{\"type\":\"function\",\"target\":\"cat\",\"line\":3}}";
   const char* command_2 = "{\"seq\":102,"
       "\"type\":\"request\","
       "\"command\":\"setbreakpoint\","
       "\"arguments\":{\"type\":\"function\",\"target\":\"dog\",\"line\":3}}";
-  const char* command_3 = "{\"seq\":103,"
-      "\"type\":\"request\","
-      "\"command\":\"continue\"}";
-  const char* command_4 = "{\"seq\":104,"
+  const char* command_3 = "{\"seq\":104,"
       "\"type\":\"request\","
       "\"command\":\"evaluate\","
       "\"arguments\":{\"expression\":\"dog()\",\"disable_break\":false}}";
-  const char* command_5 = "{\"seq\":105,"
+  const char* command_4 = "{\"seq\":105,"
       "\"type\":\"request\","
       "\"command\":\"evaluate\","
       "\"arguments\":{\"expression\":\"x\",\"disable_break\":true}}";
-  const char* command_6 = "{\"seq\":106,"
+  const char* command_5 = "{\"seq\":106,"
       "\"type\":\"request\","
       "\"command\":\"continue\"}";
-  const char* command_7 = "{\"seq\":107,"
+  const char* command_6 = "{\"seq\":107,"
       "\"type\":\"request\","
       "\"command\":\"continue\"}";
-  const char* command_8 = "{\"seq\":108,"
+  const char* command_7 = "{\"seq\":108,"
      "\"type\":\"request\","
      "\"command\":\"evaluate\","
      "\"arguments\":{\"expression\":\"dog()\",\"disable_break\":true}}";
-  const char* command_9 = "{\"seq\":109,"
+  const char* command_8 = "{\"seq\":109,"
       "\"type\":\"request\","
       "\"command\":\"continue\"}";
 
 
   // v8 thread initializes, runs source_1
   breakpoints_barriers->barrier_1.Wait();
   // 1:Set breakpoint in cat().
-  v8::Debug::DebugBreak();
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_1, buffer));
   // 2:Set breakpoint in dog()
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer));
-  // 3:Continue
-  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_3, buffer));
   breakpoints_barriers->barrier_2.Wait();
   // v8 thread starts compiling source_2.
   // Automatic break happens, to run queued commands
   // breakpoints_barriers->semaphore_1->Wait();
   // Commands 1 through 3 run, thread continues.
   // v8 thread runs source_2 to breakpoint in cat().
   // message callback receives break event.
   breakpoints_barriers->semaphore_1->Wait();
   // 4:Evaluate dog() (which has a breakpoint).
-  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_4, buffer));
+  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_3, buffer));
   // v8 thread hits breakpoint in dog()
   breakpoints_barriers->semaphore_1->Wait();  // wait for break event
   // 5:Evaluate x
+  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_4, buffer));
+  // 6:Continue evaluation of dog()
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_5, buffer));
-  // 6:Continue evaluation of dog()
-  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_6, buffer));
   // dog() finishes.
   // 7:Continue evaluation of source_2, finish cat(17), hit breakpoint
   // in cat(19).
-  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_7, buffer));
+  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_6, buffer));
   // message callback gets break event
   breakpoints_barriers->semaphore_1->Wait();  // wait for break event
   // 8: Evaluate dog() with breaks disabled
+  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_7, buffer));
+  // 9: Continue evaluation of source2, reach end.
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_8, buffer));
-  // 9: Continue evaluation of source2, reach end.
-  v8::Debug::SendCommand(buffer, AsciiToUtf16(command_9, buffer));
 }
 
 BreakpointsDebuggerThread breakpoints_debugger_thread;
 BreakpointsV8Thread breakpoints_v8_thread;
 
 TEST(RecursiveBreakpoints) {
+  i::FLAG_debugger_auto_break = true;
+
   // Create a V8 environment
   Barriers stack_allocated_breakpoints_barriers;
   stack_allocated_breakpoints_barriers.Initialize();
   breakpoints_barriers = &stack_allocated_breakpoints_barriers;
 
   breakpoints_v8_thread.Start();
   breakpoints_debugger_thread.Start();
 
   breakpoints_v8_thread.Join();
   breakpoints_debugger_thread.Join();
@@ skipping 251 matching lines @@
 
 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;
+
   v8::HandleScope scope;
   DebugLocalContext env;
 
   const int kBufferSize = 1000;
   uint16_t buffer[kBufferSize];
   const char* command_continue =
-    "{\"seq\":106,"
+    "{\"seq\":0,"
      "\"type\":\"request\","
      "\"command\":\"continue\"}";
 
   // Setup message and host dispatch handlers.
   v8::Debug::SetMessageHandler(DummyMessageHandler);
   v8::Debug::SetHostDispatchHandler(HostDispatchHandlerHitCount,
                                     NULL);
 
   // Fill a host dispatch and a continue command on the command queue before
-  // generating a debug break.
+  // running some code.
   v8::Debug::SendHostDispatch(NULL);
   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_continue, buffer));
-  CompileRun("debugger");
+  CompileRun("void 0");
 
   // The host dispatch callback should be called.
   CHECK_EQ(1, host_dispatch_hit_count);
 }