Deprecate Start/StopCpuProfiling methods

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 @@
 
 
 TEST(DeleteCpuProfile) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
   i::CpuProfiler* iprofiler = reinterpret_cast<i::CpuProfiler*>(cpu_profiler);
 
   CHECK_EQ(0, iprofiler->GetProfilesCount());
   v8::Local<v8::String> name1 = v8::String::NewFromUtf8(env->GetIsolate(), "1");
-  cpu_profiler->StartCpuProfiling(name1);
-  const v8::CpuProfile* p1 = cpu_profiler->StopCpuProfiling(name1);
+  cpu_profiler->StartProfiling(name1);
+  v8::CpuProfile* p1 = cpu_profiler->StopProfiling(name1);
   CHECK_NE(NULL, p1);
   CHECK_EQ(1, iprofiler->GetProfilesCount());
   CHECK(FindCpuProfile(cpu_profiler, p1));
-  const_cast<v8::CpuProfile*>(p1)->Delete();
+  p1->Delete();
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 
   v8::Local<v8::String> name2 = v8::String::NewFromUtf8(env->GetIsolate(), "2");
-  cpu_profiler->StartCpuProfiling(name2);
-  const v8::CpuProfile* p2 = cpu_profiler->StopCpuProfiling(name2);
+  cpu_profiler->StartProfiling(name2);
+  v8::CpuProfile* p2 = cpu_profiler->StopProfiling(name2);
   CHECK_NE(NULL, p2);
   CHECK_EQ(1, iprofiler->GetProfilesCount());
   CHECK(FindCpuProfile(cpu_profiler, p2));
   v8::Local<v8::String> name3 = v8::String::NewFromUtf8(env->GetIsolate(), "3");
-  cpu_profiler->StartCpuProfiling(name3);
-  const v8::CpuProfile* p3 = cpu_profiler->StopCpuProfiling(name3);
+  cpu_profiler->StartProfiling(name3);
+  v8::CpuProfile* p3 = cpu_profiler->StopProfiling(name3);
   CHECK_NE(NULL, p3);
   CHECK_EQ(2, iprofiler->GetProfilesCount());
   CHECK_NE(p2, p3);
   CHECK(FindCpuProfile(cpu_profiler, p3));
   CHECK(FindCpuProfile(cpu_profiler, p2));
-  const_cast<v8::CpuProfile*>(p2)->Delete();
+  p2->Delete();
   CHECK_EQ(1, iprofiler->GetProfilesCount());
   CHECK(!FindCpuProfile(cpu_profiler, p2));
   CHECK(FindCpuProfile(cpu_profiler, p3));
-  const_cast<v8::CpuProfile*>(p3)->Delete();
+  p3->Delete();
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 }
 
 
 TEST(ProfileStartEndTime) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
 
   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);
+  cpu_profiler->StartProfiling(profile_name);
+  const v8::CpuProfile* profile = cpu_profiler->StopProfiling(profile_name);
   CHECK(profile->GetStartTime() <= profile->GetEndTime());
 }
 
 
-static const v8::CpuProfile* RunProfiler(
+static v8::CpuProfile* RunProfiler(
     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);
+  cpu_profiler->StartProfiling(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);
 
-  const v8::CpuProfile* profile = cpu_profiler->StopCpuProfiling(profile_name);
+  v8::CpuProfile* profile = cpu_profiler->StopProfiling(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();
+  reinterpret_cast<i::CpuProfile*>(profile)->Print();
 
   return profile;
 }
 
 
 static bool ContainsString(v8::Handle<v8::String> string,
                            const Vector<v8::Handle<v8::String> >& vector) {
   for (int i = 0; i < vector.length(); i++) {
     if (string->Equals(vector[i]))
       return true;
@@ skipping 111 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 =
+  v8::CpuProfile* profile =
       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);
@@ skipping 11 matching lines @@
   const char* barBranch[] = { "bar", "delay", "loop" };
   CheckSimpleBranch(env->GetIsolate(), fooNode, barBranch,
                     ARRAY_SIZE(barBranch));
   const char* bazBranch[] = { "baz", "delay", "loop" };
   CheckSimpleBranch(env->GetIsolate(), fooNode, bazBranch,
                     ARRAY_SIZE(bazBranch));
   const char* delayBranch[] = { "delay", "loop" };
   CheckSimpleBranch(env->GetIsolate(), fooNode, delayBranch,
                     ARRAY_SIZE(delayBranch));
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 
 static const char* cpu_profiler_test_source2 = "function loop() {}\n"
 "function delay() { loop(); }\n"
 "function start(count) {\n"
 "  var k = 0;\n"
 "  do {\n"
 "    delay();\n"
@@ skipping 21 matching lines @@
       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(env->GetIsolate(), repeat_count)
   };
-  const v8::CpuProfile* profile =
+  v8::CpuProfile* profile =
       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);
 
   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(env->GetIsolate(), startNode, "delay");
     if (delayNode->GetChildrenCount() > 0) {
       CHECK_EQ(1, delayNode->GetChildrenCount());
       GetChild(env->GetIsolate(), delayNode, "loop");
     }
   }
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 static const char* native_accessor_test_source = "function start(count) {\n"
 "  for (var i = 0; i < count; i++) {\n"
 "    var o = instance.foo;\n"
 "    instance.foo = o + 1;\n"
 "  }\n"
 "}\n";
 
@@ skipping 72 matching lines @@
                      instance);
 
   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 =
+  v8::CpuProfile* profile =
       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();
+  profile->Delete();
 }
 
 
 // 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::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
@@ skipping 27 matching lines @@
     int32_t warm_up_iterations = 3;
     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 =
+  v8::CpuProfile* profile =
       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();
+  profile->Delete();
 }
 
 
 static const char* native_method_test_source = "function start(count) {\n"
 "  for (var i = 0; i < count; i++) {\n"
 "    instance.fooMethod();\n"
 "  }\n"
 "}\n";
 
 
@@ skipping 24 matching lines @@
   env->Global()->Set(v8::String::NewFromUtf8(isolate, "instance"),
                      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 =
+  v8::CpuProfile* profile =
       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();
+  profile->Delete();
 }
 
 
 TEST(NativeMethodMonomorphicIC) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   TestApiCallbacks callbacks(1);
   v8::Local<v8::External> data =
@@ skipping 28 matching lines @@
     int32_t warm_up_iterations = 3;
     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 =
+  v8::CpuProfile* profile =
       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();
+  profile->Delete();
 }
 
 
 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"
@@ skipping 11 matching lines @@
   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::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 =
+  v8::CpuProfile* profile =
       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);
 
   const v8::CpuProfileNode* startNode =
       GetChild(env->GetIsolate(), root, "start");
   GetChild(env->GetIsolate(), startNode, "foo");
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 static const char* call_function_test_source = "function bar(iterations) {\n"
 "}\n"
 "function start(duration) {\n"
 "  var start = Date.now();\n"
 "  while (Date.now() - start < duration) {\n"
 "    try {\n"
 "      bar.call(this, 10 * 1000);\n"
@@ skipping 23 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 =
+  v8::CpuProfile* profile =
       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");
@@ skipping 18 matching lines @@
   }
 
   const v8::CpuProfileNode* unresolvedNode = FindChild(
       env->GetIsolate(), root, i::ProfileGenerator::kUnresolvedFunctionName);
   if (unresolvedNode) {
     ScopedVector<v8::Handle<v8::String> > names(1);
     names[0] = v8::String::NewFromUtf8(env->GetIsolate(), "call");
     CheckChildrenNames(unresolvedNode, names);
   }
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 static const char* function_apply_test_source = "function bar(iterations) {\n"
 "}\n"
 "function test() {\n"
 "  bar.apply(this, [10 * 1000]);\n"
 "}\n"
 "function start(duration) {\n"
 "  var start = Date.now();\n"
@@ skipping 23 matching lines @@
       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::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 =
+  v8::CpuProfile* profile =
       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");
@@ skipping 24 matching lines @@
     if (const v8::CpuProfileNode* unresolvedNode =
             FindChild(env->GetIsolate(), startNode,
                       ProfileGenerator::kUnresolvedFunctionName)) {
       ScopedVector<v8::Handle<v8::String> > names(1);
       names[0] = v8::String::NewFromUtf8(env->GetIsolate(), "apply");
       CheckChildrenNames(unresolvedNode, names);
       GetChild(env->GetIsolate(), unresolvedNode, "apply");
     }
   }
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 static const char* js_native_js_test_source =
 "var is_profiling = false;\n"
 "function foo(iterations) {\n"
 "  if (!is_profiling) {\n"
 "    is_profiling = true;\n"
 "    startProfiling('my_profile');\n"
 "  }\n"
@@ skipping 41 matching lines @@
 
   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::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), duration_ms)
   };
-  const v8::CpuProfile* profile =
+  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::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(env->GetIsolate(), root, "start");
   CHECK_EQ(1, startNode->GetChildrenCount());
   const v8::CpuProfileNode* nativeFunctionNode =
       GetChild(env->GetIsolate(), startNode, "CallJsFunction");
 
   CHECK_EQ(1, nativeFunctionNode->GetChildrenCount());
   const v8::CpuProfileNode* barNode =
       GetChild(env->GetIsolate(), nativeFunctionNode, "bar");
 
   CHECK_EQ(1, barNode->GetChildrenCount());
   GetChild(env->GetIsolate(), barNode, "foo");
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 static const char* js_native_js_runtime_js_test_source =
 "var is_profiling = false;\n"
 "function foo(iterations) {\n"
 "  if (!is_profiling) {\n"
 "    is_profiling = true;\n"
 "    startProfiling('my_profile');\n"
 "  }\n"
@@ skipping 37 matching lines @@
   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::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), duration_ms)
   };
-  const v8::CpuProfile* profile =
+  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::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(env->GetIsolate(), root, "start");
   CHECK_EQ(1, startNode->GetChildrenCount());
   const v8::CpuProfileNode* nativeFunctionNode =
       GetChild(env->GetIsolate(), startNode, "CallJsFunction");
 
   CHECK_EQ(1, nativeFunctionNode->GetChildrenCount());
   const v8::CpuProfileNode* barNode =
       GetChild(env->GetIsolate(), nativeFunctionNode, "bar");
 
   CHECK_EQ(1, barNode->GetChildrenCount());
   GetChild(env->GetIsolate(), barNode, "foo");
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 static void CallJsFunction2(const v8::FunctionCallbackInfo<v8::Value>& info) {
   CallJsFunction(info);
 }
 
 
 static const char* js_native1_js_native2_js_test_source =
 "var is_profiling = false;\n"
@@ skipping 48 matching lines @@
   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::NewFromUtf8(env->GetIsolate(), "start")));
 
   int32_t duration_ms = 20;
   v8::Handle<v8::Value> args[] = {
     v8::Integer::New(env->GetIsolate(), duration_ms)
   };
-  const v8::CpuProfile* profile =
+  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::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(env->GetIsolate(), root, "start");
   CHECK_EQ(1, startNode->GetChildrenCount());
   const v8::CpuProfileNode* nativeNode1 =
       GetChild(env->GetIsolate(), startNode, "CallJsFunction1");
 
   CHECK_EQ(1, nativeNode1->GetChildrenCount());
   const v8::CpuProfileNode* barNode =
       GetChild(env->GetIsolate(), nativeNode1, "bar");
 
   CHECK_EQ(1, barNode->GetChildrenCount());
   const v8::CpuProfileNode* nativeNode2 =
       GetChild(env->GetIsolate(), barNode, "CallJsFunction2");
 
   CHECK_EQ(1, nativeNode2->GetChildrenCount());
   GetChild(env->GetIsolate(), nativeNode2, "foo");
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 // [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::NewFromUtf8(env->GetIsolate(), "my_profile");
-  cpu_profiler->StartCpuProfiling(profile_name);
+  cpu_profiler->StartProfiling(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);
+  v8::CpuProfile* profile = cpu_profiler->StopProfiling(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();
+  reinterpret_cast<i::CpuProfile*>(profile)->Print();
 
   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(),
                                      ProfileGenerator::kIdleEntryName);
   CheckChildrenNames(root, names);
 
   const v8::CpuProfileNode* programNode =
       GetChild(env->GetIsolate(), root, ProfileGenerator::kProgramEntryName);
   CHECK_EQ(0, programNode->GetChildrenCount());
   CHECK_GE(programNode->GetHitCount(), 3);
 
   const v8::CpuProfileNode* idleNode =
       GetChild(env->GetIsolate(), root, ProfileGenerator::kIdleEntryName);
   CHECK_EQ(0, idleNode->GetChildrenCount());
   CHECK_GE(idleNode->GetHitCount(), 3);
 
-  const_cast<v8::CpuProfile*>(profile)->Delete();
+  profile->Delete();
 }
 
 
 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),
@@ skipping 52 matching lines @@
   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::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);
+  profiler->StartProfiling(outer);
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 
   v8::Handle<v8::String> inner = v8::String::NewFromUtf8(isolate, "inner");
-  profiler->StartCpuProfiling(inner);
+  profiler->StartProfiling(inner);
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 
-  const v8::CpuProfile* inner_profile = profiler->StopCpuProfiling(inner);
+  v8::CpuProfile* inner_profile = profiler->StopProfiling(inner);
   CHECK(inner_profile);
   CHECK_EQ(1, iprofiler->GetProfilesCount());
-  const_cast<v8::CpuProfile*>(inner_profile)->Delete();
+  inner_profile->Delete();
   inner_profile = NULL;
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 
-  const v8::CpuProfile* outer_profile = profiler->StopCpuProfiling(outer);
+  v8::CpuProfile* outer_profile = profiler->StopProfiling(outer);
   CHECK(outer_profile);
   CHECK_EQ(1, iprofiler->GetProfilesCount());
-  const_cast<v8::CpuProfile*>(outer_profile)->Delete();
+  outer_profile->Delete();
   outer_profile = NULL;
   CHECK_EQ(0, iprofiler->GetProfilesCount());
 }