Prepare removal of ObjectTemplate::New without Isolate parameter.

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 4337 matching lines @@
 
 static void IndexedGetter(uint32_t index,
                           const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(static_cast<double>(index + 1));
 }
 
 
 TEST(InterceptorPropertyMirror) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
   env.ExposeDebug();
 
   // Create object with named interceptor.
-  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
+  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
   named->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
   env->Global()->Set(
-      v8::String::NewFromUtf8(env->GetIsolate(), "intercepted_named"),
+      v8::String::NewFromUtf8(isolate, "intercepted_named"),
       named->NewInstance());
 
   // Create object with indexed interceptor.
-  v8::Handle<v8::ObjectTemplate> indexed = v8::ObjectTemplate::New();
+  v8::Handle<v8::ObjectTemplate> indexed = v8::ObjectTemplate::New(isolate);
   indexed->SetIndexedPropertyHandler(IndexedGetter,
                                      NULL,
                                      NULL,
                                      NULL,
                                      IndexedEnum);
   env->Global()->Set(
-      v8::String::NewFromUtf8(env->GetIsolate(), "intercepted_indexed"),
+      v8::String::NewFromUtf8(isolate, "intercepted_indexed"),
       indexed->NewInstance());
 
   // Create object with both named and indexed interceptor.
-  v8::Handle<v8::ObjectTemplate> both = v8::ObjectTemplate::New();
+  v8::Handle<v8::ObjectTemplate> both = v8::ObjectTemplate::New(isolate);
   both->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
   both->SetIndexedPropertyHandler(IndexedGetter, NULL, NULL, NULL, IndexedEnum);
   env->Global()->Set(
-      v8::String::NewFromUtf8(env->GetIsolate(), "intercepted_both"),
+      v8::String::NewFromUtf8(isolate, "intercepted_both"),
       both->NewInstance());
 
   // Get mirrors for the three objects with interceptor.
   CompileRun(
       "var named_mirror = debug.MakeMirror(intercepted_named);"
       "var indexed_mirror = debug.MakeMirror(intercepted_indexed);"
       "var both_mirror = debug.MakeMirror(intercepted_both)");
   CHECK(CompileRun(
        "named_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CHECK(CompileRun(
@@ skipping 195 matching lines @@
 static void ProtperyXNativeGetter(
     v8::Local<v8::String> property,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(10);
 }
 
 
 TEST(NativeGetterPropertyMirror) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
   env.ExposeDebug();
 
-  v8::Handle<v8::String> name = v8::String::NewFromUtf8(env->GetIsolate(), "x");
+  v8::Handle<v8::String> name = v8::String::NewFromUtf8(isolate, "x");
   // Create object with named accessor.
-  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
+  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
   named->SetAccessor(name, &ProtperyXNativeGetter, NULL,
       v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
 
   // Create object with named property getter.
-  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+  env->Global()->Set(v8::String::NewFromUtf8(isolate, "instance"),
                      named->NewInstance());
   CHECK_EQ(10, CompileRun("instance.x")->Int32Value());
 
   // Get mirror for the object with property getter.
   CompileRun("var instance_mirror = debug.MakeMirror(instance);");
   CHECK(CompileRun(
       "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
 
   CompileRun("var named_names = instance_mirror.propertyNames();");
   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
   CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
   CHECK(CompileRun(
       "instance_mirror.property('x').value().isNumber()")->BooleanValue());
   CHECK(CompileRun(
       "instance_mirror.property('x').value().value() == 10")->BooleanValue());
 }
 
 
 static void ProtperyXNativeGetterThrowingError(
     v8::Local<v8::String> property,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   CompileRun("throw new Error('Error message');");
 }
 
 
 TEST(NativeGetterThrowingErrorPropertyMirror) {
   // Create a V8 environment with debug access.
   DebugLocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
   env.ExposeDebug();
 
-  v8::Handle<v8::String> name = v8::String::NewFromUtf8(env->GetIsolate(), "x");
+  v8::Handle<v8::String> name = v8::String::NewFromUtf8(isolate, "x");
   // Create object with named accessor.
-  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
+  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
   named->SetAccessor(name, &ProtperyXNativeGetterThrowingError, NULL,
       v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
 
   // Create object with named property getter.
-  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+  env->Global()->Set(v8::String::NewFromUtf8(isolate, "instance"),
                      named->NewInstance());
 
   // Get mirror for the object with property getter.
   CompileRun("var instance_mirror = debug.MakeMirror(instance);");
   CHECK(CompileRun(
       "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
   CompileRun("named_names = instance_mirror.propertyNames();");
   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
   CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
   CHECK(CompileRun(
@@ skipping 549 matching lines @@
       "  while ( flag == true ) {\n"
       "    if ( x == 1 ) {\n"
       "      ThreadedAtBarrier1();\n"
       "    }\n"
       "    x = x + 1;\n"
       "  }\n"
       "}\n"
       "\n"
       "foo();\n";
 
-  v8::Isolate::Scope isolate_scope(CcTest::isolate());
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::Isolate::Scope isolate_scope(isolate);
   DebugLocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetMessageHandler2(&ThreadedMessageHandler);
-  v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
+  v8::Handle<v8::ObjectTemplate> global_template =
+      v8::ObjectTemplate::New(env->GetIsolate());
   global_template->Set(
       v8::String::NewFromUtf8(env->GetIsolate(), "ThreadedAtBarrier1"),
-      v8::FunctionTemplate::New(CcTest::isolate(), ThreadedAtBarrier1));
-  v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate(),
+      v8::FunctionTemplate::New(isolate, ThreadedAtBarrier1));
+  v8::Handle<v8::Context> context = v8::Context::New(isolate,
                                                      NULL,
                                                      global_template);
   v8::Context::Scope context_scope(context);
 
   CompileRun(source);
 }
 
 
 void DebuggerThread::Run() {
   const int kBufSize = 1000;
@@ skipping 335 matching lines @@
 static void CheckClosure(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(v8::Debug::Call(debugger_call_with_closure)->IsNumber());
   CHECK_EQ(3, v8::Debug::Call(debugger_call_with_closure)->Int32Value());
 }
 
 
 // Test functions called through the debugger.
 TEST(CallFunctionInDebugger) {
   // Create and enter a context with the functions CheckFrameCount,
   // CheckSourceLine and CheckDataParameter installed.
-  v8::HandleScope scope(CcTest::isolate());
-  v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::HandleScope scope(isolate);
+  v8::Handle<v8::ObjectTemplate> global_template =
+      v8::ObjectTemplate::New(isolate);
   global_template->Set(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckFrameCount"),
-      v8::FunctionTemplate::New(CcTest::isolate(), CheckFrameCount));
+      v8::String::NewFromUtf8(isolate, "CheckFrameCount"),
+      v8::FunctionTemplate::New(isolate, CheckFrameCount));
   global_template->Set(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckSourceLine"),
-      v8::FunctionTemplate::New(CcTest::isolate(), CheckSourceLine));
+      v8::String::NewFromUtf8(isolate, "CheckSourceLine"),
+      v8::FunctionTemplate::New(isolate, CheckSourceLine));
   global_template->Set(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckDataParameter"),
-      v8::FunctionTemplate::New(CcTest::isolate(), CheckDataParameter));
+      v8::String::NewFromUtf8(isolate, "CheckDataParameter"),
+      v8::FunctionTemplate::New(isolate, CheckDataParameter));
   global_template->Set(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckClosure"),
-      v8::FunctionTemplate::New(CcTest::isolate(), CheckClosure));
-  v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate(),
+      v8::String::NewFromUtf8(isolate, "CheckClosure"),
+      v8::FunctionTemplate::New(isolate, CheckClosure));
+  v8::Handle<v8::Context> context = v8::Context::New(isolate,
                                                      NULL,
                                                      global_template);
   v8::Context::Scope context_scope(context);
 
   // Compile a function for checking the number of JavaScript frames.
   v8::Script::Compile(
-      v8::String::NewFromUtf8(CcTest::isolate(), frame_count_source))->Run();
+      v8::String::NewFromUtf8(isolate, frame_count_source))->Run();
   frame_count = v8::Local<v8::Function>::Cast(context->Global()->Get(
-      v8::String::NewFromUtf8(CcTest::isolate(), "frame_count")));
+      v8::String::NewFromUtf8(isolate, "frame_count")));
 
   // Compile a function for returning the source line for the top frame.
-  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate,
                                               frame_source_line_source))->Run();
   frame_source_line = v8::Local<v8::Function>::Cast(context->Global()->Get(
-      v8::String::NewFromUtf8(CcTest::isolate(), "frame_source_line")));
+      v8::String::NewFromUtf8(isolate, "frame_source_line")));
 
   // Compile a function returning the data parameter.
-  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate,
                                               debugger_call_with_data_source))
       ->Run();
   debugger_call_with_data = v8::Local<v8::Function>::Cast(
       context->Global()->Get(v8::String::NewFromUtf8(
-          CcTest::isolate(), "debugger_call_with_data")));
+          isolate, "debugger_call_with_data")));
 
   // Compile a function capturing closure.
   debugger_call_with_closure =
       v8::Local<v8::Function>::Cast(v8::Script::Compile(
-          v8::String::NewFromUtf8(CcTest::isolate(),
+          v8::String::NewFromUtf8(isolate,
                                   debugger_call_with_closure_source))->Run());
 
   // Calling a function through the debugger returns 0 frames if there are
   // no JavaScript frames.
-  CHECK_EQ(v8::Integer::New(CcTest::isolate(), 0),
+  CHECK_EQ(v8::Integer::New(isolate, 0),
            v8::Debug::Call(frame_count));
 
   // Test that the number of frames can be retrieved.
   v8::Script::Compile(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckFrameCount(1)"))->Run();
-  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+      v8::String::NewFromUtf8(isolate, "CheckFrameCount(1)"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate,
                                               "function f() {"
                                               "  CheckFrameCount(2);"
                                               "}; f()"))->Run();
 
   // Test that the source line can be retrieved.
   v8::Script::Compile(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckSourceLine(0)"))->Run();
-  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+      v8::String::NewFromUtf8(isolate, "CheckSourceLine(0)"))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate,
                                               "function f() {\n"
                                               "  CheckSourceLine(1)\n"
                                               "  CheckSourceLine(2)\n"
                                               "  CheckSourceLine(3)\n"
                                               "}; f()"))->Run();
 
   // Test that a parameter can be passed to a function called in the debugger.
-  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate,
                                               "CheckDataParameter()"))->Run();
 
   // Test that a function with closure can be run in the debugger.
   v8::Script::Compile(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckClosure()"))->Run();
+      v8::String::NewFromUtf8(isolate, "CheckClosure()"))->Run();
 
   // Test that the source line is correct when there is a line offset.
-  v8::ScriptOrigin origin(v8::String::NewFromUtf8(CcTest::isolate(), "test"),
-                          v8::Integer::New(CcTest::isolate(), 7));
+  v8::ScriptOrigin origin(v8::String::NewFromUtf8(isolate, "test"),
+                          v8::Integer::New(isolate, 7));
   v8::Script::Compile(
-      v8::String::NewFromUtf8(CcTest::isolate(), "CheckSourceLine(7)"), &origin)
+      v8::String::NewFromUtf8(isolate, "CheckSourceLine(7)"), &origin)
       ->Run();
-  v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(),
+  v8::Script::Compile(v8::String::NewFromUtf8(isolate,
                                               "function f() {\n"
                                               "  CheckSourceLine(8)\n"
                                               "  CheckSourceLine(9)\n"
                                               "  CheckSourceLine(10)\n"
                                               "}; f()"),
                       &origin)->Run();
 }
 
 
 // Debugger message handler which counts the number of breaks.
@@ skipping 1484 matching lines @@
     v8::Handle<v8::Value> result = func->Call(exec_state, argc, argv);
     CHECK(result->IsTrue());
   }
 }
 
 
 TEST(CallingContextIsNotDebugContext) {
   v8::internal::Debug* debug = CcTest::i_isolate()->debug();
   // Create and enter a debugee context.
   DebugLocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
   env.ExposeDebug();
 
   // Save handles to the debugger and debugee contexts to be used in
   // NamedGetterWithCallingContextCheck.
   debugee_context = env.context();
   debugger_context = v8::Utils::ToLocal(debug->debug_context());
 
   // Create object with 'a' property accessor.
-  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
-  named->SetAccessor(v8::String::NewFromUtf8(env->GetIsolate(), "a"),
+  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
+  named->SetAccessor(v8::String::NewFromUtf8(isolate, "a"),
                      NamedGetterWithCallingContextCheck);
-  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "obj"),
+  env->Global()->Set(v8::String::NewFromUtf8(isolate, "obj"),
                      named->NewInstance());
 
   // Register the debug event listener
   v8::Debug::SetDebugEventListener2(DebugEventGetAtgumentPropertyValue);
 
   // Create a function that invokes debugger.
   v8::Local<v8::Function> foo = CompileFunction(
       &env,
       "function bar(x) { debugger; }"
       "function foo(){ bar(obj); }",
@@ skipping 498 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