Reinforce fast-accessor-assembler tests.

test/cctest/test-api-fast-accessor-builder.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 "include/v8.h"
 #include "include/v8-experimental.h"
 
 #include "src/api.h"
@@ skipping 42 matching lines @@
   "*/ "  // 16 lines * 64 'X' =~ 1024 character comment.
 #define FN(name, src) "function " name "() { " src INLINE_SPOILER " }"
 #define WARMUP(name, count) "for(i = 0; i < " count "; i++) { " name "() } "
 #define FN_WARMUP(name, src) FN(name, src) "; " WARMUP(name, "2")
 
 static void NativePropertyAccessor(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8_num(123));
 }
 
+const char* kWatermarkProperty = "watermark";
+
 }  // anonymous namespace
 
+void CheckImplicitParameters(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  v8::Isolate* isolate = info.GetIsolate();
+  CHECK_NOT_NULL(isolate);
+
+  auto context = isolate->GetCurrentContext();
+  CHECK(!context.IsEmpty());
+
+  // The context must point to the same isolate, this should be enough to
+  // validate the context, mainly to prevent having a random object instead.
+  CHECK_EQ(isolate, context->GetIsolate());
+  CHECK(info.Data()->IsUndefined());
+
+  CHECK(info.Holder()->Has(v8_str(kWatermarkProperty)));
+}
 
 // Build a simple "fast accessor" and verify that it is being called.
 TEST(FastAccessor) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::FunctionTemplate> foo = v8::FunctionTemplate::New(isolate);
 
   // Native accessor, bar, returns 123.
@@ skipping 218 matching lines @@
   ExpectInt32("nonzero()", 0);
   val.intval = 27;
   ExpectInt32("nonzero()", 1);
 
   // Access val.v8val:
   CompileRun(FN_WARMUP("loadval", "return obj.loadval"));
   ExpectString("loadval()", "Hello");
 }
 
 void ApiCallbackInt(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  CheckImplicitParameters(info);
   info.GetReturnValue().Set(12345);
 }
 
 const char* kApiCallbackStringValue =
     "Hello World! Bizarro C++ world, actually.";
 void ApiCallbackString(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  CheckImplicitParameters(info);
   info.GetReturnValue().Set(v8_str(kApiCallbackStringValue));
 }
 
 void ApiCallbackParam(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  CheckImplicitParameters(info);
   CHECK_EQ(1, info.Length());
   CHECK(info[0]->IsNumber());
   info.GetReturnValue().Set(info[0]);
 }
 
 // "Fast" accessor, callback to embedder
 TEST(FastAccessorCallback) {
   // Crankshaft support for fast accessors is not implemented; crankshafted
   // code uses the slow accessor which breaks this test's expectations.
   v8::internal::FLAG_always_opt = false;
@@ skipping 18 matching lines @@
                                  isolate, NativePropertyAccessor, builder));
 
     builder = v8::experimental::FastAccessorBuilder::New(isolate);
     builder->ReturnValue(
         builder->Call(&ApiCallbackParam, builder->IntegerConstant(1000)));
     foo->SetAccessorProperty(v8_str("param"),
                              v8::FunctionTemplate::NewWithFastHandler(
                                  isolate, NativePropertyAccessor, builder));
   }
 
+  // Add dummy property to validate the holder.
+  {
+    auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
+    builder->ReturnValue(builder->IntegerConstant(537));
+
+    foo->SetAccessorProperty(v8_str(kWatermarkProperty),
+                             v8::FunctionTemplate::NewWithFastHandler(
+                                 isolate, NativePropertyAccessor, builder));
+  }

[vogelheim, 2016/07/19 14:44:58]

I think this is a bit more complex than necessary... since we're not planning to
call the watermark, but merely check for its existence, something like this
would also do:

  foo->CreateDataProperty(..., v8_str(kWaterMarkProperty), ..)

+
   // Create an instance.
   v8::Local<v8::Object> obj = foo->NewInstance(env.local()).ToLocalChecked();
   CHECK(env->Global()->Set(env.local(), v8_str("obj"), obj).FromJust());
 
   // Callbacks:
   CompileRun(FN_WARMUP("callbackint", "return obj.int"));
   ExpectInt32("callbackint()", 12345);
 
   CompileRun(FN_WARMUP("callbackstr", "return obj.str"));
   ExpectString("callbackstr()", kApiCallbackStringValue);
 
   CompileRun(FN_WARMUP("callbackparam", "return obj.param"));
   ExpectInt32("callbackparam()", 1000);
 }