Version 3.19.17.

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 786 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::Object> global = env->Global();
   global->Set(v8_str("pi"), v8_num(3.1415926));
   Local<Value> pi = global->Get(v8_str("pi"));
   CHECK_EQ(3.1415926, pi->NumberValue());
 }
 
 
 template<typename T>
-static void CheckReturnValue(const T& t, i::Address callback) {
+static void CheckReturnValue(const T& t) {
   v8::ReturnValue<v8::Value> rv = t.GetReturnValue();
   i::Object** o = *reinterpret_cast<i::Object***>(&rv);
   CHECK_EQ(v8::Isolate::GetCurrent(), t.GetIsolate());
   CHECK_EQ(t.GetIsolate(), rv.GetIsolate());
   CHECK((*o)->IsTheHole() || (*o)->IsUndefined());
   // Verify reset
   bool is_runtime = (*o)->IsTheHole();
   rv.Set(true);
   CHECK(!(*o)->IsTheHole() && !(*o)->IsUndefined());
   rv.Set(v8::Handle<v8::Object>());
   CHECK((*o)->IsTheHole() || (*o)->IsUndefined());
   CHECK_EQ(is_runtime, (*o)->IsTheHole());
-
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(t.GetIsolate());
-  // If CPU profiler is active check that when API callback is invoked
-  // VMState is set to EXTERNAL.
-  if (isolate->cpu_profiler()->is_profiling()) {
-    CHECK_EQ(i::EXTERNAL, isolate->current_vm_state());
-    CHECK(isolate->external_callback());
-    CHECK_EQ(callback, isolate->external_callback());
-  }
 }
 
-static v8::Handle<Value> handle_call_impl(
-    const v8::Arguments& args,
-    i::Address callback) {
+static v8::Handle<Value> handle_call(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, callback);
+  CheckReturnValue(args);
   args.GetReturnValue().Set(v8_str("bad value"));
   return v8_num(102);
 }
 
-static v8::Handle<Value> handle_call(const v8::Arguments& args) {
-  return handle_call_impl(args, FUNCTION_ADDR(handle_call));
+static v8::Handle<Value> handle_call_2(const v8::Arguments& args) {
+  return handle_call(args);
 }
 
-static v8::Handle<Value> handle_call_2(const v8::Arguments& args) {
-  return handle_call_impl(args, FUNCTION_ADDR(handle_call_2));
-}
-
-static v8::Handle<Value> handle_call_indirect_impl(const v8::Arguments& args,
-                                                   i::Address callback) {
+static v8::Handle<Value> handle_call_indirect(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, callback);
+  CheckReturnValue(args);
   args.GetReturnValue().Set(v8_str("bad value"));
   args.GetReturnValue().Set(v8_num(102));
   return v8::Handle<Value>();
 }
 
-static v8::Handle<Value> handle_call_indirect(const v8::Arguments& args) {
-  return handle_call_indirect_impl(args, FUNCTION_ADDR(handle_call_indirect));
+static v8::Handle<Value> handle_call_indirect_2(const v8::Arguments& args) {
+  return handle_call_indirect(args);
 }
 
-static v8::Handle<Value> handle_call_indirect_2(const v8::Arguments& args) {
-  return handle_call_indirect_impl(args, FUNCTION_ADDR(handle_call_indirect_2));
-}
-
-static void handle_callback_impl(const v8::FunctionCallbackInfo<Value>& info,
-                                 i::Address callback) {
+static void handle_callback(const v8::FunctionCallbackInfo<Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info, callback);
+  CheckReturnValue(info);
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(v8_num(102));
 }
 
-static void handle_callback(const v8::FunctionCallbackInfo<Value>& info) {
-  return handle_callback_impl(info, FUNCTION_ADDR(handle_callback));
-}
-
 static void handle_callback_2(const v8::FunctionCallbackInfo<Value>& info) {
-  return handle_callback_impl(info, FUNCTION_ADDR(handle_callback_2));
+  return handle_callback(info);
 }
 
 static v8::Handle<Value> construct_call(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, FUNCTION_ADDR(construct_call));
+  CheckReturnValue(args);
   args.This()->Set(v8_str("x"), v8_num(1));
   args.This()->Set(v8_str("y"), v8_num(2));
   args.GetReturnValue().Set(v8_str("bad value"));
   return args.This();
 }
 
 static v8::Handle<Value> construct_call_indirect(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, FUNCTION_ADDR(construct_call_indirect));
+  CheckReturnValue(args);
   args.This()->Set(v8_str("x"), v8_num(1));
   args.This()->Set(v8_str("y"), v8_num(2));
   args.GetReturnValue().Set(v8_str("bad value"));
   args.GetReturnValue().Set(args.This());
   return v8::Handle<Value>();
 }
 
 static void construct_callback(
     const v8::FunctionCallbackInfo<Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info, FUNCTION_ADDR(construct_callback));
+  CheckReturnValue(info);
   info.This()->Set(v8_str("x"), v8_num(1));
   info.This()->Set(v8_str("y"), v8_num(2));
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(info.This());
 }
 
 
 static v8::Handle<Value> Return239(
     Local<String> name, const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info, FUNCTION_ADDR(Return239));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(v8_str("bad value"));
   return v8_num(239);
 }
 
 static v8::Handle<Value> Return239Indirect(
     Local<String> name, const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info, FUNCTION_ADDR(Return239Indirect));
+  CheckReturnValue(info);
   Handle<Value> value = v8_num(239);
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(value);
   return v8::Handle<Value>();
 }
 
 static void Return239Callback(
     Local<String> name, const v8::PropertyCallbackInfo<Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info, FUNCTION_ADDR(Return239Callback));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(v8_num(239));
 }
 
 
 template<typename Handler>
 static void TestFunctionTemplateInitializer(Handler handler,
                                             Handler handler_2) {
-  for (int i = 0; i < 2; i++) {
-    bool is_profiling = (i > 0);
-    // Test constructor calls.
-    {
-      LocalContext env;
-      v8::HandleScope scope(env->GetIsolate());
-
-      v8::Local<v8::String> profile_name = v8::String::New("my_profile1");
-      v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
-      if (is_profiling) {
-        cpu_profiler->StartCpuProfiling(profile_name);
-      }
-
-      Local<v8::FunctionTemplate> fun_templ =
-          v8::FunctionTemplate::New(handler);
-      Local<Function> fun = fun_templ->GetFunction();
-      env->Global()->Set(v8_str("obj"), fun);
-      Local<Script> script = v8_compile("obj()");
-      for (int i = 0; i < 30; i++) {
-        CHECK_EQ(102, script->Run()->Int32Value());
-      }
-
-      if (is_profiling) {
-        cpu_profiler->StopCpuProfiling(profile_name);
-      }
+  // Test constructor calls.
+  {
+    LocalContext env;
+    v8::HandleScope scope(env->GetIsolate());
+    Local<v8::FunctionTemplate> fun_templ =
+        v8::FunctionTemplate::New(handler);
+    Local<Function> fun = fun_templ->GetFunction();
+    env->Global()->Set(v8_str("obj"), fun);
+    Local<Script> script = v8_compile("obj()");
+    for (int i = 0; i < 30; i++) {
+      CHECK_EQ(102, script->Run()->Int32Value());
     }
-    // Use SetCallHandler to initialize a function template, should work like
-    // the previous one.
-    {
-      LocalContext env;
-      v8::HandleScope scope(env->GetIsolate());
-
-      v8::Local<v8::String> profile_name = v8::String::New("my_profile2");
-      v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
-      if (is_profiling) {
-        cpu_profiler->StartCpuProfiling(profile_name);
-      }
-
-      Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
-      fun_templ->SetCallHandler(handler_2);
-      Local<Function> fun = fun_templ->GetFunction();
-      env->Global()->Set(v8_str("obj"), fun);
-      Local<Script> script = v8_compile("obj()");
-      for (int i = 0; i < 30; i++) {
-        CHECK_EQ(102, script->Run()->Int32Value());
-      }
-
-      if (is_profiling) {
-        cpu_profiler->DeleteAllCpuProfiles();
-      }
+  }
+  // Use SetCallHandler to initialize a function template, should work like the
+  // previous one.
+  {
+    LocalContext env;
+    v8::HandleScope scope(env->GetIsolate());
+    Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
+    fun_templ->SetCallHandler(handler_2);
+    Local<Function> fun = fun_templ->GetFunction();
+    env->Global()->Set(v8_str("obj"), fun);
+    Local<Script> script = v8_compile("obj()");
+    for (int i = 0; i < 30; i++) {
+      CHECK_EQ(102, script->Run()->Int32Value());
     }
   }
 }
 
 
 template<typename Constructor, typename Accessor>
 static void TestFunctionTemplateAccessor(Constructor constructor,
                                          Accessor accessor) {
-  for (int i = 0; i < 2; i++) {
-    bool is_profiling = (i > 0);
-    LocalContext env;
-    v8::HandleScope scope(env->GetIsolate());
-
-    v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
-    if (is_profiling) {
-      v8::Local<v8::String> profile_name = v8::String::New("my_profile1");
-      cpu_profiler->StartCpuProfiling(profile_name);
-    }
-
-    Local<v8::FunctionTemplate> fun_templ =
-        v8::FunctionTemplate::New(constructor);
-    fun_templ->SetClassName(v8_str("funky"));
-    fun_templ->InstanceTemplate()->SetAccessor(v8_str("m"), accessor);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
-    Local<Value> result = v8_compile("(new obj()).toString()")->Run();
-    CHECK_EQ(v8_str("[object funky]"), result);
-    CompileRun("var obj_instance = new obj();");
-    Local<Script> script;
-    script = v8_compile("obj_instance.x");
-    for (int i = 0; i < 30; i++) {
-      CHECK_EQ(1, script->Run()->Int32Value());
-    }
-    script = v8_compile("obj_instance.m");
-    for (int i = 0; i < 30; i++) {
-      CHECK_EQ(239, script->Run()->Int32Value());
-    }
-
-    if (is_profiling) {
-      cpu_profiler->DeleteAllCpuProfiles();
-    }
+  LocalContext env;
+  v8::HandleScope scope(env->GetIsolate());
+  Local<v8::FunctionTemplate> fun_templ =
+      v8::FunctionTemplate::New(constructor);
+  fun_templ->SetClassName(v8_str("funky"));
+  fun_templ->InstanceTemplate()->SetAccessor(v8_str("m"), accessor);
+  Local<Function> fun = fun_templ->GetFunction();
+  env->Global()->Set(v8_str("obj"), fun);
+  Local<Value> result = v8_compile("(new obj()).toString()")->Run();
+  CHECK_EQ(v8_str("[object funky]"), result);
+  CompileRun("var obj_instance = new obj();");
+  Local<Script> script;
+  script = v8_compile("obj_instance.x");
+  for (int i = 0; i < 30; i++) {
+    CHECK_EQ(1, script->Run()->Int32Value());
+  }
+  script = v8_compile("obj_instance.m");
+  for (int i = 0; i < 30; i++) {
+    CHECK_EQ(239, script->Run()->Int32Value());
   }
 }
 
 
 THREADED_TEST(FunctionTemplate) {
   TestFunctionTemplateInitializer(handle_call, handle_call_2);
   TestFunctionTemplateInitializer(handle_call_indirect, handle_call_indirect_2);
   TestFunctionTemplateInitializer(handle_callback, handle_callback_2);
 
   TestFunctionTemplateAccessor(construct_call, Return239);
   TestFunctionTemplateAccessor(construct_call_indirect, Return239Indirect);
   TestFunctionTemplateAccessor(construct_callback, Return239Callback);
 }
 
 
 static v8::Handle<v8::Value> SimpleDirectCallback(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, FUNCTION_ADDR(SimpleDirectCallback));
+  CheckReturnValue(args);
   args.GetReturnValue().Set(v8_str("bad value"));
   return v8_num(51423 + args.Length());
 }
 
 static v8::Handle<v8::Value> SimpleIndirectCallback(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, FUNCTION_ADDR(SimpleIndirectCallback));
+  CheckReturnValue(args);
   args.GetReturnValue().Set(v8_num(51423 + args.Length()));
   return v8::Handle<v8::Value>();
 }
 
 static void SimpleCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info, FUNCTION_ADDR(SimpleCallback));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(v8_num(51423 + info.Length()));
 }
 
 
 template<typename Callback>
 static void TestSimpleCallback(Callback callback) {
-  for (int i = 0; i < 2; i++) {
-    bool is_profiling = i;
-    LocalContext env;
-    v8::HandleScope scope(env->GetIsolate());
-
-    v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
-    if (is_profiling) {
-      v8::Local<v8::String> profile_name = v8::String::New("my_profile1");
-      cpu_profiler->StartCpuProfiling(profile_name);
-    }
-
-    v8::Handle<v8::ObjectTemplate> object_template = v8::ObjectTemplate::New();
-    object_template->Set("callback", v8::FunctionTemplate::New(callback));
-    v8::Local<v8::Object> object = object_template->NewInstance();
-    (*env)->Global()->Set(v8_str("callback_object"), object);
-    v8::Handle<v8::Script> script;
-    script = v8_compile("callback_object.callback(17)");
-    for (int i = 0; i < 30; i++) {
-      CHECK_EQ(51424, script->Run()->Int32Value());
-    }
-    script = v8_compile("callback_object.callback(17, 24)");
-    for (int i = 0; i < 30; i++) {
-      CHECK_EQ(51425, script->Run()->Int32Value());
-    }
-
-    if (is_profiling) {
-      cpu_profiler->DeleteAllCpuProfiles();
-    }
+  LocalContext env;
+  v8::HandleScope scope(env->GetIsolate());
+  v8::Handle<v8::ObjectTemplate> object_template = v8::ObjectTemplate::New();
+  object_template->Set("callback", v8::FunctionTemplate::New(callback));
+  v8::Local<v8::Object> object = object_template->NewInstance();
+  (*env)->Global()->Set(v8_str("callback_object"), object);
+  v8::Handle<v8::Script> script;
+  script = v8_compile("callback_object.callback(17)");
+  for (int i = 0; i < 30; i++) {
+    CHECK_EQ(51424, script->Run()->Int32Value());
+  }
+  script = v8_compile("callback_object.callback(17, 24)");
+  for (int i = 0; i < 30; i++) {
+    CHECK_EQ(51425, script->Run()->Int32Value());
   }
 }
 
 
 THREADED_TEST(SimpleCallback) {
   TestSimpleCallback(SimpleDirectCallback);
   TestSimpleCallback(SimpleIndirectCallback);
   TestSimpleCallback(SimpleCallback);
 }
 
 
 template<typename T>
 void FastReturnValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
 
 // constant return values
 static int32_t fast_return_value_int32 = 471;
 static uint32_t fast_return_value_uint32 = 571;
 static const double kFastReturnValueDouble = 2.7;
 // variable return values
 static bool fast_return_value_bool = false;
 enum ReturnValueOddball {
   kNullReturnValue,
   kUndefinedReturnValue,
   kEmptyStringReturnValue
 };
 static ReturnValueOddball fast_return_value_void;
 static bool fast_return_value_object_is_empty = false;
 
-// Helper function to avoid compiler error: insufficient contextual information
-// to determine type when applying FUNCTION_ADDR to a template function.
-static i::Address address_of(v8::FunctionCallback callback) {
-  return FUNCTION_ADDR(callback);
-}
-
 template<>
 void FastReturnValueCallback<int32_t>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, address_of(FastReturnValueCallback<int32_t>));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(fast_return_value_int32);
 }
 
 template<>
 void FastReturnValueCallback<uint32_t>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, address_of(FastReturnValueCallback<uint32_t>));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(fast_return_value_uint32);
 }
 
 template<>
 void FastReturnValueCallback<double>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, address_of(FastReturnValueCallback<double>));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(kFastReturnValueDouble);
 }
 
 template<>
 void FastReturnValueCallback<bool>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, address_of(FastReturnValueCallback<bool>));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(fast_return_value_bool);
 }
 
 template<>
 void FastReturnValueCallback<void>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, address_of(FastReturnValueCallback<void>));
+  CheckReturnValue(info);
   switch (fast_return_value_void) {
     case kNullReturnValue:
       info.GetReturnValue().SetNull();
       break;
     case kUndefinedReturnValue:
       info.GetReturnValue().SetUndefined();
       break;
     case kEmptyStringReturnValue:
       info.GetReturnValue().SetEmptyString();
       break;
@@ skipping 956 matching lines @@
   Local<Script> script = v8_compile("obj[900]");
   CHECK_EQ(script->Run()->Int32Value(), 900);
 }
 
 
 v8::Handle<v8::Object> bottom;
 
 static void CheckThisIndexedPropertyHandler(
     uint32_t index,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyHandler));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 static void CheckThisNamedPropertyHandler(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyHandler));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 void CheckThisIndexedPropertySetter(
     uint32_t index,
     Local<Value> value,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertySetter));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertySetter(
     Local<String> property,
     Local<Value> value,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertySetter));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 void CheckThisIndexedPropertyQuery(
     uint32_t index,
     const v8::PropertyCallbackInfo<v8::Integer>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyQuery));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertyQuery(
     Local<String> property,
     const v8::PropertyCallbackInfo<v8::Integer>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyQuery));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisIndexedPropertyDeleter(
     uint32_t index,
     const v8::PropertyCallbackInfo<v8::Boolean>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyDeleter));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertyDeleter(
     Local<String> property,
     const v8::PropertyCallbackInfo<v8::Boolean>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyDeleter));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisIndexedPropertyEnumerator(
     const v8::PropertyCallbackInfo<v8::Array>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyEnumerator));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertyEnumerator(
     const v8::PropertyCallbackInfo<v8::Array>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyEnumerator));
+  CheckReturnValue(info);
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 THREADED_TEST(PropertyHandlerInPrototype) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Set up a prototype chain with three interceptors.
@@ skipping 897 matching lines @@
     Local<String> str = v8_str("str");
     global_handles =
         reinterpret_cast<v8::internal::Isolate*>(isolate)->global_handles();
     initial_handle_count = global_handles->NumberOfGlobalHandles();
     global.Reset(isolate, str);
   }
   CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count + 1);
   String* str = global.ClearAndLeak();
   CHECK(global.IsEmpty());
   CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count + 1);
-  global_handles->Destroy(reinterpret_cast<i::Object**>(str));
+  v8::Persistent<String>* new_global =
+      reinterpret_cast<v8::Persistent<String>*>(&str);
+  new_global->Dispose();
   CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count);
 }
 
 
 THREADED_TEST(GlobalHandleUpcast) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope scope(isolate);
   v8::Local<String> local = v8::Local<String>::New(v8_str("str"));
   v8::Persistent<String> global_string(isolate, local);
 #ifdef V8_USE_UNSAFE_HANDLES
@@ skipping 7565 matching lines @@
     "  result"
     "} catch(e) {"
     "  e"
     "};");
   CHECK_EQ(239 * 10, value->Int32Value());
 }
 
 static v8::Handle<Value> InterceptorCallICFastApi(Local<String> name,
                                                   const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info, FUNCTION_ADDR(InterceptorCallICFastApi));
+  CheckReturnValue(info);
   int* call_count =
       reinterpret_cast<int*>(v8::External::Cast(*info.Data())->Value());
   ++(*call_count);
   if ((*call_count) % 20 == 0) {
     HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
   }
   return v8::Handle<Value>();
 }
 
 static v8::Handle<Value> FastApiCallback_TrivialSignature(
     const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_TrivialSignature));
+  CheckReturnValue(args);
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   CHECK_EQ(isolate, args.GetIsolate());
   CHECK_EQ(args.This(), args.Holder());
   CHECK(args.Data()->Equals(v8_str("method_data")));
   return v8::Integer::New(args[0]->Int32Value() + 1);
 }
 
 static v8::Handle<Value> FastApiCallback_SimpleSignature(
     const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_SimpleSignature));
+  CheckReturnValue(args);
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   CHECK_EQ(isolate, args.GetIsolate());
   CHECK_EQ(args.This()->GetPrototype(), args.Holder());
   CHECK(args.Data()->Equals(v8_str("method_data")));
   // Note, we're using HasRealNamedProperty instead of Has to avoid
   // invoking the interceptor again.
   CHECK(args.Holder()->HasRealNamedProperty(v8_str("foo")));
   return v8::Integer::New(args[0]->Int32Value() + 1);
 }
 
@@ skipping 67 matching lines @@
 static Handle<Value> DoDirectGetter() {
   if (++p_getter_count % 3 == 0) {
     HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
     GenerateSomeGarbage();
   }
   return v8_str("Direct Getter Result");
 }
 
 static v8::Handle<v8::Value> DirectGetter(Local<String> name,
                                   const v8::AccessorInfo& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(DirectGetter));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(v8_str("Garbage"));
   return DoDirectGetter();
 }
 
 static v8::Handle<v8::Value> DirectGetterIndirect(
     Local<String> name,
     const v8::AccessorInfo& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(DirectGetterIndirect));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(DoDirectGetter());
   return v8::Handle<v8::Value>();
 }
 
 static void DirectGetterCallback(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info, FUNCTION_ADDR(DirectGetterCallback));
+  CheckReturnValue(info);
   info.GetReturnValue().Set(DoDirectGetter());
 }
 
 
 template<typename Accessor>
 static void LoadICFastApi_DirectCall_GCMoveStub(Accessor accessor) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::Handle<v8::ObjectTemplate> obj = v8::ObjectTemplate::New();
   obj->SetAccessor(v8_str("p1"), accessor);
@@ skipping 1895 matching lines @@
   v8::Isolate* isolate = outer->GetIsolate();
   v8::Persistent<v8::Context> inner;
   {
     v8::HandleScope scope(isolate);
     inner.Reset(isolate, v8::Context::New(isolate));
   }
   v8::HandleScope scope(isolate);
   {
     // Don't want a handle here, so do this unsafely
     v8::Handle<v8::Context> inner_local =
-        v8::Utils::Convert<i::Object, v8::Context>(
-            v8::Utils::OpenPersistent(inner));
+        *reinterpret_cast<v8::Handle<v8::Context>*>(&inner);
     inner_local->Enter();
     inner.Dispose();
     inner.Clear();
     inner_local->Exit();
   }
 }
 
 
 // Regression test for issue 54, object templates with internal fields
 // but no accessors or interceptors did not get their internal field
@@ skipping 6675 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32