Reland v8::Private and related APIs

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 91 matching lines @@
     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<Object> self = Handle<Object>::Cast(info.This());
-  info.GetReturnValue().Set(self->GetHiddenValue(v8_str(name_str + i)));
+  info.GetReturnValue().Set(
+      self->GetPrivate(
+              info.GetIsolate()->GetCurrentContext(),
+              v8::Private::ForApi(info.GetIsolate(), v8_str(name_str + i)))
+          .ToLocalChecked());
 }
 
 
 void StringInterceptorSetter(Local<String> name, Local<Value> value,
                              const v8::PropertyCallbackInfo<v8::Value>& info) {
   // Intercept accesses that set certain integer values, for which the name does
   // not start with 'accessor_'.
   String::Utf8Value utf8(name);
   char* name_str = *utf8;
   char prefix[] = "accessor_";
   int i;
   for (i = 0; name_str[i] && prefix[i]; ++i) {
     if (name_str[i] != prefix[i]) break;
   }
   if (!prefix[i]) return;
 
   if (value->IsInt32() && value->Int32Value() < 10000) {
     Handle<Object> self = Handle<Object>::Cast(info.This());
-    self->SetHiddenValue(name, value);
+    Handle<Context> context = info.GetIsolate()->GetCurrentContext();
+    Handle<v8::Private> symbol = v8::Private::ForApi(info.GetIsolate(), name);
+    self->SetPrivate(context, symbol, value).FromJust();
     info.GetReturnValue().Set(value);
   }
 }
 
 void InterceptorGetter(Local<Name> generic_name,
                        const v8::PropertyCallbackInfo<v8::Value>& info) {
   if (generic_name->IsSymbol()) return;
   StringInterceptorGetter(Local<String>::Cast(generic_name), info);
 }
 
@@ skipping 1165 matching lines @@
 }
 
 
 THREADED_TEST(HiddenPropertiesWithInterceptors) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
 
   interceptor_for_hidden_properties_called = false;
 
-  v8::Local<v8::String> key = v8_str("api-test::hidden-key");
+  v8::Local<v8::Private> key =
+      v8::Private::New(isolate, v8_str("api-test::hidden-key"));
 
   // Associate an interceptor with an object and start setting hidden values.
   Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New(isolate);
   Local<v8::ObjectTemplate> instance_templ = fun_templ->InstanceTemplate();
   instance_templ->SetHandler(
       v8::NamedPropertyHandlerConfiguration(InterceptorForHiddenProperties));
   Local<v8::Function> function = fun_templ->GetFunction();
   Local<v8::Object> obj = function->NewInstance();
-  CHECK(obj->SetHiddenValue(key, v8::Integer::New(isolate, 2302)));
-  CHECK_EQ(2302, obj->GetHiddenValue(key)->Int32Value());
+  CHECK(obj->SetPrivate(context.local(), key, v8::Integer::New(isolate, 2302))
+            .FromJust());
+  CHECK_EQ(
+      2302,
+      obj->GetPrivate(context.local(), key).ToLocalChecked()->Int32Value());
   CHECK(!interceptor_for_hidden_properties_called);
 }
 
 
 static void XPropertyGetter(Local<Name> property,
                             const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CHECK(info.Data()->IsUndefined());
   info.GetReturnValue().Set(property);
 }
@@ skipping 2033 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);
 }