[api] Add DefineProperty() method that skips interceptors.

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 1555 matching lines @@
             ->BooleanValue(env.local())
             .FromJust());
   CHECK(v8_compile("delete obj.myProperty")
             ->Run(env.local())
             .ToLocalChecked()
             ->BooleanValue(env.local())
             .FromJust());
 }
 
 namespace {
+int definer_was_called;
+
 void NotInterceptingPropertyDefineCallback(
     Local<Name> name, const v8::PropertyDescriptor& desc,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
+  definer_was_called++;
   // Do not intercept by not calling info.GetReturnValue().Set().
 }
 
 void InterceptingPropertyDefineCallback(
     Local<Name> name, const v8::PropertyDescriptor& desc,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   // Intercept the callback by setting a non-empty handle
+  definer_was_called++;
   info.GetReturnValue().Set(name);
 }
 
 void CheckDescriptorInDefineCallback(
     Local<Name> name, const v8::PropertyDescriptor& desc,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(!desc.has_writable());
   CHECK(!desc.has_value());
   CHECK(!desc.has_enumerable());
   CHECK(desc.has_configurable());
@@ skipping 213 matching lines @@
       "Object.freeze(obj.x); "
       "Object.isFrozen(obj.x);";
 
   CHECK(v8_compile(code)
             ->Run(env.local())
             .ToLocalChecked()
             ->BooleanValue(env.local())
             .FromJust());
 }
 
+// Check that the define interceptor is not triggered for DefineProperty
+// with the SKIP_INTERCEPTORS flag.
+THREADED_TEST(DefinePropertyWithoutInterceptors) {
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::HandleScope scope(isolate);
+  v8::Local<v8::ObjectTemplate> templ = ObjectTemplate::New(isolate);
+
+  templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
+      nullptr, nullptr, nullptr, nullptr, nullptr,
+      InterceptingPropertyDefineCallback));
+
+  LocalContext context;
+  v8::Local<v8::Name> p;
+
+  v8::Local<v8::Object> obj =
+      templ->NewInstance(context.local()).ToLocalChecked();
+
+  definer_was_called = 0;
+
+  // Use a generic descriptor.
+  v8::PropertyDescriptor desc_generic;
+
+  p = v8_str("foo");
+
+  // DONT_SKIP_INTERCEPTORS (default) triggers the interceptors when setting
+  // own property of an object.
+  CHECK(obj->DefineProperty(context.local(), p, desc_generic).FromJust());
+  CHECK_EQ(1, definer_was_called);
+
+  definer_was_called = 0;
+
+  // SKIP_INTERCEPTORS does not trigger the interceptors.
+  CHECK(obj->DefineProperty(context.local(), p, desc_generic,
+                            v8::SKIP_INTERCEPTORS)
+            .FromJust());
+  CHECK_EQ(0, definer_was_called);
+}
+
 // Check that the descriptor passed to the callback is enumerable.
 namespace {
 void CheckEnumerablePropertyDefineCallback(
     Local<Name> name, const v8::PropertyDescriptor& desc,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(desc.has_value());
   CHECK_EQ(42, desc.value()
                    ->Int32Value(info.GetIsolate()->GetCurrentContext())
                    .FromJust());
   CHECK(desc.has_enumerable());
@@ skipping 3185 matching lines @@
             ->Set(env.local(), v8_str("Fun"),
                   fun_templ->GetFunction(env.local()).ToLocalChecked())
             .FromJust());
 
   CompileRun(
       "var f = new Fun();"
       "Number.prototype.__proto__ = f;"
       "var a = 42;"
       "for (var i = 0; i<3; i++) { a.foo; }");
 }