Remove usage of deprecated APIs from cctests

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 337 matching lines @@
   return NULL;
 }
 
 
 TEST(DeleteCpuProfile) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
 
   CHECK_EQ(0, cpu_profiler->GetProfileCount());
-  v8::Local<v8::String> name1 = v8::String::New("1");
+  v8::Local<v8::String> name1 = v8::String::NewFromUtf8(env->GetIsolate(), "1");
   cpu_profiler->StartCpuProfiling(name1);
   const v8::CpuProfile* p1 = cpu_profiler->StopCpuProfiling(name1);
   CHECK_NE(NULL, p1);
   CHECK_EQ(1, cpu_profiler->GetProfileCount());
   unsigned uid1 = p1->GetUid();
   CHECK_EQ(p1, FindCpuProfile(cpu_profiler, uid1));
   const_cast<v8::CpuProfile*>(p1)->Delete();
   CHECK_EQ(0, cpu_profiler->GetProfileCount());
   CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1));
 
-  v8::Local<v8::String> name2 = v8::String::New("2");
+  v8::Local<v8::String> name2 = v8::String::NewFromUtf8(env->GetIsolate(), "2");
   cpu_profiler->StartCpuProfiling(name2);
   const v8::CpuProfile* p2 = cpu_profiler->StopCpuProfiling(name2);
   CHECK_NE(NULL, p2);
   CHECK_EQ(1, cpu_profiler->GetProfileCount());
   unsigned uid2 = p2->GetUid();
   CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid2));
   CHECK_EQ(p2, FindCpuProfile(cpu_profiler, uid2));
   CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1));
-  v8::Local<v8::String> name3 = v8::String::New("3");
+  v8::Local<v8::String> name3 = v8::String::NewFromUtf8(env->GetIsolate(), "3");
   cpu_profiler->StartCpuProfiling(name3);
   const v8::CpuProfile* p3 = cpu_profiler->StopCpuProfiling(name3);
   CHECK_NE(NULL, p3);
   CHECK_EQ(2, cpu_profiler->GetProfileCount());
   unsigned uid3 = p3->GetUid();
   CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid3));
   CHECK_EQ(p3, FindCpuProfile(cpu_profiler, uid3));
   CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1));
   const_cast<v8::CpuProfile*>(p2)->Delete();
   CHECK_EQ(1, cpu_profiler->GetProfileCount());
   CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid2));
   CHECK_EQ(p3, FindCpuProfile(cpu_profiler, uid3));
   const_cast<v8::CpuProfile*>(p3)->Delete();
   CHECK_EQ(0, cpu_profiler->GetProfileCount());
   CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid3));
   CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid2));
   CHECK_EQ(NULL, FindCpuProfile(cpu_profiler, uid1));
 }
 
 
 TEST(ProfileStartEndTime) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
 
-  v8::Local<v8::String> profile_name = v8::String::New("test");
+  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::Value> argv[], int argc,
     unsigned min_js_samples) {
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
-  v8::Local<v8::String> profile_name = v8::String::New("my_profile");
+  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();
   sampler->StartCountingSamples();
   do {
     function->Call(env->Global(), argc, argv);
   } while (sampler->js_and_external_sample_count() < min_js_samples);
 
@@ skipping 26 matching lines @@
     CHECK(ContainsString(name, names));
     // Check that there are no duplicates.
     for (int j = 0; j < count; j++) {
       if (j == i) continue;
       CHECK_NE(name, node->GetChild(j)->GetFunctionName());
     }
   }
 }
 
 
-static const v8::CpuProfileNode* FindChild(const v8::CpuProfileNode* node,
+static const v8::CpuProfileNode* FindChild(v8::Isolate* isolate,
+                                           const v8::CpuProfileNode* node,
                                            const char* name) {
   int count = node->GetChildrenCount();
-  v8::Handle<v8::String> nameHandle = v8::String::New(name);
+  v8::Handle<v8::String> nameHandle = v8::String::NewFromUtf8(isolate, name);
   for (int i = 0; i < count; i++) {
     const v8::CpuProfileNode* child = node->GetChild(i);
     if (nameHandle->Equals(child->GetFunctionName())) return child;
   }
   return NULL;
 }
 
 
-static const v8::CpuProfileNode* GetChild(const v8::CpuProfileNode* node,
+static const v8::CpuProfileNode* GetChild(v8::Isolate* isolate,
+                                          const v8::CpuProfileNode* node,
                                           const char* name) {
-  const v8::CpuProfileNode* result = FindChild(node, name);
+  const v8::CpuProfileNode* result = FindChild(isolate, node, name);
   if (!result) {
     char buffer[100];
     i::OS::SNPrintF(Vector<char>(buffer, ARRAY_SIZE(buffer)),
                     "Failed to GetChild: %s", name);
     FATAL(buffer);
   }
   return result;
 }
 
 
-static void CheckSimpleBranch(const v8::CpuProfileNode* node,
+static void CheckSimpleBranch(v8::Isolate* isolate,
+                              const v8::CpuProfileNode* node,
                               const char* names[], int length) {
   for (int i = 0; i < length; i++) {
     const char* name = names[i];
-    node = GetChild(node, name);
+    node = GetChild(isolate, node, name);
     int expectedChildrenCount = (i == length - 1) ? 0 : 1;
     CHECK_EQ(expectedChildrenCount, node->GetChildrenCount());
   }
 }
 
 
 static const char* cpu_profiler_test_source = "function loop(timeout) {\n"
 "  this.mmm = 0;\n"
 "  var start = Date.now();\n"
 "  while (Date.now() - start < timeout) {\n"
@@ skipping 39 matching lines @@
 //   522   522          loop [-1]
 //   263     0        bar [-1]
 //   263     1          delay [-1]
 //   262   262            loop [-1]
 //     2     2    (program) [-1]
 //     6     6    (garbage collector) [-1]
 TEST(CollectCpuProfile) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
-  v8::Script::Compile(v8::String::New(cpu_profiler_test_source))->Run();
+  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::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t profiling_interval_ms = 200;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(profiling_interval_ms) };
   const v8::CpuProfile* profile =
       RunProfiler(env, 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::New(ProfileGenerator::kGarbageCollectorEntryName);
-  names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-  names[2] = v8::String::New("start");
+  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);
 
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
   CHECK_EQ(1, startNode->GetChildrenCount());
 
-  const v8::CpuProfileNode* fooNode = GetChild(startNode, "foo");
+  const v8::CpuProfileNode* fooNode =
+      GetChild(env->GetIsolate(), startNode, "foo");
   CHECK_EQ(3, fooNode->GetChildrenCount());
 
   const char* barBranch[] = { "bar", "delay", "loop" };
-  CheckSimpleBranch(fooNode, barBranch, ARRAY_SIZE(barBranch));
+  CheckSimpleBranch(env->GetIsolate(), fooNode, barBranch,
+                    ARRAY_SIZE(barBranch));
   const char* bazBranch[] = { "baz", "delay", "loop" };
-  CheckSimpleBranch(fooNode, bazBranch, ARRAY_SIZE(bazBranch));
+  CheckSimpleBranch(env->GetIsolate(), fooNode, bazBranch,
+                    ARRAY_SIZE(bazBranch));
   const char* delayBranch[] = { "delay", "loop" };
-  CheckSimpleBranch(fooNode, delayBranch, ARRAY_SIZE(delayBranch));
+  CheckSimpleBranch(env->GetIsolate(), fooNode, delayBranch,
+                    ARRAY_SIZE(delayBranch));
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 
 static const char* cpu_profiler_test_source2 = "function loop() {}\n"
 "function delay() { loop(); }\n"
 "function start(count) {\n"
@@ skipping 11 matching lines @@
 // [Top down]:
 //   135     0   (root) [-1] #1
 //   121    72    start [-1] #3
 //    49    33      delay [-1] #4
 //    16    16        loop [-1] #5
 //    14    14    (program) [-1] #2
 TEST(SampleWhenFrameIsNotSetup) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
-  v8::Script::Compile(v8::String::New(cpu_profiler_test_source2))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(
+                          env->GetIsolate(), cpu_profiler_test_source2))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   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(repeat_count) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
 
   ScopedVector<v8::Handle<v8::String> > names(3);
-  names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-  names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-  names[2] = v8::String::New("start");
+  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);
 
-  const v8::CpuProfileNode* startNode = FindChild(root, "start");
+  const v8::CpuProfileNode* startNode =
+      FindChild(env->GetIsolate(), root, "start");
   // On slow machines there may be no meaningfull samples at all, skip the
   // check there.
   if (startNode && startNode->GetChildrenCount() > 0) {
     CHECK_EQ(1, startNode->GetChildrenCount());
-    const v8::CpuProfileNode* delayNode = GetChild(startNode, "delay");
+    const v8::CpuProfileNode* delayNode =
+        GetChild(env->GetIsolate(), startNode, "delay");
     if (delayNode->GetChildrenCount() > 0) {
       CHECK_EQ(1, delayNode->GetChildrenCount());
-      GetChild(delayNode, "loop");
+      GetChild(env->GetIsolate(), delayNode, "loop");
     }
   }
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* native_accessor_test_source = "function start(count) {\n"
 "  for (var i = 0; i < count; i++) {\n"
@@ skipping 61 matching lines @@
 
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New();
   v8::Local<v8::ObjectTemplate> instance_template =
       func_template->InstanceTemplate();
 
   TestApiCallbacks accessors(100);
   v8::Local<v8::External> data =
       v8::External::New(env->GetIsolate(), &accessors);
   instance_template->SetAccessor(
-      v8::String::New("foo"), &TestApiCallbacks::Getter,
-      &TestApiCallbacks::Setter, data);
+      v8::String::NewFromUtf8(env->GetIsolate(), "foo"),
+      &TestApiCallbacks::Getter, &TestApiCallbacks::Setter, data);
   v8::Local<v8::Function> func = func_template->GetFunction();
   v8::Local<v8::Object> instance = func->NewInstance();
-  env->Global()->Set(v8::String::New("instance"), instance);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+                     instance);
 
-  v8::Script::Compile(v8::String::New(native_accessor_test_source))->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), native_accessor_test_source))
+      ->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t repeat_count = 1;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(repeat_count) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 180);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
-  GetChild(startNode, "get foo");
-  GetChild(startNode, "set foo");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
+  GetChild(env->GetIsolate(), startNode, "get foo");
+  GetChild(env->GetIsolate(), startNode, "set foo");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 // Test that native accessors are properly reported in the CPU profile.
 // This test makes sure that the accessors are called enough times to become
 // hot and to trigger optimizations.
 TEST(NativeAccessorMonomorphicIC) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New();
   v8::Local<v8::ObjectTemplate> instance_template =
       func_template->InstanceTemplate();
 
   TestApiCallbacks accessors(1);
   v8::Local<v8::External> data =
       v8::External::New(env->GetIsolate(), &accessors);
   instance_template->SetAccessor(
-      v8::String::New("foo"), &TestApiCallbacks::Getter,
-      &TestApiCallbacks::Setter, data);
+      v8::String::NewFromUtf8(env->GetIsolate(), "foo"),
+      &TestApiCallbacks::Getter, &TestApiCallbacks::Setter, data);
   v8::Local<v8::Function> func = func_template->GetFunction();
   v8::Local<v8::Object> instance = func->NewInstance();
-  env->Global()->Set(v8::String::New("instance"), instance);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+                     instance);
 
-  v8::Script::Compile(v8::String::New(native_accessor_test_source))->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), native_accessor_test_source))
+      ->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   {
     // Make sure accessors ICs are in monomorphic state before starting
     // profiling.
     accessors.set_warming_up(true);
     int32_t warm_up_iterations = 3;
     v8::Handle<v8::Value> args[] = { v8::Integer::New(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(repeat_count) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 200);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
-  GetChild(startNode, "get foo");
-  GetChild(startNode, "set foo");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
+  GetChild(env->GetIsolate(), startNode, "get foo");
+  GetChild(env->GetIsolate(), startNode, "set foo");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* native_method_test_source = "function start(count) {\n"
 "  for (var i = 0; i < count; i++) {\n"
 "    instance.fooMethod();\n"
 "  }\n"
 "}\n";
 
 
 TEST(NativeMethodUninitializedIC) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   TestApiCallbacks callbacks(100);
   v8::Local<v8::External> data =
       v8::External::New(env->GetIsolate(), &callbacks);
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New();
-  func_template->SetClassName(v8::String::New("Test_InstanceCostructor"));
+  func_template->SetClassName(
+      v8::String::NewFromUtf8(env->GetIsolate(), "Test_InstanceCostructor"));
   v8::Local<v8::ObjectTemplate> proto_template =
       func_template->PrototypeTemplate();
   v8::Local<v8::Signature> signature = v8::Signature::New(func_template);
-  proto_template->Set(v8::String::New("fooMethod"), v8::FunctionTemplate::New(
-      &TestApiCallbacks::Callback, data, signature, 0));
+  proto_template->Set(v8::String::NewFromUtf8(env->GetIsolate(), "fooMethod"),
+                      v8::FunctionTemplate::New(&TestApiCallbacks::Callback,
+                                                data, signature, 0));
 
   v8::Local<v8::Function> func = func_template->GetFunction();
   v8::Local<v8::Object> instance = func->NewInstance();
-  env->Global()->Set(v8::String::New("instance"), instance);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+                     instance);
 
-  v8::Script::Compile(v8::String::New(native_method_test_source))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(
+                          env->GetIsolate(), native_method_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t repeat_count = 1;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(repeat_count) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
-  GetChild(startNode, "fooMethod");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
+  GetChild(env->GetIsolate(), startNode, "fooMethod");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 TEST(NativeMethodMonomorphicIC) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   TestApiCallbacks callbacks(1);
   v8::Local<v8::External> data =
       v8::External::New(env->GetIsolate(), &callbacks);
 
   v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New();
-  func_template->SetClassName(v8::String::New("Test_InstanceCostructor"));
+  func_template->SetClassName(
+      v8::String::NewFromUtf8(env->GetIsolate(), "Test_InstanceCostructor"));
   v8::Local<v8::ObjectTemplate> proto_template =
       func_template->PrototypeTemplate();
   v8::Local<v8::Signature> signature = v8::Signature::New(func_template);
-  proto_template->Set(v8::String::New("fooMethod"), v8::FunctionTemplate::New(
-      &TestApiCallbacks::Callback, data, signature, 0));
+  proto_template->Set(v8::String::NewFromUtf8(env->GetIsolate(), "fooMethod"),
+                      v8::FunctionTemplate::New(&TestApiCallbacks::Callback,
+                                                data, signature, 0));
 
   v8::Local<v8::Function> func = func_template->GetFunction();
   v8::Local<v8::Object> instance = func->NewInstance();
-  env->Global()->Set(v8::String::New("instance"), instance);
+  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "instance"),
+                     instance);
 
-  v8::Script::Compile(v8::String::New(native_method_test_source))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(
+                          env->GetIsolate(), native_method_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
   {
     // Make sure method ICs are in monomorphic state before starting
     // profiling.
     callbacks.set_warming_up(true);
     int32_t warm_up_iterations = 3;
     v8::Handle<v8::Value> args[] = { v8::Integer::New(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(repeat_count) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
-  GetChild(root, "start");
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
-  GetChild(startNode, "fooMethod");
+  GetChild(env->GetIsolate(), root, "start");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
+  GetChild(env->GetIsolate(), startNode, "fooMethod");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* bound_function_test_source = "function foo(iterations) {\n"
 "  var r = 0;\n"
 "  for (var i = 0; i < iterations; i++) { r += i; }\n"
 "  return r;\n"
 "}\n"
 "function start(duration) {\n"
 "  var callback = foo.bind(this);\n"
 "  var start = Date.now();\n"
 "  while (Date.now() - start < duration) {\n"
 "    callback(10 * 1000);\n"
 "  }\n"
 "}";
 
 
 TEST(BoundFunctionCall) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
-  v8::Script::Compile(v8::String::New(bound_function_test_source))->Run();
+  v8::Script::Compile(
+      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::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 100;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   ScopedVector<v8::Handle<v8::String> > names(3);
-  names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-  names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-  names[2] = v8::String::New("start");
+  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);
 
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
-  GetChild(startNode, "foo");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
+  GetChild(env->GetIsolate(), startNode, "foo");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* call_function_test_source = "function bar(iterations) {\n"
 "}\n"
 "function start(duration) {\n"
 "  var start = Date.now();\n"
@@ skipping 17 matching lines @@
 //    71    70    start [-1] #3
 //     1     1      bar [-1] #7
 //    19    19    (program) [-1] #2
 TEST(FunctionCallSample) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Collect garbage that might have be generated while installing extensions.
   CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
 
-  v8::Script::Compile(v8::String::New(call_function_test_source))->Run();
+  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::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 100;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   {
     ScopedVector<v8::Handle<v8::String> > names(4);
-    names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-    names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-    names[2] = v8::String::New("start");
-    names[3] = v8::String::New(i::ProfileGenerator::kUnresolvedFunctionName);
+    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(
+        env->GetIsolate(), i::ProfileGenerator::kUnresolvedFunctionName);
     // Don't allow |bar| and |call| nodes to be at the top level.
     CheckChildrenNames(root, names);
   }
 
   // In case of GC stress tests all samples may be in GC phase and there
   // won't be |start| node in the profiles.
   bool is_gc_stress_testing =
       (i::FLAG_gc_interval != -1) || i::FLAG_stress_compaction;
-  const v8::CpuProfileNode* startNode = FindChild(root, "start");
+  const v8::CpuProfileNode* startNode =
+      FindChild(env->GetIsolate(), root, "start");
   CHECK(is_gc_stress_testing || startNode);
   if (startNode) {
     ScopedVector<v8::Handle<v8::String> > names(2);
-    names[0] = v8::String::New("bar");
-    names[1] = v8::String::New("call");
+    names[0] = v8::String::NewFromUtf8(env->GetIsolate(), "bar");
+    names[1] = v8::String::NewFromUtf8(env->GetIsolate(), "call");
     CheckChildrenNames(startNode, names);
   }
 
-  const v8::CpuProfileNode* unresolvedNode =
-      FindChild(root, i::ProfileGenerator::kUnresolvedFunctionName);
+  const v8::CpuProfileNode* unresolvedNode = FindChild(
+      env->GetIsolate(), root, i::ProfileGenerator::kUnresolvedFunctionName);
   if (unresolvedNode) {
     ScopedVector<v8::Handle<v8::String> > names(1);
-    names[0] = v8::String::New("call");
+    names[0] = v8::String::NewFromUtf8(env->GetIsolate(), "call");
     CheckChildrenNames(unresolvedNode, names);
   }
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* function_apply_test_source = "function bar(iterations) {\n"
 "}\n"
@@ skipping 17 matching lines @@
 //     1     0      (unresolved function) [-1] #0 8
 //     1     1        apply [-1] #0 9
 //    32    21      test [-1] #16 4
 //     2     2        bar [-1] #16 6
 //     9     9        apply [-1] #0 5
 //    10    10    (program) [-1] #0 2
 TEST(FunctionApplySample) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
-  v8::Script::Compile(v8::String::New(function_apply_test_source))->Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(), function_apply_test_source))
+      ->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 100;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
 
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 100);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   {
     ScopedVector<v8::Handle<v8::String> > names(3);
-    names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-    names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-    names[2] = v8::String::New("start");
+    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.
     CheckChildrenNames(root, names);
   }
 
-  const v8::CpuProfileNode* startNode = FindChild(root, "start");
+  const v8::CpuProfileNode* startNode =
+      FindChild(env->GetIsolate(), root, "start");
   if (startNode) {
     {
       ScopedVector<v8::Handle<v8::String> > names(2);
-      names[0] = v8::String::New("test");
-      names[1] = v8::String::New(ProfileGenerator::kUnresolvedFunctionName);
+      names[0] = v8::String::NewFromUtf8(env->GetIsolate(), "test");
+      names[1] = v8::String::NewFromUtf8(
+          env->GetIsolate(), ProfileGenerator::kUnresolvedFunctionName);
       CheckChildrenNames(startNode, names);
     }
 
-    const v8::CpuProfileNode* testNode = FindChild(startNode, "test");
+    const v8::CpuProfileNode* testNode =
+        FindChild(env->GetIsolate(), startNode, "test");
     if (testNode) {
       ScopedVector<v8::Handle<v8::String> > names(2);
-      names[0] = v8::String::New("bar");
-      names[1] = v8::String::New("apply");
+      names[0] = v8::String::NewFromUtf8(env->GetIsolate(), "bar");
+      names[1] = v8::String::NewFromUtf8(env->GetIsolate(), "apply");
       CheckChildrenNames(testNode, names);
     }
 
     if (const v8::CpuProfileNode* unresolvedNode =
-            FindChild(startNode, ProfileGenerator::kUnresolvedFunctionName)) {
+            FindChild(env->GetIsolate(), startNode,
+                      ProfileGenerator::kUnresolvedFunctionName)) {
       ScopedVector<v8::Handle<v8::String> > names(1);
-      names[0] = v8::String::New("apply");
+      names[0] = v8::String::NewFromUtf8(env->GetIsolate(), "apply");
       CheckChildrenNames(unresolvedNode, names);
-      GetChild(unresolvedNode, "apply");
+      GetChild(env->GetIsolate(), unresolvedNode, "apply");
     }
   }
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* js_native_js_test_source =
 "var is_profiling = false;\n"
@@ skipping 34 matching lines @@
 //    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::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       CallJsFunction);
   v8::Local<v8::Function> func = func_template->GetFunction();
-  func->SetName(v8::String::New("CallJsFunction"));
-  env->Global()->Set(v8::String::New("CallJsFunction"), func);
+  func->SetName(v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"));
+  env->Global()->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"), func);
 
-  v8::Script::Compile(v8::String::New(js_native_js_test_source))->Run();
+  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                              js_native_js_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 10);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   {
     ScopedVector<v8::Handle<v8::String> > names(3);
-    names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-    names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-    names[2] = v8::String::New("start");
+    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);
   }
 
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
   CHECK_EQ(1, startNode->GetChildrenCount());
   const v8::CpuProfileNode* nativeFunctionNode =
-      GetChild(startNode, "CallJsFunction");
+      GetChild(env->GetIsolate(), startNode, "CallJsFunction");
 
   CHECK_EQ(1, nativeFunctionNode->GetChildrenCount());
-  const v8::CpuProfileNode* barNode = GetChild(nativeFunctionNode, "bar");
+  const v8::CpuProfileNode* barNode =
+      GetChild(env->GetIsolate(), nativeFunctionNode, "bar");
 
   CHECK_EQ(1, barNode->GetChildrenCount());
-  GetChild(barNode, "foo");
+  GetChild(env->GetIsolate(), barNode, "foo");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static const char* js_native_js_runtime_js_test_source =
 "var is_profiling = false;\n"
 "function foo(iterations) {\n"
 "  if (!is_profiling) {\n"
@@ skipping 27 matching lines @@
 //     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::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       CallJsFunction);
   v8::Local<v8::Function> func = func_template->GetFunction();
-  func->SetName(v8::String::New("CallJsFunction"));
-  env->Global()->Set(v8::String::New("CallJsFunction"), func);
+  func->SetName(v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"));
+  env->Global()->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction"), func);
 
-  v8::Script::Compile(v8::String::New(js_native_js_runtime_js_test_source))->
-      Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              js_native_js_runtime_js_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 10);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   ScopedVector<v8::Handle<v8::String> > names(3);
-  names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-  names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-  names[2] = v8::String::New("start");
+  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);
 
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
   CHECK_EQ(1, startNode->GetChildrenCount());
   const v8::CpuProfileNode* nativeFunctionNode =
-      GetChild(startNode, "CallJsFunction");
+      GetChild(env->GetIsolate(), startNode, "CallJsFunction");
 
   CHECK_EQ(1, nativeFunctionNode->GetChildrenCount());
-  const v8::CpuProfileNode* barNode = GetChild(nativeFunctionNode, "bar");
+  const v8::CpuProfileNode* barNode =
+      GetChild(env->GetIsolate(), nativeFunctionNode, "bar");
 
   CHECK_EQ(1, barNode->GetChildrenCount());
-  GetChild(barNode, "foo");
+  GetChild(env->GetIsolate(), barNode, "foo");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 static void CallJsFunction2(const v8::FunctionCallbackInfo<v8::Value>& info) {
   CallJsFunction(info);
 }
 
@@ skipping 32 matching lines @@
 //     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::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
       CallJsFunction);
   v8::Local<v8::Function> func1 = func_template->GetFunction();
-  func1->SetName(v8::String::New("CallJsFunction1"));
-  env->Global()->Set(v8::String::New("CallJsFunction1"), func1);
+  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(
       CallJsFunction2)->GetFunction();
-  func2->SetName(v8::String::New("CallJsFunction2"));
-  env->Global()->Set(v8::String::New("CallJsFunction2"), func2);
+  func2->SetName(v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction2"));
+  env->Global()->Set(
+      v8::String::NewFromUtf8(env->GetIsolate(), "CallJsFunction2"), func2);
 
-  v8::Script::Compile(v8::String::New(js_native1_js_native2_js_test_source))->
-      Run();
+  v8::Script::Compile(
+      v8::String::NewFromUtf8(env->GetIsolate(),
+                              js_native1_js_native2_js_test_source))->Run();
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::New("start")));
+      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = { v8::Integer::New(duration_ms) };
   const v8::CpuProfile* profile =
       RunProfiler(env, function, args, ARRAY_SIZE(args), 10);
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   ScopedVector<v8::Handle<v8::String> > names(3);
-  names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-  names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-  names[2] = v8::String::New("start");
+  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);
 
-  const v8::CpuProfileNode* startNode = GetChild(root, "start");
+  const v8::CpuProfileNode* startNode =
+      GetChild(env->GetIsolate(), root, "start");
   CHECK_EQ(1, startNode->GetChildrenCount());
   const v8::CpuProfileNode* nativeNode1 =
-      GetChild(startNode, "CallJsFunction1");
+      GetChild(env->GetIsolate(), startNode, "CallJsFunction1");
 
   CHECK_EQ(1, nativeNode1->GetChildrenCount());
-  const v8::CpuProfileNode* barNode = GetChild(nativeNode1, "bar");
+  const v8::CpuProfileNode* barNode =
+      GetChild(env->GetIsolate(), nativeNode1, "bar");
 
   CHECK_EQ(1, barNode->GetChildrenCount());
-  const v8::CpuProfileNode* nativeNode2 = GetChild(barNode, "CallJsFunction2");
+  const v8::CpuProfileNode* nativeNode2 =
+      GetChild(env->GetIsolate(), barNode, "CallJsFunction2");
 
   CHECK_EQ(1, nativeNode2->GetChildrenCount());
-  GetChild(nativeNode2, "foo");
+  GetChild(env->GetIsolate(), nativeNode2, "foo");
 
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
 // [Top down]:
 //     6     0   (root) #0 1
 //     3     3    (program) #0 2
 //     3     3    (idle) #0 3
 TEST(IdleTime) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
 
-  v8::Local<v8::String> profile_name = v8::String::New("my_profile");
+  v8::Local<v8::String> profile_name =
+      v8::String::NewFromUtf8(env->GetIsolate(), "my_profile");
   cpu_profiler->StartCpuProfiling(profile_name);
 
   i::Isolate* isolate = CcTest::i_isolate();
   i::ProfilerEventsProcessor* processor = isolate->cpu_profiler()->processor();
   processor->AddCurrentStack(isolate);
 
   cpu_profiler->SetIdle(true);
 
   for (int i = 0; i < 3; i++) {
     processor->AddCurrentStack(isolate);
   }
 
   cpu_profiler->SetIdle(false);
   processor->AddCurrentStack(isolate);
 
 
   const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name);
   CHECK_NE(NULL, profile);
   // Dump collected profile to have a better diagnostic in case of failure.
   reinterpret_cast<i::CpuProfile*>(
       const_cast<v8::CpuProfile*>(profile))->Print();
 
   const v8::CpuProfileNode* root = profile->GetTopDownRoot();
   ScopedVector<v8::Handle<v8::String> > names(3);
-  names[0] = v8::String::New(ProfileGenerator::kGarbageCollectorEntryName);
-  names[1] = v8::String::New(ProfileGenerator::kProgramEntryName);
-  names[2] = v8::String::New(ProfileGenerator::kIdleEntryName);
+  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(),
+                                     ProfileGenerator::kIdleEntryName);
   CheckChildrenNames(root, names);
 
   const v8::CpuProfileNode* programNode =
-      GetChild(root, ProfileGenerator::kProgramEntryName);
+      GetChild(env->GetIsolate(), root, ProfileGenerator::kProgramEntryName);
   CHECK_EQ(0, programNode->GetChildrenCount());
   CHECK_GE(programNode->GetHitCount(), 3);
 
   const v8::CpuProfileNode* idleNode =
-      GetChild(root, ProfileGenerator::kIdleEntryName);
+      GetChild(env->GetIsolate(), root, ProfileGenerator::kIdleEntryName);
   CHECK_EQ(0, idleNode->GetChildrenCount());
   CHECK_GE(idleNode->GetHitCount(), 3);
 
   cpu_profiler->DeleteAllCpuProfiles();
 }
 
 
-static void CheckFunctionDetails(const v8::CpuProfileNode* node,
-    const char* name, const char* script_name, int script_id,
-    int line, int column) {
-  CHECK_EQ(v8::String::New(name), node->GetFunctionName());
-  CHECK_EQ(v8::String::New(script_name), node->GetScriptResourceName());
+static void CheckFunctionDetails(v8::Isolate* isolate,
+                                 const v8::CpuProfileNode* node,
+                                 const char* name, const char* script_name,
+                                 int script_id, int line, int column) {
+  CHECK_EQ(v8::String::NewFromUtf8(isolate, name),
+           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::CpuProfiler* profiler = env->GetIsolate()->GetCpuProfiler();
   CHECK_EQ(0, profiler->GetProfileCount());
-  v8::Handle<v8::Script> script_a = v8::Script::Compile(v8::String::New(
-      "    function foo\n() { try { bar(); } catch(e) {} }\n"
-      " function bar() { startProfiling(); }\n"), v8::String::New("script_a"));
+  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::New(
-      "\n\n   function baz() { try { foo(); } catch(e) {} }\n"
-      "\n\nbaz();\n"
-      "stopProfiling();\n"), v8::String::New("script_b"));
+  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();
   CHECK_EQ(1, profiler->GetProfileCount());
   const v8::CpuProfile* profile = profiler->GetCpuProfile(0);
   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(root,
+  const v8::CpuProfileNode* script = GetChild(env->GetIsolate(), root,
       ProfileGenerator::kAnonymousFunctionName);
-  CheckFunctionDetails(script, ProfileGenerator::kAnonymousFunctionName,
-      "script_b", script_b->GetId(), 1, 1);
-  const v8::CpuProfileNode* baz = GetChild(script, "baz");
-  CheckFunctionDetails(baz, "baz", "script_b", script_b->GetId(), 3, 16);
-  const v8::CpuProfileNode* foo = GetChild(baz, "foo");
-  CheckFunctionDetails(foo, "foo", "script_a", script_a->GetId(), 2, 1);
-  const v8::CpuProfileNode* bar = GetChild(foo, "bar");
-  CheckFunctionDetails(bar, "bar", "script_a", script_a->GetId(), 3, 14);
+  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);
 }