A64: Synchronize with r15358.

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 55 matching lines @@
 using ::v8::Script;
 using ::v8::StackTrace;
 using ::v8::String;
 using ::v8::TryCatch;
 using ::v8::Undefined;
 using ::v8::UniqueId;
 using ::v8::V8;
 using ::v8::Value;
 
 
+#define THREADED_PROFILED_TEST(Name)                                 \
+  static void Test##Name();                                          \
+  TEST(Name##WithProfiler) {                                         \
+    RunWithProfiler(&Test##Name);                                    \
+  }                                                                  \
+  THREADED_TEST(Name)
+
+void RunWithProfiler(void (*test)()) {
+  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();
+
+  cpu_profiler->StartCpuProfiling(profile_name);
+  (*test)();
+  cpu_profiler->DeleteAllCpuProfiles();
+}
+
+
 static void ExpectString(const char* code, const char* expected) {
   Local<Value> result = CompileRun(code);
   CHECK(result->IsString());
   String::Utf8Value utf8(result);
   CHECK_EQ(expected, *utf8);
 }
 
 static void ExpectInt32(const char* code, int expected) {
   Local<Value> result = CompileRun(code);
   CHECK(result->IsInt32());
@@ skipping 23 matching lines @@
 }
 
 
 static void ExpectUndefined(const char* code) {
   Local<Value> result = CompileRun(code);
   CHECK(result->IsUndefined());
 }
 
 
 static int signature_callback_count;
-static v8::Handle<Value> IncrementingSignatureCallback(
-    const v8::Arguments& args) {
+static void IncrementingSignatureCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   signature_callback_count++;
   v8::Handle<v8::Array> result = v8::Array::New(args.Length());
   for (int i = 0; i < args.Length(); i++)
     result->Set(v8::Integer::New(i), args[i]);
-  return result;
+  args.GetReturnValue().Set(result);
 }
 
 
-static v8::Handle<Value> SignatureCallback(const v8::Arguments& args) {
+static void SignatureCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   v8::Handle<v8::Array> result = v8::Array::New(args.Length());
   for (int i = 0; i < args.Length(); i++) {
     result->Set(v8::Integer::New(i), args[i]);
   }
-  return result;
+  args.GetReturnValue().Set(result);
 }
 
 
 THREADED_TEST(Handles) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<Context> local_env;
   {
     LocalContext env;
     local_env = env.local();
   }
@@ skipping 674 matching lines @@
   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) {
-  ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, callback);
-  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_impl(args, FUNCTION_ADDR(handle_call_2));
-}
-
-static v8::Handle<Value> handle_call_indirect_impl(const v8::Arguments& args,
-                                                   i::Address callback) {
-  ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, callback);
-  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_impl(args, FUNCTION_ADDR(handle_call_indirect_2));
-}
 
 static void handle_callback_impl(const v8::FunctionCallbackInfo<Value>& info,
                                  i::Address callback) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(info, callback);
   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));
 }
 
-static v8::Handle<Value> construct_call(const v8::Arguments& args) {
-  ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args, FUNCTION_ADDR(construct_call));
-  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));
-  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));
   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));
-  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));
-  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));
   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());
+  // 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());
+    }
+  }
+  // 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(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);
-      }
-    }
-    // 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();
-      }
+    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());
+  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();
-    }
+  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);
+THREADED_PROFILED_TEST(FunctionTemplate) {
   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));
-  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));
-  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));
   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());
+  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();
-    }
+  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);
+THREADED_PROFILED_TEST(SimpleCallback) {
   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;
@@ skipping 72 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::ObjectTemplate> object_template = v8::ObjectTemplate::New();
   v8::FunctionCallback callback = &FastReturnValueCallback<T>;
   object_template->Set("callback", v8::FunctionTemplate::New(callback));
   v8::Local<v8::Object> object = object_template->NewInstance();
   (*env)->Global()->Set(v8_str("callback_object"), object);
   return scope.Close(CompileRun("callback_object.callback()"));
 }
 
-THREADED_TEST(FastReturnValues) {
+THREADED_PROFILED_TEST(FastReturnValues) {
   LocalContext env;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::Value> value;
   // check int32_t and uint32_t
   int32_t int_values[] = {
       0, 234, -723,
       i::Smi::kMinValue, i::Smi::kMaxValue
   };
   for (size_t i = 0; i < ARRAY_SIZE(int_values); i++) {
     for (int modifier = -1; modifier <= 1; modifier++) {
@@ skipping 51 matching lines @@
   value = TestFastReturnValues<Object>();
   CHECK(value->IsUndefined());
 }
 
 
 THREADED_TEST(FunctionTemplateSetLength) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   {
     Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New(
-        handle_call, Handle<v8::Value>(), Handle<v8::Signature>(), 23);
+        handle_callback, Handle<v8::Value>(), Handle<v8::Signature>(), 23);
     Local<Function> fun = fun_templ->GetFunction();
     env->Global()->Set(v8_str("obj"), fun);
     Local<Script> script = v8_compile("obj.length");
     CHECK_EQ(23, script->Run()->Int32Value());
   }
   {
     Local<v8::FunctionTemplate> fun_templ =
-        v8::FunctionTemplate::New(handle_call);
+        v8::FunctionTemplate::New(handle_callback);
     fun_templ->SetLength(22);
     Local<Function> fun = fun_templ->GetFunction();
     env->Global()->Set(v8_str("obj"), fun);
     Local<Script> script = v8_compile("obj.length");
     CHECK_EQ(22, script->Run()->Int32Value());
   }
   {
     // Without setting length it defaults to 0.
     Local<v8::FunctionTemplate> fun_templ =
-        v8::FunctionTemplate::New(handle_call);
+        v8::FunctionTemplate::New(handle_callback);
     Local<Function> fun = fun_templ->GetFunction();
     env->Global()->Set(v8_str("obj"), fun);
     Local<Script> script = v8_compile("obj.length");
     CHECK_EQ(0, script->Run()->Int32Value());
   }
 }
 
 
 static void* expected_ptr;
-static v8::Handle<v8::Value> callback(const v8::Arguments& args) {
+static void callback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   void* ptr = v8::External::Cast(*args.Data())->Value();
   CHECK_EQ(expected_ptr, ptr);
-  return v8::True();
+  args.GetReturnValue().Set(true);
 }
 
 
 static void TestExternalPointerWrapping() {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Value> data = v8::External::New(expected_ptr);
 
   v8::Handle<v8::Object> obj = v8::Object::New();
@@ skipping 357 matching lines @@
   v8::Handle<String> str2 = v8_str("x");
   CHECK(str2->BooleanValue());
   CHECK(!v8::Number::New(0)->BooleanValue());
   CHECK(v8::Number::New(-1)->BooleanValue());
   CHECK(v8::Number::New(1)->BooleanValue());
   CHECK(v8::Number::New(42)->BooleanValue());
   CHECK(!v8_compile("NaN")->Run()->BooleanValue());
 }
 
 
-static v8::Handle<Value> DummyCallHandler(const v8::Arguments& args) {
+static void DummyCallHandler(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(13.4);
+  args.GetReturnValue().Set(v8_num(13.4));
 }
 
 
-static v8::Handle<Value> GetM(Local<String> name, const AccessorInfo&) {
+static void GetM(Local<String> name,
+                 const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(876);
+  info.GetReturnValue().Set(v8_num(876));
 }
 
 
 THREADED_TEST(GlobalPrototype) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> func_templ = v8::FunctionTemplate::New();
   func_templ->PrototypeTemplate()->Set(
       "dummy",
       v8::FunctionTemplate::New(DummyCallHandler));
   v8::Handle<ObjectTemplate> templ = func_templ->InstanceTemplate();
@@ skipping 25 matching lines @@
   templ2->Set("b", templ1);
   Local<v8::Object> instance2 = templ2->NewInstance();
   env->Global()->Set(v8_str("q"), instance2);
   CHECK(v8_compile("(q.nirk == 123)")->Run()->BooleanValue());
   CHECK(v8_compile("(q.a == 12)")->Run()->BooleanValue());
   CHECK(v8_compile("(q.b.x == 10)")->Run()->BooleanValue());
   CHECK(v8_compile("(q.b.y == 13)")->Run()->BooleanValue());
 }
 
 
-static v8::Handle<Value> GetFlabby(const v8::Arguments& args) {
+static void GetFlabby(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(17.2);
+  args.GetReturnValue().Set(v8_num(17.2));
 }
 
 
-static v8::Handle<Value> GetKnurd(Local<String> property, const AccessorInfo&) {
+static void GetKnurd(Local<String> property,
+                     const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(15.2);
+  info.GetReturnValue().Set(v8_num(15.2));
 }
 
 
 THREADED_TEST(DescriptorInheritance) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> super = v8::FunctionTemplate::New();
   super->PrototypeTemplate()->Set("flabby",
                                   v8::FunctionTemplate::New(GetFlabby));
   super->PrototypeTemplate()->Set("PI", v8_num(3.14));
 
@@ skipping 42 matching lines @@
 
   // base1 and base2 cannot cross reference to each's prototype
   CHECK(v8_compile("obj.v2")->Run()->IsUndefined());
   CHECK(v8_compile("obj2.v1")->Run()->IsUndefined());
 }
 
 
 int echo_named_call_count;
 
 
-static v8::Handle<Value> EchoNamedProperty(Local<String> name,
-                                           const AccessorInfo& info) {
+static void EchoNamedProperty(Local<String> name,
+                              const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(v8_str("data"), info.Data());
   echo_named_call_count++;
-  return name;
+  info.GetReturnValue().Set(name);
 }
 
 // Helper functions for Interceptor/Accessor interaction tests
 
-Handle<Value> SimpleAccessorGetter(Local<String> name,
-                                   const AccessorInfo& info) {
+void SimpleAccessorGetter(Local<String> name,
+                          const v8::PropertyCallbackInfo<v8::Value>& info) {
   Handle<Object> self = info.This();
-  return self->Get(String::Concat(v8_str("accessor_"), name));
+  info.GetReturnValue().Set(
+      self->Get(String::Concat(v8_str("accessor_"), name)));
 }
 
 void SimpleAccessorSetter(Local<String> name, Local<Value> value,
-                          const AccessorInfo& info) {
+                          const v8::PropertyCallbackInfo<void>& info) {
   Handle<Object> self = info.This();
   self->Set(String::Concat(v8_str("accessor_"), name), value);
 }
 
-Handle<Value> EmptyInterceptorGetter(Local<String> name,
-                                     const AccessorInfo& info) {
-  return Handle<Value>();
+void EmptyInterceptorGetter(Local<String> name,
+                            const v8::PropertyCallbackInfo<v8::Value>& info) {
 }
 
-Handle<Value> EmptyInterceptorSetter(Local<String> name,
-                                     Local<Value> value,
-                                     const AccessorInfo& info) {
-  return Handle<Value>();
+void EmptyInterceptorSetter(Local<String> name,
+                            Local<Value> value,
+                            const v8::PropertyCallbackInfo<v8::Value>& info) {
 }
 
-Handle<Value> InterceptorGetter(Local<String> name,
-                                const AccessorInfo& info) {
+void InterceptorGetter(Local<String> name,
+                       const v8::PropertyCallbackInfo<v8::Value>& info) {
   // Intercept names that start with 'interceptor_'.
   String::Utf8Value utf8(name);
   char* name_str = *utf8;
   char prefix[] = "interceptor_";
   int i;
   for (i = 0; name_str[i] && prefix[i]; ++i) {
-    if (name_str[i] != prefix[i]) return Handle<Value>();
+    if (name_str[i] != prefix[i]) return;
   }
   Handle<Object> self = info.This();
-  return self->GetHiddenValue(v8_str(name_str + i));
+  info.GetReturnValue().Set(self->GetHiddenValue(v8_str(name_str + i)));
 }
 
-Handle<Value> InterceptorSetter(Local<String> name,
-                                Local<Value> value,
-                                const AccessorInfo& info) {
+void InterceptorSetter(Local<String> name,
+                       Local<Value> value,
+                       const v8::PropertyCallbackInfo<v8::Value>& info) {
   // Intercept accesses that set certain integer values.
   if (value->IsInt32() && value->Int32Value() < 10000) {
     Handle<Object> self = info.This();
     self->SetHiddenValue(name, value);
-    return value;
+    info.GetReturnValue().Set(value);
   }
-  return Handle<Value>();
 }
 
 void AddAccessor(Handle<FunctionTemplate> templ,
                  Handle<String> name,
-                 v8::AccessorGetter getter,
-                 v8::AccessorSetter setter) {
+                 v8::AccessorGetterCallback getter,
+                 v8::AccessorSetterCallback setter) {
   templ->PrototypeTemplate()->SetAccessor(name, getter, setter);
 }
 
 void AddInterceptor(Handle<FunctionTemplate> templ,
-                    v8::NamedPropertyGetter getter,
-                    v8::NamedPropertySetter setter) {
+                    v8::NamedPropertyGetterCallback getter,
+                    v8::NamedPropertySetterCallback setter) {
   templ->InstanceTemplate()->SetNamedPropertyHandler(getter, setter);
 }
 
 THREADED_TEST(EmptyInterceptorDoesNotShadowAccessors) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Handle<FunctionTemplate> parent = FunctionTemplate::New();
   Handle<FunctionTemplate> child = FunctionTemplate::New();
   child->Inherit(parent);
   AddAccessor(parent, v8_str("age"),
               SimpleAccessorGetter, SimpleAccessorSetter);
@@ skipping 220 matching lines @@
   // Check default behavior
   CHECK_EQ(v8_compile("obj.flob = 10;")->Run()->Int32Value(), 10);
   CHECK(v8_compile("'myProperty' in obj")->Run()->BooleanValue());
   CHECK(v8_compile("delete obj.myProperty")->Run()->BooleanValue());
 }
 
 
 int echo_indexed_call_count = 0;
 
 
-static v8::Handle<Value> EchoIndexedProperty(uint32_t index,
-                                             const AccessorInfo& info) {
+static void EchoIndexedProperty(
+    uint32_t index,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(v8_num(637), info.Data());
   echo_indexed_call_count++;
-  return v8_num(index);
+  info.GetReturnValue().Set(v8_num(index));
 }
 
 
 THREADED_TEST(IndexedPropertyHandlerGetter) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
   templ->InstanceTemplate()->SetIndexedPropertyHandler(EchoIndexedProperty,
                                                        0, 0, 0, 0,
                                                        v8_num(637));
   LocalContext env;
@@ skipping 86 matching lines @@
 
 
 void CheckThisNamedPropertyEnumerator(
     const v8::PropertyCallbackInfo<v8::Array>& info) {
   CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyEnumerator));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
-THREADED_TEST(PropertyHandlerInPrototype) {
+THREADED_PROFILED_TEST(PropertyHandlerInPrototype) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Set up a prototype chain with three interceptors.
   v8::Handle<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
   templ->InstanceTemplate()->SetIndexedPropertyHandler(
       CheckThisIndexedPropertyHandler,
       CheckThisIndexedPropertySetter,
       CheckThisIndexedPropertyQuery,
       CheckThisIndexedPropertyDeleter,
@@ skipping 28 matching lines @@
 
   // Indexed and named deleter.
   Script::Compile(v8_str("delete obj[0]"))->Run();
   Script::Compile(v8_str("delete obj.x"))->Run();
 
   // Enumerators.
   Script::Compile(v8_str("for (var p in obj) ;"))->Run();
 }
 
 
-static v8::Handle<Value> PrePropertyHandlerGet(Local<String> key,
-                                               const AccessorInfo& info) {
+static void PrePropertyHandlerGet(
+    Local<String> key,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (v8_str("pre")->Equals(key)) {
-    return v8_str("PrePropertyHandler: pre");
+    info.GetReturnValue().Set(v8_str("PrePropertyHandler: pre"));
   }
-  return v8::Handle<String>();
 }
 
 
-static v8::Handle<v8::Integer> PrePropertyHandlerQuery(Local<String> key,
-                                                       const AccessorInfo&) {
+static void PrePropertyHandlerQuery(
+    Local<String> key,
+    const v8::PropertyCallbackInfo<v8::Integer>& info) {
   if (v8_str("pre")->Equals(key)) {
-    return v8::Integer::New(v8::None);
+    info.GetReturnValue().Set(static_cast<int32_t>(v8::None));
   }
-
-  return v8::Handle<v8::Integer>();  // do not intercept the call
 }
 
 
 THREADED_TEST(PrePropertyHandler) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> desc = v8::FunctionTemplate::New();
   desc->InstanceTemplate()->SetNamedPropertyHandler(PrePropertyHandlerGet,
                                                     0,
                                                     PrePropertyHandlerQuery);
   LocalContext env(NULL, desc->InstanceTemplate());
@@ skipping 14 matching lines @@
   v8::Handle<Value> result = Script::Compile(v8_str(
       "this.propertyIsEnumerable(undefined)"))->Run();
   CHECK(result->IsFalse());
 }
 
 
 v8::Handle<Script> call_recursively_script;
 static const int kTargetRecursionDepth = 200;  // near maximum
 
 
-static v8::Handle<Value> CallScriptRecursivelyCall(const v8::Arguments& args) {
+static void CallScriptRecursivelyCall(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   int depth = args.This()->Get(v8_str("depth"))->Int32Value();
-  if (depth == kTargetRecursionDepth) return v8::Undefined();
+  if (depth == kTargetRecursionDepth) return;
   args.This()->Set(v8_str("depth"), v8::Integer::New(depth + 1));
-  return call_recursively_script->Run();
+  args.GetReturnValue().Set(call_recursively_script->Run());
 }
 
 
-static v8::Handle<Value> CallFunctionRecursivelyCall(
-    const v8::Arguments& args) {
+static void CallFunctionRecursivelyCall(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   int depth = args.This()->Get(v8_str("depth"))->Int32Value();
   if (depth == kTargetRecursionDepth) {
     printf("[depth = %d]\n", depth);
-    return v8::Undefined();
+    return;
   }
   args.This()->Set(v8_str("depth"), v8::Integer::New(depth + 1));
   v8::Handle<Value> function =
       args.This()->Get(v8_str("callFunctionRecursively"));
-  return function.As<Function>()->Call(args.This(), 0, NULL);
+  args.GetReturnValue().Set(
+      function.As<Function>()->Call(args.This(), 0, NULL));
 }
 
 
 THREADED_TEST(DeepCrossLanguageRecursion) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> global = ObjectTemplate::New();
   global->Set(v8_str("callScriptRecursively"),
               v8::FunctionTemplate::New(CallScriptRecursivelyCall));
   global->Set(v8_str("callFunctionRecursively"),
               v8::FunctionTemplate::New(CallFunctionRecursivelyCall));
   LocalContext env(NULL, global);
 
   env->Global()->Set(v8_str("depth"), v8::Integer::New(0));
   call_recursively_script = v8_compile("callScriptRecursively()");
   call_recursively_script->Run();
   call_recursively_script = v8::Handle<Script>();
 
   env->Global()->Set(v8_str("depth"), v8::Integer::New(0));
   Script::Compile(v8_str("callFunctionRecursively()"))->Run();
 }
 
 
-static v8::Handle<Value>
-    ThrowingPropertyHandlerGet(Local<String> key, const AccessorInfo&) {
+static void ThrowingPropertyHandlerGet(
+    Local<String> key,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8::ThrowException(key);
+  info.GetReturnValue().Set(v8::ThrowException(key));
 }
 
 
-static v8::Handle<Value> ThrowingPropertyHandlerSet(Local<String> key,
-                                                    Local<Value>,
-                                                    const AccessorInfo&) {
+static void ThrowingPropertyHandlerSet(
+    Local<String> key,
+    Local<Value>,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::ThrowException(key);
-  return v8::Undefined();  // not the same as v8::Handle<v8::Value>()
+  info.GetReturnValue().SetUndefined();  // not the same as empty handle
 }
 
 
 THREADED_TEST(CallbackExceptionRegression) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New();
   obj->SetNamedPropertyHandler(ThrowingPropertyHandlerGet,
                                ThrowingPropertyHandlerSet);
   LocalContext env;
   env->Global()->Set(v8_str("obj"), obj->NewInstance());
@@ skipping 386 matching lines @@
   CHECK_EQ(100, result->Int32Value());
   CHECK_EQ(0xBB, my_data[0]);
   CHECK_EQ(0xCC, my_data[1]);
   my_data[0] = 0xCC;
   my_data[1] = 0x11;
   result = CompileRun("u8_b[0] + u8_b[1]");
   CHECK_EQ(0xDD, result->Int32Value());
 }
 
 
+static void CheckDataViewIsNeutered(v8::Handle<v8::DataView> dv) {
+  CHECK_EQ(0, static_cast<int>(dv->ByteLength()));
+  CHECK_EQ(0, static_cast<int>(dv->ByteOffset()));
+}
+
+
 static void CheckIsNeutered(v8::Handle<v8::TypedArray> ta) {
   CHECK_EQ(0, static_cast<int>(ta->ByteLength()));
   CHECK_EQ(0, static_cast<int>(ta->Length()));
   CHECK_EQ(0, static_cast<int>(ta->ByteOffset()));
 }
 
+
+static void CheckIsTypedArrayVarNeutered(const char* name) {
+  i::ScopedVector<char> source(1024);
+  i::OS::SNPrintF(source,
+      "%s.byteLength == 0 && %s.byteOffset == 0 && %s.length == 0",
+      name, name, name);
+  CHECK(CompileRun(source.start())->IsTrue());
+  v8::Handle<v8::TypedArray> ta =
+    v8::Handle<v8::TypedArray>::Cast(CompileRun(name));
+  CheckIsNeutered(ta);
+}
+
+
 template <typename TypedArray, int kElementSize>
 static Handle<TypedArray> CreateAndCheck(Handle<v8::ArrayBuffer> ab,
                                          int byteOffset,
                                          int length) {
   v8::Handle<TypedArray> ta = TypedArray::New(ab, byteOffset, length);
   CHECK_EQ(byteOffset, static_cast<int>(ta->ByteOffset()));
   CHECK_EQ(length, static_cast<int>(ta->Length()));
   CHECK_EQ(length * kElementSize, static_cast<int>(ta->ByteLength()));
   return ta;
 }
@@ skipping 21 matching lines @@
   v8::Handle<v8::Uint32Array> u32a =
     CreateAndCheck<v8::Uint32Array, 4>(buffer, 4, 255);
   v8::Handle<v8::Int32Array> i32a =
     CreateAndCheck<v8::Int32Array, 4>(buffer, 4, 255);
 
   v8::Handle<v8::Float32Array> f32a =
     CreateAndCheck<v8::Float32Array, 4>(buffer, 4, 255);
   v8::Handle<v8::Float64Array> f64a =
     CreateAndCheck<v8::Float64Array, 8>(buffer, 8, 127);
 
+  v8::Handle<v8::DataView> dv = v8::DataView::New(buffer, 1, 1023);
+  CHECK_EQ(1, static_cast<int>(dv->ByteOffset()));
+  CHECK_EQ(1023, static_cast<int>(dv->ByteLength()));
+
   ScopedArrayBufferContents contents(buffer->Externalize());
   buffer->Neuter();
   CHECK_EQ(0, static_cast<int>(buffer->ByteLength()));
   CheckIsNeutered(u8a);
   CheckIsNeutered(u8c);
   CheckIsNeutered(i8a);
   CheckIsNeutered(u16a);
   CheckIsNeutered(i16a);
   CheckIsNeutered(u32a);
   CheckIsNeutered(i32a);
   CheckIsNeutered(f32a);
   CheckIsNeutered(f64a);
+  CheckDataViewIsNeutered(dv);
 }
 
 THREADED_TEST(ArrayBuffer_NeuteringScript) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   CompileRun(
       "var ab = new ArrayBuffer(1024);"
       "var u8a = new Uint8Array(ab, 1, 1023);"
       "var u8c = new Uint8ClampedArray(ab, 1, 1023);"
       "var i8a = new Int8Array(ab, 1, 1023);"
       "var u16a = new Uint16Array(ab, 2, 511);"
       "var i16a = new Int16Array(ab, 2, 511);"
       "var u32a = new Uint32Array(ab, 4, 255);"
       "var i32a = new Int32Array(ab, 4, 255);"
       "var f32a = new Float32Array(ab, 4, 255);"
-      "var f64a = new Float64Array(ab, 8, 127);");
+      "var f64a = new Float64Array(ab, 8, 127);"
+      "var dv = new DataView(ab, 1, 1023);");
 
   v8::Handle<v8::ArrayBuffer> ab =
       Local<v8::ArrayBuffer>::Cast(CompileRun("ab"));
 
-  v8::Handle<v8::Uint8Array> u8a =
-      v8::Handle<v8::Uint8Array>::Cast(CompileRun("u8a"));
-  v8::Handle<v8::Uint8ClampedArray> u8c =
-      v8::Handle<v8::Uint8ClampedArray>::Cast(CompileRun("u8c"));
-  v8::Handle<v8::Int8Array> i8a =
-      v8::Handle<v8::Int8Array>::Cast(CompileRun("i8a"));
-
-  v8::Handle<v8::Uint16Array> u16a =
-      v8::Handle<v8::Uint16Array>::Cast(CompileRun("u16a"));
-  v8::Handle<v8::Int16Array> i16a =
-      v8::Handle<v8::Int16Array>::Cast(CompileRun("i16a"));
-  v8::Handle<v8::Uint32Array> u32a =
-      v8::Handle<v8::Uint32Array>::Cast(CompileRun("u32a"));
-  v8::Handle<v8::Int32Array> i32a =
-      v8::Handle<v8::Int32Array>::Cast(CompileRun("i32a"));
-  v8::Handle<v8::Float32Array> f32a =
-      v8::Handle<v8::Float32Array>::Cast(CompileRun("f32a"));
-  v8::Handle<v8::Float64Array> f64a =
-    v8::Handle<v8::Float64Array>::Cast(CompileRun("f64a"));
+  v8::Handle<v8::DataView> dv =
+    v8::Handle<v8::DataView>::Cast(CompileRun("dv"));
 
   ScopedArrayBufferContents contents(ab->Externalize());
   ab->Neuter();
   CHECK_EQ(0, static_cast<int>(ab->ByteLength()));
-  CheckIsNeutered(u8a);
-  CheckIsNeutered(u8c);
-  CheckIsNeutered(i8a);
-  CheckIsNeutered(u16a);
-  CheckIsNeutered(i16a);
-  CheckIsNeutered(u32a);
-  CheckIsNeutered(i32a);
-  CheckIsNeutered(f32a);
-  CheckIsNeutered(f64a);
+  CHECK_EQ(0, CompileRun("ab.byteLength")->Int32Value());
+
+  CheckIsTypedArrayVarNeutered("u8a");
+  CheckIsTypedArrayVarNeutered("u8c");
+  CheckIsTypedArrayVarNeutered("i8a");
+  CheckIsTypedArrayVarNeutered("u16a");
+  CheckIsTypedArrayVarNeutered("i16a");
+  CheckIsTypedArrayVarNeutered("u32a");
+  CheckIsTypedArrayVarNeutered("i32a");
+  CheckIsTypedArrayVarNeutered("f32a");
+  CheckIsTypedArrayVarNeutered("f64a");
+
+  CHECK(CompileRun("dv.byteLength == 0 && dv.byteOffset == 0")->IsTrue());
+  CheckDataViewIsNeutered(dv);
 }
 
 
 
 THREADED_TEST(HiddenProperties) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Local<v8::Object> obj = v8::Object::New();
   v8::Local<v8::String> key = v8_str("api-test::hidden-key");
@@ skipping 65 matching lines @@
   // Make sure that the getter and setter from Object.prototype is not invoked.
   // If it did we would have full access to the hidden properties in
   // the accessor.
   CHECK(obj->SetHiddenValue(key, v8::Integer::New(42)));
   ExpectFalse("set_called");
   CHECK_EQ(42, obj->GetHiddenValue(key)->Int32Value());
 }
 
 
 static bool interceptor_for_hidden_properties_called;
-static v8::Handle<Value> InterceptorForHiddenProperties(
-    Local<String> name, const AccessorInfo& info) {
+static void InterceptorForHiddenProperties(
+    Local<String> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
   interceptor_for_hidden_properties_called = true;
-  return v8::Handle<Value>();
 }
 
 
 THREADED_TEST(HiddenPropertiesWithInterceptors) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   interceptor_for_hidden_properties_called = false;
 
   v8::Local<v8::String> key = v8_str("api-test::hidden-key");
@@ skipping 69 matching lines @@
 
 THREADED_TEST(ResettingGlobalHandle) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::Persistent<String> global;
   {
     v8::HandleScope scope(isolate);
     global.Reset(isolate, v8_str("str"));
   }
   v8::internal::GlobalHandles* global_handles =
       reinterpret_cast<v8::internal::Isolate*>(isolate)->global_handles();
-  int initial_handle_count = global_handles->NumberOfGlobalHandles();
+  int initial_handle_count = global_handles->global_handles_count();
   {
     v8::HandleScope scope(isolate);
     CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 3);
   }
   {
     v8::HandleScope scope(isolate);
     global.Reset(isolate, v8_str("longer"));
   }
-  CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count);
+  CHECK_EQ(global_handles->global_handles_count(), initial_handle_count);
   {
     v8::HandleScope scope(isolate);
     CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 6);
   }
   global.Dispose(isolate);
-  CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count - 1);
+  CHECK_EQ(global_handles->global_handles_count(), initial_handle_count - 1);
 }
 
 
 THREADED_TEST(ResettingGlobalHandleToEmpty) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::Persistent<String> global;
   {
     v8::HandleScope scope(isolate);
     global.Reset(isolate, v8_str("str"));
   }
   v8::internal::GlobalHandles* global_handles =
       reinterpret_cast<v8::internal::Isolate*>(isolate)->global_handles();
-  int initial_handle_count = global_handles->NumberOfGlobalHandles();
+  int initial_handle_count = global_handles->global_handles_count();
   {
     v8::HandleScope scope(isolate);
     CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 3);
   }
   {
     v8::HandleScope scope(isolate);
     Local<String> empty;
     global.Reset(isolate, empty);
   }
   CHECK(global.IsEmpty());
-  CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count - 1);
+  CHECK_EQ(global_handles->global_handles_count(), initial_handle_count - 1);
 }
 
 
 THREADED_TEST(ClearAndLeakGlobal) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::internal::GlobalHandles* global_handles = NULL;
   int initial_handle_count = 0;
   v8::Persistent<String> global;
   {
     v8::HandleScope scope(isolate);
     Local<String> str = v8_str("str");
     global_handles =
         reinterpret_cast<v8::internal::Isolate*>(isolate)->global_handles();
-    initial_handle_count = global_handles->NumberOfGlobalHandles();
+    initial_handle_count = global_handles->global_handles_count();
     global.Reset(isolate, str);
   }
-  CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count + 1);
+  CHECK_EQ(global_handles->global_handles_count(), initial_handle_count + 1);
   String* str = global.ClearAndLeak();
   CHECK(global.IsEmpty());
-  CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count + 1);
+  CHECK_EQ(global_handles->global_handles_count(), initial_handle_count + 1);
   global_handles->Destroy(reinterpret_cast<i::Object**>(str));
-  CHECK_EQ(global_handles->NumberOfGlobalHandles(), initial_handle_count);
+  CHECK_EQ(global_handles->global_handles_count(), 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
   v8::Persistent<Value> global_value =
@@ skipping 548 matching lines @@
   CHECK_EQ(1, arr->Get(0)->Int32Value());
   CHECK_EQ(2, arr->Get(1)->Int32Value());
   CHECK_EQ(3, arr->Get(2)->Int32Value());
   array = v8::Array::New(27);
   CHECK_EQ(27, array->Length());
   array = v8::Array::New(-27);
   CHECK_EQ(0, array->Length());
 }
 
 
-v8::Handle<Value> HandleF(const v8::Arguments& args) {
+void HandleF(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   ApiTestFuzzer::Fuzz();
   Local<v8::Array> result = v8::Array::New(args.Length());
   for (int i = 0; i < args.Length(); i++)
     result->Set(i, args[i]);
-  return scope.Close(result);
+  args.GetReturnValue().Set(scope.Close(result));
 }
 
 
 THREADED_TEST(Vector) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> global = ObjectTemplate::New();
   global->Set(v8_str("f"), v8::FunctionTemplate::New(HandleF));
   LocalContext context(0, global);
 
   const char* fun = "f()";
@@ skipping 103 matching lines @@
   Local<Script> script =
       Script::Compile(String::New(js_code_causing_out_of_memory));
   Local<Value> result = script->Run();
 
   // Check for out of memory state.
   CHECK(result.IsEmpty());
   CHECK(context->HasOutOfMemoryException());
 }
 
 
-v8::Handle<Value> ProvokeOutOfMemory(const v8::Arguments& args) {
+void ProvokeOutOfMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
 
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<Script> script =
       Script::Compile(String::New(js_code_causing_out_of_memory));
   Local<Value> result = script->Run();
 
   // Check for out of memory state.
   CHECK(result.IsEmpty());
   CHECK(context->HasOutOfMemoryException());
 
-  return result;
+  args.GetReturnValue().Set(result);
 }
 
 
 TEST(OutOfMemoryNested) {
   // It's not possible to read a snapshot into a heap with different dimensions.
   if (i::Snapshot::IsEnabled()) return;
   // Set heap limits.
   static const int K = 1024;
   v8::ResourceConstraints constraints;
   constraints.set_max_young_space_size(256 * K);
@@ skipping 252 matching lines @@
   double number_value = obj->NumberValue();
   CHECK_NE(0, std::isnan(number_value));
   CheckUncle(&try_catch);
 
   int64_t integer_value = obj->IntegerValue();
   CHECK_EQ(0.0, static_cast<double>(integer_value));
   CheckUncle(&try_catch);
 }
 
 
-v8::Handle<Value> ThrowFromC(const v8::Arguments& args) {
+void ThrowFromC(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8::ThrowException(v8_str("konto"));
+  v8::ThrowException(v8_str("konto"));
 }
 
 
-v8::Handle<Value> CCatcher(const v8::Arguments& args) {
-  if (args.Length() < 1) return v8::False();
+void CCatcher(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  if (args.Length() < 1) {
+    args.GetReturnValue().Set(false);
+    return;
+  }
   v8::HandleScope scope(args.GetIsolate());
   v8::TryCatch try_catch;
   Local<Value> result = v8::Script::Compile(args[0]->ToString())->Run();
   CHECK(!try_catch.HasCaught() || result.IsEmpty());
-  return v8::Boolean::New(try_catch.HasCaught());
+  args.GetReturnValue().Set(try_catch.HasCaught());
 }
 
 
 THREADED_TEST(APICatch) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->Set(v8_str("ThrowFromC"),
              v8::FunctionTemplate::New(ThrowFromC));
   LocalContext context(0, templ);
   CompileRun(
@@ skipping 45 matching lines @@
 
 
 static void check_reference_error_message(
     v8::Handle<v8::Message> message,
     v8::Handle<v8::Value> data) {
   const char* reference_error = "Uncaught ReferenceError: asdf is not defined";
   CHECK(message->Get()->Equals(v8_str(reference_error)));
 }
 
 
-static v8::Handle<Value> Fail(const v8::Arguments& args) {
+static void Fail(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK(false);
-  return v8::Undefined();
 }
 
 
 // Test that overwritten methods are not invoked on uncaught exception
 // formatting. However, they are invoked when performing normal error
 // string conversions.
 TEST(APIThrowMessageOverwrittenToString) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::V8::AddMessageListener(check_reference_error_message);
   Local<ObjectTemplate> templ = ObjectTemplate::New();
@@ skipping 123 matching lines @@
       = Script::Compile(v8_str("ThrowFromC(); throw 'panama';"));
   Local<Value> result = script->Run();
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
   String::Utf8Value exception_value(try_catch.Exception());
   CHECK_EQ("konto", *exception_value);
 }
 
 
 
-v8::Handle<Value> CThrowCountDown(const v8::Arguments& args) {
+void CThrowCountDown(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(4, args.Length());
   int count = args[0]->Int32Value();
   int cInterval = args[2]->Int32Value();
   if (count == 0) {
-    return v8::ThrowException(v8_str("FromC"));
+    v8::ThrowException(v8_str("FromC"));
+    return;
   } else {
     Local<v8::Object> global = Context::GetCurrent()->Global();
     Local<Value> fun = global->Get(v8_str("JSThrowCountDown"));
     v8::Handle<Value> argv[] = { v8_num(count - 1),
                                  args[1],
                                  args[2],
                                  args[3] };
     if (count % cInterval == 0) {
       v8::TryCatch try_catch;
       Local<Value> result = fun.As<Function>()->Call(global, 4, argv);
       int expected = args[3]->Int32Value();
       if (try_catch.HasCaught()) {
         CHECK_EQ(expected, count);
         CHECK(result.IsEmpty());
         CHECK(!i::Isolate::Current()->has_scheduled_exception());
       } else {
         CHECK_NE(expected, count);
       }
-      return result;
+      args.GetReturnValue().Set(result);
+      return;
     } else {
-      return fun.As<Function>()->Call(global, 4, argv);
+      args.GetReturnValue().Set(fun.As<Function>()->Call(global, 4, argv));
+      return;
     }
   }
 }
 
 
-v8::Handle<Value> JSCheck(const v8::Arguments& args) {
+void JSCheck(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(3, args.Length());
   bool equality = args[0]->BooleanValue();
   int count = args[1]->Int32Value();
   int expected = args[2]->Int32Value();
   if (equality) {
     CHECK_EQ(count, expected);
   } else {
     CHECK_NE(count, expected);
   }
-  return v8::Undefined();
 }
 
 
 THREADED_TEST(EvalInTryFinally) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::TryCatch try_catch;
   CompileRun("(function() {"
              "  try {"
              "    eval('asldkf (*&^&*^');"
@@ skipping 74 matching lines @@
 
   // JS[6] *C[5] @JS[4] C[3] JS[2] C[1] JS[0]
   v8::Handle<Value> a4[argc] = { v8_num(6), v8_num(4), v8_num(5), v8_num(4) };
   fun->Call(fun, argc, a4);
 
   // JS[6] C[5] *JS[4] @C[3] JS[2] C[1] JS[0]
   v8::Handle<Value> a5[argc] = { v8_num(6), v8_num(4), v8_num(3), v8_num(3) };
   fun->Call(fun, argc, a5);
 }
 
-
-v8::Handle<Value> ThrowValue(const v8::Arguments& args) {
+void ThrowValue(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(1, args.Length());
-  return v8::ThrowException(args[0]);
+  v8::ThrowException(args[0]);
 }
 
 
 THREADED_TEST(ThrowValues) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->Set(v8_str("Throw"), v8::FunctionTemplate::New(ThrowValue));
   LocalContext context(0, templ);
   v8::Handle<v8::Array> result = v8::Handle<v8::Array>::Cast(CompileRun(
     "function Run(obj) {"
@@ skipping 46 matching lines @@
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::TryCatch try_catch;
   CHECK(!try_catch.HasCaught());
   CompileRun("function f(k) { try { this[k]; } finally { return 0; } };");
   CompileRun("f({toString: function() { throw 42; }});");
   CHECK(!try_catch.HasCaught());
 }
 
 
-v8::Handle<v8::Value> WithTryCatch(const v8::Arguments& args) {
+void WithTryCatch(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::TryCatch try_catch;
-  return v8::Undefined();
 }
 
 
 THREADED_TEST(TryCatchAndFinally) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   context->Global()->Set(
       v8_str("native_with_try_catch"),
       v8::FunctionTemplate::New(WithTryCatch)->GetFunction());
   v8::TryCatch try_catch;
@@ skipping 67 matching lines @@
 
 THREADED_TEST(MultiRun) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<Script> script = Script::Compile(v8_str("x"));
   for (int i = 0; i < 10; i++)
     script->Run();
 }
 
 
-static v8::Handle<Value> GetXValue(Local<String> name,
-                                   const AccessorInfo& info) {
+static void GetXValue(Local<String> name,
+                      const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(info.Data(), v8_str("donut"));
   CHECK_EQ(name, v8_str("x"));
-  return name;
+  info.GetReturnValue().Set(name);
 }
 
 
 THREADED_TEST(SimplePropertyRead) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut"));
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> script = Script::Compile(v8_str("obj.x"));
@@ skipping 216 matching lines @@
     v8::TryCatch try_catch;
     CompileRun("Object.defineProperty(obj2, 'x',"
         "{get: function() { return 'func'; }})");
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value(try_catch.Exception());
     CHECK_EQ(*exception_value, "TypeError: Cannot redefine property: x");
   }
 }
 
 
-static v8::Handle<Value> Get239Value(Local<String> name,
-                                     const AccessorInfo& info) {
+static void Get239Value(Local<String> name,
+                        const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(info.Data(), v8_str("donut"));
   CHECK_EQ(name, v8_str("239"));
-  return name;
+  info.GetReturnValue().Set(name);
 }
 
 
 THREADED_TEST(ElementAPIAccessor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   LocalContext context;
 
   context->Global()->Set(v8_str("obj1"), templ->NewInstance());
   CompileRun("var obj2 = {};");
@@ skipping 12 matching lines @@
   ExpectString("obj1['239']", "239");
   ExpectString("obj2['239']", "239");
 }
 
 
 v8::Persistent<Value> xValue;
 
 
 static void SetXValue(Local<String> name,
                       Local<Value> value,
-                      const AccessorInfo& info) {
+                      const v8::PropertyCallbackInfo<void>& info) {
   CHECK_EQ(value, v8_num(4));
   CHECK_EQ(info.Data(), v8_str("donut"));
   CHECK_EQ(name, v8_str("x"));
   CHECK(xValue.IsEmpty());
   xValue.Reset(info.GetIsolate(), value);
 }
 
 
 THREADED_TEST(SimplePropertyWrite) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
@@ skipping 26 matching lines @@
     xValue.Dispose(context->GetIsolate());
     xValue.Clear();
   }
 }
 
 
 THREADED_TEST(NoAccessors) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"),
-                     static_cast<v8::AccessorGetter>(NULL),
+                     static_cast<v8::AccessorGetterCallback>(NULL),
                      NULL,
                      v8_str("donut"));
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> script = Script::Compile(v8_str("obj.x = 4; obj.x"));
   for (int i = 0; i < 10; i++) {
     script->Run();
   }
 }
 
 
-static v8::Handle<Value> XPropertyGetter(Local<String> property,
-                                         const AccessorInfo& info) {
+static void XPropertyGetter(Local<String> property,
+                            const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK(info.Data()->IsUndefined());
-  return property;
+  info.GetReturnValue().Set(property);
 }
 
 
 THREADED_TEST(NamedInterceptorPropertyRead) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(XPropertyGetter);
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> script = Script::Compile(v8_str("obj.x"));
@@ skipping 68 matching lines @@
   }
 
   // Return to the original context and force some object to the slow case
   // to cause the NormalizedMapCache to verify.
   context1->Enter();
   CompileRun("var obj = { x : 0 }; delete obj.x;");
   context1->Exit();
 }
 
 
-static v8::Handle<Value> SetXOnPrototypeGetter(Local<String> property,
-                                               const AccessorInfo& info) {
+static void SetXOnPrototypeGetter(
+    Local<String> property,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   // Set x on the prototype object and do not handle the get request.
   v8::Handle<v8::Value> proto = info.Holder()->GetPrototype();
   proto.As<v8::Object>()->Set(v8_str("x"), v8::Integer::New(23));
-  return v8::Handle<Value>();
 }
 
 
 // This is a regression test for http://crbug.com/20104. Map
 // transitions should not interfere with post interceptor lookup.
 THREADED_TEST(NamedInterceptorMapTransitionRead) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<v8::FunctionTemplate> function_template = v8::FunctionTemplate::New();
   Local<v8::ObjectTemplate> instance_template
       = function_template->InstanceTemplate();
   instance_template->SetNamedPropertyHandler(SetXOnPrototypeGetter);
   LocalContext context;
   context->Global()->Set(v8_str("F"), function_template->GetFunction());
   // Create an instance of F and introduce a map transition for x.
   CompileRun("var o = new F(); o.x = 23;");
   // Create an instance of F and invoke the getter. The result should be 23.
   Local<Value> result = CompileRun("o = new F(); o.x");
   CHECK_EQ(result->Int32Value(), 23);
 }
 
 
-static v8::Handle<Value> IndexedPropertyGetter(uint32_t index,
-                                               const AccessorInfo& info) {
+static void IndexedPropertyGetter(
+    uint32_t index,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (index == 37) {
-    return v8::Handle<Value>(v8_num(625));
+    info.GetReturnValue().Set(v8_num(625));
   }
-  return v8::Handle<Value>();
 }
 
 
-static v8::Handle<Value> IndexedPropertySetter(uint32_t index,
-                                               Local<Value> value,
-                                               const AccessorInfo& info) {
+static void IndexedPropertySetter(
+    uint32_t index,
+    Local<Value> value,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (index == 39) {
-    return value;
+    info.GetReturnValue().Set(value);
   }
-  return v8::Handle<Value>();
 }
 
 
 THREADED_TEST(IndexedInterceptorWithIndexedAccessor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetIndexedPropertyHandler(IndexedPropertyGetter,
                                    IndexedPropertySetter);
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
@@ skipping 13 matching lines @@
   CHECK_EQ(v8_num(5), result);
   result = setter_script->Run();
   CHECK_EQ(v8_num(23), result);
   result = interceptor_setter_script->Run();
   CHECK_EQ(v8_num(23), result);
   result = interceptor_getter_script->Run();
   CHECK_EQ(v8_num(625), result);
 }
 
 
-static v8::Handle<Value> UnboxedDoubleIndexedPropertyGetter(
+static void UnboxedDoubleIndexedPropertyGetter(
     uint32_t index,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (index < 25) {
-    return v8::Handle<Value>(v8_num(index));
+    info.GetReturnValue().Set(v8_num(index));
   }
-  return v8::Handle<Value>();
 }
 
 
-static v8::Handle<Value> UnboxedDoubleIndexedPropertySetter(
+static void UnboxedDoubleIndexedPropertySetter(
     uint32_t index,
     Local<Value> value,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (index < 25) {
-    return v8::Handle<Value>(v8_num(index));
+    info.GetReturnValue().Set(v8_num(index));
   }
-  return v8::Handle<Value>();
 }
 
 
-Handle<v8::Array> UnboxedDoubleIndexedPropertyEnumerator(
-    const AccessorInfo& info) {
+void UnboxedDoubleIndexedPropertyEnumerator(
+    const v8::PropertyCallbackInfo<v8::Array>& info) {
   // Force the list of returned keys to be stored in a FastDoubleArray.
   Local<Script> indexed_property_names_script = Script::Compile(v8_str(
       "keys = new Array(); keys[125000] = 1;"
       "for(i = 0; i < 80000; i++) { keys[i] = i; };"
       "keys.length = 25; keys;"));
   Local<Value> result = indexed_property_names_script->Run();
-  return Local<v8::Array>::Cast(result);
+  info.GetReturnValue().Set(Local<v8::Array>::Cast(result));
 }
 
 
 // Make sure that the the interceptor code in the runtime properly handles
 // merging property name lists for double-array-backed arrays.
 THREADED_TEST(IndexedInterceptorUnboxedDoubleWithIndexedAccessor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetIndexedPropertyHandler(UnboxedDoubleIndexedPropertyGetter,
                                    UnboxedDoubleIndexedPropertySetter,
@@ skipping 10 matching lines @@
       "obj;"));
   Local<Value> result = create_unboxed_double_script->Run();
   CHECK(result->ToObject()->HasRealIndexedProperty(2000));
   Local<Script> key_count_check = Script::Compile(v8_str(
       "key_count;"));
   result = key_count_check->Run();
   CHECK_EQ(v8_num(40013), result);
 }
 
 
-Handle<v8::Array> NonStrictArgsIndexedPropertyEnumerator(
-    const AccessorInfo& info) {
+void NonStrictArgsIndexedPropertyEnumerator(
+    const v8::PropertyCallbackInfo<v8::Array>& info) {
   // Force the list of returned keys to be stored in a Arguments object.
   Local<Script> indexed_property_names_script = Script::Compile(v8_str(
       "function f(w,x) {"
       " return arguments;"
       "}"
       "keys = f(0, 1, 2, 3);"
       "keys;"));
   Local<Object> result =
       Local<Object>::Cast(indexed_property_names_script->Run());
   // Have to populate the handle manually, as it's not Cast-able.
   i::Handle<i::JSObject> o =
       v8::Utils::OpenHandle<Object, i::JSObject>(result);
   i::Handle<i::JSArray> array(reinterpret_cast<i::JSArray*>(*o));
-  return v8::Utils::ToLocal(array);
+  info.GetReturnValue().Set(v8::Utils::ToLocal(array));
 }
 
 
-static v8::Handle<Value> NonStrictIndexedPropertyGetter(
+static void NonStrictIndexedPropertyGetter(
     uint32_t index,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (index < 4) {
-    return v8::Handle<Value>(v8_num(index));
+    info.GetReturnValue().Set(v8_num(index));
   }
-  return v8::Handle<Value>();
 }
 
 
 // Make sure that the the interceptor code in the runtime properly handles
 // merging property name lists for non-string arguments arrays.
 THREADED_TEST(IndexedInterceptorNonStrictArgsWithIndexedAccessor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetIndexedPropertyHandler(NonStrictIndexedPropertyGetter,
                                    0,
                                    0,
                                    0,
                                    NonStrictArgsIndexedPropertyEnumerator);
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> create_args_script =
       Script::Compile(v8_str(
           "var key_count = 0;"
           "for (x in obj) {key_count++;} key_count;"));
   Local<Value> result = create_args_script->Run();
   CHECK_EQ(v8_num(4), result);
 }
 
 
-static v8::Handle<Value> IdentityIndexedPropertyGetter(
+static void IdentityIndexedPropertyGetter(
     uint32_t index,
-    const AccessorInfo& info) {
-  return v8::Integer::NewFromUnsigned(index);
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(index);
 }
 
 
 THREADED_TEST(IndexedInterceptorWithGetOwnPropertyDescriptor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetIndexedPropertyHandler(IdentityIndexedPropertyGetter);
 
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
@@ skipping 550 matching lines @@
   p_str.Dispose();
   Local<Script> scr = Script::Compile(v8_str(""));
   v8::Persistent<Script> p_scr(isolate, scr);
   p_scr.Dispose();
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   v8::Persistent<ObjectTemplate> p_templ(isolate, templ);
   p_templ.Dispose();
 }
 
 
-static v8::Handle<Value> HandleLogDelegator(const v8::Arguments& args) {
+static void HandleLogDelegator(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8::Undefined();
 }
 
 
 THREADED_TEST(GlobalObjectTemplate) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
   Local<ObjectTemplate> global_template = ObjectTemplate::New();
   global_template->Set(v8_str("JSNI_Log"),
                        v8::FunctionTemplate::New(HandleLogDelegator));
   v8::Local<Context> context = Context::New(isolate, 0, global_template);
@@ skipping 214 matching lines @@
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str(kNativeCallTest))->Run();
   CHECK_EQ(result, v8::Integer::New(3));
 }
 
 
 class NativeFunctionExtension : public Extension {
  public:
   NativeFunctionExtension(const char* name,
                           const char* source,
-                          v8::InvocationCallback fun = &Echo)
+                          v8::FunctionCallback fun = &Echo)
       : Extension(name, source),
         function_(fun) { }
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
     return v8::FunctionTemplate::New(function_);
   }
 
-  static v8::Handle<v8::Value> Echo(const v8::Arguments& args) {
-    if (args.Length() >= 1) return (args[0]);
-    return v8::Undefined();
+  static void Echo(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    if (args.Length() >= 1) args.GetReturnValue().Set(args[0]);
   }
  private:
-  v8::InvocationCallback function_;
+  v8::FunctionCallback function_;
 };
 
 
 THREADED_TEST(NativeFunctionDeclaration) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   const char* name = "nativedecl";
   v8::RegisterExtension(new NativeFunctionExtension(name,
                                                     "native function foo();"));
   const char* extension_names[] = { name };
   v8::ExtensionConfiguration extensions(1, extension_names);
@@ skipping 76 matching lines @@
   "native function A();"
   "native function B();"
   "native function C();"
   "function Foo(i) {"
   "  if (i == 0) return A();"
   "  if (i == 1) return B();"
   "  if (i == 2) return C();"
   "}";
 
 
-static v8::Handle<Value> CallFun(const v8::Arguments& args) {
+static void CallFun(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   if (args.IsConstructCall()) {
     args.This()->Set(v8_str("data"), args.Data());
-    return v8::Null();
+    args.GetReturnValue().SetNull();
+    return;
   }
-  return args.Data();
+  args.GetReturnValue().Set(args.Data());
 }
 
 
 class FunctionExtension : public Extension {
  public:
   FunctionExtension() : Extension("functiontest", kExtensionTestScript) { }
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<String> name);
 };
 
@@ skipping 144 matching lines @@
   v8::Persistent<Script> script_;
 };
 
 static void HandleWeakReference(v8::Isolate* isolate,
                                 v8::Persistent<v8::Value>* obj,
                                 Snorkel* snorkel) {
   delete snorkel;
   obj->ClearWeak(isolate);
 }
 
-v8::Handle<Value> WhammyPropertyGetter(Local<String> name,
-                                       const AccessorInfo& info) {
+void WhammyPropertyGetter(Local<String> name,
+                          const v8::PropertyCallbackInfo<v8::Value>& info) {
   Whammy* whammy =
     static_cast<Whammy*>(v8::Handle<v8::External>::Cast(info.Data())->Value());
 
   v8::Persistent<v8::Object>& prev = whammy->objects_[whammy->cursor_];
 
   v8::Handle<v8::Object> obj = v8::Object::New();
   if (!prev.IsEmpty()) {
     v8::Local<v8::Object>::New(info.GetIsolate(), prev)
         ->Set(v8_str("next"), obj);
     prev.MakeWeak<Value, Snorkel>(new Snorkel(), &HandleWeakReference);
     whammy->objects_[whammy->cursor_].Clear();
   }
   whammy->objects_[whammy->cursor_].Reset(info.GetIsolate(), obj);
   whammy->cursor_ = (whammy->cursor_ + 1) % Whammy::kObjectCount;
-  return whammy->getScript()->Run();
+  info.GetReturnValue().Set(whammy->getScript()->Run());
 }
 
 THREADED_TEST(WeakReference) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ= v8::ObjectTemplate::New();
   Whammy* whammy = new Whammy(v8::Isolate::GetCurrent());
   templ->SetNamedPropertyHandler(WhammyPropertyGetter,
                                  0, 0, 0, 0,
                                  v8::External::New(whammy));
   const char* extension_list[] = { "v8/gc" };
@@ skipping 149 matching lines @@
     v8::Local<String> y_str = v8_str("y");
     CHECK_EQ(v8::Integer::New(1), o->Get(v8_str("x")));
     CHECK(o->Get(y_str)->Equals(y_str));
   }
 }
 
 
 v8::Handle<Function> args_fun;
 
 
-static v8::Handle<Value> ArgumentsTestCallback(const v8::Arguments& args) {
+static void ArgumentsTestCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(args_fun, args.Callee());
   CHECK_EQ(3, args.Length());
   CHECK_EQ(v8::Integer::New(1), args[0]);
   CHECK_EQ(v8::Integer::New(2), args[1]);
   CHECK_EQ(v8::Integer::New(3), args[2]);
   CHECK_EQ(v8::Undefined(), args[3]);
   v8::HandleScope scope(args.GetIsolate());
   HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
-  return v8::Undefined();
 }
 
 
 THREADED_TEST(Arguments) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> global = ObjectTemplate::New();
   global->Set(v8_str("f"), v8::FunctionTemplate::New(ArgumentsTestCallback));
   LocalContext context(NULL, global);
   args_fun = context->Global()->Get(v8_str("f")).As<Function>();
   v8_compile("f(1, 2, 3)")->Run();
 }
 
 
-static v8::Handle<Value> NoBlockGetterX(Local<String> name,
-                                        const AccessorInfo&) {
-  return v8::Handle<Value>();
+static void NoBlockGetterX(Local<String> name,
+                           const v8::PropertyCallbackInfo<v8::Value>&) {
 }
 
 
-static v8::Handle<Value> NoBlockGetterI(uint32_t index,
-                                        const AccessorInfo&) {
-  return v8::Handle<Value>();
+static void NoBlockGetterI(uint32_t index,
+                           const v8::PropertyCallbackInfo<v8::Value>&) {
 }
 
 
-static v8::Handle<v8::Boolean> PDeleter(Local<String> name,
-                                        const AccessorInfo&) {
+static void PDeleter(Local<String> name,
+                     const v8::PropertyCallbackInfo<v8::Boolean>& info) {
   if (!name->Equals(v8_str("foo"))) {
-    return v8::Handle<v8::Boolean>();  // not intercepted
+    return;  // not intercepted
   }
 
-  return v8::False();  // intercepted, and don't delete the property
+  info.GetReturnValue().Set(false);  // intercepted, don't delete the property
 }
 
 
-static v8::Handle<v8::Boolean> IDeleter(uint32_t index, const AccessorInfo&) {
+static void IDeleter(uint32_t index,
+                     const v8::PropertyCallbackInfo<v8::Boolean>& info) {
   if (index != 2) {
-    return v8::Handle<v8::Boolean>();  // not intercepted
+    return;  // not intercepted
   }
 
-  return v8::False();  // intercepted, and don't delete the property
+  info.GetReturnValue().Set(false);  // intercepted, don't delete the property
 }
 
 
 THREADED_TEST(Deleter) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New();
   obj->SetNamedPropertyHandler(NoBlockGetterX, NULL, NULL, PDeleter, NULL);
   obj->SetIndexedPropertyHandler(NoBlockGetterI, NULL, NULL, IDeleter, NULL);
   LocalContext context;
   context->Global()->Set(v8_str("k"), obj->NewInstance());
   CompileRun(
     "k.foo = 'foo';"
     "k.bar = 'bar';"
     "k[2] = 2;"
     "k[4] = 4;");
   CHECK(v8_compile("delete k.foo")->Run()->IsFalse());
   CHECK(v8_compile("delete k.bar")->Run()->IsTrue());
 
   CHECK_EQ(v8_compile("k.foo")->Run(), v8_str("foo"));
   CHECK(v8_compile("k.bar")->Run()->IsUndefined());
 
   CHECK(v8_compile("delete k[2]")->Run()->IsFalse());
   CHECK(v8_compile("delete k[4]")->Run()->IsTrue());
 
   CHECK_EQ(v8_compile("k[2]")->Run(), v8_num(2));
   CHECK(v8_compile("k[4]")->Run()->IsUndefined());
 }
 
 
-static v8::Handle<Value> GetK(Local<String> name, const AccessorInfo&) {
+static void GetK(Local<String> name,
+                 const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (name->Equals(v8_str("foo")) ||
       name->Equals(v8_str("bar")) ||
       name->Equals(v8_str("baz"))) {
-    return v8::Undefined();
+    info.GetReturnValue().SetUndefined();
   }
-  return v8::Handle<Value>();
 }
 
 
-static v8::Handle<Value> IndexedGetK(uint32_t index, const AccessorInfo&) {
+static void IndexedGetK(uint32_t index,
+                        const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  if (index == 0 || index == 1) return v8::Undefined();
-  return v8::Handle<Value>();
+  if (index == 0 || index == 1) info.GetReturnValue().SetUndefined();
 }
 
 
-static v8::Handle<v8::Array> NamedEnum(const AccessorInfo&) {
+static void NamedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
   ApiTestFuzzer::Fuzz();
   v8::Handle<v8::Array> result = v8::Array::New(3);
   result->Set(v8::Integer::New(0), v8_str("foo"));
   result->Set(v8::Integer::New(1), v8_str("bar"));
   result->Set(v8::Integer::New(2), v8_str("baz"));
-  return result;
+  info.GetReturnValue().Set(result);
 }
 
 
-static v8::Handle<v8::Array> IndexedEnum(const AccessorInfo&) {
+static void IndexedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
   ApiTestFuzzer::Fuzz();
   v8::Handle<v8::Array> result = v8::Array::New(2);
   result->Set(v8::Integer::New(0), v8_str("0"));
   result->Set(v8::Integer::New(1), v8_str("1"));
-  return result;
+  info.GetReturnValue().Set(result);
 }
 
 
 THREADED_TEST(Enumerators) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New();
   obj->SetNamedPropertyHandler(GetK, NULL, NULL, NULL, NamedEnum);
   obj->SetIndexedPropertyHandler(IndexedGetK, NULL, NULL, NULL, IndexedEnum);
   LocalContext context;
   context->Global()->Set(v8_str("k"), obj->NewInstance());
@@ skipping 44 matching lines @@
   CHECK_EQ(v8_str("foo"), result->Get(v8::Integer::New(14)));
   CHECK_EQ(v8_str("bar"), result->Get(v8::Integer::New(15)));
   CHECK_EQ(v8_str("baz"), result->Get(v8::Integer::New(16)));
 }
 
 
 int p_getter_count;
 int p_getter_count2;
 
 
-static v8::Handle<Value> PGetter(Local<String> name, const AccessorInfo& info) {
+static void PGetter(Local<String> name,
+                    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   p_getter_count++;
   v8::Handle<v8::Object> global = Context::GetCurrent()->Global();
   CHECK_EQ(info.Holder(), global->Get(v8_str("o1")));
   if (name->Equals(v8_str("p1"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o1")));
   } else if (name->Equals(v8_str("p2"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o2")));
   } else if (name->Equals(v8_str("p3"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o3")));
   } else if (name->Equals(v8_str("p4"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o4")));
   }
-  return v8::Undefined();
 }
 
 
 static void RunHolderTest(v8::Handle<v8::ObjectTemplate> obj) {
   ApiTestFuzzer::Fuzz();
   LocalContext context;
   context->Global()->Set(v8_str("o1"), obj->NewInstance());
   CompileRun(
     "o1.__proto__ = { };"
     "var o2 = { __proto__: o1 };"
     "var o3 = { __proto__: o2 };"
     "var o4 = { __proto__: o3 };"
     "for (var i = 0; i < 10; i++) o4.p4;"
     "for (var i = 0; i < 10; i++) o3.p3;"
     "for (var i = 0; i < 10; i++) o2.p2;"
     "for (var i = 0; i < 10; i++) o1.p1;");
 }
 
 
-static v8::Handle<Value> PGetter2(Local<String> name,
-                                  const AccessorInfo& info) {
+static void PGetter2(Local<String> name,
+                     const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   p_getter_count2++;
   v8::Handle<v8::Object> global = Context::GetCurrent()->Global();
   CHECK_EQ(info.Holder(), global->Get(v8_str("o1")));
   if (name->Equals(v8_str("p1"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o1")));
   } else if (name->Equals(v8_str("p2"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o2")));
   } else if (name->Equals(v8_str("p3"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o3")));
   } else if (name->Equals(v8_str("p4"))) {
     CHECK_EQ(info.This(), global->Get(v8_str("o4")));
   }
-  return v8::Undefined();
 }
 
 
 THREADED_TEST(GetterHolders) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New();
   obj->SetAccessor(v8_str("p1"), PGetter);
   obj->SetAccessor(v8_str("p2"), PGetter);
   obj->SetAccessor(v8_str("p3"), PGetter);
   obj->SetAccessor(v8_str("p4"), PGetter);
@@ skipping 573 matching lines @@
   CHECK(syntax_error.As<v8::Object>()->Get(message)->Equals(foo));
   v8::Handle<Value> type_error = v8::Exception::TypeError(foo);
   CHECK(type_error->IsObject());
   CHECK(type_error.As<v8::Object>()->Get(message)->Equals(foo));
   v8::Handle<Value> error = v8::Exception::Error(foo);
   CHECK(error->IsObject());
   CHECK(error.As<v8::Object>()->Get(message)->Equals(foo));
 }
 
 
-static v8::Handle<Value> YGetter(Local<String> name, const AccessorInfo& info) {
+static void YGetter(Local<String> name,
+                    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(10);
+  info.GetReturnValue().Set(v8_num(10));
 }
 
 
 static void YSetter(Local<String> name,
                     Local<Value> value,
-                    const AccessorInfo& info) {
+                    const v8::PropertyCallbackInfo<void>& info) {
   if (info.This()->Has(name)) {
     info.This()->Delete(name);
   }
   info.This()->Set(name, value);
 }
 
 
 THREADED_TEST(DeleteAccessor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New();
@@ skipping 54 matching lines @@
   // Always allow read access.
   if (type == v8::ACCESS_GET)
     return true;
 
   // Sometimes allow other access.
   return g_security_callback_result;
 }
 
 
 static int trouble_nesting = 0;
-static v8::Handle<Value> TroubleCallback(const v8::Arguments& args) {
+static void TroubleCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   trouble_nesting++;
 
   // Call a JS function that throws an uncaught exception.
   Local<v8::Object> arg_this = Context::GetCurrent()->Global();
   Local<Value> trouble_callee = (trouble_nesting == 3) ?
     arg_this->Get(v8_str("trouble_callee")) :
     arg_this->Get(v8_str("trouble_caller"));
   CHECK(trouble_callee->IsFunction());
-  return Function::Cast(*trouble_callee)->Call(arg_this, 0, NULL);
+  args.GetReturnValue().Set(
+      Function::Cast(*trouble_callee)->Call(arg_this, 0, NULL));
 }
 
 
 static int report_count = 0;
 static void ApiUncaughtExceptionTestListener(v8::Handle<v8::Message>,
                                              v8::Handle<Value>) {
   report_count++;
 }
 
 
@@ skipping 509 matching lines @@
 static bool IndexedAccessBlocker(Local<v8::Object> global,
                                  uint32_t key,
                                  v8::AccessType type,
                                  Local<Value> data) {
   return Context::GetCurrent()->Global()->Equals(global) ||
       allowed_access_type[type];
 }
 
 
 static int g_echo_value = -1;
-static v8::Handle<Value> EchoGetter(Local<String> name,
-                                    const AccessorInfo& info) {
-  return v8_num(g_echo_value);
+static void EchoGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(v8_num(g_echo_value));
 }
 
 
 static void EchoSetter(Local<String> name,
                        Local<Value> value,
-                       const AccessorInfo&) {
+                       const v8::PropertyCallbackInfo<void>&) {
   if (value->IsNumber())
     g_echo_value = value->Int32Value();
 }
 
 
-static v8::Handle<Value> UnreachableGetter(Local<String> name,
-                                           const AccessorInfo& info) {
+static void UnreachableGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(false);  // This function should not be called..
-  return v8::Undefined();
 }
 
 
-static void UnreachableSetter(Local<String>, Local<Value>,
-                              const AccessorInfo&) {
+static void UnreachableSetter(Local<String>,
+                              Local<Value>,
+                              const v8::PropertyCallbackInfo<void>&) {
   CHECK(false);  // This function should nto be called.
 }
 
 
 TEST(AccessControl) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
 
   global_template->SetAccessCheckCallbacks(NamedAccessBlocker,
@@ skipping 356 matching lines @@
   CHECK(value->IsTrue());
 
   value = CompileRun("Object.getOwnPropertyNames(object).length == 0");
   CHECK(value->IsTrue());
 
   context1->Exit();
   context0->Exit();
 }
 
 
-static v8::Handle<v8::Array> IndexedPropertyEnumerator(const AccessorInfo&) {
+static void IndexedPropertyEnumerator(
+    const v8::PropertyCallbackInfo<v8::Array>& info) {
   v8::Handle<v8::Array> result = v8::Array::New(2);
   result->Set(0, v8::Integer::New(7));
   result->Set(1, v8::Object::New());
-  return result;
+  info.GetReturnValue().Set(result);
 }
 
 
-static v8::Handle<v8::Array> NamedPropertyEnumerator(const AccessorInfo& info) {
+static void NamedPropertyEnumerator(
+    const v8::PropertyCallbackInfo<v8::Array>& info) {
   v8::Handle<v8::Array> result = v8::Array::New(2);
   result->Set(0, v8_str("x"));
   result->Set(1, v8::Object::New());
-  return result;
+  info.GetReturnValue().Set(result);
 }
 
 
 THREADED_TEST(GetOwnPropertyNamesWithInterceptor) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> obj_template = v8::ObjectTemplate::New();
 
   obj_template->Set(v8_str("7"), v8::Integer::New(7));
   obj_template->Set(v8_str("x"), v8::Integer::New(42));
   obj_template->SetIndexedPropertyHandler(NULL, NULL, NULL, NULL,
@@ skipping 12 matching lines @@
   CHECK_EQ(3, result_array->Length());
   CHECK(result_array->Get(0)->IsString());
   CHECK(result_array->Get(1)->IsString());
   CHECK(result_array->Get(2)->IsString());
   CHECK_EQ(v8_str("7"), result_array->Get(0));
   CHECK_EQ(v8_str("[object Object]"), result_array->Get(1));
   CHECK_EQ(v8_str("x"), result_array->Get(2));
 }
 
 
-static v8::Handle<Value> ConstTenGetter(Local<String> name,
-                                        const AccessorInfo& info) {
-  return v8_num(10);
+static void ConstTenGetter(Local<String> name,
+                           const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(v8_num(10));
 }
 
 
 THREADED_TEST(CrossDomainAccessors) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
 
   v8::Handle<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New();
 
   v8::Handle<v8::ObjectTemplate> global_template =
@@ skipping 243 matching lines @@
   v8::Handle<Value> value;
 
   value = v8_compile("var p = 'as' + 'df';")->Run();
   value = v8_compile("obj[p];")->Run();
 
   context1->Exit();
   context0->Exit();
 }
 
 
-static v8::Handle<Value> AccessControlNamedGetter(
-    Local<String>, const AccessorInfo&) {
-  return v8::Integer::New(42);
+static void AccessControlNamedGetter(
+    Local<String>,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(42);
 }
 
 
-static v8::Handle<Value> AccessControlNamedSetter(
-    Local<String>, Local<Value> value, const AccessorInfo&) {
-  return value;
+static void AccessControlNamedSetter(
+    Local<String>,
+    Local<Value> value,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(value);
 }
 
 
-static v8::Handle<Value> AccessControlIndexedGetter(
+static void AccessControlIndexedGetter(
       uint32_t index,
-      const AccessorInfo& info) {
-  return v8_num(42);
+      const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(v8_num(42));
 }
 
 
-static v8::Handle<Value> AccessControlIndexedSetter(
-    uint32_t, Local<Value> value, const AccessorInfo&) {
-  return value;
+static void AccessControlIndexedSetter(
+    uint32_t,
+    Local<Value> value,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(value);
 }
 
 
 THREADED_TEST(AccessControlInterceptorIC) {
   named_access_count = 0;
   indexed_access_count = 0;
 
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
 
@@ skipping 54 matching lines @@
   context1->Exit();
   context0->Exit();
 }
 
 
 THREADED_TEST(Version) {
   v8::V8::GetVersion();
 }
 
 
-static v8::Handle<Value> InstanceFunctionCallback(const v8::Arguments& args) {
+static void InstanceFunctionCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(12);
+  args.GetReturnValue().Set(v8_num(12));
 }
 
 
 THREADED_TEST(InstanceProperties) {
   LocalContext context;
   v8::HandleScope handle_scope(context->GetIsolate());
 
   Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New();
   Local<ObjectTemplate> instance = t->InstanceTemplate();
 
   instance->Set(v8_str("x"), v8_num(42));
   instance->Set(v8_str("f"),
                 v8::FunctionTemplate::New(InstanceFunctionCallback));
 
   Local<Value> o = t->GetFunction()->NewInstance();
 
   context->Global()->Set(v8_str("i"), o);
   Local<Value> value = Script::Compile(v8_str("i.x"))->Run();
   CHECK_EQ(42, value->Int32Value());
 
   value = Script::Compile(v8_str("i.f()"))->Run();
   CHECK_EQ(12, value->Int32Value());
 }
 
 
-static v8::Handle<Value>
-GlobalObjectInstancePropertiesGet(Local<String> key, const AccessorInfo&) {
+static void GlobalObjectInstancePropertiesGet(
+    Local<String> key,
+    const v8::PropertyCallbackInfo<v8::Value>&) {
   ApiTestFuzzer::Fuzz();
-  return v8::Handle<Value>();
 }
 
 
 THREADED_TEST(GlobalObjectInstanceProperties) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   Local<Value> global_object;
 
   Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New();
   t->InstanceTemplate()->SetNamedPropertyHandler(
@@ skipping 79 matching lines @@
 
   {
     // Create new environment reusing the global object.
     LocalContext env(NULL, instance_template, global_object);
     env->Global()->Set(v8_str("foo"), foo);
     Script::Compile(v8_str("foo()"))->Run();
   }
 }
 
 
-static v8::Handle<Value> ShadowFunctionCallback(const v8::Arguments& args) {
+static void ShadowFunctionCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(42);
+  args.GetReturnValue().Set(v8_num(42));
 }
 
 
 static int shadow_y;
 static int shadow_y_setter_call_count;
 static int shadow_y_getter_call_count;
 
 
-static void ShadowYSetter(Local<String>, Local<Value>, const AccessorInfo&) {
+static void ShadowYSetter(Local<String>,
+                          Local<Value>,
+                          const v8::PropertyCallbackInfo<void>&) {
   shadow_y_setter_call_count++;
   shadow_y = 42;
 }
 
 
-static v8::Handle<Value> ShadowYGetter(Local<String> name,
-                                       const AccessorInfo& info) {
+static void ShadowYGetter(Local<String> name,
+                          const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   shadow_y_getter_call_count++;
-  return v8_num(shadow_y);
+  info.GetReturnValue().Set(v8_num(shadow_y));
 }
 
 
-static v8::Handle<Value> ShadowIndexedGet(uint32_t index,
-                                          const AccessorInfo& info) {
-  return v8::Handle<Value>();
+static void ShadowIndexedGet(uint32_t index,
+                             const v8::PropertyCallbackInfo<v8::Value>&) {
 }
 
 
-static v8::Handle<Value> ShadowNamedGet(Local<String> key,
-                                        const AccessorInfo&) {
-  return v8::Handle<Value>();
+static void ShadowNamedGet(Local<String> key,
+                           const v8::PropertyCallbackInfo<v8::Value>&) {
 }
 
 
 THREADED_TEST(ShadowObject) {
   shadow_y = shadow_y_setter_call_count = shadow_y_getter_call_count = 0;
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   Local<ObjectTemplate> global_template = v8::ObjectTemplate::New();
   LocalContext context(NULL, global_template);
 
@@ skipping 329 matching lines @@
   Local<Function> cons = templ->GetFunction();
   context->Global()->Set(v8_str("Fun"), cons);
   Local<v8::Object> inst = cons->NewInstance();
   i::Handle<i::JSObject> obj(v8::Utils::OpenHandle(*inst));
   CHECK(obj->IsJSObject());
   Local<Value> value = CompileRun("(new Fun()).constructor === Fun");
   CHECK(value->BooleanValue());
 }
 
 
-static Handle<Value> ConstructorCallback(const Arguments& args) {
+static void ConstructorCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   Local<Object> This;
 
   if (args.IsConstructCall()) {
     Local<Object> Holder = args.Holder();
     This = Object::New();
     Local<Value> proto = Holder->GetPrototype();
     if (proto->IsObject()) {
       This->SetPrototype(proto);
     }
   } else {
     This = args.This();
   }
 
   This->Set(v8_str("a"), args[0]);
-  return This;
+  args.GetReturnValue().Set(This);
 }
 
 
-static Handle<Value> FakeConstructorCallback(const Arguments& args) {
+static void FakeConstructorCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return args[0];
+  args.GetReturnValue().Set(args[0]);
 }
 
 
 THREADED_TEST(ConstructorForObject) {
   LocalContext context;
   v8::HandleScope handle_scope(context->GetIsolate());
 
   { Local<ObjectTemplate> instance_template = ObjectTemplate::New();
     instance_template->SetCallAsFunctionHandler(ConstructorCallback);
     Local<Object> instance = instance_template->NewInstance();
@@ skipping 347 matching lines @@
   current->Global()->Set(v8_str("other"), other->Global());
 
   // Trigger lazy loading in other context.
   Local<Script> script =
       Script::Compile(v8_str("other.eval('new Date(42)')"));
   Local<Value> value = script->Run();
   CHECK_EQ(42.0, value->NumberValue());
 }
 
 
-static v8::Handle<Value> call_as_function(const v8::Arguments& args) {
+static void call_as_function(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   if (args.IsConstructCall()) {
     if (args[0]->IsInt32()) {
-       return v8_num(-args[0]->Int32Value());
+      args.GetReturnValue().Set(v8_num(-args[0]->Int32Value()));
+      return;
     }
   }
 
-  return args[0];
+  args.GetReturnValue().Set(args[0]);
 }
 
 
 // Test that a call handler can be set for objects which will allow
 // non-function objects created through the API to be called as
 // functions.
 THREADED_TEST(CallAsFunction) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
@@ skipping 183 matching lines @@
         CHECK_EQ(j + 1 + kIterations, CountHandles());
       }
     }
     CHECK_EQ(kIterations, CountHandles());
   }
   CHECK_EQ(0, CountHandles());
   CHECK_EQ(kNesting * kIterations, Recurse(kNesting, kIterations));
 }
 
 
-static v8::Handle<Value> InterceptorHasOwnPropertyGetter(
+static void InterceptorHasOwnPropertyGetter(
     Local<String> name,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8::Handle<Value>();
 }
 
 
 THREADED_TEST(InterceptorHasOwnProperty) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   Local<v8::ObjectTemplate> instance_templ = fun_templ->InstanceTemplate();
   instance_templ->SetNamedPropertyHandler(InterceptorHasOwnPropertyGetter);
   Local<Function> function = fun_templ->GetFunction();
   context->Global()->Set(v8_str("constructor"), function);
   v8::Handle<Value> value = CompileRun(
       "var o = new constructor();"
       "o.hasOwnProperty('ostehaps');");
   CHECK_EQ(false, value->BooleanValue());
   value = CompileRun(
       "o.ostehaps = 42;"
       "o.hasOwnProperty('ostehaps');");
   CHECK_EQ(true, value->BooleanValue());
   value = CompileRun(
       "var p = new constructor();"
       "p.hasOwnProperty('ostehaps');");
   CHECK_EQ(false, value->BooleanValue());
 }
 
 
-static v8::Handle<Value> InterceptorHasOwnPropertyGetterGC(
+static void InterceptorHasOwnPropertyGetterGC(
     Local<String> name,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
-  return v8::Handle<Value>();
 }
 
 
 THREADED_TEST(InterceptorHasOwnPropertyCausingGC) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   Local<v8::ObjectTemplate> instance_templ = fun_templ->InstanceTemplate();
   instance_templ->SetNamedPropertyHandler(InterceptorHasOwnPropertyGetterGC);
   Local<Function> function = fun_templ->GetFunction();
@@ skipping 12 matching lines @@
       "x = makestr(31415);"
       "x = makestr(23456);");
   v8::Handle<Value> value = CompileRun(
       "var o = new constructor();"
       "o.__proto__ = new String(x);"
       "o.hasOwnProperty('ostehaps');");
   CHECK_EQ(false, value->BooleanValue());
 }
 
 
-typedef v8::Handle<Value> (*NamedPropertyGetter)(Local<String> property,
-                                                 const AccessorInfo& info);
+typedef void (*NamedPropertyGetter)(
+    Local<String> property,
+    const v8::PropertyCallbackInfo<v8::Value>& info);
 
 
 static void CheckInterceptorLoadIC(NamedPropertyGetter getter,
                                    const char* source,
                                    int expected) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(getter, 0, 0, 0, 0, v8_str("data"));
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ->NewInstance());
   v8::Handle<Value> value = CompileRun(source);
   CHECK_EQ(expected, value->Int32Value());
 }
 
 
-static v8::Handle<Value> InterceptorLoadICGetter(Local<String> name,
-                                                 const AccessorInfo& info) {
+static void InterceptorLoadICGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   CHECK_EQ(isolate, info.GetIsolate());
   CHECK_EQ(v8_str("data"), info.Data());
   CHECK_EQ(v8_str("x"), name);
-  return v8::Integer::New(42);
+  info.GetReturnValue().Set(v8::Integer::New(42));
 }
 
 
 // This test should hit the load IC for the interceptor case.
 THREADED_TEST(InterceptorLoadIC) {
   CheckInterceptorLoadIC(InterceptorLoadICGetter,
     "var result = 0;"
     "for (var i = 0; i < 1000; i++) {"
     "  result = o.x;"
     "}",
     42);
 }
 
 
 // Below go several tests which verify that JITing for various
 // configurations of interceptor and explicit fields works fine
 // (those cases are special cased to get better performance).
 
-static v8::Handle<Value> InterceptorLoadXICGetter(Local<String> name,
-                                                 const AccessorInfo& info) {
+static void InterceptorLoadXICGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8_str("x")->Equals(name)
-      ? v8::Handle<v8::Value>(v8::Integer::New(42)) : v8::Handle<v8::Value>();
+  info.GetReturnValue().Set(
+      v8_str("x")->Equals(name) ?
+          v8::Handle<v8::Value>(v8::Integer::New(42)) :
+          v8::Handle<v8::Value>());
 }
 
 
 THREADED_TEST(InterceptorLoadICWithFieldOnHolder) {
   CheckInterceptorLoadIC(InterceptorLoadXICGetter,
     "var result = 0;"
     "o.y = 239;"
     "for (var i = 0; i < 1000; i++) {"
     "  result = o.y;"
     "}",
@@ skipping 88 matching lines @@
     "var result = 0;"
     "for (var i = 0; i < 1000; i++) {"
     "  result += o.y;"
     "}"
     "result;",
     42 * 1000);
 }
 
 
 static int interceptor_load_not_handled_calls = 0;
-static v8::Handle<Value> InterceptorLoadNotHandled(Local<String> name,
-                                                   const AccessorInfo& info) {
+static void InterceptorLoadNotHandled(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ++interceptor_load_not_handled_calls;
-  return v8::Handle<v8::Value>();
 }
 
 
 // Test how post-interceptor lookups are done in the non-cacheable
 // case: the interceptor should not be invoked during this lookup.
 THREADED_TEST(InterceptorLoadICPostInterceptor) {
   interceptor_load_not_handled_calls = 0;
   CheckInterceptorLoadIC(InterceptorLoadNotHandled,
     "receiver = new Object();"
     "receiver.__proto__ = o;"
@@ skipping 30 matching lines @@
     "for (var i = 0; i < 10; i++) {"
     "  result += o.y;"
     "}"
     "result;",
     42 * 10);
 }
 
 
 static void SetOnThis(Local<String> name,
                       Local<Value> value,
-                      const AccessorInfo& info) {
+                      const v8::PropertyCallbackInfo<void>& info) {
   info.This()->ForceSet(name, value);
 }
 
 
 THREADED_TEST(InterceptorLoadICWithCallbackOnHolder) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorLoadXICGetter);
-  templ->SetAccessor(v8_str("y"), Return239);
+  templ->SetAccessor(v8_str("y"), Return239Callback);
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ->NewInstance());
 
   // Check the case when receiver and interceptor's holder
   // are the same objects.
   v8::Handle<Value> value = CompileRun(
       "var result = 0;"
       "for (var i = 0; i < 7; i++) {"
       "  result = o.y;"
       "}");
   CHECK_EQ(239, value->Int32Value());
 
   // Check the case when interceptor's holder is in proto chain
   // of receiver.
   value = CompileRun(
       "r = { __proto__: o };"
       "var result = 0;"
       "for (var i = 0; i < 7; i++) {"
       "  result = r.y;"
       "}");
   CHECK_EQ(239, value->Int32Value());
 }
 
 
 THREADED_TEST(InterceptorLoadICWithCallbackOnProto) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ_o = ObjectTemplate::New();
   templ_o->SetNamedPropertyHandler(InterceptorLoadXICGetter);
   v8::Handle<v8::ObjectTemplate> templ_p = ObjectTemplate::New();
-  templ_p->SetAccessor(v8_str("y"), Return239);
+  templ_p->SetAccessor(v8_str("y"), Return239Callback);
 
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ_o->NewInstance());
   context->Global()->Set(v8_str("p"), templ_p->NewInstance());
 
   // Check the case when receiver and interceptor's holder
   // are the same objects.
   v8::Handle<Value> value = CompileRun(
       "o.__proto__ = p;"
       "var result = 0;"
@@ skipping 11 matching lines @@
       "  result = r.x + r.y;"
       "}");
   CHECK_EQ(239 + 42, value->Int32Value());
 }
 
 
 THREADED_TEST(InterceptorLoadICForCallbackWithOverride) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorLoadXICGetter);
-  templ->SetAccessor(v8_str("y"), Return239);
+  templ->SetAccessor(v8_str("y"), Return239Callback);
 
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ->NewInstance());
 
   v8::Handle<Value> value = CompileRun(
     "fst = new Object();  fst.__proto__ = o;"
     "snd = new Object();  snd.__proto__ = fst;"
     "var result1 = 0;"
     "for (var i = 0; i < 7;  i++) {"
     "  result1 = snd.x;"
     "}"
     "fst.x = 239;"
     "var result = 0;"
     "for (var i = 0; i < 7; i++) {"
     "  result = snd.x;"
     "}"
     "result + result1");
   CHECK_EQ(239 + 42, value->Int32Value());
 }
 
 
 // Test the case when we stored callback into
 // a stub, but interceptor produced value on its own.
 THREADED_TEST(InterceptorLoadICCallbackNotNeeded) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ_o = ObjectTemplate::New();
   templ_o->SetNamedPropertyHandler(InterceptorLoadXICGetter);
   v8::Handle<v8::ObjectTemplate> templ_p = ObjectTemplate::New();
-  templ_p->SetAccessor(v8_str("y"), Return239);
+  templ_p->SetAccessor(v8_str("y"), Return239Callback);
 
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ_o->NewInstance());
   context->Global()->Set(v8_str("p"), templ_p->NewInstance());
 
   v8::Handle<Value> value = CompileRun(
     "o.__proto__ = p;"
     "for (var i = 0; i < 7; i++) {"
     "  o.x;"
     // Now it should be ICed and keep a reference to x defined on p
     "}"
     "var result = 0;"
     "for (var i = 0; i < 7; i++) {"
     "  result += o.x;"
     "}"
     "result");
   CHECK_EQ(42 * 7, value->Int32Value());
 }
 
 
 // Test the case when we stored callback into
 // a stub, but it got invalidated later on.
 THREADED_TEST(InterceptorLoadICInvalidatedCallback) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ_o = ObjectTemplate::New();
   templ_o->SetNamedPropertyHandler(InterceptorLoadXICGetter);
   v8::Handle<v8::ObjectTemplate> templ_p = ObjectTemplate::New();
-  templ_p->SetAccessor(v8_str("y"), Return239, SetOnThis);
+  templ_p->SetAccessor(v8_str("y"), Return239Callback, SetOnThis);
 
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ_o->NewInstance());
   context->Global()->Set(v8_str("p"), templ_p->NewInstance());
 
   v8::Handle<Value> value = CompileRun(
     "inbetween = new Object();"
     "o.__proto__ = inbetween;"
     "inbetween.__proto__ = p;"
     "for (var i = 0; i < 10; i++) {"
@@ skipping 11 matching lines @@
 
 
 // Test the case when we stored callback into
 // a stub, but it got invalidated later on due to override on
 // global object which is between interceptor and callbacks' holders.
 THREADED_TEST(InterceptorLoadICInvalidatedCallbackViaGlobal) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ_o = ObjectTemplate::New();
   templ_o->SetNamedPropertyHandler(InterceptorLoadXICGetter);
   v8::Handle<v8::ObjectTemplate> templ_p = ObjectTemplate::New();
-  templ_p->SetAccessor(v8_str("y"), Return239, SetOnThis);
+  templ_p->SetAccessor(v8_str("y"), Return239Callback, SetOnThis);
 
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ_o->NewInstance());
   context->Global()->Set(v8_str("p"), templ_p->NewInstance());
 
   v8::Handle<Value> value = CompileRun(
     "o.__proto__ = this;"
     "this.__proto__ = p;"
     "for (var i = 0; i < 10; i++) {"
     "  if (o.y != 239) throw 'oops: ' + o.y;"
     // Now it should be ICed and keep a reference to y defined on p
     "}"
     "this.y = 42;"
     "var result = 0;"
     "for (var i = 0; i < 10; i++) {"
     "  result += o.y;"
     "}"
     "result");
   CHECK_EQ(42 * 10, value->Int32Value());
 }
 
 
-static v8::Handle<Value> InterceptorLoadICGetter0(Local<String> name,
-                                                  const AccessorInfo& info) {
+static void InterceptorLoadICGetter0(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK(v8_str("x")->Equals(name));
-  return v8::Integer::New(0);
+  info.GetReturnValue().Set(v8::Integer::New(0));
 }
 
 
 THREADED_TEST(InterceptorReturningZero) {
   CheckInterceptorLoadIC(InterceptorLoadICGetter0,
      "o.x == undefined ? 1 : 0",
      0);
 }
 
 
-static v8::Handle<Value> InterceptorStoreICSetter(
-    Local<String> key, Local<Value> value, const AccessorInfo&) {
+static void InterceptorStoreICSetter(
+    Local<String> key,
+    Local<Value> value,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(v8_str("x")->Equals(key));
   CHECK_EQ(42, value->Int32Value());
-  return value;
+  info.GetReturnValue().Set(value);
 }
 
 
 // This test should hit the store IC for the interceptor case.
 THREADED_TEST(InterceptorStoreIC) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorLoadICGetter,
                                  InterceptorStoreICSetter,
                                  0, 0, 0, v8_str("data"));
@@ skipping 20 matching lines @@
   CHECK_EQ(239 + 42, value->Int32Value());
 }
 
 
 
 
 v8::Handle<Value> call_ic_function;
 v8::Handle<Value> call_ic_function2;
 v8::Handle<Value> call_ic_function3;
 
-static v8::Handle<Value> InterceptorCallICGetter(Local<String> name,
-                                                 const AccessorInfo& info) {
+static void InterceptorCallICGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK(v8_str("x")->Equals(name));
-  return call_ic_function;
+  info.GetReturnValue().Set(call_ic_function);
 }
 
 
 // This test should hit the call IC for the interceptor case.
 THREADED_TEST(InterceptorCallIC) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorCallICGetter);
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ->NewInstance());
@@ skipping 20 matching lines @@
     "o.x = function f(x) { return x + 1; };"
     "var result = 0;"
     "for (var i = 0; i < 7; i++) {"
     "  result = o.x(41);"
     "}");
   CHECK_EQ(42, value->Int32Value());
 }
 
 
 static v8::Handle<Value> call_ic_function4;
-static v8::Handle<Value> InterceptorCallICGetter4(Local<String> name,
-                                                  const AccessorInfo& info) {
+static void InterceptorCallICGetter4(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK(v8_str("x")->Equals(name));
-  return call_ic_function4;
+  info.GetReturnValue().Set(call_ic_function4);
 }
 
 
 // This test checks that if interceptor provides a function,
 // even if we cached shadowed variant, interceptor's function
 // is invoked
 THREADED_TEST(InterceptorCallICCacheableNotNeeded) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorCallICGetter4);
@@ skipping 52 matching lines @@
     "o.x = inc;"
     "var result = 0;"
     "for (var i = 0; i < 1000; i++) {"
     "  result = o.x(42);"
     "}");
   CHECK_EQ(43, value->Int32Value());
 }
 
 
 static v8::Handle<Value> call_ic_function5;
-static v8::Handle<Value> InterceptorCallICGetter5(Local<String> name,
-                                                  const AccessorInfo& info) {
+static void InterceptorCallICGetter5(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (v8_str("x")->Equals(name))
-    return call_ic_function5;
-  else
-    return Local<Value>();
+    info.GetReturnValue().Set(call_ic_function5);
 }
 
 
 // This test checks that if interceptor provides a function,
 // even if we cached constant function, interceptor's function
 // is invoked
 THREADED_TEST(InterceptorCallICConstantFunctionNotNeeded) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorCallICGetter5);
   LocalContext context;
   context->Global()->Set(v8_str("o"), templ->NewInstance());
   call_ic_function5 =
       v8_compile("function f(x) { return x - 1; }; f")->Run();
   v8::Handle<Value> value = CompileRun(
     "function inc(x) { return x + 1; };"
     "inc(1);"
     "o.x = inc;"
     "var result = 0;"
     "for (var i = 0; i < 1000; i++) {"
     "  result = o.x(42);"
     "}");
   CHECK_EQ(41, value->Int32Value());
 }
 
 
 static v8::Handle<Value> call_ic_function6;
-static v8::Handle<Value> InterceptorCallICGetter6(Local<String> name,
-                                                  const AccessorInfo& info) {
+static void InterceptorCallICGetter6(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (v8_str("x")->Equals(name))
-    return call_ic_function6;
-  else
-    return Local<Value>();
+    info.GetReturnValue().Set(call_ic_function6);
 }
 
 
 // Same test as above, except the code is wrapped in a function
 // to test the optimized compiler.
 THREADED_TEST(InterceptorCallICConstantFunctionNotNeededWrapped) {
   i::FLAG_allow_natives_syntax = true;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorCallICGetter6);
@@ skipping 98 matching lines @@
     "  for (var i = 0; i < 10; i++) {"
     "    result += o.parseFloat('239');"
     "  }"
     "  result"
     "} catch(e) {"
     "  e"
     "};");
   CHECK_EQ(239 * 10, value->Int32Value());
 }
 
-static v8::Handle<Value> InterceptorCallICFastApi(Local<String> name,
-                                                  const AccessorInfo& info) {
+static void InterceptorCallICFastApi(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(info, FUNCTION_ADDR(InterceptorCallICFastApi));
   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) {
+static void FastApiCallback_TrivialSignature(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_TrivialSignature));
   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);
+  args.GetReturnValue().Set(args[0]->Int32Value() + 1);
 }
 
-static v8::Handle<Value> FastApiCallback_SimpleSignature(
-    const v8::Arguments& args) {
+static void FastApiCallback_SimpleSignature(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_SimpleSignature));
   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);
+  args.GetReturnValue().Set(args[0]->Int32Value() + 1);
 }
 
 // Helper to maximize the odds of object moving.
 static void GenerateSomeGarbage() {
   CompileRun(
       "var garbage;"
       "for (var i = 0; i < 1000; i++) {"
       "  garbage = [1/i, \"garbage\" + i, garbage, {foo: garbage}];"
       "}"
       "garbage = undefined;");
 }
 
 
-v8::Handle<v8::Value> DirectApiCallback(const v8::Arguments& args) {
+void DirectApiCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   static int count = 0;
   if (count++ % 3 == 0) {
     HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
         // This should move the stub
     GenerateSomeGarbage();  // This should ensure the old stub memory is flushed
   }
-  return v8::Handle<v8::Value>();
 }
 
 
 THREADED_TEST(CallICFastApi_DirectCall_GCMoveStub) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::Handle<v8::ObjectTemplate> nativeobject_templ = v8::ObjectTemplate::New();
   nativeobject_templ->Set("callback",
                           v8::FunctionTemplate::New(DirectApiCallback));
   v8::Local<v8::Object> nativeobject_obj = nativeobject_templ->NewInstance();
   context->Global()->Set(v8_str("nativeobject"), nativeobject_obj);
   // call the api function multiple times to ensure direct call stub creation.
   CompileRun(
         "function f() {"
         "  for (var i = 1; i <= 30; i++) {"
         "    nativeobject.callback();"
         "  }"
         "}"
         "f();");
 }
 
 
-v8::Handle<v8::Value> ThrowingDirectApiCallback(const v8::Arguments& args) {
-  return v8::ThrowException(v8_str("g"));
+void ThrowingDirectApiCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::ThrowException(v8_str("g"));
 }
 
 
 THREADED_TEST(CallICFastApi_DirectCall_Throw) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::Handle<v8::ObjectTemplate> nativeobject_templ = v8::ObjectTemplate::New();
   nativeobject_templ->Set("callback",
                           v8::FunctionTemplate::New(ThrowingDirectApiCallback));
   v8::Local<v8::Object> nativeobject_obj = nativeobject_templ->NewInstance();
@@ skipping 12 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));
-  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));
-  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));
   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);
   context->Global()->Set(v8_str("o1"), obj->NewInstance());
   p_getter_count = 0;
   v8::Handle<v8::Value> result = CompileRun(
       "function f() {"
       "  for (var i = 0; i < 30; i++) o1.p1;"
       "  return o1.p1"
       "}"
       "f();");
   CHECK_EQ(v8_str("Direct Getter Result"), result);
   CHECK_EQ(31, p_getter_count);
 }
 
-THREADED_TEST(LoadICFastApi_DirectCall_GCMoveStub) {
-  LoadICFastApi_DirectCall_GCMoveStub(DirectGetterIndirect);
+THREADED_PROFILED_TEST(LoadICFastApi_DirectCall_GCMoveStub) {
   LoadICFastApi_DirectCall_GCMoveStub(DirectGetterCallback);
-  LoadICFastApi_DirectCall_GCMoveStub(DirectGetter);
 }
 
 
-v8::Handle<v8::Value> ThrowingDirectGetterCallback(
-    Local<String> name, const v8::AccessorInfo& info) {
-  return v8::ThrowException(v8_str("g"));
+void ThrowingDirectGetterCallback(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  v8::ThrowException(v8_str("g"));
 }
 
 
 THREADED_TEST(LoadICFastApi_DirectCall_Throw) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::Handle<v8::ObjectTemplate> obj = v8::ObjectTemplate::New();
   obj->SetAccessor(v8_str("p1"), ThrowingDirectGetterCallback);
   context->Global()->Set(v8_str("o1"), obj->NewInstance());
   v8::Handle<Value> result = CompileRun(
       "var result = '';"
       "for (var i = 0; i < 5; i++) {"
       "    try { o1.p1; } catch (e) { result += e; }"
       "}"
       "result;");
   CHECK_EQ(v8_str("ggggg"), result);
 }
 
 
-THREADED_TEST(InterceptorCallICFastApi_TrivialSignature) {
+THREADED_PROFILED_TEST(InterceptorCallICFastApi_TrivialSignature) {
   int interceptor_call_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_TrivialSignature,
                                 v8_str("method_data"),
                                 v8::Handle<v8::Signature>());
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   v8::Handle<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
   templ->SetNamedPropertyHandler(InterceptorCallICFastApi,
                                  NULL, NULL, NULL, NULL,
                                  v8::External::New(&interceptor_call_count));
   LocalContext context;
   v8::Handle<v8::Function> fun = fun_templ->GetFunction();
   GenerateSomeGarbage();
   context->Global()->Set(v8_str("o"), fun->NewInstance());
   CompileRun(
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = o.method(41);"
       "}");
   CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
   CHECK_EQ(100, interceptor_call_count);
 }
 
-THREADED_TEST(InterceptorCallICFastApi_SimpleSignature) {
+THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature) {
   int interceptor_call_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
@@ skipping 10 matching lines @@
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "}");
   CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
   CHECK_EQ(100, interceptor_call_count);
 }
 
-THREADED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss1) {
+THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss1) {
   int interceptor_call_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
@@ skipping 16 matching lines @@
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = {method: function(x) { return x - 1 }};"
       "  }"
       "}");
   CHECK_EQ(40, context->Global()->Get(v8_str("result"))->Int32Value());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
   CHECK_GE(interceptor_call_count, 50);
 }
 
-THREADED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss2) {
+THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss2) {
   int interceptor_call_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
@@ skipping 16 matching lines @@
       "  if (i == 50) {"
       "    saved_result = result;"
       "    o.method = function(x) { return x - 1 };"
       "  }"
       "}");
   CHECK_EQ(40, context->Global()->Get(v8_str("result"))->Int32Value());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
   CHECK_GE(interceptor_call_count, 50);
 }
 
-THREADED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss3) {
+THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss3) {
   int interceptor_call_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
@@ skipping 19 matching lines @@
       "    receiver = 333;"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
   CHECK_EQ(v8_str("TypeError: Object 333 has no method 'method'"),
            try_catch.Exception()->ToString());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
   CHECK_GE(interceptor_call_count, 50);
 }
 
-THREADED_TEST(InterceptorCallICFastApi_SimpleSignature_TypeError) {
+THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_TypeError) {
   int interceptor_call_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
@@ skipping 19 matching lines @@
       "    receiver = {method: receiver.method};"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
   CHECK_EQ(v8_str("TypeError: Illegal invocation"),
            try_catch.Exception()->ToString());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
   CHECK_GE(interceptor_call_count, 50);
 }
 
-THREADED_TEST(CallICFastApi_TrivialSignature) {
+THREADED_PROFILED_TEST(CallICFastApi_TrivialSignature) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_TrivialSignature,
                                 v8_str("method_data"),
                                 v8::Handle<v8::Signature>());
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
   USE(templ);
   LocalContext context;
   v8::Handle<v8::Function> fun = fun_templ->GetFunction();
   GenerateSomeGarbage();
   context->Global()->Set(v8_str("o"), fun->NewInstance());
   CompileRun(
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = o.method(41);"
       "}");
 
   CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
 }
 
-THREADED_TEST(CallICFastApi_SimpleSignature) {
+THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
   v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
   CHECK(!templ.IsEmpty());
   LocalContext context;
   v8::Handle<v8::Function> fun = fun_templ->GetFunction();
   GenerateSomeGarbage();
   context->Global()->Set(v8_str("o"), fun->NewInstance());
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "}");
 
   CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
 }
 
-THREADED_TEST(CallICFastApi_SimpleSignature_Miss1) {
+THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature_Miss1) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
   v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
@@ skipping 12 matching lines @@
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = {method: function(x) { return x - 1 }};"
       "  }"
       "}");
   CHECK_EQ(40, context->Global()->Get(v8_str("result"))->Int32Value());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
 }
 
-THREADED_TEST(CallICFastApi_SimpleSignature_Miss2) {
+THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature_Miss2) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
   v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
@@ skipping 15 matching lines @@
       "    saved_result = result;"
       "    receiver = 333;"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
   CHECK_EQ(v8_str("TypeError: Object 333 has no method 'method'"),
            try_catch.Exception()->ToString());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
 }
 
-THREADED_TEST(CallICFastApi_SimpleSignature_TypeError) {
+THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature_TypeError) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   v8::Handle<v8::FunctionTemplate> method_templ =
       v8::FunctionTemplate::New(FastApiCallback_SimpleSignature,
                                 v8_str("method_data"),
                                 v8::Signature::New(fun_templ));
   v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
   v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
@@ skipping 18 matching lines @@
       "}");
   CHECK(try_catch.HasCaught());
   CHECK_EQ(v8_str("TypeError: Illegal invocation"),
            try_catch.Exception()->ToString());
   CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
 }
 
 
 v8::Handle<Value> keyed_call_ic_function;
 
-static v8::Handle<Value> InterceptorKeyedCallICGetter(
-    Local<String> name, const AccessorInfo& info) {
+static void InterceptorKeyedCallICGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (v8_str("x")->Equals(name)) {
-    return keyed_call_ic_function;
+    info.GetReturnValue().Set(keyed_call_ic_function);
   }
-  return v8::Handle<Value>();
 }
 
 
 // Test the case when we stored cacheable lookup into
 // a stub, but the function name changed (to another cacheable function).
 THREADED_TEST(InterceptorKeyedCallICKeyChange1) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(NoBlockGetterX);
   LocalContext context;
@@ skipping 130 matching lines @@
     "for (var i = 0; i < 10; i++) {"
     "  if (i == 5) { proto.method = function(x) { return x - 1; }; };"
     "  result += o[m](41);"
     "}");
   CHECK_EQ(42*5 + 40*5, context->Global()->Get(v8_str("result"))->Int32Value());
 }
 
 
 static int interceptor_call_count = 0;
 
-static v8::Handle<Value> InterceptorICRefErrorGetter(Local<String> name,
-                                                     const AccessorInfo& info) {
+static void InterceptorICRefErrorGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (v8_str("x")->Equals(name) && interceptor_call_count++ < 20) {
-    return call_ic_function2;
+    info.GetReturnValue().Set(call_ic_function2);
   }
-  return v8::Handle<Value>();
 }
 
 
 // This test should hit load and call ICs for the interceptor case.
 // Once in a while, the interceptor will reply that a property was not
 // found in which case we should get a reference error.
 THREADED_TEST(InterceptorICReferenceErrors) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorICRefErrorGetter);
@@ skipping 16 matching lines @@
     "  }"
     "  return false;"
     "};"
     "g();");
   CHECK_EQ(true, value->BooleanValue());
 }
 
 
 static int interceptor_ic_exception_get_count = 0;
 
-static v8::Handle<Value> InterceptorICExceptionGetter(
+static void InterceptorICExceptionGetter(
     Local<String> name,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (v8_str("x")->Equals(name) && ++interceptor_ic_exception_get_count < 20) {
-    return call_ic_function3;
+    info.GetReturnValue().Set(call_ic_function3);
   }
   if (interceptor_ic_exception_get_count == 20) {
-    return v8::ThrowException(v8_num(42));
+    v8::ThrowException(v8_num(42));
+    return;
   }
-  // Do not handle get for properties other than x.
-  return v8::Handle<Value>();
 }
 
 // Test interceptor load/call IC where the interceptor throws an
 // exception once in a while.
 THREADED_TEST(InterceptorICGetterExceptions) {
   interceptor_ic_exception_get_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(InterceptorICExceptionGetter);
   LocalContext context(0, templ, v8::Handle<Value>());
@@ skipping 15 matching lines @@
     "  }"
     "  return false;"
     "};"
     "f();");
   CHECK_EQ(true, value->BooleanValue());
 }
 
 
 static int interceptor_ic_exception_set_count = 0;
 
-static v8::Handle<Value> InterceptorICExceptionSetter(
-      Local<String> key, Local<Value> value, const AccessorInfo&) {
+static void InterceptorICExceptionSetter(
+      Local<String> key,
+      Local<Value> value,
+      const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   if (++interceptor_ic_exception_set_count > 20) {
-    return v8::ThrowException(v8_num(42));
+    v8::ThrowException(v8_num(42));
   }
-  // Do not actually handle setting.
-  return v8::Handle<Value>();
 }
 
 // Test interceptor store IC where the interceptor throws an exception
 // once in a while.
 THREADED_TEST(InterceptorICSetterExceptions) {
   interceptor_ic_exception_set_count = 0;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(0, InterceptorICExceptionSetter);
   LocalContext context(0, templ, v8::Handle<Value>());
   v8::Handle<Value> value = CompileRun(
     "function f() {"
     "  for (var i = 0; i < 100; i++) {"
     "    try { x = 42; } catch(e) { return true; }"
     "  }"
     "  return false;"
     "};"
     "f();");
   CHECK_EQ(true, value->BooleanValue());
 }
 
 
 // Test that we ignore null interceptors.
 THREADED_TEST(NullNamedInterceptor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
-  templ->SetNamedPropertyHandler(static_cast<v8::NamedPropertyGetter>(0));
+  templ->SetNamedPropertyHandler(
+      static_cast<v8::NamedPropertyGetterCallback>(0));
   LocalContext context;
   templ->Set("x", v8_num(42));
   v8::Handle<v8::Object> obj = templ->NewInstance();
   context->Global()->Set(v8_str("obj"), obj);
   v8::Handle<Value> value = CompileRun("obj.x");
   CHECK(value->IsInt32());
   CHECK_EQ(42, value->Int32Value());
 }
 
 
 // Test that we ignore null interceptors.
 THREADED_TEST(NullIndexedInterceptor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
-  templ->SetIndexedPropertyHandler(static_cast<v8::IndexedPropertyGetter>(0));
+  templ->SetIndexedPropertyHandler(
+      static_cast<v8::IndexedPropertyGetterCallback>(0));
   LocalContext context;
   templ->Set("42", v8_num(42));
   v8::Handle<v8::Object> obj = templ->NewInstance();
   context->Global()->Set(v8_str("obj"), obj);
   v8::Handle<Value> value = CompileRun("obj[42]");
   CHECK(value->IsInt32());
   CHECK_EQ(42, value->Int32Value());
 }
 
 
 THREADED_TEST(NamedPropertyHandlerGetterAttributes) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
   templ->InstanceTemplate()->SetNamedPropertyHandler(InterceptorLoadXICGetter);
   LocalContext env;
   env->Global()->Set(v8_str("obj"),
                      templ->GetFunction()->NewInstance());
   ExpectTrue("obj.x === 42");
   ExpectTrue("!obj.propertyIsEnumerable('x')");
 }
 
 
-static Handle<Value> ThrowingGetter(Local<String> name,
-                                    const AccessorInfo& info) {
+static void ThrowingGetter(Local<String> name,
+                           const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   ThrowException(Handle<Value>());
-  return Undefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 
 THREADED_TEST(VariousGetPropertiesAndThrowingCallbacks) {
   LocalContext context;
   HandleScope scope(context->GetIsolate());
 
   Local<FunctionTemplate> templ = FunctionTemplate::New();
   Local<ObjectTemplate> instance_templ = templ->InstanceTemplate();
   instance_templ->SetAccessor(v8_str("f"), ThrowingGetter);
@@ skipping 36 matching lines @@
   try_catch.Reset();
   CHECK(result.IsEmpty());
 
   result = with_js_getter->Get(v8_str("f"));
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
   CHECK(result.IsEmpty());
 }
 
 
-static Handle<Value> ThrowingCallbackWithTryCatch(const Arguments& args) {
+static void ThrowingCallbackWithTryCatch(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   TryCatch try_catch;
   // Verboseness is important: it triggers message delivery which can call into
   // external code.
   try_catch.SetVerbose(true);
   CompileRun("throw 'from JS';");
   CHECK(try_catch.HasCaught());
   CHECK(!i::Isolate::Current()->has_pending_exception());
   CHECK(!i::Isolate::Current()->has_scheduled_exception());
-  return Undefined();
 }
 
 
 static int call_depth;
 
 
 static void WithTryCatch(Handle<Message> message, Handle<Value> data) {
   TryCatch try_catch;
 }
 
@@ skipping 37 matching lines @@
         "var thrown = false;\n"
         "try { func(); } catch(e) { thrown = true; }\n"
         "thrown\n");
     if (callback != NULL) {
       V8::RemoveMessageListeners(callback);
     }
   }
 }
 
 
-static v8::Handle<Value> ParentGetter(Local<String> name,
-                                      const AccessorInfo& info) {
+static void ParentGetter(Local<String> name,
+                         const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(1);
+  info.GetReturnValue().Set(v8_num(1));
 }
 
 
-static v8::Handle<Value> ChildGetter(Local<String> name,
-                                     const AccessorInfo& info) {
+static void ChildGetter(Local<String> name,
+                        const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(42);
+  info.GetReturnValue().Set(v8_num(42));
 }
 
 
 THREADED_TEST(Overriding) {
   i::FLAG_es5_readonly = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   // Parent template.
   Local<v8::FunctionTemplate> parent_templ = v8::FunctionTemplate::New();
@@ skipping 41 matching lines @@
   // Check that 'h' cannot be shadowed.
   value = v8_compile("o.h = 3; o.h")->Run();
   CHECK_EQ(1, value->Int32Value());
 
   // Check that 'i' cannot be shadowed or changed.
   value = v8_compile("o.i = 3; o.i")->Run();
   CHECK_EQ(42, value->Int32Value());
 }
 
 
-static v8::Handle<Value> IsConstructHandler(const v8::Arguments& args) {
+static void IsConstructHandler(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8::Boolean::New(args.IsConstructCall());
+  args.GetReturnValue().Set(args.IsConstructCall());
 }
 
 
 THREADED_TEST(IsConstructCall) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
 
   // Function template with call handler.
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
   templ->SetCallHandler(IsConstructHandler);
 
@@ skipping 220 matching lines @@
 
 void ApiTestFuzzer::CallTest() {
   if (kLogThreading)
     printf("Start test %d\n", test_number_);
   CallTestNumber(test_number_);
   if (kLogThreading)
     printf("End test %d\n", test_number_);
 }
 
 
-static v8::Handle<Value> ThrowInJS(const v8::Arguments& args) {
+static void ThrowInJS(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(v8::Locker::IsLocked(CcTest::default_isolate()));
   ApiTestFuzzer::Fuzz();
   v8::Unlocker unlocker(CcTest::default_isolate());
   const char* code = "throw 7;";
   {
     v8::Locker nested_locker(CcTest::default_isolate());
     v8::HandleScope scope(args.GetIsolate());
     v8::Handle<Value> exception;
     { v8::TryCatch try_catch;
       v8::Handle<Value> value = CompileRun(code);
       CHECK(value.IsEmpty());
       CHECK(try_catch.HasCaught());
       // Make sure to wrap the exception in a new handle because
       // the handle returned from the TryCatch is destroyed
       // when the TryCatch is destroyed.
       exception = Local<Value>::New(try_catch.Exception());
     }
-    return v8::ThrowException(exception);
+    v8::ThrowException(exception);
   }
 }
 
 
-static v8::Handle<Value> ThrowInJSNoCatch(const v8::Arguments& args) {
+static void ThrowInJSNoCatch(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(v8::Locker::IsLocked(CcTest::default_isolate()));
   ApiTestFuzzer::Fuzz();
   v8::Unlocker unlocker(CcTest::default_isolate());
   const char* code = "throw 7;";
   {
     v8::Locker nested_locker(CcTest::default_isolate());
     v8::HandleScope scope(args.GetIsolate());
     v8::Handle<Value> value = CompileRun(code);
     CHECK(value.IsEmpty());
-    return scope.Close(v8_str("foo"));
+    args.GetReturnValue().Set(v8_str("foo"));
   }
 }
 
 
 // These are locking tests that don't need to be run again
 // as part of the locking aggregation tests.
 TEST(NestedLockers) {
   v8::Locker locker(CcTest::default_isolate());
   CHECK(v8::Locker::IsLocked(CcTest::default_isolate()));
   LocalContext env;
@@ skipping 37 matching lines @@
 
 THREADED_TEST(RecursiveLocking) {
   v8::Locker locker(CcTest::default_isolate());
   {
     v8::Locker locker2(CcTest::default_isolate());
     CHECK(v8::Locker::IsLocked(CcTest::default_isolate()));
   }
 }
 
 
-static v8::Handle<Value> UnlockForAMoment(const v8::Arguments& args) {
+static void UnlockForAMoment(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   v8::Unlocker unlocker(CcTest::default_isolate());
-  return v8::Undefined();
 }
 
 
 THREADED_TEST(LockUnlockLock) {
   {
     v8::Locker locker(CcTest::default_isolate());
     v8::HandleScope scope(CcTest::default_isolate());
     LocalContext env;
     Local<v8::FunctionTemplate> fun_templ =
         v8::FunctionTemplate::New(UnlockForAMoment);
@@ skipping 737 matching lines @@
   v8::Handle<v8::Script> script1 =
       v8::Script::Compile(source1, v8::String::New("test.js"));
   v8::Handle<v8::Script> script2 =
       v8::Script::Compile(source0);  // different origin
   CHECK_EQ(1234, script0->Run()->Int32Value());
   CHECK_EQ(1234, script1->Run()->Int32Value());
   CHECK_EQ(1234, script2->Run()->Int32Value());
 }
 
 
-static v8::Handle<Value> FunctionNameCallback(const v8::Arguments& args) {
+static void FunctionNameCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  return v8_num(42);
+  args.GetReturnValue().Set(v8_num(42));
 }
 
 
 THREADED_TEST(CallbackFunctionName) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<ObjectTemplate> t = ObjectTemplate::New();
   t->Set(v8_str("asdf"), v8::FunctionTemplate::New(FunctionNameCallback));
   context->Global()->Set(v8_str("obj"), t->NewInstance());
   v8::Handle<v8::Value> value = CompileRun("obj.asdf.name");
@@ skipping 1148 matching lines @@
   CHECK_EQ(v8::Integer::New(0), res);
   // Check with 'with'.
   res = CompileRun("function f() { with (this) { y = 44 }; return y; }; f()");
   CHECK_EQ(v8::Integer::New(0), res);
 }
 
 static int force_set_set_count = 0;
 static int force_set_get_count = 0;
 bool pass_on_get = false;
 
-static v8::Handle<v8::Value> ForceSetGetter(v8::Local<v8::String> name,
-                                            const v8::AccessorInfo& info) {
+static void ForceSetGetter(v8::Local<v8::String> name,
+                           const v8::PropertyCallbackInfo<v8::Value>& info) {
   force_set_get_count++;
   if (pass_on_get) {
-    return v8::Handle<v8::Value>();
-  } else {
-    return v8::Int32::New(3);
+    return;
   }
+  info.GetReturnValue().Set(3);
 }
 
 static void ForceSetSetter(v8::Local<v8::String> name,
                            v8::Local<v8::Value> value,
-                           const v8::AccessorInfo& info) {
+                           const v8::PropertyCallbackInfo<void>& info) {
   force_set_set_count++;
 }
 
-static v8::Handle<v8::Value> ForceSetInterceptSetter(
+static void ForceSetInterceptSetter(
     v8::Local<v8::String> name,
     v8::Local<v8::Value> value,
-    const v8::AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   force_set_set_count++;
-  return v8::Undefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 TEST(ForceSet) {
   force_set_get_count = 0;
   force_set_set_count = 0;
   pass_on_get = false;
 
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New();
   v8::Handle<v8::String> access_property = v8::String::New("a");
@@ skipping 93 matching lines @@
   // This should succeed even though the property is dont-delete.
   CHECK(global->ForceDelete(simple_property));
   CHECK(global->Get(simple_property)->IsUndefined());
 }
 
 
 static int force_delete_interceptor_count = 0;
 static bool pass_on_delete = false;
 
 
-static v8::Handle<v8::Boolean> ForceDeleteDeleter(
+static void ForceDeleteDeleter(
     v8::Local<v8::String> name,
-    const v8::AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Boolean>& info) {
   force_delete_interceptor_count++;
-  if (pass_on_delete) {
-    return v8::Handle<v8::Boolean>();
-  } else {
-    return v8::True();
-  }
+  if (pass_on_delete) return;
+  info.GetReturnValue().Set(true);
 }
 
 
 THREADED_TEST(ForceDeleteWithInterceptor) {
   force_delete_interceptor_count = 0;
   pass_on_delete = false;
 
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New();
   templ->SetNamedPropertyHandler(0, 0, 0, ForceDeleteDeleter);
@@ skipping 85 matching lines @@
 
 
 static v8::Local<Context> calling_context0;
 static v8::Local<Context> calling_context1;
 static v8::Local<Context> calling_context2;
 
 
 // Check that the call to the callback is initiated in
 // calling_context2, the directly calling context is calling_context1
 // and the callback itself is in calling_context0.
-static v8::Handle<Value> GetCallingContextCallback(const v8::Arguments& args) {
+static void GetCallingContextCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK(Context::GetCurrent() == calling_context0);
   CHECK(args.GetIsolate()->GetCurrentContext() == calling_context0);
   CHECK(Context::GetCalling() == calling_context1);
   CHECK(Context::GetEntered() == calling_context2);
-  return v8::Integer::New(42);
+  args.GetReturnValue().Set(42);
 }
 
 
+THREADED_TEST(GetCurrentContextWhenNotInContext) {
+  i::Isolate* isolate = i::Isolate::Current();
+  CHECK(isolate != NULL);
+  CHECK(isolate->context() == NULL);
+  v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
+  v8::HandleScope scope(v8_isolate);
+  // The following should not crash, but return an empty handle.
+  v8::Local<v8::Context> current = v8_isolate->GetCurrentContext();
+  CHECK(current.IsEmpty());
+}
+
+
 THREADED_TEST(GetCallingContext) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope scope(isolate);
 
   Local<Context> calling_context0(Context::New(isolate));
   Local<Context> calling_context1(Context::New(isolate));
   Local<Context> calling_context2(Context::New(isolate));
   ::calling_context0 = calling_context0;
   ::calling_context1 = calling_context1;
   ::calling_context2 = calling_context2;
@@ skipping 482 matching lines @@
     v8::Handle<v8::Object> obj = v8::Object::New();
     obj->SetIndexedPropertiesToPixelData(pixel_data, size);
     CHECK(obj->HasIndexedPropertiesInPixelData());
     CHECK_EQ(pixel_data, obj->GetIndexedPropertiesPixelData());
     CHECK_EQ(size, obj->GetIndexedPropertiesPixelDataLength());
     free(pixel_data);
   }
 }
 
 
-static v8::Handle<Value> NotHandledIndexedPropertyGetter(
+static void NotHandledIndexedPropertyGetter(
     uint32_t index,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8::Handle<Value>();
 }
 
 
-static v8::Handle<Value> NotHandledIndexedPropertySetter(
+static void NotHandledIndexedPropertySetter(
     uint32_t index,
     Local<Value> value,
-    const AccessorInfo& info) {
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  return v8::Handle<Value>();
 }
 
 
 THREADED_TEST(PixelArrayWithInterceptor) {
   LocalContext context;
   i::Factory* factory = i::Isolate::Current()->factory();
   v8::HandleScope scope(context->GetIsolate());
   const int kElementCount = 260;
   uint8_t* pixel_data = reinterpret_cast<uint8_t*>(malloc(kElementCount));
   i::Handle<i::ExternalPixelArray> pixels =
@@ skipping 710 matching lines @@
   ExternalArrayLimitTestHelper(v8::kExternalPixelArray, 0x40000000);
   ExternalArrayLimitTestHelper(v8::kExternalPixelArray, 0xffffffff);
 }
 
 
 template <typename ElementType, typename TypedArray,
           class ExternalArrayClass>
 void TypedArrayTestHelper(v8::ExternalArrayType array_type,
                           int64_t low, int64_t high) {
   const int kElementCount = 50;
-  i::FLAG_harmony_array_buffer = true;
-  i::FLAG_harmony_typed_arrays = true;
 
   i::ScopedVector<ElementType> backing_store(kElementCount+2);
 
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
       backing_store.start(), (kElementCount+2)*sizeof(ElementType));
   Local<TypedArray> ta =
@@ skipping 63 matching lines @@
       v8::kExternalDoubleArray, -500, 500);
 }
 
 
 THREADED_TEST(Uint8ClampedArray) {
   TypedArrayTestHelper<uint8_t, v8::Uint8ClampedArray, i::ExternalPixelArray>(
       v8::kExternalPixelArray, 0, 0xFF);
 }
 
 
-#define IS_TYPED_ARRAY_TEST(TypedArray) \
-  THREADED_TEST(Is##TypedArray) {                                             \
+THREADED_TEST(DataView) {
+  const int kSize = 50;
+
+  i::ScopedVector<uint8_t> backing_store(kSize+2);
+
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
+      backing_store.start(), 2 + kSize);
+  Local<v8::DataView> dv =
+      v8::DataView::New(ab, 2, kSize);
+  CHECK_EQ(2, static_cast<int>(dv->ByteOffset()));
+  CHECK_EQ(kSize, static_cast<int>(dv->ByteLength()));
+  CHECK_EQ(ab, dv->Buffer());
+}
+
+
+#define IS_ARRAY_BUFFER_VIEW_TEST(View)                                       \
+  THREADED_TEST(Is##View) {                                                   \
     i::FLAG_harmony_array_buffer = true;                                      \
     i::FLAG_harmony_typed_arrays = true;                                      \
     LocalContext env;                                                         \
     v8::Isolate* isolate = env->GetIsolate();                                 \
     v8::HandleScope handle_scope(isolate);                                    \
                                                                               \
     Handle<Value> result = CompileRun(                                        \
         "var ab = new ArrayBuffer(128);"                                      \
-        "new " #TypedArray "(ab)");                                           \
-    CHECK(result->Is##TypedArray());                                          \
+        "new " #View "(ab)");                                                 \
+    CHECK(result->IsArrayBufferView());                                       \
+    CHECK(result->Is##View());                                                \
   }
 
-IS_TYPED_ARRAY_TEST(Uint8Array)
-IS_TYPED_ARRAY_TEST(Int8Array)
-IS_TYPED_ARRAY_TEST(Uint16Array)
-IS_TYPED_ARRAY_TEST(Int16Array)
-IS_TYPED_ARRAY_TEST(Uint32Array)
-IS_TYPED_ARRAY_TEST(Int32Array)
-IS_TYPED_ARRAY_TEST(Float32Array)
-IS_TYPED_ARRAY_TEST(Float64Array)
-IS_TYPED_ARRAY_TEST(Uint8ClampedArray)
+IS_ARRAY_BUFFER_VIEW_TEST(Uint8Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Int8Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Uint16Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Int16Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Uint32Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Int32Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Float32Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Float64Array)
+IS_ARRAY_BUFFER_VIEW_TEST(Uint8ClampedArray)
+IS_ARRAY_BUFFER_VIEW_TEST(DataView)
 
-#undef IS_TYPED_ARRAY_TEST
+#undef IS_ARRAY_BUFFER_VIEW_TEST
 
 
 
 THREADED_TEST(ScriptContextDependence) {
   LocalContext c1;
   v8::HandleScope scope(c1->GetIsolate());
   const char *source = "foo";
   v8::Handle<v8::Script> dep = v8::Script::Compile(v8::String::New(source));
   v8::Handle<v8::Script> indep = v8::Script::New(v8::String::New(source));
   c1->Global()->Set(v8::String::New("foo"), v8::Integer::New(100));
@@ skipping 35 matching lines @@
     CHECK(strstr(*script_name, expected_script_name) != NULL);
   }
   CHECK(strstr(*func_name, expected_func_name) != NULL);
   CHECK_EQ(expected_line_number, frame->GetLineNumber());
   CHECK_EQ(expected_column, frame->GetColumn());
   CHECK_EQ(is_eval, frame->IsEval());
   CHECK_EQ(is_constructor, frame->IsConstructor());
 }
 
 
-v8::Handle<Value> AnalyzeStackInNativeCode(const v8::Arguments& args) {
+void AnalyzeStackInNativeCode(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   const char* origin = "capture-stack-trace-test";
   const int kOverviewTest = 1;
   const int kDetailedTest = 2;
 
   ASSERT(args.Length() == 1);
 
   int testGroup = args[0]->Int32Value();
   if (testGroup == kOverviewTest) {
     v8::Handle<v8::StackTrace> stackTrace =
@@ skipping 27 matching lines @@
 
     // This is the source string inside the eval which has the call to baz.
     checkStackFrame(NULL, "", 1, 5, is_eval, false,
                     stackTrace->GetFrame(2));
     // The last frame is an anonymous function which has the initial eval call.
     checkStackFrame(origin, "", 10, 1, false, false,
                     stackTrace->GetFrame(3));
 
     CHECK(stackTrace->AsArray()->IsArray());
   }
-  return v8::Undefined();
 }
 
 
 // Tests the C++ StackTrace API.
 // TODO(3074796): Reenable this as a THREADED_TEST once it passes.
 // THREADED_TEST(CaptureStackTrace) {
 TEST(CaptureStackTrace) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::String> origin = v8::String::New("capture-stack-trace-test");
   Local<ObjectTemplate> templ = ObjectTemplate::New();
@@ skipping 218 matching lines @@
       "var e = {__proto__: new Error()} \n"
       "throw e;                         \n";
   v8::V8::AddMessageListener(RethrowBogusErrorStackTraceHandler);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
   CompileRun(source);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
   v8::V8::RemoveMessageListeners(RethrowBogusErrorStackTraceHandler);
 }
 
 
-v8::Handle<Value> AnalyzeStackOfEvalWithSourceURL(const v8::Arguments& args) {
+void AnalyzeStackOfEvalWithSourceURL(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   v8::Handle<v8::StackTrace> stackTrace =
       v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
   CHECK_EQ(5, stackTrace->GetFrameCount());
   v8::Handle<v8::String> url = v8_str("eval_url");
   for (int i = 0; i < 3; i++) {
     v8::Handle<v8::String> name =
         stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
     CHECK(!name.IsEmpty());
     CHECK_EQ(url, name);
   }
-  return v8::Undefined();
 }
 
 
 TEST(SourceURLInStackTrace) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->Set(v8_str("AnalyzeStackOfEvalWithSourceURL"),
              v8::FunctionTemplate::New(AnalyzeStackOfEvalWithSourceURL));
   LocalContext context(0, templ);
 
@@ skipping 11 matching lines @@
     "eval('(' + outer +')()%s');";
 
   i::ScopedVector<char> code(1024);
   i::OS::SNPrintF(code, source, "//# sourceURL=eval_url");
   CHECK(CompileRun(code.start())->IsUndefined());
   i::OS::SNPrintF(code, source, "//@ sourceURL=eval_url");
   CHECK(CompileRun(code.start())->IsUndefined());
 }
 
 
-v8::Handle<Value> AnalyzeStackOfInlineScriptWithSourceURL(
-    const v8::Arguments& args) {
+void AnalyzeStackOfInlineScriptWithSourceURL(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   v8::Handle<v8::StackTrace> stackTrace =
       v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
   CHECK_EQ(4, stackTrace->GetFrameCount());
   v8::Handle<v8::String> url = v8_str("url");
   for (int i = 0; i < 3; i++) {
     v8::Handle<v8::String> name =
         stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
     CHECK(!name.IsEmpty());
     CHECK_EQ(url, name);
   }
-  return v8::Undefined();
 }
 
 
 TEST(InlineScriptWithSourceURLInStackTrace) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->Set(v8_str("AnalyzeStackOfInlineScriptWithSourceURL"),
              v8::FunctionTemplate::New(
                  AnalyzeStackOfInlineScriptWithSourceURL));
   LocalContext context(0, templ);
@@ skipping 12 matching lines @@
     "outer()\n%s";
 
   i::ScopedVector<char> code(1024);
   i::OS::SNPrintF(code, source, "//# sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 1)->IsUndefined());
   i::OS::SNPrintF(code, source, "//@ sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 1)->IsUndefined());
 }
 
 
-v8::Handle<Value> AnalyzeStackOfDynamicScriptWithSourceURL(
-    const v8::Arguments& args) {
+void AnalyzeStackOfDynamicScriptWithSourceURL(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   v8::Handle<v8::StackTrace> stackTrace =
       v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
   CHECK_EQ(4, stackTrace->GetFrameCount());
   v8::Handle<v8::String> url = v8_str("source_url");
   for (int i = 0; i < 3; i++) {
     v8::Handle<v8::String> name =
         stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
     CHECK(!name.IsEmpty());
     CHECK_EQ(url, name);
   }
-  return v8::Undefined();
 }
 
 
 TEST(DynamicWithSourceURLInStackTrace) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->Set(v8_str("AnalyzeStackOfDynamicScriptWithSourceURL"),
              v8::FunctionTemplate::New(
                  AnalyzeStackOfDynamicScriptWithSourceURL));
   LocalContext context(0, templ);
@@ skipping 115 matching lines @@
   bool finished = false;
   for (int i = 0; i < 200 && !finished; i++) {
     finished = v8::V8::IdleNotification(kShortIdlePauseInMs);
   }
   intptr_t final_size = HEAP->SizeOfObjects();
   CHECK_LT(final_size, initial_size + 1);
 }
 
 static uint32_t* stack_limit;
 
-static v8::Handle<Value> GetStackLimitCallback(const v8::Arguments& args) {
+static void GetStackLimitCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   stack_limit = reinterpret_cast<uint32_t*>(
       i::Isolate::Current()->stack_guard()->real_climit());
-  return v8::Undefined();
 }
 
 
 // Uses the address of a local variable to determine the stack top now.
 // Given a size, returns an address that is that far from the current
 // top of stack.
 static uint32_t* ComputeStackLimit(uint32_t size) {
   uint32_t* answer = &size - (size / sizeof(size));
   // If the size is very large and the stack is very near the bottom of
   // memory then the calculation above may wrap around and give an address
@@ skipping 248 matching lines @@
       // on MIPS architecture. Allowed by IEEE-754.
       CHECK_EQ(0xffe, static_cast<int>((stored_bits >> 51) & 0xfff));
 #else
       CHECK_EQ(0xfff, static_cast<int>((stored_bits >> 51) & 0xfff));
 #endif
     }
   }
 }
 
 
-static v8::Handle<Value> SpaghettiIncident(const v8::Arguments& args) {
+static void SpaghettiIncident(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   v8::TryCatch tc;
   v8::Handle<v8::String> str(args[0]->ToString());
   USE(str);
   if (tc.HasCaught())
-    return tc.ReThrow();
-  return v8::Undefined();
+    tc.ReThrow();
 }
 
 
 // Test that an exception can be propagated down through a spaghetti
 // stack using ReThrow.
 THREADED_TEST(SpaghettiStackReThrow) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   LocalContext context;
   context->Global()->Set(
       v8::String::New("s"),
@@ skipping 183 matching lines @@
   script->Run();
   v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::New("foo")));
   v8::Local<v8::Function> bar = v8::Local<v8::Function>::Cast(
       env->Global()->Get(v8::String::New("bar")));
   CHECK_EQ(script->Id(), foo->GetScriptId());
   CHECK_EQ(script->Id(), bar->GetScriptId());
 }
 
 
-static v8::Handle<Value> GetterWhichReturns42(Local<String> name,
-                                              const AccessorInfo& info) {
+static void GetterWhichReturns42(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject());
   CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject());
-  return v8_num(42);
+  info.GetReturnValue().Set(v8_num(42));
 }
 
 
-static void SetterWhichSetsYOnThisTo23(Local<String> name,
-                                       Local<Value> value,
-                                       const AccessorInfo& info) {
+static void SetterWhichSetsYOnThisTo23(
+    Local<String> name,
+    Local<Value> value,
+    const v8::PropertyCallbackInfo<void>& info) {
   CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject());
   CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject());
   info.This()->Set(v8_str("y"), v8_num(23));
 }
 
 
-Handle<Value> FooGetInterceptor(Local<String> name,
-                                const AccessorInfo& info) {
+void FooGetInterceptor(Local<String> name,
+                       const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject());
   CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject());
-  if (!name->Equals(v8_str("foo"))) return Handle<Value>();
-  return v8_num(42);
+  if (!name->Equals(v8_str("foo"))) return;
+  info.GetReturnValue().Set(v8_num(42));
 }
 
 
-Handle<Value> FooSetInterceptor(Local<String> name,
-                                Local<Value> value,
-                                const AccessorInfo& info) {
+void FooSetInterceptor(Local<String> name,
+                       Local<Value> value,
+                       const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(v8::Utils::OpenHandle(*info.This())->IsJSObject());
   CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject());
-  if (!name->Equals(v8_str("foo"))) return Handle<Value>();
+  if (!name->Equals(v8_str("foo"))) return;
   info.This()->Set(v8_str("y"), v8_num(23));
-  return v8_num(23);
+  info.GetReturnValue().Set(v8_num(23));
 }
 
 
 TEST(SetterOnConstructorPrototype) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"),
                      GetterWhichReturns42,
                      SetterWhichSetsYOnThisTo23);
   LocalContext context;
@@ skipping 18 matching lines @@
 
   script = v8::Script::Compile(v8_str("new C2();"));
   for (int i = 0; i < 10; i++) {
     v8::Handle<v8::Object> c2 = v8::Handle<v8::Object>::Cast(script->Run());
     CHECK_EQ(42, c2->Get(v8_str("x"))->Int32Value());
     CHECK_EQ(23, c2->Get(v8_str("y"))->Int32Value());
   }
 }
 
 
-static v8::Handle<Value> NamedPropertyGetterWhichReturns42(
-    Local<String> name, const AccessorInfo& info) {
-  return v8_num(42);
+static void NamedPropertyGetterWhichReturns42(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(v8_num(42));
 }
 
 
-static v8::Handle<Value> NamedPropertySetterWhichSetsYOnThisTo23(
-    Local<String> name, Local<Value> value, const AccessorInfo& info) {
+static void NamedPropertySetterWhichSetsYOnThisTo23(
+    Local<String> name,
+    Local<Value> value,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   if (name->Equals(v8_str("x"))) {
     info.This()->Set(v8_str("y"), v8_num(23));
   }
-  return v8::Handle<Value>();
 }
 
 
 THREADED_TEST(InterceptorOnConstructorPrototype) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetNamedPropertyHandler(NamedPropertyGetterWhichReturns42,
                                  NamedPropertySetterWhichSetsYOnThisTo23);
   LocalContext context;
   context->Global()->Set(v8_str("P"), templ->NewInstance());
@@ skipping 118 matching lines @@
   v8::V8::RemoveGCEpilogueCallback(EpilogueCallbackSecond);
   HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
   CHECK_EQ(2, prologue_call_count);
   CHECK_EQ(2, epilogue_call_count);
   CHECK_EQ(2, prologue_call_count_second);
   CHECK_EQ(2, epilogue_call_count_second);
 }
 
 
 THREADED_TEST(AddToJSFunctionResultCache) {
+  i::FLAG_stress_compaction = false;
   i::FLAG_allow_natives_syntax = true;
   v8::HandleScope scope(v8::Isolate::GetCurrent());
 
   LocalContext context;
 
   const char* code =
       "(function() {"
       "  var key0 = 'a';"
       "  var key1 = 'b';"
       "  var r0 = %_GetFromCache(0, key0);"
@@ skipping 1081 matching lines @@
   CHECK(!globalProxy->StrictEquals(global));
   CHECK(globalProxy->StrictEquals(globalProxy));
 
   CHECK(global->Equals(global));
   CHECK(!global->Equals(globalProxy));
   CHECK(!globalProxy->Equals(global));
   CHECK(globalProxy->Equals(globalProxy));
 }
 
 
-static v8::Handle<v8::Value> Getter(v8::Local<v8::String> property,
-                                    const v8::AccessorInfo& info ) {
-  return v8_str("42!");
+static void Getter(v8::Local<v8::String> property,
+                   const v8::PropertyCallbackInfo<v8::Value>& info ) {
+  info.GetReturnValue().Set(v8_str("42!"));
 }
 
 
-static v8::Handle<v8::Array> Enumerator(const v8::AccessorInfo& info) {
+static void Enumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
   v8::Handle<v8::Array> result = v8::Array::New();
   result->Set(0, v8_str("universalAnswer"));
-  return result;
+  info.GetReturnValue().Set(result);
 }
 
 
 TEST(NamedEnumeratorAndForIn) {
   LocalContext context;
   v8::HandleScope handle_scope(context->GetIsolate());
   v8::Context::Scope context_scope(context.local());
 
   v8::Handle<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New();
   tmpl->SetNamedPropertyHandler(Getter, NULL, NULL, NULL, Enumerator);
@@ skipping 125 matching lines @@
   {
     Context::Scope scope(context);
     function = CompileRun("function foo() {}; foo").As<Object>();
   }
 
   CHECK(function->CreationContext() == context);
   CheckContextId(function, 1);
 }
 
 
-Handle<Value> HasOwnPropertyIndexedPropertyGetter(uint32_t index,
-                                                  const AccessorInfo& info) {
-  if (index == 42) return v8_str("yes");
-  return Handle<v8::Integer>();
+void HasOwnPropertyIndexedPropertyGetter(
+    uint32_t index,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  if (index == 42) info.GetReturnValue().Set(v8_str("yes"));
 }
 
 
-Handle<Value> HasOwnPropertyNamedPropertyGetter(Local<String> property,
-                                                const AccessorInfo& info) {
-  if (property->Equals(v8_str("foo"))) return v8_str("yes");
-  return Handle<Value>();
+void HasOwnPropertyNamedPropertyGetter(
+    Local<String> property,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  if (property->Equals(v8_str("foo"))) info.GetReturnValue().Set(v8_str("yes"));
 }
 
 
-Handle<v8::Integer> HasOwnPropertyIndexedPropertyQuery(
-    uint32_t index, const AccessorInfo& info) {
-  if (index == 42) return v8_num(1).As<v8::Integer>();
-  return Handle<v8::Integer>();
+void HasOwnPropertyIndexedPropertyQuery(
+    uint32_t index, const v8::PropertyCallbackInfo<v8::Integer>& info) {
+  if (index == 42) info.GetReturnValue().Set(1);
 }
 
 
-Handle<v8::Integer> HasOwnPropertyNamedPropertyQuery(
-    Local<String> property, const AccessorInfo& info) {
-  if (property->Equals(v8_str("foo"))) return v8_num(1).As<v8::Integer>();
-  return Handle<v8::Integer>();
+void HasOwnPropertyNamedPropertyQuery(
+    Local<String> property,
+    const v8::PropertyCallbackInfo<v8::Integer>& info) {
+  if (property->Equals(v8_str("foo"))) info.GetReturnValue().Set(1);
 }
 
 
-Handle<v8::Integer> HasOwnPropertyNamedPropertyQuery2(
-    Local<String> property, const AccessorInfo& info) {
-  if (property->Equals(v8_str("bar"))) return v8_num(1).As<v8::Integer>();
-  return Handle<v8::Integer>();
+void HasOwnPropertyNamedPropertyQuery2(
+    Local<String> property,
+    const v8::PropertyCallbackInfo<v8::Integer>& info) {
+  if (property->Equals(v8_str("bar"))) info.GetReturnValue().Set(1);
 }
 
 
-Handle<Value> HasOwnPropertyAccessorGetter(Local<String> property,
-                                           const AccessorInfo& info) {
-  return v8_str("yes");
+void HasOwnPropertyAccessorGetter(
+    Local<String> property,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(v8_str("yes"));
 }
 
 
 TEST(HasOwnProperty) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   { // Check normal properties and defined getters.
     Handle<Value> value = CompileRun(
         "function Foo() {"
         "    this.foo = 11;"
@@ skipping 166 matching lines @@
   context->AllowCodeGenerationFromStrings(false);
   context->SetErrorMessageForCodeGenerationFromStrings(message);
   Handle<Value> result = CompileRun("eval('42')");
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
   Handle<String> actual_message = try_catch.Message()->Get();
   CHECK(expected_message->Equals(actual_message));
 }
 
 
-static v8::Handle<Value> NonObjectThis(const v8::Arguments& args) {
-  return v8::Undefined();
+static void NonObjectThis(const v8::FunctionCallbackInfo<v8::Value>& args) {
 }
 
 
 THREADED_TEST(CallAPIFunctionOnNonObject) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Handle<FunctionTemplate> templ = v8::FunctionTemplate::New(NonObjectThis);
   Handle<Function> function = templ->GetFunction();
   context->Global()->Set(v8_str("f"), function);
   TryCatch try_catch;
@@ skipping 292 matching lines @@
   callback_fired ^= 1;  // Toggle first bit.
 }
 
 
 void CallCompletedCallback2() {
   i::OS::Print("Firing callback 2.\n");
   callback_fired ^= 2;  // Toggle second bit.
 }
 
 
-Handle<Value> RecursiveCall(const Arguments& args) {
+void RecursiveCall(const v8::FunctionCallbackInfo<v8::Value>& args) {
   int32_t level = args[0]->Int32Value();
   if (level < 3) {
     level++;
     i::OS::Print("Entering recursion level %d.\n", level);
     char script[64];
     i::Vector<char> script_vector(script, sizeof(script));
     i::OS::SNPrintF(script_vector, "recursion(%d)", level);
     CompileRun(script_vector.start());
     i::OS::Print("Leaving recursion level %d.\n", level);
     CHECK_EQ(0, callback_fired);
   } else {
     i::OS::Print("Recursion ends.\n");
     CHECK_EQ(0, callback_fired);
   }
-  return Undefined();
 }
 
 
 TEST(CallCompletedCallback) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::FunctionTemplate> recursive_runtime =
       v8::FunctionTemplate::New(RecursiveCall);
   env->Global()->Set(v8_str("recursion"),
                      recursive_runtime->GetFunction());
@@ skipping 112 matching lines @@
 TEST(SecondaryStubCache) {
   StubCacheHelper(true);
 }
 
 
 TEST(PrimaryStubCache) {
   StubCacheHelper(false);
 }
 
 
-static int fatal_error_callback_counter = 0;
-static void CountingErrorCallback(const char* location, const char* message) {
-  printf("CountingErrorCallback(\"%s\", \"%s\")\n", location, message);
-  fatal_error_callback_counter++;
-}
-
-
 TEST(StaticGetters) {
   LocalContext context;
   i::Factory* factory = i::Isolate::Current()->factory();
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope scope(isolate);
   i::Handle<i::Object> undefined_value = factory->undefined_value();
   CHECK(*v8::Utils::OpenHandle(*v8::Undefined()) == *undefined_value);
   CHECK(*v8::Utils::OpenHandle(*v8::Undefined(isolate)) == *undefined_value);
   i::Handle<i::Object> null_value = factory->null_value();
   CHECK(*v8::Utils::OpenHandle(*v8::Null()) == *null_value);
   CHECK(*v8::Utils::OpenHandle(*v8::Null(isolate)) == *null_value);
   i::Handle<i::Object> true_value = factory->true_value();
   CHECK(*v8::Utils::OpenHandle(*v8::True()) == *true_value);
   CHECK(*v8::Utils::OpenHandle(*v8::True(isolate)) == *true_value);
   i::Handle<i::Object> false_value = factory->false_value();
   CHECK(*v8::Utils::OpenHandle(*v8::False()) == *false_value);
   CHECK(*v8::Utils::OpenHandle(*v8::False(isolate)) == *false_value);
-
-  // Test after-death behavior.
-  CHECK(i::Internals::IsInitialized(isolate));
-  CHECK_EQ(0, fatal_error_callback_counter);
-  v8::V8::SetFatalErrorHandler(CountingErrorCallback);
-  v8::Utils::ReportApiFailure("StaticGetters()", "Kill V8");
-  i::Isolate::Current()->TearDown();
-  CHECK(!i::Internals::IsInitialized(isolate));
-  CHECK_EQ(1, fatal_error_callback_counter);
-  CHECK(v8::Undefined().IsEmpty());
-  CHECK_EQ(2, fatal_error_callback_counter);
-  CHECK(v8::Undefined(isolate).IsEmpty());
-  CHECK_EQ(3, fatal_error_callback_counter);
-  CHECK(v8::Null().IsEmpty());
-  CHECK_EQ(4, fatal_error_callback_counter);
-  CHECK(v8::Null(isolate).IsEmpty());
-  CHECK_EQ(5, fatal_error_callback_counter);
-  CHECK(v8::True().IsEmpty());
-  CHECK_EQ(6, fatal_error_callback_counter);
-  CHECK(v8::True(isolate).IsEmpty());
-  CHECK_EQ(7, fatal_error_callback_counter);
-  CHECK(v8::False().IsEmpty());
-  CHECK_EQ(8, fatal_error_callback_counter);
-  CHECK(v8::False(isolate).IsEmpty());
-  CHECK_EQ(9, fatal_error_callback_counter);
 }
 
 
 TEST(IsolateEmbedderData) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   CHECK_EQ(NULL, isolate->GetData());
   CHECK_EQ(NULL, ISOLATE->GetData());
   static void* data1 = reinterpret_cast<void*>(0xacce55ed);
   isolate->SetData(data1);
   CHECK_EQ(data1, isolate->GetData());
   CHECK_EQ(data1, ISOLATE->GetData());
   static void* data2 = reinterpret_cast<void*>(0xdecea5ed);
   ISOLATE->SetData(data2);
   CHECK_EQ(data2, isolate->GetData());
   CHECK_EQ(data2, ISOLATE->GetData());
   ISOLATE->TearDown();
   CHECK_EQ(data2, isolate->GetData());
   CHECK_EQ(data2, ISOLATE->GetData());
 }
 
 
 TEST(StringEmpty) {
   LocalContext context;
   i::Factory* factory = i::Isolate::Current()->factory();
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope scope(isolate);
   i::Handle<i::Object> empty_string = factory->empty_string();
   CHECK(*v8::Utils::OpenHandle(*v8::String::Empty()) == *empty_string);
   CHECK(*v8::Utils::OpenHandle(*v8::String::Empty(isolate)) == *empty_string);
-
-  // Test after-death behavior.
-  CHECK(i::Internals::IsInitialized(isolate));
-  CHECK_EQ(0, fatal_error_callback_counter);
-  v8::V8::SetFatalErrorHandler(CountingErrorCallback);
-  v8::Utils::ReportApiFailure("StringEmpty()", "Kill V8");
-  i::Isolate::Current()->TearDown();
-  CHECK(!i::Internals::IsInitialized(isolate));
-  CHECK_EQ(1, fatal_error_callback_counter);
-  CHECK(v8::String::Empty().IsEmpty());
-  CHECK_EQ(2, fatal_error_callback_counter);
-  CHECK(v8::String::Empty(isolate).IsEmpty());
-  CHECK_EQ(3, fatal_error_callback_counter);
 }
 
 
 static int instance_checked_getter_count = 0;
-static Handle<Value> InstanceCheckedGetter(Local<String> name,
-                                           const AccessorInfo& info) {
+static void InstanceCheckedGetter(
+    Local<String> name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK_EQ(name, v8_str("foo"));
   instance_checked_getter_count++;
-  return v8_num(11);
+  info.GetReturnValue().Set(v8_num(11));
 }
 
 
 static int instance_checked_setter_count = 0;
 static void InstanceCheckedSetter(Local<String> name,
                       Local<Value> value,
-                      const AccessorInfo& info) {
+                      const v8::PropertyCallbackInfo<void>& info) {
   CHECK_EQ(name, v8_str("foo"));
   CHECK_EQ(value, v8_num(23));
   instance_checked_setter_count++;
 }
 
 
 static void CheckInstanceCheckedResult(int getters,
                                        int setters,
                                        bool expects_callbacks,
                                        TryCatch* try_catch) {
@@ skipping 371 matching lines @@
   v8::HandleScope scope(context->GetIsolate());
   Local<Value> set_value = CompileRun("new Set();");
   Local<Object> set_object(Local<Object>::Cast(set_value));
   CHECK_EQ(0, set_object->InternalFieldCount());
   Local<Value> map_value = CompileRun("new Map();");
   Local<Object> map_object(Local<Object>::Cast(map_value));
   CHECK_EQ(0, map_object->InternalFieldCount());
 }
 
 
+THREADED_TEST(Regress2746) {
+  LocalContext context;
+  v8::HandleScope scope(context->GetIsolate());
+  Local<Object> obj = Object::New();
+  Local<String> key = String::New("key");
+  obj->SetHiddenValue(key, v8::Undefined());
+  Local<Value> value = obj->GetHiddenValue(key);
+  CHECK(!value.IsEmpty());
+  CHECK(value->IsUndefined());
+}
+
+
 #ifndef WIN32
 class ThreadInterruptTest {
  public:
   ThreadInterruptTest() : sem_(NULL), sem_value_(0) { }
   ~ThreadInterruptTest() { delete sem_; }
 
   void RunTest() {
     sem_ = i::OS::CreateSemaphore(0);
 
     InterruptThread i_thread(this);
@@ skipping 43 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32