Plumb accessing context through to access control callbacks

test/cctest/test-api-interceptors.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include "test/cctest/test-api.h"
 
 #include "include/v8-util.h"
 #include "src/api.h"
@@ skipping 1642 matching lines @@
       "    if (v != 0) throw 'Wrong value ' + v + ' at iteration ' + i;"
       "  }"
       "  'PASSED'"
       "} catch(e) {"
       "  e"
       "}";
   ExpectString(code, "PASSED");
 }
 
 
-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> accessed_object) {
   return false;
 }
 
 
 THREADED_TEST(IndexedInterceptorWithAccessorCheck) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetHandler(
       v8::IndexedPropertyHandlerConfiguration(IdentityIndexedPropertyGetter));
 
-  templ->SetAccessCheckCallbacks(AccessAlwaysBlocked, nullptr);
+  templ->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   LocalContext context;
   Local<v8::Object> obj = templ->NewInstance();
   context->Global()->Set(v8_str("obj"), obj);
 
   const char* code =
       "var result = 'PASSED';"
       "for (var i = 0; i < 100; i++) {"
       "  try {"
       "    var v = obj[0];"
@@ skipping 1213 matching lines @@
   return reinterpret_cast<T*>(
       Object::Cast(*data)->GetAlignedPointerFromInternalField(0));
 }
 
 
 struct AccessCheckData {
   int count;
   bool result;
 };
 
+AccessCheckData* g_access_check_data = nullptr;
 
-bool SimpleAccessChecker(Local<v8::Object> global, Local<Value> name,
-                         v8::AccessType type, Local<Value> data) {
-  auto access_check_data = GetWrappedObject<AccessCheckData>(data);
-  access_check_data->count++;
-  return access_check_data->result;
+
+bool SimpleAccessChecker(Local<v8::Context> accessing_context,
+                         Local<v8::Object> access_object) {
+  g_access_check_data->count++;
+  return g_access_check_data->result;
 }
 
 
 struct ShouldInterceptData {
   int value;
   bool should_intercept;
 };
 
 
 void ShouldNamedInterceptor(Local<Name> name,
@@ skipping 11 matching lines @@
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(info, FUNCTION_ADDR(ShouldIndexedInterceptor));
   auto data = GetWrappedObject<ShouldInterceptData>(info.Data());
   if (!data->should_intercept) return;
   info.GetReturnValue().Set(v8_num(data->value));
 }
 
 }  // namespace
 
 
-THREADED_TEST(NamedAllCanReadInterceptor) {
+TEST(NamedAllCanReadInterceptor) {
   auto isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext context;
 
   AccessCheckData access_check_data;
   access_check_data.result = true;
   access_check_data.count = 0;
 
+  g_access_check_data = &access_check_data;
+
   ShouldInterceptData intercept_data_0;
   intercept_data_0.value = 239;
   intercept_data_0.should_intercept = true;
 
   ShouldInterceptData intercept_data_1;
   intercept_data_1.value = 165;
   intercept_data_1.should_intercept = false;
 
   auto intercepted_0 = v8::ObjectTemplate::New(isolate);
   {
     v8::NamedPropertyHandlerConfiguration conf(ShouldNamedInterceptor);
     conf.flags = v8::PropertyHandlerFlags::kAllCanRead;
     conf.data =
         BuildWrappedObject<ShouldInterceptData>(isolate, &intercept_data_0);
     intercepted_0->SetHandler(conf);
   }
 
   auto intercepted_1 = v8::ObjectTemplate::New(isolate);
   {
     v8::NamedPropertyHandlerConfiguration conf(ShouldNamedInterceptor);
     conf.flags = v8::PropertyHandlerFlags::kAllCanRead;
     conf.data =
         BuildWrappedObject<ShouldInterceptData>(isolate, &intercept_data_1);
     intercepted_1->SetHandler(conf);
   }
 
   auto checked = v8::ObjectTemplate::New(isolate);
-  checked->SetAccessCheckCallbacks(
-      SimpleAccessChecker, nullptr,
-      BuildWrappedObject<AccessCheckData>(isolate, &access_check_data));
+  checked->SetAccessCheckCallback(SimpleAccessChecker);
 
   context->Global()->Set(v8_str("intercepted_0"), intercepted_0->NewInstance());
   context->Global()->Set(v8_str("intercepted_1"), intercepted_1->NewInstance());
   auto checked_instance = checked->NewInstance();
   checked_instance->Set(v8_str("whatever"), v8_num(17));
   context->Global()->Set(v8_str("checked"), checked_instance);
   CompileRun(
       "checked.__proto__ = intercepted_1;"
       "intercepted_1.__proto__ = intercepted_0;");
 
@@ skipping 14 matching lines @@
   CHECK_EQ(7, access_check_data.count);
 
   intercept_data_1.should_intercept = true;
   ExpectInt32("checked.whatever", intercept_data_1.value);
   {
     v8::TryCatch try_catch(isolate);
     CompileRun("Object.getOwnPropertyDescriptor(checked, 'whatever')");
     CHECK(try_catch.HasCaught());
   }
   CHECK_EQ(9, access_check_data.count);
+  g_access_check_data = nullptr;
 }
 
 
-THREADED_TEST(IndexedAllCanReadInterceptor) {
+TEST(IndexedAllCanReadInterceptor) {
   auto isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext context;
 
   AccessCheckData access_check_data;
   access_check_data.result = true;
   access_check_data.count = 0;
 
+  g_access_check_data = &access_check_data;
+
   ShouldInterceptData intercept_data_0;
   intercept_data_0.value = 239;
   intercept_data_0.should_intercept = true;
 
   ShouldInterceptData intercept_data_1;
   intercept_data_1.value = 165;
   intercept_data_1.should_intercept = false;
 
   auto intercepted_0 = v8::ObjectTemplate::New(isolate);
   {
     v8::IndexedPropertyHandlerConfiguration conf(ShouldIndexedInterceptor);
     conf.flags = v8::PropertyHandlerFlags::kAllCanRead;
     conf.data =
         BuildWrappedObject<ShouldInterceptData>(isolate, &intercept_data_0);
     intercepted_0->SetHandler(conf);
   }
 
   auto intercepted_1 = v8::ObjectTemplate::New(isolate);
   {
     v8::IndexedPropertyHandlerConfiguration conf(ShouldIndexedInterceptor);
     conf.flags = v8::PropertyHandlerFlags::kAllCanRead;
     conf.data =
         BuildWrappedObject<ShouldInterceptData>(isolate, &intercept_data_1);
     intercepted_1->SetHandler(conf);
   }
 
   auto checked = v8::ObjectTemplate::New(isolate);
-  checked->SetAccessCheckCallbacks(
-      SimpleAccessChecker, nullptr,
-      BuildWrappedObject<AccessCheckData>(isolate, &access_check_data));
+  checked->SetAccessCheckCallback(SimpleAccessChecker);
 
   context->Global()->Set(v8_str("intercepted_0"), intercepted_0->NewInstance());
   context->Global()->Set(v8_str("intercepted_1"), intercepted_1->NewInstance());
   auto checked_instance = checked->NewInstance();
   context->Global()->Set(v8_str("checked"), checked_instance);
   checked_instance->Set(15, v8_num(17));
   CompileRun(
       "checked.__proto__ = intercepted_1;"
       "intercepted_1.__proto__ = intercepted_0;");
 
@@ skipping 15 matching lines @@
   CHECK_EQ(7, access_check_data.count);
 
   intercept_data_1.should_intercept = true;
   ExpectInt32("checked[15]", intercept_data_1.value);
   {
     v8::TryCatch try_catch(isolate);
     CompileRun("Object.getOwnPropertyDescriptor(checked, '15')");
     CHECK(try_catch.HasCaught());
   }
   CHECK_EQ(9, access_check_data.count);
+
+  g_access_check_data = nullptr;
 }
 
 
 THREADED_TEST(NonMaskingInterceptorOwnProperty) {
   auto isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext context;
 
   ShouldInterceptData intercept_data;
   intercept_data.value = 239;
@@ skipping 172 matching lines @@
       "var obj = intercepted_1;"
       "obj.x = 4;"
       "eval('obj.x');"
       "eval('obj.x');"
       "eval('obj.x');"
       "obj = intercepted_2;"
       "obj.x = 9;"
       "eval('obj.x');",
       9);
 }