[debugger] flood function for stepping before calling it.

test/cctest/test-debug.cc

 // Copyright 2012 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 329 matching lines @@
 }
 
 
 // Prepare to step to next break location.
 static void PrepareStep(StepAction step_action) {
   v8::internal::Debug* debug = CcTest::i_isolate()->debug();
   debug->PrepareStep(step_action, 1, StackFrame::NO_ID);
 }
 
 
+static void ClearStepping() { CcTest::i_isolate()->debug()->ClearStepping(); }
+
+
 // This function is in namespace v8::internal to be friend with class
 // v8::internal::Debug.
 namespace v8 {
 namespace internal {
 
 // Collect the currently debugged functions.
 Handle<FixedArray> GetDebuggedFunctions() {
   Debug* debug = CcTest::i_isolate()->debug();
 
   v8::internal::DebugInfoListNode* node = debug->debug_info_list_;
@@ skipping 3471 matching lines @@
                       "[Function.call, bar]);"
                       "}",
                       "foo");
 
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(DebugEventStep);
   step_action = StepIn;
 
   break_point_hit_count = 0;
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
-  CHECK_EQ(5, break_point_hit_count);
+  CHECK_EQ(6, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded();
 
   // Register a debug event listener which just counts.
   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
 
   break_point_hit_count = 0;
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
 
@@ skipping 352 matching lines @@
   const char* src = "function a() { n(); }; "
                     "function b() { c(); }; "
                     "function c() { n(); }; "
                     "function d() { x = 1; try { e(); } catch(x) { x = 2; } }; "
                     "function e() { n(); }; "
                     "function f() { x = 1; try { g(); } catch(x) { x = 2; } }; "
                     "function g() { h(); }; "
                     "function h() { x = 1; throw 1; }; ";
 
   // Step through invocation of a.
+  ClearStepping();
   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
   SetBreakPoint(a, 0);
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "aa";
   CHECK(a->Call(context, env->Global(), 0, NULL).IsEmpty());
   CHECK_EQ(StrLength(expected_step_sequence),
            break_point_hit_count);
 
   // Step through invocation of b + c.
+  ClearStepping();
   v8::Local<v8::Function> b = CompileFunction(&env, src, "b");
   SetBreakPoint(b, 0);
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "bcc";
   CHECK(b->Call(context, env->Global(), 0, NULL).IsEmpty());
   CHECK_EQ(StrLength(expected_step_sequence),
            break_point_hit_count);
+
   // Step through invocation of d + e.
+  ClearStepping();
   v8::Local<v8::Function> d = CompileFunction(&env, src, "d");
   SetBreakPoint(d, 0);
   ChangeBreakOnException(false, true);
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "ddedd";
   d->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(StrLength(expected_step_sequence),
            break_point_hit_count);
 
   // Step through invocation of d + e now with break on caught exceptions.
   ChangeBreakOnException(true, true);
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "ddeedd";
   d->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(StrLength(expected_step_sequence),
            break_point_hit_count);
 
   // Step through invocation of f + g + h.
+  ClearStepping();
   v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
   SetBreakPoint(f, 0);
   ChangeBreakOnException(false, true);
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "ffghhff";
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(StrLength(expected_step_sequence),
            break_point_hit_count);
 
@@ skipping 3759 matching lines @@
   CompileRun("function foo() {}; foo();");
   --after_compile_handler_depth;
 }
 
 
 TEST(NoInterruptsInDebugListener) {
   DebugLocalContext env;
   v8::Debug::SetDebugEventListener(NoInterruptsOnDebugEvent);
   CompileRun("void(0);");
 }