Plumb accessing context through to access control callbacks

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 7841 matching lines @@
              "}");
   CHECK(try_catch.HasCaught());
   CHECK(!try_catch.Message().IsEmpty());
   String::Utf8Value finally_exception_value(try_catch.Exception());
   CHECK_EQ(0, strcmp(*finally_exception_value, "2"));
 }
 
 
 // For use within the TestSecurityHandler() test.
 static bool g_security_callback_result = false;
-static bool SecurityTestCallback(Local<v8::Object> global, Local<Value> name,
-                                 v8::AccessType type, Local<Value> data) {
+static bool SecurityTestCallback(Local<v8::Context> accessing_context,
+                                 Local<v8::Object> accessed_object) {
   printf("a\n");
   return g_security_callback_result;
 }
 
 
 // SecurityHandler can't be run twice
 TEST(SecurityHandler) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope0(isolate);
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
-  global_template->SetAccessCheckCallbacks(SecurityTestCallback, NULL);
+  global_template->SetAccessCheckCallback(SecurityTestCallback);
   // Create an environment
   v8::Handle<Context> context0 = Context::New(isolate, NULL, global_template);
   context0->Enter();
 
   v8::Handle<v8::Object> global0 = context0->Global();
   v8::Handle<Script> script0 = v8_compile("foo = 111");
   script0->Run();
   global0->Set(v8_str("0"), v8_num(999));
   v8::Handle<Value> foo0 = global0->Get(v8_str("foo"));
   CHECK_EQ(111, foo0->Int32Value());
@@ skipping 140 matching lines @@
   Local<Script> access_f3 = v8_compile("f[99]");
   for (int k = 0; k < 5; k++) {
     CHECK(access_f2->Run().IsEmpty());
     CHECK(access_f3->Run().IsEmpty());
   }
 }
 
 
 static bool security_check_with_gc_called;
 
-static bool SecurityTestCallbackWithGC(Local<v8::Object> global,
-                                       Local<v8::Value> name,
-                                       v8::AccessType type, Local<Value> data) {
+static bool SecurityTestCallbackWithGC(Local<v8::Context> accessing_context,
+                                       Local<v8::Object> accessed_object) {
   CcTest::heap()->CollectAllGarbage();
   security_check_with_gc_called = true;
   return true;
 }
 
 
 TEST(SecurityTestGCAllowed) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
-  object_template->SetAccessCheckCallbacks(SecurityTestCallbackWithGC, NULL);
+  object_template->SetAccessCheckCallback(SecurityTestCallbackWithGC);
 
   v8::Handle<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
   context->Global()->Set(v8_str("obj"), object_template->NewInstance());
 
   security_check_with_gc_called = false;
   CompileRun("obj[0] = new String(1002);");
   CHECK(security_check_with_gc_called);
 
@@ skipping 388 matching lines @@
   for (int i = 0; i < 16; i += 4) {
     CHECK(v8_str("env2_x")->Equals(results->Get(i + 0)));
     CHECK(v8_str("env1_x")->Equals(results->Get(i + 1)));
     CHECK(v8_str("env3_x")->Equals(results->Get(i + 2)));
     CHECK(v8_str("env2_x")->Equals(results->Get(i + 3)));
   }
 }
 
 
 static bool allowed_access = false;
-static bool AccessBlocker(Local<v8::Object> global, Local<Value> name,
-                          v8::AccessType type, Local<Value> data) {
-  return CcTest::isolate()->GetCurrentContext()->Global()->Equals(global) ||
+static bool AccessBlocker(Local<v8::Context> accessing_context,
+                          Local<v8::Object> accessed_object) {
+  return CcTest::isolate()->GetCurrentContext()->Global()->Equals(
+             accessed_object) ||
          allowed_access;
 }
 
 
 static int g_echo_value = -1;
 
 
 static void EchoGetter(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ skipping 28 matching lines @@
   CHECK(false);  // This function should not be called..
 }
 
 
 TEST(AccessControl) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
 
-  global_template->SetAccessCheckCallbacks(AccessBlocker, NULL);
+  global_template->SetAccessCheckCallback(AccessBlocker);
 
   // Add an accessor accessible by cross-domain JS code.
   global_template->SetAccessor(
       v8_str("accessible_prop"),
       EchoGetter, EchoSetter,
       v8::Handle<Value>(),
       v8::AccessControl(v8::ALL_CAN_READ | v8::ALL_CAN_WRITE));
 
 
   // Add an accessor that is not accessible by cross-domain JS code.
@@ skipping 143 matching lines @@
   context0->Exit();
 }
 
 
 TEST(AccessControlES5) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
 
-  global_template->SetAccessCheckCallbacks(AccessBlocker, NULL);
+  global_template->SetAccessCheckCallback(AccessBlocker);
 
   // Add accessible accessor.
   global_template->SetAccessor(
       v8_str("accessible_prop"),
       EchoGetter, EchoSetter,
       v8::Handle<Value>(),
       v8::AccessControl(v8::ALL_CAN_READ | v8::ALL_CAN_WRITE));
 
 
   // Add an accessor that is not accessible by cross-domain JS code.
@@ skipping 44 matching lines @@
 
   // [[DefineOwnProperty]] always throws for access-checked objects.
   CHECK(
       CompileRun("Object.defineProperty(other, 'accessible_prop', {value: 43})")
           .IsEmpty());
   CHECK(CompileRun("other.accessible_prop == 42")->IsTrue());
   CHECK_EQ(42, g_echo_value);  // Make sure we didn't call the setter.
 }
 
 
-static bool AccessAlwaysBlocked(Local<v8::Object> global, Local<Value> name,
-                                v8::AccessType type, Local<Value> data) {
+static bool AccessAlwaysBlocked(Local<v8::Context> accessing_context,
+                                Local<v8::Object> global) {
   i::PrintF("Access blocked.\n");
   return false;
 }
 
 
 THREADED_TEST(AccessControlGetOwnPropertyNames) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> obj_template =
       v8::ObjectTemplate::New(isolate);
 
   obj_template->Set(v8_str("x"), v8::Integer::New(isolate, 42));
-  obj_template->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  obj_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Add an accessor accessible by cross-domain JS code.
   obj_template->SetAccessor(
       v8_str("accessible_prop"), EchoGetter, EchoSetter, v8::Handle<Value>(),
       v8::AccessControl(v8::ALL_CAN_READ | v8::ALL_CAN_WRITE));
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, obj_template);
   context0->Enter();
 
@@ skipping 28 matching lines @@
   context1->Exit();
   context0->Exit();
 }
 
 
 TEST(Regress470113) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> obj_template =
       v8::ObjectTemplate::New(isolate);
-  obj_template->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  obj_template->SetAccessCheckCallback(AccessAlwaysBlocked);
   LocalContext env;
   env->Global()->Set(v8_str("prohibited"), obj_template->NewInstance());
 
   {
     v8::TryCatch try_catch(isolate);
     CompileRun(
         "'use strict';\n"
         "class C extends Object {\n"
         "   m() { super.powned = 'Powned!'; }\n"
         "}\n"
@@ skipping 59 matching lines @@
   value = v8_compile("other.unreachable")->Run();
   CHECK(value.IsEmpty());
 
   context1->Exit();
   context0->Exit();
 }
 
 
 static int access_count = 0;
 
-static bool AccessCounter(Local<v8::Object> global, Local<Value> name,
-                          v8::AccessType type, Local<Value> data) {
+static bool AccessCounter(Local<v8::Context> accessing_context,
+                          Local<v8::Object> accessed_object) {
   access_count++;
   return true;
 }
 
 
 // This one is too easily disturbed by other tests.
 TEST(AccessControlIC) {
   access_count = 0;
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
 
   // Create an environment.
   v8::Local<Context> context0 = Context::New(isolate);
   context0->Enter();
 
   // Create an object that requires access-check functions to be
   // called for cross-domain access.
   v8::Handle<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
-  object_template->SetAccessCheckCallbacks(AccessCounter, NULL);
+  object_template->SetAccessCheckCallback(AccessCounter);
   Local<v8::Object> object = object_template->NewInstance();
 
   v8::HandleScope scope1(isolate);
 
   // Create another environment.
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
 
   // Make easy access to the object from the other environment.
   v8::Handle<v8::Object> global1 = context1->Global();
@@ skipping 3875 matching lines @@
     printf("p[%u]\n", i);
   }
 }
 
 
 THREADED_TEST(AccessChecksReenabledCorrectly) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
-  templ->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  templ->SetAccessCheckCallback(AccessAlwaysBlocked);
   templ->Set(v8_str("a"), v8_str("a"));
   // Add more than 8 (see kMaxFastProperties) properties
   // so that the constructor will force copying map.
   // Cannot sprintf, gcc complains unsafety.
   char buf[4];
   for (char i = '0'; i <= '9' ; i++) {
     buf[0] = i;
     for (char j = '0'; j <= '9'; j++) {
       buf[1] = j;
       for (char k = '0'; k <= '9'; k++) {
@@ skipping 600 matching lines @@
   CompileRun("Object.freeze(a);");
   {
     // Can't change non-extensible objects.
     v8::TryCatch try_catch(isolate);
     CHECK(!obj->CreateDataProperty(env.local(), v8_str("baz"),
                                    v8::Integer::New(isolate, 42)).FromJust());
     CHECK(!try_catch.HasCaught());
   }
 
   v8::Local<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
-  templ->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  templ->SetAccessCheckCallback(AccessAlwaysBlocked);
   v8::Local<v8::Object> access_checked =
       templ->NewInstance(env.local()).ToLocalChecked();
   {
     v8::TryCatch try_catch(isolate);
     CHECK(access_checked->CreateDataProperty(env.local(), v8_str("foo"),
                                              v8::Integer::New(isolate, 42))
               .IsNothing());
     CHECK(try_catch.HasCaught());
   }
 }
@@ skipping 98 matching lines @@
   CompileRun("Object.freeze(a);");
   {
     // Can't change non-extensible objects.
     v8::TryCatch try_catch(isolate);
     CHECK(!obj->DefineOwnProperty(env.local(), v8_str("baz"),
                                   v8::Integer::New(isolate, 42)).FromJust());
     CHECK(!try_catch.HasCaught());
   }
 
   v8::Local<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
-  templ->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  templ->SetAccessCheckCallback(AccessAlwaysBlocked);
   v8::Local<v8::Object> access_checked =
       templ->NewInstance(env.local()).ToLocalChecked();
   {
     v8::TryCatch try_catch(isolate);
     CHECK(access_checked->DefineOwnProperty(env.local(), v8_str("foo"),
                                             v8::Integer::New(isolate, 42))
               .IsNothing());
     CHECK(try_catch.HasCaught());
   }
 }
@@ skipping 3163 matching lines @@
   v8::V8::Initialize();
   v8::V8::SetFailedAccessCheckCallbackFunction(&FailedAccessCheckCallbackGC);
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Create an ObjectTemplate for global objects and install access
   // check callbacks that will block access.
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
-  global_template->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL,
-                                           v8::Handle<v8::Value>());
+  global_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Create a context and set an x property on it's global object.
   LocalContext context0(NULL, global_template);
   context0->Global()->Set(v8_str("x"), v8_num(42));
   v8::Handle<v8::Object> global0 = context0->Global();
 
   // Create a context with a different security token so that the
   // failed access check callback will be called on each access.
   LocalContext context1(NULL, global_template);
   context1->Global()->Set(v8_str("other"), global0);
@@ skipping 1212 matching lines @@
   CHECK_GT(elements, CountLiveMapsInMapCache(CcTest::i_isolate()->context()));
 }
 
 
 THREADED_TEST(Regress93759) {
   v8::Isolate* isolate = CcTest::isolate();
   HandleScope scope(isolate);
 
   // Template for object with security check.
   Local<ObjectTemplate> no_proto_template = v8::ObjectTemplate::New(isolate);
-  no_proto_template->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  no_proto_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Templates for objects with hidden prototypes and possibly security check.
   Local<FunctionTemplate> hidden_proto_template =
       v8::FunctionTemplate::New(isolate);
   hidden_proto_template->SetHiddenPrototype(true);
 
   Local<FunctionTemplate> protected_hidden_proto_template =
       v8::FunctionTemplate::New(isolate);
-  protected_hidden_proto_template->InstanceTemplate()->SetAccessCheckCallbacks(
-      AccessAlwaysBlocked, NULL);
+  protected_hidden_proto_template->InstanceTemplate()->SetAccessCheckCallback(
+      AccessAlwaysBlocked);
   protected_hidden_proto_template->SetHiddenPrototype(true);
 
   // Context for "foreign" objects used in test.
   Local<Context> context = v8::Context::New(isolate);
   context->Enter();
 
   // Plain object, no security check.
   Local<Object> simple_object = Object::New(isolate);
 
   // Object with explicit security check.
@@ skipping 1147 matching lines @@
 
 TEST(JSONStringifyAccessCheck) {
   v8::V8::Initialize();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Create an ObjectTemplate for global objects and install access
   // check callbacks that will block access.
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
-  global_template->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  global_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Create a context and set an x property on it's global object.
   LocalContext context0(NULL, global_template);
   v8::Handle<v8::Object> global0 = context0->Global();
   global0->Set(v8_str("x"), v8_num(42));
   ExpectString("JSON.stringify(this)", "{\"x\":42}");
 
   for (int i = 0; i < 2; i++) {
     if (i == 1) {
       // Install a toJSON function on the second run.
@@ skipping 67 matching lines @@
   i::FLAG_allow_natives_syntax = true;
   v8::V8::Initialize();
   v8::V8::SetFailedAccessCheckCallbackFunction(&FailedAccessCheckThrows);
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Create an ObjectTemplate for global objects and install access
   // check callbacks that will block access.
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
-  global_template->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  global_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Create a context and set an x property on it's global object.
   LocalContext context0(NULL, global_template);
   v8::Handle<v8::Object> global0 = context0->Global();
 
   // Create a context with a different security token so that the
   // failed access check callback will be called on each access.
   LocalContext context1(NULL, global_template);
   context1->Global()->Set(v8_str("other"), global0);
 
@@ skipping 1054 matching lines @@
   CHECK(try_catch.HasCaught());
 }
 
 
 TEST(Regress354123) {
   LocalContext current;
   v8::Isolate* isolate = current->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
-  templ->SetAccessCheckCallbacks(AccessCounter, NULL);
+  templ->SetAccessCheckCallback(AccessCounter);
   current->Global()->Set(v8_str("friend"), templ->NewInstance());
 
   // Test access using __proto__ from the prototype chain.
   access_count = 0;
   CompileRun("friend.__proto__ = {};");
   CHECK_EQ(2, access_count);
   CompileRun("friend.__proto__;");
   CHECK_EQ(4, access_count);
 
   // Test access using __proto__ as a hijacked function (A).
@@ skipping 169 matching lines @@
   set->Call(x, 1, args);
   CHECK(v8_num(14)->Equals(get->Call(x, 0, NULL)));
 }
 
 
 TEST(Regress411877) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
-  object_template->SetAccessCheckCallbacks(AccessCounter, NULL);
+  object_template->SetAccessCheckCallback(AccessCounter);
 
   v8::Handle<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
   context->Global()->Set(v8_str("o"), object_template->NewInstance());
   CompileRun("Object.getOwnPropertyNames(o)");
 }
 
 
 TEST(GetHiddenPropertyTableAfterAccessCheck) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
-  object_template->SetAccessCheckCallbacks(AccessCounter, NULL);
+  object_template->SetAccessCheckCallback(AccessCounter);
 
   v8::Handle<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
   v8::Handle<v8::Object> obj = object_template->NewInstance();
   obj->Set(v8_str("key"), v8_str("value"));
   obj->Delete(v8_str("key"));
 
   obj->SetHiddenValue(v8_str("hidden key 2"), v8_str("hidden value 2"));
 }
 
 
 TEST(Regress411793) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
-  object_template->SetAccessCheckCallbacks(AccessCounter, NULL);
+  object_template->SetAccessCheckCallback(AccessCounter);
 
   v8::Handle<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
   context->Global()->Set(v8_str("o"), object_template->NewInstance());
   CompileRun(
       "Object.defineProperty(o, 'key', "
       "    { get: function() {}, set: function() {} });");
 }
 
@@ skipping 643 matching lines @@
 
 
 TEST(GetPrototypeAccessControl) {
   i::FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
 
   v8::Handle<v8::ObjectTemplate> obj_template =
       v8::ObjectTemplate::New(isolate);
-  obj_template->SetAccessCheckCallbacks(AccessAlwaysBlocked, NULL);
+  obj_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   env->Global()->Set(v8_str("prohibited"), obj_template->NewInstance());
 
   CHECK(CompileRun(
             "function f() { return %_GetPrototype(prohibited); }"
             "%OptimizeFunctionOnNextCall(f);"
             "f();")->IsNull());
 }
 
 
@@ skipping 122 matching lines @@
     v8::Local<v8::Object> obj = v8::Object::New(isolate);
 
     USE(obj);
   }
 }
 
 
 static bool access_was_called = false;
 
 
-static bool AccessAlwaysAllowedWithFlag(Local<v8::Object> global,
-                                        Local<Value> name, v8::AccessType type,
-                                        Local<Value> data) {
+static bool AccessAlwaysAllowedWithFlag(Local<v8::Context> accessing_context,
+                                        Local<v8::Object> accessed_object) {
   access_was_called = true;
   return true;
 }
 
 
-static bool AccessAlwaysBlockedWithFlag(Local<v8::Object> global,
-                                        Local<Value> name, v8::AccessType type,
-                                        Local<Value> data) {
+static bool AccessAlwaysBlockedWithFlag(Local<v8::Context> accessing_context,
+                                        Local<v8::Object> accessed_object) {
   access_was_called = true;
   return false;
 }
 
 
 TEST(StrongModeAccessCheckAllowed) {
   i::FLAG_strong_mode = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<Value> value;
   access_was_called = false;
 
   v8::Handle<v8::ObjectTemplate> obj_template =
       v8::ObjectTemplate::New(isolate);
 
   obj_template->Set(v8_str("x"), v8::Integer::New(isolate, 42));
-  obj_template->SetAccessCheckCallbacks(AccessAlwaysAllowedWithFlag, NULL);
+  obj_template->SetAccessCheckCallback(AccessAlwaysAllowedWithFlag);
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, obj_template);
   context0->Enter();
   v8::Handle<v8::Object> global0 = context0->Global();
   global0->Set(v8_str("object"), obj_template->NewInstance());
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.x");
     CHECK(!try_catch.HasCaught());
@@ skipping 49 matching lines @@
   i::FLAG_strong_mode = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Handle<Value> value;
   access_was_called = false;
 
   v8::Handle<v8::ObjectTemplate> obj_template =
       v8::ObjectTemplate::New(isolate);
 
   obj_template->Set(v8_str("x"), v8::Integer::New(isolate, 42));
-  obj_template->SetAccessCheckCallbacks(AccessAlwaysBlockedWithFlag, NULL);
+  obj_template->SetAccessCheckCallback(AccessAlwaysBlockedWithFlag);
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, obj_template);
   context0->Enter();
   v8::Handle<v8::Object> global0 = context0->Global();
   global0->Set(v8_str("object"), obj_template->NewInstance());
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.x");
     CHECK(!try_catch.HasCaught());
@@ skipping 452 matching lines @@
 
 
 TEST(AccessCheckedIsConcatSpreadable) {
   i::FLAG_harmony_concat_spreadable = true;
   v8::Isolate* isolate = CcTest::isolate();
   HandleScope scope(isolate);
   LocalContext env;
 
   // Object with access check
   Local<ObjectTemplate> spreadable_template = v8::ObjectTemplate::New(isolate);
-  spreadable_template->SetAccessCheckCallbacks(AccessBlocker, nullptr);
+  spreadable_template->SetAccessCheckCallback(AccessBlocker);
   spreadable_template->Set(v8::Symbol::GetIsConcatSpreadable(isolate),
                            v8::Boolean::New(isolate, true));
   Local<Object> object = spreadable_template->NewInstance();
 
   allowed_access = true;
   env->Global()->Set(v8_str("object"), object);
   object->Set(v8_str("length"), v8_num(2));
   object->Set(0U, v8_str("a"));
   object->Set(1U, v8_str("b"));
 
@@ skipping 39 matching lines @@
     env2->Global()->Set(v8_str("obj2"), object2);
     ExpectString("typeof obj2.values", "function");
     CHECK_NE(*object->Get(v8_str("values")), *object2->Get(v8_str("values")));
 
     auto values2 = Local<Function>::Cast(object2->Get(v8_str("values")));
     auto fn2 = v8::Utils::OpenHandle(*values2);
     auto ctx2 = v8::Utils::OpenHandle(*env2.local());
     CHECK_EQ(fn2->GetCreationContext(), *ctx2);
   }
 }