Remove usage of deprecated APIs from cctests

test/cctest/test-profile-generator.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 538 matching lines @@
   static const char* kSource;
 };
 
 
 const char* ProfilerExtension::kSource =
     "native function startProfiling();"
     "native function stopProfiling();";
 
 v8::Handle<v8::FunctionTemplate> ProfilerExtension::GetNativeFunction(
     v8::Handle<v8::String> name) {
-  if (name->Equals(v8::String::New("startProfiling"))) {
+  if (name->Equals(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(),
+                                           "startProfiling"))) {
     return v8::FunctionTemplate::New(ProfilerExtension::StartProfiling);
-  } else if (name->Equals(v8::String::New("stopProfiling"))) {
+  } else if (name->Equals(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(),
+                                                  "stopProfiling"))) {
     return v8::FunctionTemplate::New(ProfilerExtension::StopProfiling);
   } else {
     CHECK(false);
     return v8::Handle<v8::FunctionTemplate>();
   }
 }
 
 
 void ProfilerExtension::StartProfiling(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::CpuProfiler* cpu_profiler = args.GetIsolate()->GetCpuProfiler();
   if (args.Length() > 0)
     cpu_profiler->StartCpuProfiling(args[0].As<v8::String>());
   else
-    cpu_profiler->StartCpuProfiling(v8::String::New(""));
+    cpu_profiler->StartCpuProfiling(
+        v8::String::NewFromUtf8(args.GetIsolate(), ""));
 }
 
 
 void ProfilerExtension::StopProfiling(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::CpuProfiler* cpu_profiler = args.GetIsolate()->GetCpuProfiler();
   if (args.Length() > 0)
     cpu_profiler->StopCpuProfiling(args[0].As<v8::String>());
   else
-    cpu_profiler->StopCpuProfiling(v8::String::New(""));
+    cpu_profiler->StopCpuProfiling(
+        v8::String::NewFromUtf8(args.GetIsolate(), ""));
 }
 
 
 static ProfilerExtension kProfilerExtension;
 v8::DeclareExtension kProfilerExtensionDeclaration(&kProfilerExtension);
 
 static const ProfileNode* PickChild(const ProfileNode* parent,
                                     const char* name) {
   for (int i = 0; i < parent->children()->length(); ++i) {
     const ProfileNode* child = parent->children()->at(i);
@@ skipping 69 matching lines @@
       "maximum", CpuProfilesCollection::kMaxSimultaneousProfiles + 1, false));
   for (int i = 0; i < CpuProfilesCollection::kMaxSimultaneousProfiles; ++i)
     i::DeleteArray(titles[i]);
 }
 
 
 static const v8::CpuProfileNode* PickChild(const v8::CpuProfileNode* parent,
                                            const char* name) {
   for (int i = 0; i < parent->GetChildrenCount(); ++i) {
     const v8::CpuProfileNode* child = parent->GetChild(i);
-    v8::String::AsciiValue function_name(child->GetFunctionName());
+    v8::String::Utf8Value function_name(child->GetFunctionName());
     if (strcmp(*function_name, name) == 0) return child;
   }
   return NULL;
 }
 
 
 TEST(ProfileNodeScriptId) {
   // This test does not pass with inlining enabled since inlined functions
   // don't appear in the stack trace.
   i::FLAG_use_inlining = false;
 
   const char* extensions[] = { "v8/profiler" };
   v8::ExtensionConfiguration config(1, extensions);
   LocalContext env(&config);
   v8::HandleScope hs(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 a() { startProfiling(); }\n"));
+  v8::Handle<v8::Script> script_a = v8::Script::Compile(v8::String::NewFromUtf8(
+      env->GetIsolate(), "function a() { startProfiling(); }\n"));
   script_a->Run();
-  v8::Handle<v8::Script> script_b = v8::Script::Compile(v8::String::New(
-      "function b() { a(); }\n"
-      "b();\n"
-      "stopProfiling();\n"));
+  v8::Handle<v8::Script> script_b =
+      v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                                  "function b() { a(); }\n"
+                                                  "b();\n"
+                                                  "stopProfiling();\n"));
   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:
   //  (root)
   //   (anonymous function)
   //     b
@@ skipping 74 matching lines @@
 
 
 TEST(BailoutReason) {
   const char* extensions[] = { "v8/profiler" };
   v8::ExtensionConfiguration config(1, extensions);
   LocalContext env(&config);
   v8::HandleScope hs(env->GetIsolate());
 
   v8::CpuProfiler* profiler = env->GetIsolate()->GetCpuProfiler();
   CHECK_EQ(0, profiler->GetProfileCount());
-  v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(
-      "function TryCatch() {\n"
-      "  try {\n"
-      "    startProfiling();\n"
-      "  } catch (e) { };\n"
-      "}\n"
-      "function TryFinally() {\n"
-      "  try {\n"
-      "    TryCatch();\n"
-      "  } finally { };\n"
-      "}\n"
-      "TryFinally();\n"
-      "stopProfiling();"));
+  v8::Handle<v8::Script> script =
+      v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
+                                                  "function TryCatch() {\n"
+                                                  "  try {\n"
+                                                  "    startProfiling();\n"
+                                                  "  } catch (e) { };\n"
+                                                  "}\n"
+                                                  "function TryFinally() {\n"
+                                                  "  try {\n"
+                                                  "    TryCatch();\n"
+                                                  "  } finally { };\n"
+                                                  "}\n"
+                                                  "TryFinally();\n"
+                                                  "stopProfiling();"));
   script->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:
   //  (root)
   //   (anonymous function)
   //     kTryFinally
   //       kTryCatch
   current = PickChild(current, i::ProfileGenerator::kAnonymousFunctionName);
   CHECK_NE(NULL, const_cast<v8::CpuProfileNode*>(current));
 
   current = PickChild(current, "TryFinally");
   CHECK_NE(NULL, const_cast<v8::CpuProfileNode*>(current));
   CHECK(!strcmp("TryFinallyStatement", current->GetBailoutReason()));
 
   current = PickChild(current, "TryCatch");
   CHECK_NE(NULL, const_cast<v8::CpuProfileNode*>(current));
   CHECK(!strcmp("TryCatchStatement", current->GetBailoutReason()));
 }