[debug] Revert debug API removal

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 4107 matching lines @@
       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());
+  CHECK(v8::Debug::CheckDebugBreak(env->GetIsolate()));
 

[Yang, 2016/12/01 09:04:33]

Let's not restore tests.

   // 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();
   }
 
   // One break for each function called.
@@ 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());
+  CHECK(v8::Debug::CheckDebugBreak(env->GetIsolate()));
   v8::Debug::CancelDebugBreak(env->GetIsolate());
+  CHECK(!v8::Debug::CheckDebugBreak(env->GetIsolate()));
 
   // Set the debug break flag.
   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);
 
   {
@@ skipping 1078 matching lines @@
   // Enter and run function in the second context.
   {
     v8::Context::Scope context_scope(context_2);
     expected_context = context_2;
     expected_context_data = data_2;
     v8::Local<v8::Function> f = CompileFunction(isolate, source, "f");
     f->Call(context_2, context_2->Global(), 0, NULL).ToLocalChecked();
   }
 
   // Two times compile event and two times break event.
-  CHECK_GT(event_listener_hit_count, 3);
+  CHECK_GT(event_listener_hit_count, 4);
 
   v8::Debug::SetDebugEventListener(isolate, nullptr);
   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) {
@@ skipping 401 matching lines @@
   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(GetMirror) {
+  DebugLocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+  v8::Local<v8::Context> context = env.context();
+  v8::Local<v8::Value> obj =
+      v8::Debug::GetMirror(context, v8_str(isolate, "hodja")).ToLocalChecked();
+  v8::ScriptCompiler::Source source(
+      v8_str("function runTest(mirror) {"
+             "  return mirror.isString() && (mirror.length() == 5);"
+             "}"
+             ""
+             "runTest;"));
+  v8::Local<v8::Function> run_test = v8::Local<v8::Function>::Cast(
+      v8::ScriptCompiler::CompileUnboundScript(isolate, &source)
+          .ToLocalChecked()
+          ->BindToCurrentContext()
+          ->Run(context)
+          .ToLocalChecked());
+  v8::Local<v8::Value> result =
+      run_test->Call(context, env->Global(), 1, &obj).ToLocalChecked();
+  CHECK(result->IsTrue());
+}
 
 // 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,
@@ skipping 119 matching lines @@
 }
 
 
 TEST(NoDebugContextWhenDebuggerDisabled) {
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> context =
       v8::Debug::GetDebugContext(CcTest::isolate());
   CHECK(context.IsEmpty());
 }
 
+static void DebugEventCheckContext(
+    const v8::Debug::EventDetails& event_details) {
+  if (event_details.GetEvent() == v8::Break) {
+    v8::Isolate* isolate = event_details.GetIsolate();
+    CHECK(v8::Debug::GetDebuggedContext(isolate)
+              .ToLocalChecked()
+              ->Global()
+              ->Equals(isolate->GetCurrentContext(),
+                       event_details.GetEventContext()->Global())
+              .FromJust());
+  }
+}
+
+static void CheckContext(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK(v8::Debug::GetDebuggedContext(args.GetIsolate()).IsEmpty());
+}
+
+TEST(DebuggedContext) {
+  DebugLocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+
+  v8::Debug::SetDebugEventListener(isolate, DebugEventCheckContext);
+
+  v8::Local<v8::Function> foo =
+      CompileFunction(&env, "function foo(){bar=0;}", "foo");
+
+  SetBreakPoint(foo, 0);
+  foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
+
+  v8::Local<v8::Function> fun = v8::FunctionTemplate::New(isolate, CheckContext)
+                                    ->GetFunction(env.context())
+                                    .ToLocalChecked();
+  fun->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
+}
+
 static v8::Local<v8::Value> expected_callback_data;
 static void DebugEventContextChecker(const v8::Debug::EventDetails& details) {
   CHECK(details.GetEventContext() == expected_context);
   CHECK(expected_callback_data->Equals(details.GetEventContext(),
                                        details.GetCallbackData())
             .FromJust());
 }
 
 
 // Check that event details contain context where debug event occured.
@@ skipping 961 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);
 }