[debug] do not retroactively apply script break points.

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 1582 matching lines @@
   CHECK_EQ(1, break_point_hit_count);
 
   EnableScriptBreakPointFromJS(isolate, sbp);
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
   DisableScriptBreakPointFromJS(isolate, sbp);
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
-  // Reload the script and get f again checking that the disabling survives.
-  v8::Script::Compile(context, script, &origin)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
-  f = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(context, v8_str(isolate, "f")).ToLocalChecked());
-  f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
-  CHECK_EQ(2, break_point_hit_count);
-
-  EnableScriptBreakPointFromJS(isolate, sbp);
-  f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
-  CHECK_EQ(3, break_point_hit_count);
-
   v8::Debug::SetDebugEventListener(isolate, nullptr);
   CheckDebuggerUnloaded(isolate);
 }
 
 
 // Test conditional script break points.
 TEST(ConditionalScriptBreakPoint) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
@@ skipping 37 matching lines @@
   f->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(1, break_point_hit_count);
 
   ChangeScriptBreakPointConditionFromJS(env->GetIsolate(), sbp1, "x % 2 == 0");
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   }
   CHECK_EQ(5, break_point_hit_count);
 
-  // Reload the script and get f again checking that the condition survives.
-  v8::Script::Compile(context, script, &origin)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
-  f = v8::Local<v8::Function>::Cast(
-      env->Global()
-          ->Get(context, v8_str(env->GetIsolate(), "f"))
-          .ToLocalChecked());
-
-  break_point_hit_count = 0;
-  for (int i = 0; i < 10; i++) {
-    f->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
-  }
-  CHECK_EQ(5, break_point_hit_count);
-
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
-
-
-// Test that script break points survive when a script is reloaded.
-TEST(ScriptBreakPointReload) {
-  break_point_hit_count = 0;
-  DebugLocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
-  env.ExposeDebug();
-
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
-
-  v8::Local<v8::Context> context = env.context();
-  v8::Local<v8::Function> f;
-  v8::Local<v8::String> script = v8_str(env->GetIsolate(),
-                                        "function f() {\n"
-                                        "  function h() {\n"
-                                        "    a = 0;  // line 2\n"
-                                        "  }\n"
-                                        "  b = 1;  // line 4\n"
-                                        "  return h();\n"
-                                        "}");
-
-  v8::ScriptOrigin origin_1 = v8::ScriptOrigin(v8_str(env->GetIsolate(), "1"));
-  v8::ScriptOrigin origin_2 = v8::ScriptOrigin(v8_str(env->GetIsolate(), "2"));
-
-  // Set a script break point before the script is loaded.
-  SetScriptBreakPointByNameFromJS(env->GetIsolate(), "1", 2, 0);
-
-  // Compile the script and get the function.
-  v8::Script::Compile(context, script, &origin_1)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
-  f = v8::Local<v8::Function>::Cast(
-      env->Global()
-          ->Get(context, v8_str(env->GetIsolate(), "f"))
-          .ToLocalChecked());
-
-  // Call f and check that the script break point is active.
-  break_point_hit_count = 0;
-  f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
-  CHECK_EQ(1, break_point_hit_count);
-
-  // Compile the script again with a different script data and get the
-  // function.
-  v8::Script::Compile(context, script, &origin_2)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
-  f = v8::Local<v8::Function>::Cast(
-      env->Global()
-          ->Get(context, v8_str(env->GetIsolate(), "f"))
-          .ToLocalChecked());
-
-  // Call f and check that no break points are set.
-  break_point_hit_count = 0;
-  f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
-  CHECK_EQ(0, break_point_hit_count);
-
-  // Compile the script again and get the function.
-  v8::Script::Compile(context, script, &origin_1)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
-  f = v8::Local<v8::Function>::Cast(
-      env->Global()
-          ->Get(context, v8_str(env->GetIsolate(), "f"))
-          .ToLocalChecked());
-
-  // Call f and check that the script break point is active.
-  break_point_hit_count = 0;
-  f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
-  CHECK_EQ(1, break_point_hit_count);
-
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
-  CheckDebuggerUnloaded(env->GetIsolate());
-}
 
 
 // Test when several scripts has the same script data
 TEST(ScriptBreakPointMultiple) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    DebugEventBreakPointHitCount);
 
   v8::Local<v8::Context> context = env.context();
   v8::Local<v8::Function> f;
   v8::Local<v8::String> script_f = v8_str(env->GetIsolate(),
                                           "function f() {\n"
                                           "  a = 0;  // line 1\n"
                                           "}");
 
   v8::Local<v8::Function> g;
   v8::Local<v8::String> script_g = v8_str(env->GetIsolate(),
                                           "function g() {\n"
                                           "  b = 0;  // line 1\n"
                                           "}");
 
   v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str(env->GetIsolate(), "test"));
 
-  // Set a script break point before the scripts are loaded.
-  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
-
   // Compile the scripts with same script data and get the functions.
   v8::Script::Compile(context, script_f, &origin)
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
   f = v8::Local<v8::Function>::Cast(
       env->Global()
           ->Get(context, v8_str(env->GetIsolate(), "f"))
           .ToLocalChecked());
   v8::Script::Compile(context, script_g, &origin)
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
   g = v8::Local<v8::Function>::Cast(
       env->Global()
           ->Get(context, v8_str(env->GetIsolate(), "g"))
           .ToLocalChecked());
 
+  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
+
   // Call f and g and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(1, break_point_hit_count);
   g->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
   // Clear the script break point.
   ClearBreakPointFromJS(env->GetIsolate(), sbp);
 
@@ skipping 35 matching lines @@
       v8_str(env->GetIsolate(),
              "function f() {\n"
              "  a = 0;  // line 8 as this script has line offset 7\n"
              "  b = 0;  // line 9 as this script has line offset 7\n"
              "}");
 
   // Create script origin both name and line offset.
   v8::ScriptOrigin origin(v8_str(env->GetIsolate(), "test.html"),
                           v8::Integer::New(env->GetIsolate(), 7));
 
-  // Set two script break points before the script is loaded.
-  int sbp1 =
-      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 8, 0);
-  int sbp2 =
-      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 9, 0);
-
   // Compile the script and get the function.
   v8::Script::Compile(context, script, &origin)
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
+
+  int sbp1 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 8, 0);
+  int sbp2 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 9, 0);
+
   f = v8::Local<v8::Function>::Cast(
       env->Global()
           ->Get(context, v8_str(env->GetIsolate(), "f"))
           .ToLocalChecked());
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
@@ skipping 45 matching lines @@
              " a = 2;                    // line 4\n"
              "  /* xx */ function g() {  // line 5\n"
              "    function h() {         // line 6\n"
              "      a = 3;               // line 7\n"
              "    }\n"
              "    h();                   // line 9\n"
              "    a = 4;                 // line 10\n"
              "  }\n"
              " a=5;                      // line 12");
 
-  // Set a couple script break point before the script is loaded.
+  // Compile the script and get the function.
+  break_point_hit_count = 0;
+  v8::ScriptOrigin origin(v8_str(env->GetIsolate(), "test.html"),
+                          v8::Integer::New(env->GetIsolate(), 0));
+  v8::Local<v8::Script> compiled =
+      v8::Script::Compile(context, script, &origin).ToLocalChecked();
+
   int sbp1 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 0, -1);
   int sbp2 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 1, -1);
   int sbp3 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 5, -1);
 
-  // Compile the script and get the function.
-  break_point_hit_count = 0;
-  v8::ScriptOrigin origin(v8_str(env->GetIsolate(), "test.html"),
-                          v8::Integer::New(env->GetIsolate(), 0));
-  v8::Script::Compile(context, script, &origin)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
+  compiled->Run(context).ToLocalChecked();
+
   f = v8::Local<v8::Function>::Cast(
       env->Global()
           ->Get(context, v8_str(env->GetIsolate(), "f"))
           .ToLocalChecked());
   g = v8::Local<v8::Function>::Cast(
       env->Global()
           ->Get(context, v8_str(env->GetIsolate(), "g"))
           .ToLocalChecked());
 
   // Check that a break point was hit when the script was run.
@@ skipping 25 matching lines @@
   // more.
   ClearBreakPointFromJS(env->GetIsolate(), sbp2);
   ClearBreakPointFromJS(env->GetIsolate(), sbp4);
   int sbp5 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 4, -1);
   break_point_hit_count = 0;
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   g->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
-  // Reload the script which should hit two break points.
-  break_point_hit_count = 0;
-  v8::Script::Compile(context, script, &origin)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
-  CHECK_EQ(2, break_point_hit_count);
-  CHECK_EQ(0, StrLength(last_function_hit));
-
   // Set a break point in the code after the last function decleration.
   int sbp6 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 12, -1);
 
-  // Reload the script which should hit three break points.
-  break_point_hit_count = 0;
-  v8::Script::Compile(context, script, &origin)
-      .ToLocalChecked()
-      ->Run(context)
-      .ToLocalChecked();
-  CHECK_EQ(3, break_point_hit_count);
-  CHECK_EQ(0, StrLength(last_function_hit));
-
-  // Clear the last break points, and reload the script which should not hit any
-  // break points.
-  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
-  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
-  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
+  // Reloading the script should not hit any break points.
   break_point_hit_count = 0;
   v8::Script::Compile(context, script, &origin)
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
+  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
+  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
+
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test top level script break points set on lines.
 TEST(ScriptBreakPointLineTopLevel) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
@@ skipping 20 matching lines @@
 
   CcTest::CollectAllGarbage(i::Heap::kFinalizeIncrementalMarkingMask);
 
   SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
 
   // Call f and check that there was no break points.
   break_point_hit_count = 0;
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
-  // Recompile and run script and check that break point was hit.
+  // Recompile and run script and check that break point was not reapplied.
   break_point_hit_count = 0;
   CompileRunWithOrigin(script, "test.html");
-  CHECK_EQ(1, break_point_hit_count);
-
-  // Call f and check that there are still no break points.
-  break_point_hit_count = 0;
-  f = v8::Local<v8::Function>::Cast(
-      env->Global()
-          ->Get(context, v8_str(env->GetIsolate(), "f"))
-          .ToLocalChecked());
   CHECK_EQ(0, break_point_hit_count);
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that it is possible to add and remove break points in a top level
 // function which has no references but has not been collected yet.
 TEST(ScriptBreakPointTopLevelCrash) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    DebugEventBreakPointHitCount);
 
-  v8::Local<v8::String> script_source = v8_str(env->GetIsolate(),
-                                               "function f() {\n"
-                                               "  return 0;\n"
-                                               "}\n"
-                                               "f()");
+  CompileRunWithOrigin(
+      "function f() {\n"
+      "  return 0;\n"
+      "}\n",
+      "test.html");
+  int sbp1 =
+      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 1, -1);
+  break_point_hit_count = 0;
 
-  int sbp1 =
-      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
-  {
-    v8::HandleScope scope(env->GetIsolate());
-    break_point_hit_count = 0;
-    CompileRunWithOrigin(script_source, "test.html");
-    CHECK_EQ(1, break_point_hit_count);
-  }
+  CompileRun("f();");
+
+  CHECK_EQ(1, break_point_hit_count);
 
   int sbp2 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
   ClearBreakPointFromJS(env->GetIsolate(), sbp1);
   ClearBreakPointFromJS(env->GetIsolate(), sbp2);
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
@@ skipping 1494 matching lines @@
   env.ExposeDebug();
 
   // Register a debug event listener which counts.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), DebugEventCounter);
 
   v8::Local<v8::Context> context = env.context();
   // Create a script that returns a function.
   const char* src = "(function (evt) {})";
   const char* script_name = "StepInHandlerTest";
 
-  // Set breakpoint in the script.
-  SetScriptBreakPointByNameFromJS(env->GetIsolate(), script_name, 0, -1);
-  break_point_hit_count = 0;
-
   v8::ScriptOrigin origin(v8_str(env->GetIsolate(), script_name),
                           v8::Integer::New(env->GetIsolate(), 0));
   v8::Local<v8::Script> script =
       v8::Script::Compile(context, v8_str(env->GetIsolate(), src), &origin)
           .ToLocalChecked();
+
+  // Set breakpoint in the script.
+  SetScriptBreakPointByNameFromJS(env->GetIsolate(), script_name, 0, -1);
+  break_point_hit_count = 0;
+
   v8::Local<v8::Value> r = script->Run(context).ToLocalChecked();
 
   CHECK(r->IsFunction());
   CHECK_EQ(1, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
@@ skipping 3134 matching lines @@
       "function foo() {\n"
       "  try { throw new Error(); } catch (e) {}\n"
       "}\n"
       "debugger;\n"
       "foo();\n"
       "foo();\n");
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CHECK_EQ(break_point_hit_count, 4);
 }