[debugger,api] deprecate everything in v8-debug.h

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 122 matching lines @@
 }
 
 
 // Compile and run the supplied source and return the requested function.
 static v8::Local<v8::Function> CompileFunction(DebugLocalContext* env,
                                                const char* source,
                                                const char* function_name) {
   return CompileFunction(env->GetIsolate(), source, function_name);
 }
 
+static void SetDebugEventListener(
+    v8::Isolate* isolate, v8::Debug::EventCallback that,
+    v8::Local<v8::Value> data = v8::Local<v8::Value>()) {
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  i::HandleScope scope(i_isolate);
+  if (that == nullptr) {
+    i_isolate->debug()->SetDebugDelegate(nullptr, false);
+  } else {
+    i::Handle<i::Object> i_data = i_isolate->factory()->undefined_value();
+    if (!data.IsEmpty()) i_data = v8::Utils::OpenHandle(*data);
+    i::NativeDebugDelegate* delegate =
+        new i::NativeDebugDelegate(i_isolate, that, i_data);
+    i_isolate->debug()->SetDebugDelegate(delegate, true);
+  }
+}
 
 // Is there any debug info for the function?
 static bool HasDebugInfo(v8::Local<v8::Function> fun) {
   Handle<v8::internal::JSFunction> f =
       Handle<v8::internal::JSFunction>::cast(v8::Utils::OpenHandle(*fun));
   Handle<v8::internal::SharedFunctionInfo> shared(f->shared());
   return shared->HasDebugInfo();
 }
 
 // Set a break point in a function with a position relative to function start,
@@ skipping 661 matching lines @@
 
   if (event == v8::Break) {
     // Count the number of breaks.
     break_point_hit_count++;
 
     // Run the garbage collector to enforce heap verification if option
     // --verify-heap is set.
     CcTest::CollectGarbage(v8::internal::NEW_SPACE);
 
     // Set the break flag again to come back here as soon as possible.
-    v8::Debug::DebugBreak(CcTest::isolate());
+    v8::debug::DebugBreak(CcTest::isolate());
   }
 }
 
 
 // Debug event handler which re-issues a debug break until a limit has been
 // reached.
 int max_break_point_hit_count = 0;
 bool terminate_after_max_break_point_hit = false;
 static void DebugEventBreakMax(
     const v8::Debug::EventDetails& event_details) {
   v8::DebugEvent event = event_details.GetEvent();
   v8::Isolate* v8_isolate = CcTest::isolate();
   v8::internal::Isolate* isolate = CcTest::i_isolate();
   v8::internal::Debug* debug = isolate->debug();
   // When hitting a debug event listener there must be a break set.
   CHECK_NE(debug->break_id(), 0);
 
   if (event == v8::Break) {
     if (break_point_hit_count < max_break_point_hit_count) {
       // Count the number of breaks.
       break_point_hit_count++;
 
       // Set the break flag again to come back here as soon as possible.
-      v8::Debug::DebugBreak(v8_isolate);
+      v8::debug::DebugBreak(v8_isolate);
 
     } else if (terminate_after_max_break_point_hit) {
       // Terminate execution after the last break if requested.
       v8_isolate->TerminateExecution();
     }
 
     // Perform a full deoptimization when the specified number of
     // breaks have been hit.
     if (break_point_hit_count == break_point_hit_count_deoptimize) {
       i::Deoptimizer::DeoptimizeAll(isolate);
@@ skipping 58 matching lines @@
   CHECK(!HasDebugInfo(bar));
 }
 
 
 // Test that a break point can be set at an IC store location.
 TEST(BreakPointICStore) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){bar=0;}", "foo");
 
   // Run without breakpoints.
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that a break point can be set at an IC load location.
 TEST(BreakPointICLoad) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
 
   CompileRunChecked(env->GetIsolate(), "bar=1");
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){var x=bar;}", "foo");
 
   // Run without breakpoints.
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint.
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that a break point can be set at an IC call location.
 TEST(BreakPointICCall) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
   CompileRunChecked(env->GetIsolate(), "function bar(){}");
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){bar();}", "foo");
 
   // Run without breakpoints.
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env.context(), env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that a break point can be set at an IC call location and survive a GC.
 TEST(BreakPointICCallWithGC) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointCollectGarbage);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointCollectGarbage);
   CompileRunChecked(env->GetIsolate(), "function bar(){return 1;}");
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){return bar();}", "foo");
   v8::Local<v8::Context> context = env.context();
 
   // Run without breakpoints.
   CHECK_EQ(1, foo->Call(context, env->Global(), 0, NULL)
                   .ToLocalChecked()
                   ->Int32Value(context)
                   .FromJust());
@@ skipping 10 matching lines @@
                   .ToLocalChecked()
                   ->Int32Value(context)
                   .FromJust());
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that a break point can be set at an IC call location and survive a GC.
 TEST(BreakPointConstructCallWithGC) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointCollectGarbage);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointCollectGarbage);
   CompileRunChecked(env->GetIsolate(), "function bar(){ this.x = 1;}");
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){return new bar(1).x;}", "foo");
   v8::Local<v8::Context> context = env.context();
 
   // Run without breakpoints.
   CHECK_EQ(1, foo->Call(context, env->Global(), 0, NULL)
                   .ToLocalChecked()
                   ->Int32Value(context)
                   .FromJust());
@@ skipping 10 matching lines @@
                   .ToLocalChecked()
                   ->Int32Value(context)
                   .FromJust());
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that a break point can be set at a return store location.
 TEST(BreakPointReturn) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Create a functions for checking the source line and column when hitting
   // a break point.
   frame_source_line = CompileFunction(&env,
                                       frame_source_line_source,
                                       "frame_source_line");
   frame_source_column = CompileFunction(&env,
                                         frame_source_column_source,
                                         "frame_source_column");
 
-
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){}", "foo");
   v8::Local<v8::Context> context = env.context();
 
   // Run without breakpoints.
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(1, break_point_hit_count);
   CHECK_EQ(0, last_source_line);
   CHECK_EQ(15, last_source_column);
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
   CHECK_EQ(0, last_source_line);
   CHECK_EQ(15, last_source_column);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 static void CallWithBreakPoints(v8::Local<v8::Context> context,
                                 v8::Local<v8::Object> recv,
                                 v8::Local<v8::Function> f,
                                 int break_point_count, int call_count) {
   break_point_hit_count = 0;
   for (int i = 0; i < call_count; i++) {
     f->Call(context, recv, 0, NULL).ToLocalChecked();
     CHECK_EQ((i + 1) * break_point_count, break_point_hit_count);
   }
 }
 
 
 // Test GC during break point processing.
 TEST(GCDuringBreakPointProcessing) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Local<v8::Context> context = env.context();
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointCollectGarbage);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointCollectGarbage);
   v8::Local<v8::Function> foo;
 
   // Test IC store break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(context, env->Global(), foo, 1, 10);
 
   // Test IC load break point with garbage collection.
   foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(context, env->Global(), foo, 1, 10);
 
   // Test IC call break point with garbage collection.
   foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(context, env->Global(), foo, 1, 10);
 
   // Test return break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(context, env->Global(), foo, 1, 25);
 
   // Test debug break slot break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){var a;}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(context, env->Global(), foo, 1, 25);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Call the function three times with different garbage collections in between
 // and make sure that the break point survives.
 static void CallAndGC(v8::Local<v8::Context> context,
                       v8::Local<v8::Object> recv, v8::Local<v8::Function> f) {
   break_point_hit_count = 0;
 
@@ skipping 15 matching lines @@
 }
 
 
 // Test that a break point can be set at a return store location.
 TEST(BreakPointSurviveGC) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Local<v8::Context> context = env.context();
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
   v8::Local<v8::Function> foo;
 
   // Test IC store break point with garbage collection.
   {
     CompileFunction(&env, "function foo(){}", "foo");
     foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
     SetBreakPoint(foo, 0);
   }
   CallAndGC(context, env->Global(), foo);
 
@@ skipping 24 matching lines @@
   CallAndGC(context, env->Global(), foo);
 
   // Test non IC break point with garbage collection.
   {
     CompileFunction(&env, "function foo(){}", "foo");
     foo = CompileFunction(&env, "function foo(){var bar=0;}", "foo");
     SetBreakPoint(foo, 0);
   }
   CallAndGC(context, env->Global(), foo);
 
-
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that break points can be set using the global Debug object.
 TEST(BreakPointThroughJavaScript) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Context> context = env.context();
   env.ExposeDebug();
 
-  v8::Debug::SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
+  SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
   CompileRunChecked(isolate, "function bar(){}");
   CompileFunction(isolate, "function foo(){bar();bar();}", "foo");
   //                        012345678901234567890
   //                                  1         2
   // Break points are set at position 3 and 9
   v8::Local<v8::String> source = v8_str(env->GetIsolate(), "foo()");
   v8::Local<v8::Script> foo =
       v8::Script::Compile(context, source).ToLocalChecked();
 
   CHECK_EQ(0, break_point_hit_count);
@@ skipping 17 matching lines @@
   foo->Run(context).ToLocalChecked();
   CHECK_EQ(7, break_point_hit_count);
   foo->Run(context).ToLocalChecked();
   CHECK_EQ(8, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPointFromJS(env->GetIsolate(), bp1);
   foo->Run(context).ToLocalChecked();
   CHECK_EQ(8, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(isolate, nullptr);
+  SetDebugEventListener(isolate, nullptr);
   CheckDebuggerUnloaded(isolate);
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, bp1);
   CHECK_EQ(2, bp2);
 }
 
 
 // Test that break points on scripts identified by name can be set using the
 // global Debug object.
 TEST(ScriptBreakPointByNameThroughJavaScript) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Context> context = env.context();
   env.ExposeDebug();
 
-  v8::Debug::SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
+  SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
 
   v8::Local<v8::String> script = v8_str(isolate,
                                         "function f() {\n"
                                         "  function h() {\n"
                                         "    a = 0;  // line 2\n"
                                         "  }\n"
                                         "  b = 1;  // line 4\n"
                                         "  return h();\n"
                                         "}\n"
                                         "\n"
@@ skipping 65 matching lines @@
   ClearBreakPointFromJS(isolate, sbp2);
   ClearBreakPointFromJS(isolate, sbp3);
   ClearBreakPointFromJS(isolate, sbp4);
   ClearBreakPointFromJS(isolate, sbp5);
   ClearBreakPointFromJS(isolate, sbp6);
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
   g->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(isolate, nullptr);
+  SetDebugEventListener(isolate, nullptr);
   CheckDebuggerUnloaded(isolate);
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, sbp1);
   CHECK_EQ(2, sbp2);
   CHECK_EQ(3, sbp3);
   CHECK_EQ(4, sbp4);
   CHECK_EQ(5, sbp5);
   CHECK_EQ(6, sbp6);
 }
 
 
 TEST(ScriptBreakPointByIdThroughJavaScript) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Context> context = env.context();
   env.ExposeDebug();
 
-  v8::Debug::SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
+  SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
 
   v8::Local<v8::String> source = v8_str(isolate,
                                         "function f() {\n"
                                         "  function h() {\n"
                                         "    a = 0;  // line 2\n"
                                         "  }\n"
                                         "  b = 1;  // line 4\n"
                                         "  return h();\n"
                                         "}\n"
                                         "\n"
@@ skipping 67 matching lines @@
   ClearBreakPointFromJS(env->GetIsolate(), sbp2);
   ClearBreakPointFromJS(env->GetIsolate(), sbp3);
   ClearBreakPointFromJS(env->GetIsolate(), sbp4);
   ClearBreakPointFromJS(env->GetIsolate(), sbp5);
   ClearBreakPointFromJS(env->GetIsolate(), sbp6);
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
   g->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(0, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(isolate, nullptr);
+  SetDebugEventListener(isolate, nullptr);
   CheckDebuggerUnloaded(isolate);
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, sbp1);
   CHECK_EQ(2, sbp2);
   CHECK_EQ(3, sbp3);
   CHECK_EQ(4, sbp4);
   CHECK_EQ(5, sbp5);
   CHECK_EQ(6, sbp6);
 }
 
 
 // Test conditional script break points.
 TEST(EnableDisableScriptBreakPoint) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Context> context = env.context();
   env.ExposeDebug();
 
-  v8::Debug::SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
+  SetDebugEventListener(isolate, DebugEventBreakPointHitCount);
 
   v8::Local<v8::String> script = v8_str(isolate,
                                         "function f() {\n"
                                         "  a = 0;  // line 1\n"
                                         "};");
 
   // Compile the script and get function f.
   v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str(isolate, "test"));
   v8::Script::Compile(context, script, &origin)
       .ToLocalChecked()
@@ skipping 15 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);
 
-  v8::Debug::SetDebugEventListener(isolate, nullptr);
+  SetDebugEventListener(isolate, nullptr);
   CheckDebuggerUnloaded(isolate);
 }
 
 
 // Test conditional script break points.
 TEST(ConditionalScriptBreakPoint) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
 
   v8::Local<v8::String> script = v8_str(env->GetIsolate(),
                                         "count = 0;\n"
                                         "function f() {\n"
                                         "  g(count++);  // line 2\n"
                                         "};\n"
                                         "function g(x) {\n"
                                         "  var a=x;  // line 5\n"
                                         "};");
 
@@ skipping 23 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);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  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);
+  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(),
@@ skipping 43 matching lines @@
   // Set script break point with the scripts loaded.
   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);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test the script origin which has both name and line offset.
 TEST(ScriptBreakPointLineOffset) {
   break_point_hit_count = 0;
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  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"
              "  a = 0;  // line 8 as this script has line offset 7\n"
              "  b = 0;  // line 9 as this script has line offset 7\n"
              "}");
 
@@ skipping 32 matching lines @@
   CHECK_EQ(0, break_point_hit_count);
 
   // Set a script break point with the script loaded.
   sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 9, 0);
 
   // 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);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test script break points set on lines.
 TEST(ScriptBreakPointLine) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
 
   v8::Local<v8::Context> context = env.context();
   v8::Local<v8::Function> f;
   v8::Local<v8::Function> g;
   v8::Local<v8::String> script =
       v8_str(env->GetIsolate(),
              "a = 0                      // line 0\n"
              "function f() {\n"
              "  a = 1;                   // line 2\n"
              "}\n"
@@ skipping 77 matching lines @@
   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);
+  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();
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(),
-                                   DebugEventBreakPointHitCount);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
 
   v8::Local<v8::Context> context = env.context();
   v8::Local<v8::String> script =
       v8_str(env->GetIsolate(),
              "function f() {\n"
              "  a = 1;                   // line 1\n"
              "}\n"
              "a = 2;                     // line 3\n");
   v8::Local<v8::Function> f;
   {
@@ skipping 12 matching lines @@
   // 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 not reapplied.
   break_point_hit_count = 0;
   CompileRunWithOrigin(script, "test.html");
   CHECK_EQ(0, break_point_hit_count);
 
-  v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+  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);
+  SetDebugEventListener(env->GetIsolate(), DebugEventBreakPointHitCount);
 
   CompileRunWithOrigin(
       "function f() {\n"
       "  return 0;\n"
       "}\n",
       "test.html");
   int sbp1 =
       SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 1, -1);
   break_point_hit_count = 0;
 
   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);
+  SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that it is possible to remove the last break point for a function
 // inside the break handling of that break point.
 TEST(RemoveBreakPointInBreak) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
@@ skipping 1939 matching lines @@
       v8::Number::New(isolate, 1), v8::Number::New(isolate, 1),
       v8::Number::New(isolate, 1), v8::Number::New(isolate, 1)};
 
   // Call all functions to make sure that they are compiled.
   f0->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   f1->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   f2->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   f3->Call(context, env->Global(), 0, NULL).ToLocalChecked();
 
   // Set the debug break flag.
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
 
   // Call all functions with different argument count.
   break_point_hit_count = 0;
   for (unsigned int i = 0; i < arraysize(argv); i++) {
     f0->Call(context, env->Global(), i, argv).ToLocalChecked();
     f1->Call(context, env->Global(), i, argv).ToLocalChecked();
     f2->Call(context, env->Global(), i, argv).ToLocalChecked();
     f3->Call(context, env->Global(), i, argv).ToLocalChecked();
   }
 
@@ skipping 14 matching lines @@
 
   // Register a debug event listener which sets the break flag and counts.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), DebugEventCounter);
 
   v8::Local<v8::Context> context = env.context();
   // Create a function for testing stepping.
   const char* src = "function f() {g()};function g(){i=0; while(i<10){i++}}";
   v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
 
   // Set, test and cancel debug break.
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
   v8::Debug::CancelDebugBreak(env->GetIsolate());
 
   // Set the debug break flag.
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
 
   // Call all functions with different argument count.
   break_point_hit_count = 0;
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(1, break_point_hit_count);
 
   {
-    v8::Debug::DebugBreak(env->GetIsolate());
+    v8::debug::DebugBreak(env->GetIsolate());
     i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
     v8::internal::DisableBreak disable_break(isolate->debug());
     f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
     CHECK_EQ(1, break_point_hit_count);
   }
 
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   CHECK_EQ(2, break_point_hit_count);
 
   // Get rid of the debug event listener.
@@ skipping 25 matching lines @@
 // http://crbug.com/28933
 // Test that debug break is disabled when bootstrapper is active.
 TEST(NoBreakWhenBootstrapping) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Register a debug event listener which sets the break flag and counts.
   v8::Debug::SetDebugEventListener(isolate, DebugEventCounter);
 
   // Set the debug break flag.
-  v8::Debug::DebugBreak(isolate);
+  v8::debug::DebugBreak(isolate);
   break_point_hit_count = 0;
   {
     // Create a context with an extension to make sure that some JavaScript
     // code is executed during bootstrapping.
     v8::RegisterExtension(new v8::Extension("simpletest",
                                             kSimpleExtensionSource));
     const char* extension_names[] = { "simpletest" };
     v8::ExtensionConfiguration extensions(1, extension_names);
     v8::HandleScope handle_scope(isolate);
     v8::Context::New(isolate, &extensions);
@@ skipping 525 matching lines @@
   CHECK(CompileRun("obj_mirror.property('a').value().value() == 1")
             ->BooleanValue(context)
             .FromJust());
   CHECK(CompileRun("obj_mirror.property('b').value().value() == 2")
             ->BooleanValue(context)
             .FromJust());
 }
 
 
 TEST(SetDebugEventListenerOnUninitializedVM) {
-  v8::Debug::SetDebugEventListener(CcTest::isolate(), DummyDebugEventListener);
+  EnableDebugger(CcTest::isolate());
 }
 
 // Source for a JavaScript function which returns the data parameter of a
 // function called in the context of the debugger. If no data parameter is
 // passed it throws an exception.
 static const char* debugger_call_with_data_source =
     "function debugger_call_with_data(exec_state, data) {"
     "  if (data) return data;"
     "  throw 'No data!'"
     "}";
 v8::Local<v8::Function> debugger_call_with_data;
 
 
 // Source for a JavaScript function which returns the data parameter of a
 // function called in the context of the debugger. If no data parameter is
 // passed it throws an exception.
 static const char* debugger_call_with_closure_source =
     "var x = 3;"
     "(function (exec_state) {"
     "  if (exec_state.y) return x - 1;"
     "  exec_state.y = x;"
     "  return exec_state.y"
     "})";
 v8::Local<v8::Function> debugger_call_with_closure;
 
 // Function to retrieve the number of JavaScript frames by calling a JavaScript
 // in the debugger.
 static void CheckFrameCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
-  CHECK(v8::Debug::Call(context, frame_count).ToLocalChecked()->IsNumber());
+  CHECK(v8::debug::Call(context, frame_count).ToLocalChecked()->IsNumber());
   CHECK_EQ(args[0]->Int32Value(context).FromJust(),
-           v8::Debug::Call(context, frame_count)
+           v8::debug::Call(context, frame_count)
                .ToLocalChecked()
                ->Int32Value(context)
                .FromJust());
 }
 
 
 // Function to retrieve the source line of the top JavaScript frame by calling a
 // JavaScript function in the debugger.
 static void CheckSourceLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
   CHECK(
-      v8::Debug::Call(context, frame_source_line).ToLocalChecked()->IsNumber());
+      v8::debug::Call(context, frame_source_line).ToLocalChecked()->IsNumber());
   CHECK_EQ(args[0]->Int32Value(context).FromJust(),
-           v8::Debug::Call(context, frame_source_line)
+           v8::debug::Call(context, frame_source_line)
                .ToLocalChecked()
                ->Int32Value(context)
                .FromJust());
 }
 
 
 // Function to test passing an additional parameter to a JavaScript function
 // called in the debugger. It also tests that functions called in the debugger
 // can throw exceptions.
 static void CheckDataParameter(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Local<v8::String> data = v8_str(args.GetIsolate(), "Test");
   v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
-  CHECK(v8::Debug::Call(context, debugger_call_with_data, data)
+  CHECK(v8::debug::Call(context, debugger_call_with_data, data)
             .ToLocalChecked()
             ->IsString());
 
   for (int i = 0; i < 3; i++) {
     v8::TryCatch catcher(args.GetIsolate());
-    CHECK(v8::Debug::Call(context, debugger_call_with_data).IsEmpty());
+    CHECK(v8::debug::Call(context, debugger_call_with_data).IsEmpty());
     CHECK(catcher.HasCaught());
     CHECK(catcher.Exception()->IsString());
   }
 }
 
 
 // Function to test using a JavaScript with closure in the debugger.
 static void CheckClosure(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
-  CHECK(v8::Debug::Call(context, debugger_call_with_closure)
+  CHECK(v8::debug::Call(context, debugger_call_with_closure)
             .ToLocalChecked()
             ->IsNumber());
-  CHECK_EQ(3, v8::Debug::Call(context, debugger_call_with_closure)
+  CHECK_EQ(3, v8::debug::Call(context, debugger_call_with_closure)
                   .ToLocalChecked()
                   ->Int32Value(context)
                   .FromJust());
 }
 
 
 // Test functions called through the debugger.
 TEST(CallFunctionInDebugger) {
   // Create and enter a context with the functions CheckFrameCount,
   // CheckSourceLine and CheckDataParameter installed.
@@ skipping 48 matching lines @@
       v8::Script::Compile(context,
                           v8_str(isolate, debugger_call_with_closure_source))
           .ToLocalChecked()
           ->Run(context)
           .ToLocalChecked());
 
   // Calling a function through the debugger returns 0 frames if there are
   // no JavaScript frames.
   CHECK(v8::Integer::New(isolate, 0)
             ->Equals(context,
-                     v8::Debug::Call(context, frame_count).ToLocalChecked())
+                     v8::debug::Call(context, frame_count).ToLocalChecked())
             .FromJust());
 
   // Test that the number of frames can be retrieved.
   v8::Script::Compile(context, v8_str(isolate, "CheckFrameCount(1)"))
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
   v8::Script::Compile(context, v8_str(isolate,
                                       "function f() {"
                                       "  CheckFrameCount(2);"
@@ skipping 340 matching lines @@
   CheckDebuggerUnloaded(isolate);
 }
 
 // Debug event listener which issues a debug break when it hits a break event.
 static int event_listener_break_hit_count = 0;
 static void DebugBreakEventListener(const v8::Debug::EventDetails& details) {
   // Schedule a debug break for break events.
   if (details.GetEvent() == v8::Break) {
     event_listener_break_hit_count++;
     if (event_listener_break_hit_count == 1) {
-      v8::Debug::DebugBreak(details.GetIsolate());
+      v8::debug::DebugBreak(details.GetIsolate());
     }
   }
 }
 
 // Test that a debug break can be scheduled while in a event listener.
 TEST(DebugBreakInEventListener) {
   i::FLAG_turbo_inlining = false;  // Make sure g is not inlined into f.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
@@ skipping 47 matching lines @@
       } else {
         CHECK(result->IsString());
         v8::Local<v8::String> function_name(
             result->ToString(context).ToLocalChecked());
         function_name->WriteUtf8(last_function_hit);
       }
     }
 
     // Keep forcing breaks.
     if (break_point_hit_count < 20) {
-      v8::Debug::DebugBreak(CcTest::isolate());
+      v8::debug::DebugBreak(CcTest::isolate());
     }
   }
 }
 
 
 TEST(RegExpDebugBreak) {
   // This test only applies to native regexps.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Local<v8::Context> context = env.context();
@@ skipping 10 matching lines @@
 
   v8::Local<v8::Function> f = CompileFunction(env->GetIsolate(), script, "f");
   const int argc = 1;
   v8::Local<v8::Value> argv[argc] = {
       v8_str(env->GetIsolate(), "  /* xxx */ a=0;")};
   v8::Local<v8::Value> result =
       f->Call(context, env->Global(), argc, argv).ToLocalChecked();
   CHECK_EQ(12, result->Int32Value(context).FromJust());
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(), DebugEventDebugBreak);
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
   result = f->Call(context, env->Global(), argc, argv).ToLocalChecked();
 
   // Check that there was only one break event. Matching RegExp should not
   // cause Break events.
   CHECK_EQ(1, break_point_hit_count);
   CHECK_EQ(0, strcmp("f", last_function_hit));
 }
 #endif  // V8_INTERPRETED_REGEXP
 
 // Test which creates a context and sets embedder data on it. Checks that this
@@ skipping 61 matching lines @@
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    AfterCompileEventListener);
   v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    AfterCompileEventListener);
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
   v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
 
   // Setting listener to NULL should cause debugger unload.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 
   // Compilation cache should be disabled when debugger is active.
@@ skipping 72 matching lines @@
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    AfterCompileEventListener);
   v8::Script::Compile(context, v8_str(env->GetIsolate(), script))
       .ToLocalChecked()
       ->Run(context)
       .ToLocalChecked();
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    AfterCompileEventListener);
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
   v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
       env->Global()
           ->Get(context, v8_str(env->GetIsolate(), "f"))
           .ToLocalChecked());
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
 
   // Setting event listener to NULL should cause debugger unload.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 
@@ skipping 94 matching lines @@
 // debug-delay.js is executed.
 TEST(NoDebugBreakInAfterCompileEventListener) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Local<v8::Context> context = env.context();
 
   // Register a debug event listener which sets the break flag and counts.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), BreakEventListener);
 
   // Set the debug break flag.
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
 
   // Create a function for testing stepping.
   const char* src = "function f() { eval('var x = 10;'); } ";
   v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
 
   // There should be only one break event.
   CHECK_EQ(1, break_point_hit_count);
 
   // Set the debug break flag again.
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
   f->Call(context, env->Global(), 0, NULL).ToLocalChecked();
   // There should be one more break event when the script is evaluated in 'f'.
   CHECK_EQ(2, break_point_hit_count);
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
   CheckDebuggerUnloaded(env->GetIsolate());
 }
 
 
 // Test that the debug break flag works with function.apply.
 TEST(DebugBreakFunctionApply) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Local<v8::Context> context = env.context();
 
   // Create a function for testing breaking in apply.
   v8::Local<v8::Function> foo = CompileFunction(
       &env,
       "function baz(x) { }"
       "function bar(x) { baz(); }"
       "function foo(){ bar.apply(this, [1]); }",
       "foo");
 
   // Register a debug event listener which steps and counts.
   v8::Debug::SetDebugEventListener(env->GetIsolate(), DebugEventBreakMax);
 
   // Set the debug break flag before calling the code using function.apply.
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
 
   // Limit the number of debug breaks. This is a regression test for issue 493
   // where this test would enter an infinite loop.
   break_point_hit_count = 0;
   max_break_point_hit_count = 10000;  // 10000 => infinite loop.
   foo->Call(context, env->Global(), 0, NULL).ToLocalChecked();
 
   // When keeping the debug break several break will happen.
   CHECK_GT(break_point_hit_count, 1);
 
@@ skipping 137 matching lines @@
         v8::Local<v8::String> function_name(
             result->ToString(context).ToLocalChecked());
         function_name->WriteUtf8(fn);
         if (strcmp(fn, "bar") == 0) {
           i::Deoptimizer::DeoptimizeAll(CcTest::i_isolate());
           debug_event_break_deoptimize_done = true;
         }
       }
     }
 
-    v8::Debug::DebugBreak(CcTest::isolate());
+    v8::debug::DebugBreak(CcTest::isolate());
   }
 }
 
 
 // Test deoptimization when execution is broken using the debug break stack
 // check interrupt.
 TEST(DeoptimizeDuringDebugBreak) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   env.ExposeDebug();
@@ skipping 10 matching lines @@
   // time in function bar when using debug break and no break points will be at
   // the initial stack check.
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    DebugEventBreakDeoptimize);
 
   // Compile and run function bar which will optimize it for some flag settings.
   v8::Local<v8::Function> f = CompileFunction(&env, "function bar(){}", "bar");
   f->Call(context, v8::Undefined(env->GetIsolate()), 0, NULL).ToLocalChecked();
 
   // Set debug break and call bar again.
-  v8::Debug::DebugBreak(env->GetIsolate());
+  v8::debug::DebugBreak(env->GetIsolate());
   f->Call(context, v8::Undefined(env->GetIsolate()), 0, NULL).ToLocalChecked();
 
   CHECK(debug_event_break_deoptimize_done);
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
 }
 
 
 static void DebugEventBreakWithOptimizedStack(
     const v8::Debug::EventDetails& event_details) {
@@ skipping 53 matching lines @@
               (result->Int32Value(context).FromJust() == 42));
       }
     }
   }
 }
 
 
 static void ScheduleBreak(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Debug::SetDebugEventListener(args.GetIsolate(),
                                    DebugEventBreakWithOptimizedStack);
-  v8::Debug::DebugBreak(args.GetIsolate());
+  v8::debug::DebugBreak(args.GetIsolate());
 }
 
 
 TEST(DebugBreakStackInspection) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Local<v8::Context> context = env.context();
 
   frame_function_name =
       CompileFunction(&env, frame_function_name_source, "frame_function_name");
@@ skipping 52 matching lines @@
       }
 
       break_point_hit_count = 0;
       max_break_point_hit_count = kBreaksPerTest;
       terminate_after_max_break_point_hit = true;
 
       // Function with infinite loop.
       CompileRun(buffer.start());
 
       // Set the debug break to enter the debugger as soon as possible.
-      v8::Debug::DebugBreak(CcTest::isolate());
+      v8::debug::DebugBreak(CcTest::isolate());
 
       // Call function with infinite loop.
       CompileRun("f();");
       CHECK_EQ(kBreaksPerTest, break_point_hit_count);
 
       CHECK(!CcTest::isolate()->IsExecutionTerminating());
     }
   }
 }
 
@@ skipping 228 matching lines @@
   CHECK_EQ(2, v8::internal::CountNativeContexts());
 
   v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
 }
 
 
 TEST(LiveEditEnabled) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Debug::SetLiveEditEnabled(env->GetIsolate(), true);
+  v8::debug::SetLiveEditEnabled(env->GetIsolate(), true);
   CompileRun("%LiveEditCompareStrings('', '')");
 }
 
 
 TEST(LiveEditDisabled) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Debug::SetLiveEditEnabled(env->GetIsolate(), false);
+  v8::debug::SetLiveEditEnabled(env->GetIsolate(), false);
   CompileRun("%LiveEditCompareStrings('', '')");
 }
 
 
 TEST(PrecompiledFunction) {
   // Regression test for crbug.com/346207. If we have preparse data, parsing the
   // function in the presence of the debugger (and breakpoints) should still
   // succeed. The bug was that preparsing was done lazily and parsing was done
   // eagerly, so, the symbol streams didn't match.
   DebugLocalContext env;
@@ skipping 26 matching lines @@
 }
 
 
 static void DebugBreakStackTraceListener(
     const v8::Debug::EventDetails& event_details) {
   v8::StackTrace::CurrentStackTrace(CcTest::isolate(), 10);
 }
 
 
 static void AddDebugBreak(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Debug::DebugBreak(args.GetIsolate());
+  v8::debug::DebugBreak(args.GetIsolate());
 }
 
 
 TEST(DebugBreakStackTrace) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetDebugEventListener(env->GetIsolate(),
                                    DebugBreakStackTraceListener);
   v8::Local<v8::Context> context = env.context();
   v8::Local<v8::FunctionTemplate> add_debug_break_template =
@@ skipping 46 matching lines @@
 
 
 TEST(DebugBreakOffThreadTerminate) {
   DebugLocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Debug::SetDebugEventListener(isolate, DebugBreakTriggerTerminate);
   TerminationThread terminator(isolate);
   terminator.Start();
   v8::TryCatch try_catch(env->GetIsolate());
-  v8::Debug::DebugBreak(isolate);
+  v8::debug::DebugBreak(isolate);
   CompileRun("while (true);");
   CHECK(try_catch.HasTerminated());
 }
 
 
 static void DebugEventExpectNoException(
     const v8::Debug::EventDetails& event_details) {
   v8::DebugEvent event = event_details.GetEvent();
   CHECK_NE(v8::Exception, event);
 }
@@ skipping 200 matching lines @@
 
 TEST(DisableTailCallElimination) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_harmony_tailcalls = true;
   // TODO(ishell, 4698): Investigate why TurboFan in --always-opt mode makes
   // stack[2].getFunctionName() return null.
   i::FLAG_turbo_inlining = false;
 
   DebugLocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   v8::HandleScope scope(isolate);
-  CHECK(v8::Debug::IsTailCallEliminationEnabled(isolate));
+  CHECK(i_isolate->is_tail_call_elimination_enabled());
 
   CompileRun(
       "'use strict';                                                         \n"
       "Error.prepareStackTrace = (error,stack) => {                          \n"
       "  error.strace = stack;                                               \n"
       "  return error.message + \"\\n    at \" + stack.join(\"\\n    at \"); \n"
       "}                                                                     \n"
       "                                                                      \n"
       "function getCaller() {                                                \n"
       "  var e = new Error();                                                \n"
@@ skipping 16 matching lines @@
       "function h() {                                                        \n"
       "  var result = g();                                                   \n"
       "  return result;                                                      \n"
       "}                                                                     \n"
       "%NeverOptimizeFunction(getCaller);                                    \n"
       "%NeverOptimizeFunction(f);                                            \n"
       "%NeverOptimizeFunction(h);                                            \n"
       "");
   ExpectInt32("h();", 2);
   ExpectInt32("h(); %OptimizeFunctionOnNextCall(g); h();", 2);
-  v8::Debug::SetTailCallEliminationEnabled(isolate, false);
-  CHECK(!v8::Debug::IsTailCallEliminationEnabled(isolate));
+  i_isolate->SetTailCallEliminationEnabled(false);
+  CHECK(!i_isolate->is_tail_call_elimination_enabled());
   ExpectInt32("h();", 1);
   ExpectInt32("h(); %OptimizeFunctionOnNextCall(g); h();", 1);
-  v8::Debug::SetTailCallEliminationEnabled(isolate, true);
-  CHECK(v8::Debug::IsTailCallEliminationEnabled(isolate));
+  i_isolate->SetTailCallEliminationEnabled(true);
+  CHECK(i_isolate->is_tail_call_elimination_enabled());
   ExpectInt32("h();", 2);
   ExpectInt32("h(); %OptimizeFunctionOnNextCall(g); h();", 2);
 }
 
 TEST(DebugStepNextTailCallEliminiation) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_harmony_tailcalls = true;
   // TODO(ishell, 4698): Investigate why TurboFan in --always-opt mode makes
   // stack[2].getFunctionName() return null.
   i::FLAG_turbo_inlining = false;
 
   DebugLocalContext env;
   env.ExposeDebug();
   v8::Isolate* isolate = env->GetIsolate();
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   v8::HandleScope scope(isolate);
-  CHECK(v8::Debug::IsTailCallEliminationEnabled(isolate));
+  CHECK(i_isolate->is_tail_call_elimination_enabled());
 
   const char* source =
       "'use strict';                                           \n"
       "var Debug = debug.Debug;                                \n"
       "var exception = null;                                   \n"
       "var breaks = 0;                                         \n"
       "var log = [];                                           \n"
       "function f(x) {                                         \n"
       "  if (x == 2) {                                         \n"
       "    debugger;             // Break a                    \n"
@@ skipping 15 matching lines @@
       "  };                                                    \n"
       "};                                                      \n"
       "Debug.setListener(listener);                            \n"
       "f(4);                                                   \n"
       "Debug.setListener(null);  // Break d                    \n";
 
   CompileRun(source);
   ExpectNull("exception");
   ExpectString("JSON.stringify(log)", "[\"a4\",\"b2\",\"c4\",\"c11\",\"d0\"]");
 
-  v8::Debug::SetTailCallEliminationEnabled(isolate, false);
+  i_isolate->SetTailCallEliminationEnabled(false);
   CompileRun(
       "log = [];                            \n"
       "Debug.setListener(listener);         \n"
       "f(5);                                \n"
       "Debug.setListener(null);  // Break f \n");
   ExpectNull("exception");
   ExpectString("JSON.stringify(log)",
                "[\"a4\",\"b2\",\"c4\",\"e0\",\"e0\",\"e0\",\"e0\",\"f0\"]");
 }
 
@@ skipping 88 matching lines @@
   CHECK_EQ(4, function_data.End().GetColumnNumber());
   CHECK_EQ(1, function_data.Count());
 
   function_data = script_data.GetFunctionData(1);
   CHECK_EQ(0, function_data.Start().GetLineNumber());
   CHECK_EQ(0, function_data.Start().GetColumnNumber());
   CHECK_EQ(1, function_data.End().GetLineNumber());
   CHECK_EQ(1, function_data.End().GetColumnNumber());
   CHECK_EQ(2, function_data.Count());
 }