A64: Synchronize with r16918.

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 182 matching lines @@
   v8::Script::Compile(v8::String::New(source))->Run();
   return v8::Local<v8::Function>::Cast(
       (*env)->Global()->Get(v8::String::New(function_name)));
 }
 
 
 // Compile and run the supplied source and return the requested function.
 static v8::Local<v8::Function> CompileFunction(const char* source,
                                                const char* function_name) {
   v8::Script::Compile(v8::String::New(source))->Run();
+  v8::Local<v8::Object> global =
+      CcTest::isolate()->GetCurrentContext()->Global();
   return v8::Local<v8::Function>::Cast(
-    v8::Context::GetCurrent()->Global()->Get(v8::String::New(function_name)));
+      global->Get(v8::String::New(function_name)));
 }
 
 
 // Is there any debug info for the function?
 static bool HasDebugInfo(v8::Handle<v8::Function> fun) {
   Handle<v8::internal::JSFunction> f = v8::Utils::OpenHandle(*fun);
   Handle<v8::internal::SharedFunctionInfo> shared(f->shared());
   return Debug::HasDebugInfo(shared);
 }
 
@@ skipping 4920 matching lines @@
       "  while ( flag == true ) {\n"
       "    if ( x == 1 ) {\n"
       "      ThreadedAtBarrier1();\n"
       "    }\n"
       "    x = x + 1;\n"
       "  }\n"
       "}\n"
       "\n"
       "foo();\n";
 
-  v8::V8::Initialize();
+  v8::Isolate::Scope isolate_scope(CcTest::isolate());
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetMessageHandler2(&ThreadedMessageHandler);
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
   global_template->Set(v8::String::New("ThreadedAtBarrier1"),
                        v8::FunctionTemplate::New(ThreadedAtBarrier1));
   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate(),
                                                      NULL,
                                                      global_template);
   v8::Context::Scope context_scope(context);
@@ skipping 16 matching lines @@
 
   v8::Isolate* isolate = CcTest::isolate();
   threaded_debugging_barriers.barrier_1.Wait();
   v8::Debug::DebugBreak(isolate);
   threaded_debugging_barriers.barrier_2.Wait();
   v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_1, buffer));
   v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_2, buffer));
 }
 
 
-UNINITIALIZED_TEST(ThreadedDebugging) {
+TEST(ThreadedDebugging) {
   DebuggerThread debugger_thread;
   V8Thread v8_thread;
 
   // Create a V8 environment
   v8_thread.Start();
   debugger_thread.Start();
 
   v8_thread.Join();
   debugger_thread.Join();
 }
@@ skipping 58 matching lines @@
     "  var x = 1;\n"
     "  x = y_global;"
     "  var z = 3;"
     "  x += 100;\n"
     "  return x;\n"
     "}\n"
     "\n";
   const char* source_2 = "cat(17);\n"
     "cat(19);\n";
 
-  v8::V8::Initialize();
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::Isolate::Scope isolate_scope(isolate);
   DebugLocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
+  v8::HandleScope scope(isolate);
   v8::Debug::SetMessageHandler2(&BreakpointsMessageHandler);
 
   CompileRun(source_1);
   breakpoints_barriers->barrier_1.Wait();
   breakpoints_barriers->barrier_2.Wait();
   CompileRun(source_2);
 }
 
 
 void BreakpointsDebuggerThread::Run() {
@@ skipping 52 matching lines @@
         "\"type\":\"request\","
         "\"command\":\"evaluate\","
         "\"arguments\":{\"expression\":\"dog()\",\"disable_break\":true}}";
   }
   const char* command_8 = "{\"seq\":108,"
       "\"type\":\"request\","
       "\"command\":\"continue\"}";
 
 
   v8::Isolate* isolate = CcTest::isolate();
+  v8::Isolate::Scope isolate_scope(isolate);
   // v8 thread initializes, runs source_1
   breakpoints_barriers->barrier_1.Wait();
   // 1:Set breakpoint in cat() (will get id 1).
   v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_1, buffer));
   // 2:Set breakpoint in dog() (will get id 2).
   v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_2, buffer));
   breakpoints_barriers->barrier_2.Wait();
   // V8 thread starts compiling source_2.
   // Automatic break happens, to run queued commands
   // breakpoints_barriers->semaphore_1.Wait();
@@ skipping 50 matching lines @@
   breakpoints_barriers = &stack_allocated_breakpoints_barriers;
 
   breakpoints_v8_thread.Start();
   breakpoints_debugger_thread.Start();
 
   breakpoints_v8_thread.Join();
   breakpoints_debugger_thread.Join();
 }
 
 
-UNINITIALIZED_TEST(RecursiveBreakpoints) {
+TEST(RecursiveBreakpoints) {
   TestRecursiveBreakpointsGeneric(false);
 }
 
 
-UNINITIALIZED_TEST(RecursiveBreakpointsGlobal) {
+TEST(RecursiveBreakpointsGlobal) {
   TestRecursiveBreakpointsGeneric(true);
 }
 
 
 static void DummyDebugEventListener(
     const v8::Debug::EventDetails& event_details) {
 }
 
 
 TEST(SetDebugEventListenerOnUninitializedVM) {
@@ skipping 360 matching lines @@
     "function cat( new_value ) {\n"
     "  var x = new_value;\n"
     "  y_global = 4;\n"
     "  x = 3 * x + 1;\n"
     "  y_global = 5;\n"
     "  return x;\n"
     "}\n"
     "\n";
   const char* source_2 = "cat(17);\n";
 
-  v8::V8::Initialize();
+  v8::Isolate::Scope isolate_scope(CcTest::isolate());
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Set up message and host dispatch handlers.
   v8::Debug::SetMessageHandler2(HostDispatchMessageHandler);
   v8::Debug::SetHostDispatchHandler(HostDispatchDispatchHandler, 10 /* ms */);
 
   CompileRun(source_1);
   host_dispatch_barriers->barrier_1.Wait();
   host_dispatch_barriers->barrier_2.Wait();
@@ skipping 22 matching lines @@
   host_dispatch_barriers->barrier_2.Wait();
   // v8 thread starts compiling source_2.
   // Break happens, to run queued commands and host dispatches.
   // Wait for host dispatch to be processed.
   host_dispatch_barriers->semaphore_1.Wait();
   // 2: Continue evaluation
   v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_2, buffer));
 }
 
 
-UNINITIALIZED_TEST(DebuggerHostDispatch) {
+TEST(DebuggerHostDispatch) {
   HostDispatchDebuggerThread host_dispatch_debugger_thread;
   HostDispatchV8Thread host_dispatch_v8_thread;
   i::FLAG_debugger_auto_break = true;
 
   // Create a V8 environment
   Barriers stack_allocated_host_dispatch_barriers;
   host_dispatch_barriers = &stack_allocated_host_dispatch_barriers;
 
   host_dispatch_v8_thread.Start();
   host_dispatch_debugger_thread.Start();
@@ skipping 24 matching lines @@
 
 Barriers* debug_message_dispatch_barriers;
 
 
 static void DebugMessageHandler() {
   debug_message_dispatch_barriers->semaphore_1.Signal();
 }
 
 
 void DebugMessageDispatchV8Thread::Run() {
-  v8::V8::Initialize();
+  v8::Isolate::Scope isolate_scope(CcTest::isolate());
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Set up debug message dispatch handler.
   v8::Debug::SetDebugMessageDispatchHandler(DebugMessageHandler);
 
   CompileRun("var y = 1 + 2;\n");
   debug_message_dispatch_barriers->barrier_1.Wait();
   debug_message_dispatch_barriers->semaphore_1.Wait();
   debug_message_dispatch_barriers->barrier_2.Wait();
 }
 
 
 void DebugMessageDispatchDebuggerThread::Run() {
   debug_message_dispatch_barriers->barrier_1.Wait();
   SendContinueCommand();
   debug_message_dispatch_barriers->barrier_2.Wait();
 }
 
 
-UNINITIALIZED_TEST(DebuggerDebugMessageDispatch) {
+TEST(DebuggerDebugMessageDispatch) {
   DebugMessageDispatchDebuggerThread debug_message_dispatch_debugger_thread;
   DebugMessageDispatchV8Thread debug_message_dispatch_v8_thread;
 
   i::FLAG_debugger_auto_break = true;
 
   // Create a V8 environment
   Barriers stack_allocated_debug_message_dispatch_barriers;
   debug_message_dispatch_barriers =
       &stack_allocated_debug_message_dispatch_barriers;
 
@@ skipping 444 matching lines @@
         last_function_hit[0] = '\0';
       } else {
         CHECK(result->IsString());
         v8::Handle<v8::String> function_name(result->ToString());
         function_name->WriteUtf8(last_function_hit);
       }
     }
 
     // Keep forcing breaks.
     if (break_point_hit_count < 20) {
-      v8::Debug::DebugBreak();
+      v8::Debug::DebugBreak(CcTest::isolate());
     }
   }
 }
 
 
-UNINITIALIZED_TEST(RegExpDebugBreak) {
+TEST(RegExpDebugBreak) {
   // This test only applies to native regexps.
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   // Test RegExp which matches white spaces and comments at the begining of a
@@ skipping 415 matching lines @@
       isolate->stack_guard()->DebugBreak();
     } else {
       isolate->stack_guard()->Continue(i::DEBUGBREAK);
     }
   }
 }
 
 
 // Test that if DebugBreak is forced it is ignored when code from
 // debug-delay.js is executed.
-UNINITIALIZED_TEST(NoDebugBreakInAfterCompileMessageHandler) {
+TEST(NoDebugBreakInAfterCompileMessageHandler) {
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Register a debug event listener which sets the break flag and counts.
   v8::Debug::SetMessageHandler2(BreakMessageHandler);
 
   // Set the debug break flag.
-  v8::Debug::DebugBreak();
+  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());
@@ skipping 171 matching lines @@
 v8::Handle<v8::Context> debugee_context;
 v8::Handle<v8::Context> debugger_context;
 
 
 // Property getter that checks that current and calling contexts
 // are both the debugee contexts.
 static void NamedGetterWithCallingContextCheck(
     v8::Local<v8::String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK_EQ(0, strcmp(*v8::String::Utf8Value(name), "a"));
-  v8::Handle<v8::Context> current = v8::Context::GetCurrent();
+  v8::Handle<v8::Context> current = info.GetIsolate()->GetCurrentContext();
   CHECK(current == debugee_context);
   CHECK(current != debugger_context);
-  v8::Handle<v8::Context> calling = v8::Context::GetCalling();
+  v8::Handle<v8::Context> calling = info.GetIsolate()->GetCallingContext();
   CHECK(calling == debugee_context);
   CHECK(calling != debugger_context);
   info.GetReturnValue().Set(1);
 }
 
 
 // Debug event listener that checks if the first argument of a function is
 // an object with property 'a' == 1. If the property has custom accessor
 // this handler will eventually invoke it.
 static void DebugEventGetAtgumentPropertyValue(
     const v8::Debug::EventDetails& event_details) {
   v8::DebugEvent event = event_details.GetEvent();
   v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
   if (event == v8::Break) {
     break_point_hit_count++;
-    CHECK(debugger_context == v8::Context::GetCurrent());
+    CHECK(debugger_context == CcTest::isolate()->GetCurrentContext());
     v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(CompileRun(
         "(function(exec_state) {\n"
         "    return (exec_state.frame(0).argumentValue(0).property('a').\n"
         "            value().value() == 1);\n"
         "})"));
     const int argc = 1;
     v8::Handle<v8::Value> argv[argc] = { exec_state };
     v8::Handle<v8::Value> result = func->Call(exec_state, argc, argv);
     CHECK(result->IsTrue());
   }
@@ skipping 511 matching lines @@
 TEST(LiveEditDisabled) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetLiveEditEnabled(false), env->GetIsolate();
   CompileRun("%LiveEditCompareStrings('', '')");
 }
 
 
 #endif  // ENABLE_DEBUGGER_SUPPORT