Various extension-related cleanup and simplifications.

test/cctest/test-cpu-profiler.cc

 // Copyright 2010 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 382 matching lines @@
 
   v8::Local<v8::String> profile_name =
       v8::String::NewFromUtf8(env->GetIsolate(), "test");
   cpu_profiler->StartCpuProfiling(profile_name);
   const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name);
   CHECK(profile->GetStartTime() <= profile->GetEndTime());
 }
 
 
 static const v8::CpuProfile* RunProfiler(
-    LocalContext& env, v8::Handle<v8::Function> function,
+    v8::Handle<v8::Context> env, v8::Handle<v8::Function> function,
     v8::Handle<v8::Value> argv[], int argc,
     unsigned min_js_samples) {
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   v8::Local<v8::String> profile_name =
       v8::String::NewFromUtf8(env->GetIsolate(), "my_profile");
 
   cpu_profiler->StartCpuProfiling(profile_name);
 
   i::Sampler* sampler =
       reinterpret_cast<i::Isolate*>(env->GetIsolate())->logger()->sampler();
@@ skipping 133 matching lines @@
   v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
                                               cpu_profiler_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t profiling_interval_ms = 200;
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), profiling_interval_ms)
   };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 200);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 200);
   function->Call(env->Global(), ARRAY_SIZE(args), args);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
 
   ScopedVector<v8::Handle<v8::String> > names(3);
   names[0] = v8::String::NewFromUtf8(
       env->GetIsolate(), ProfileGenerator::kGarbageCollectorEntryName);
   names[1] = v8::String::NewFromUtf8(env->GetIsolate(),
                                      ProfileGenerator::kProgramEntryName);
   names[2] = v8::String::NewFromUtf8(env->GetIsolate(), "start");
@@ skipping 53 matching lines @@
 
   int32_t repeat_count = 100;
 #if defined(USE_SIMULATOR)
   // Simulators are much slower.
   repeat_count = 1;
 #endif
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), repeat_count)
   };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
 
   ScopedVector<v8::Handle<v8::String> > names(3);
   names[0] = v8::String::NewFromUtf8(
       env->GetIsolate(), ProfileGenerator::kGarbageCollectorEntryName);
   names[1] = v8::String::NewFromUtf8(env->GetIsolate(),
                                      ProfileGenerator::kProgramEntryName);
   names[2] = v8::String::NewFromUtf8(env->GetIsolate(), "start");
   CheckChildrenNames(root, names);
@@ skipping 99 matching lines @@
 
   v8::Script::Compile(
       v8::String::NewFromUtf8(isolate, native_accessor_test_source))
       ->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::NewFromUtf8(isolate, "start")));
 
   int32_t repeat_count = 1;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(isolate, repeat_count) };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 180);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 180);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   const v8::CpuProfileNode* startNode =
       GetChild(isolate, root, "start");
   GetChild(isolate, startNode, "get foo");
   GetChild(isolate, startNode, "set foo");
 
   const_cast<v8::CpuProfile*>(profile)->Delete();
 }
 
@@ skipping 36 matching lines @@
     v8::Handle<v8::Value> args[] = {
       v8::Integer::New(isolate, warm_up_iterations)
     };
     function->Call(env->Global(), ARRAY_SIZE(args), args);
     accessors.set_warming_up(false);
   }
 
   int32_t repeat_count = 100;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(isolate, repeat_count) };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 200);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 200);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   const v8::CpuProfileNode* startNode =
       GetChild(isolate, root, "start");
   GetChild(isolate, startNode, "get foo");
   GetChild(isolate, startNode, "set foo");
 
   const_cast<v8::CpuProfile*>(profile)->Delete();
 }
 
@@ skipping 33 matching lines @@
                      instance);
 
   v8::Script::Compile(v8::String::NewFromUtf8(
                           isolate, native_method_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::NewFromUtf8(isolate, "start")));
 
   int32_t repeat_count = 1;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(isolate, repeat_count) };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   const v8::CpuProfileNode* startNode =
       GetChild(isolate, root, "start");
   GetChild(isolate, startNode, "fooMethod");
 
   const_cast<v8::CpuProfile*>(profile)->Delete();
 }
 
 
@@ skipping 36 matching lines @@
     v8::Handle<v8::Value> args[] = {
       v8::Integer::New(isolate, warm_up_iterations)
     };
     function->Call(env->Global(), ARRAY_SIZE(args), args);
     callbacks.set_warming_up(false);
   }
 
   int32_t repeat_count = 100;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(isolate, repeat_count) };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   GetChild(isolate, root, "start");
   const v8::CpuProfileNode* startNode =
       GetChild(isolate, root, "start");
   GetChild(isolate, startNode, "fooMethod");
 
   const_cast<v8::CpuProfile*>(profile)->Delete();
 }
 
@@ skipping 20 matching lines @@
       v8::String::NewFromUtf8(env->GetIsolate(), bound_function_test_source))
       ->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 100;
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), duration_ms)
   };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   ScopedVector<v8::Handle<v8::String> > names(3);
   names[0] = v8::String::NewFromUtf8(
       env->GetIsolate(), ProfileGenerator::kGarbageCollectorEntryName);
   names[1] = v8::String::NewFromUtf8(env->GetIsolate(),
                                      ProfileGenerator::kProgramEntryName);
   names[2] = v8::String::NewFromUtf8(env->GetIsolate(), "start");
   // Don't allow |foo| node to be at the top level.
   CheckChildrenNames(root, names);
@@ skipping 40 matching lines @@
   v8::Script::Compile(v8::String::NewFromUtf8(
                           env->GetIsolate(), call_function_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 100;
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), duration_ms)
   };
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   {
     ScopedVector<v8::Handle<v8::String> > names(4);
     names[0] = v8::String::NewFromUtf8(
         env->GetIsolate(), ProfileGenerator::kGarbageCollectorEntryName);
     names[1] = v8::String::NewFromUtf8(env->GetIsolate(),
                                        ProfileGenerator::kProgramEntryName);
     names[2] = v8::String::NewFromUtf8(env->GetIsolate(), "start");
     names[3] = v8::String::NewFromUtf8(
@@ skipping 62 matching lines @@
       ->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 100;
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), duration_ms)
   };
 
   const v8::CpuProfile* profile =
-      RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
+      RunProfiler(env.local(), function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   {
     ScopedVector<v8::Handle<v8::String> > names(3);
     names[0] = v8::String::NewFromUtf8(
         env->GetIsolate(), ProfileGenerator::kGarbageCollectorEntryName);
     names[1] = v8::String::NewFromUtf8(env->GetIsolate(),
                                        ProfileGenerator::kProgramEntryName);
     names[2] = v8::String::NewFromUtf8(env->GetIsolate(), "start");
     // Don't allow |test|, |bar| and |apply| nodes to be at the top level.
@@ skipping 65 matching lines @@
 
 
 // [Top down]:
 //    58     0   (root) #0 1
 //     2     2    (program) #0 2
 //    56     1    start #16 3
 //    55     0      CallJsFunction #0 4
 //    55     1        bar #16 5
 //    54    54          foo #16 6
 TEST(JsNativeJsSample) {
-  const char* extensions[] = { "v8/profiler" };
-  v8::ExtensionConfiguration config(1, extensions);
-  LocalContext env(&config);
-  v8::HandleScope scope(env->GetIsolate());
+  v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> env = CcTest::NewContext(PROFILER_EXTENSION);
+  v8::Context::Scope context_scope(env);
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       env->GetIsolate(), CallJsFunction);
   v8::Local<v8::Function> func = func_template->GetFunction();
   func->SetName(v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"));
   env->Global()->Set(
       v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"), func);
 
   v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
                                               js_native_js_test_source))->Run();
@@ skipping 61 matching lines @@
 
 
 // [Top down]:
 //    57     0   (root) #0 1
 //    55     1    start #16 3
 //    54     0      CallJsFunction #0 4
 //    54     3        bar #16 5
 //    51    51          foo #16 6
 //     2     2    (program) #0 2
 TEST(JsNativeJsRuntimeJsSample) {
-  const char* extensions[] = { "v8/profiler" };
-  v8::ExtensionConfiguration config(1, extensions);
-  LocalContext env(&config);
-  v8::HandleScope scope(env->GetIsolate());
+  v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> env = CcTest::NewContext(PROFILER_EXTENSION);
+  v8::Context::Scope context_scope(env);
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       env->GetIsolate(), CallJsFunction);
   v8::Local<v8::Function> func = func_template->GetFunction();
   func->SetName(v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"));
   env->Global()->Set(
       v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"), func);
 
   v8::Script::Compile(
       v8::String::NewFromUtf8(env->GetIsolate(),
@@ skipping 65 matching lines @@
 
 // [Top down]:
 //    57     0   (root) #0 1
 //    55     1    start #16 3
 //    54     0      CallJsFunction1 #0 4
 //    54     0        bar #16 5
 //    54     0          CallJsFunction2 #0 6
 //    54    54            foo #16 7
 //     2     2    (program) #0 2
 TEST(JsNative1JsNative2JsSample) {
-  const char* extensions[] = { "v8/profiler" };
-  v8::ExtensionConfiguration config(1, extensions);
-  LocalContext env(&config);
-  v8::HandleScope scope(env->GetIsolate());
+  v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> env = CcTest::NewContext(PROFILER_EXTENSION);
+  v8::Context::Scope context_scope(env);
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       env->GetIsolate(), CallJsFunction);
   v8::Local<v8::Function> func1 = func_template->GetFunction();
   func1->SetName(v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction1"));
   env->Global()->Set(
       v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction1"), func1);
 
   v8::Local<v8::Function> func2 = v8::FunctionTemplate::New(
       env->GetIsolate(), CallJsFunction2)->GetFunction();
@@ skipping 109 matching lines @@
            node->GetFunctionName());
   CHECK_EQ(v8::String::NewFromUtf8(isolate, script_name),
            node->GetScriptResourceName());
   CHECK_EQ(script_id, node->GetScriptId());
   CHECK_EQ(line, node->GetLineNumber());
   CHECK_EQ(column, node->GetColumnNumber());
 }
 
 
 TEST(FunctionDetails) {
-  const char* extensions[] = { "v8/profiler" };
-  v8::ExtensionConfiguration config(1, extensions);
-  LocalContext env(&config);
-  v8::HandleScope handleScope(env->GetIsolate());
+  v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> env = CcTest::NewContext(PROFILER_EXTENSION);
+  v8::Context::Scope context_scope(env);
 
   v8::Handle<v8::Script> script_a = v8::Script::Compile(
       v8::String::NewFromUtf8(
           env->GetIsolate(),
           "    function foo\n() { try { bar(); } catch(e) {} }\n"
           " function bar() { startProfiling(); }\n"),
       v8::String::NewFromUtf8(env->GetIsolate(), "script_a"));
   script_a->Run();
   v8::Handle<v8::Script> script_b = v8::Script::Compile(
       v8::String::NewFromUtf8(
           env->GetIsolate(),
           "\n\n   function baz() { try { foo(); } catch(e) {} }\n"
           "\n\nbaz();\n"
           "stopProfiling();\n"),
       v8::String::NewFromUtf8(env->GetIsolate(), "script_b"));
   script_b->Run();
-  const v8::CpuProfile* profile = ProfilerExtension::last_profile;
+  const v8::CpuProfile* profile = i::ProfilerExtension::last_profile;
   const v8::CpuProfileNode* current = profile->GetTopDownRoot();
   reinterpret_cast<ProfileNode*>(
       const_cast<v8::CpuProfileNode*>(current))->Print(0);
   // The tree should look like this:
   //  0   (root) 0 #1
   //  0    (anonymous function) 19 #2 no reason script_b:1
   //  0      baz 19 #3 TryCatchStatement script_b:3
   //  0        foo 18 #4 TryCatchStatement script_a:2
   //  1          bar 18 #5 no reason script_a:3
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   const v8::CpuProfileNode* script = GetChild(env->GetIsolate(), root,
       ProfileGenerator::kAnonymousFunctionName);
   CheckFunctionDetails(env->GetIsolate(), script,
                        ProfileGenerator::kAnonymousFunctionName, "script_b",
                        script_b->GetId(), 1, 1);
   const v8::CpuProfileNode* baz = GetChild(env->GetIsolate(), script, "baz");
   CheckFunctionDetails(env->GetIsolate(), baz, "baz", "script_b",
                        script_b->GetId(), 3, 16);
   const v8::CpuProfileNode* foo = GetChild(env->GetIsolate(), baz, "foo");
   CheckFunctionDetails(env->GetIsolate(), foo, "foo", "script_a",
                        script_a->GetId(), 2, 1);
   const v8::CpuProfileNode* bar = GetChild(env->GetIsolate(), foo, "bar");
   CheckFunctionDetails(env->GetIsolate(), bar, "bar", "script_a",
                        script_a->GetId(), 3, 14);
 }
 
 
 TEST(DontStopOnFinishedProfileDelete) {
-  const char* extensions[] = { "v8/profiler" };
-  v8::ExtensionConfiguration config(1, extensions);
-  LocalContext env(&config);
+  v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> env = CcTest::NewContext(PROFILER_EXTENSION);
+  v8::Context::Scope context_scope(env);
   v8::Isolate* isolate = env->GetIsolate();
-  v8::HandleScope handleScope(isolate);
 
   v8::CpuProfiler* profiler = env->GetIsolate()->GetCpuProfiler();
   i::CpuProfiler* iprofiler = reinterpret_cast<i::CpuProfiler*>(profiler);
 
   CHECK_EQ(0, iprofiler->GetProfilesCount());
   v8::Handle<v8::String> outer = v8::String::NewFromUtf8(isolate, "outer");
   profiler->StartCpuProfiling(outer);
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 
   v8::Handle<v8::String> inner = v8::String::NewFromUtf8(isolate, "inner");
   profiler->StartCpuProfiling(inner);
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 
   const v8::CpuProfile* inner_profile = profiler->StopCpuProfiling(inner);
   CHECK(inner_profile);
   CHECK_EQ(1, iprofiler->GetProfilesCount());
   const_cast<v8::CpuProfile*>(inner_profile)->Delete();
   inner_profile = NULL;
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 
   const v8::CpuProfile* outer_profile = profiler->StopCpuProfiling(outer);
   CHECK(outer_profile);
   CHECK_EQ(1, iprofiler->GetProfilesCount());
   const_cast<v8::CpuProfile*>(outer_profile)->Delete();
   outer_profile = NULL;
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 }