[bindings] Implement an ExperimentEnabled IDL extended attribute.

third_party/WebKit/Source/bindings/tests/results/modules/V8TestInterfacePartial.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
 
 #include "config.h"
 #if ENABLE(CONDITION)
 #include "V8TestInterfacePartial.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/PrivateScriptRunner.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/V8DOMConfiguration.h"
 #include "bindings/core/v8/V8Document.h"
 #include "bindings/core/v8/V8Node.h"
 #include "bindings/core/v8/V8ObjectConstructor.h"
 #include "bindings/core/v8/V8TestInterface.h"
 #include "bindings/tests/idls/modules/TestPartialInterfaceImplementation3.h"
 #include "core/dom/ContextFeatures.h"
 #include "core/dom/Document.h"
+#include "core/experiments/Experiments.h"
 #include "core/frame/LocalFrame.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "wtf/GetPtr.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 namespace TestInterfaceImplementationPartialV8Internal {
 
 static void voidMethodPartialOverload3Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
     V8StringResource<> value;
     {
         value = info[0];
         if (!value.prepare())
             return;
     }
     TestPartialInterfaceImplementation3::voidMethodPartialOverload(*impl, value);
 }
 
 static void voidMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodPartialOverload", "TestInterface", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         break;
     case 1:
         if (true) {
             voidMethodPartialOverload3Method(info);
             return;
         }
         break;
@@ skipping 11 matching lines @@
     {
         value = info[0];
         if (!value.prepare())
             return;
     }
     TestPartialInterfaceImplementation3::staticVoidMethodPartialOverload(value);
 }
 
 static void staticVoidMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "staticVoidMethodPartialOverload", "TestInterface", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         break;
     case 1:
         if (true) {
             staticVoidMethodPartialOverload2Method(info);
             return;
         }
         break;
@@ skipping 14 matching lines @@
         if (!document) {
             v8SetReturnValue(info, ScriptPromise::rejectRaw(ScriptState::current(info.GetIsolate()), V8ThrowException::createTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("promiseMethodPartialOverload", "TestInterface", "parameter 1 is not of type 'Document'."))));
             return;
         }
     }
     v8SetReturnValue(info, TestPartialInterfaceImplementation3::promiseMethodPartialOverload(*impl, document).v8Value());
 }
 
 static void promiseMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "promiseMethodPartialOverload", "TestInterface", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         break;
     case 1:
         if (V8Document::hasInstance(info[0], info.GetIsolate())) {
             promiseMethodPartialOverload3Method(info);
             return;
         }
         break;
@@ skipping 19 matching lines @@
 static void staticPromiseMethodPartialOverload2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "staticPromiseMethodPartialOverload", "TestInterface", info.Holder(), info.GetIsolate());
     staticPromiseMethodPartialOverload2MethodPromise(info, exceptionState);
     if (exceptionState.hadException())
         v8SetReturnValue(info, exceptionState.reject(ScriptState::current(info.GetIsolate())).v8Value());
 }
 
 static void staticPromiseMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "staticPromiseMethodPartialOverload", "TestInterface", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         break;
     case 1:
         if (true) {
             staticPromiseMethodPartialOverload2Method(info);
             return;
         }
         break;
@@ skipping 26 matching lines @@
         if (!node) {
             V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("partial2VoidMethod", "TestInterface", "parameter 1 is not of type 'Node'."));
             return;
         }
     }
     TestPartialInterfaceImplementation3::partial2VoidMethod(*impl, node);
 }
 
 static void partial2VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "partial2VoidMethod", "TestInterface", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         break;
     case 1:
         if (V8Node::hasInstance(info[0], info.GetIsolate())) {
             partial2VoidMethod3Method(info);
             return;
         }
         if (true) {
@@ skipping 48 matching lines @@
     {
         value = info[0];
         if (!value.prepare())
             return;
     }
     TestPartialInterfaceImplementation3::partial2StaticVoidMethod(value);
 }
 
 static void partial2StaticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "partial2StaticVoidMethod", "TestInterface", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         break;
     case 1:
         if (true) {
             partial2StaticVoidMethod2Method(info);
             return;
         }
         break;
@@ skipping 26 matching lines @@
 };
 
 void V8TestInterfacePartial::installV8TestInterfaceTemplate(v8::Local<v8::FunctionTemplate> functionTemplate, v8::Isolate* isolate)
 {
     V8TestInterface::installV8TestInterfaceTemplate(functionTemplate, isolate);
 
     v8::Local<v8::Signature> defaultSignature;
     if (!RuntimeEnabledFeatures::featureNameEnabled())
         defaultSignature = V8DOMConfiguration::installDOMClassTemplate(isolate, functionTemplate, "TestInterface", v8::Local<v8::FunctionTemplate>(), V8TestInterface::internalFieldCount, 0, 0, 0, 0, 0, 0);
     else
-        defaultSignature = V8DOMConfiguration::installDOMClassTemplate(isolate, functionTemplate, "TestInterface", v8::Local<v8::FunctionTemplate>(), V8TestInterface::internalFieldCount,
-            0, 0,
-            0, 0,
-            V8TestInterfaceMethods, WTF_ARRAY_LENGTH(V8TestInterfaceMethods));
+        {
+            ExecutionContext* ec = currentExecutionContext(isolate);
+            ALLOW_UNUSED_LOCAL(ec);
+            String errorMessage;
+            if (!Experiments::isApiEnabled(ec, "ExperimentName", errorMessage)) {
+                defaultSignature = V8DOMConfiguration::installDOMClassTemplate(isolate, functionTemplate, "TestInterface", v8::Local<v8::FunctionTemplate>(), V8TestInterface::internalFieldCount, 0, 0, 0, 0, 0, 0);
+            }
+            else
+                defaultSignature = V8DOMConfiguration::installDOMClassTemplate(isolate, functionTemplate, "TestInterface", v8::Local<v8::FunctionTemplate>(), V8TestInterface::internalFieldCount,
+                    0, 0,
+                    0, 0,
+                    V8TestInterfaceMethods, WTF_ARRAY_LENGTH(V8TestInterfaceMethods));
+    }
+
     v8::Local<v8::ObjectTemplate> instanceTemplate = functionTemplate->InstanceTemplate();
     ALLOW_UNUSED_LOCAL(instanceTemplate);
     v8::Local<v8::ObjectTemplate> prototypeTemplate = functionTemplate->PrototypeTemplate();
     ALLOW_UNUSED_LOCAL(prototypeTemplate);
     const V8DOMConfiguration::ConstantConfiguration V8TestInterfaceConstants[] = {
         {"PARTIAL3_UNSIGNED_SHORT", 0, 0, V8DOMConfiguration::ConstantTypeUnsignedShort},
     };
     V8DOMConfiguration::installConstants(isolate, functionTemplate, prototypeTemplate, V8TestInterfaceConstants, WTF_ARRAY_LENGTH(V8TestInterfaceConstants));
+    ExecutionContext* ec = currentExecutionContext(isolate);
+    ALLOW_UNUSED_LOCAL(ec);
+    String constantsErrorMessage;
+    ALLOW_UNUSED_LOCAL(constantsErrorMessage);
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     functionTemplate->InstanceTemplate()->SetCallAsFunctionHandler(V8TestInterface::legacyCallCustom);
 }
 
 void V8TestInterfacePartial::preparePrototypeAndInterfaceObject(v8::Local<v8::Context> context, v8::Local<v8::Object> prototypeObject, v8::Local<v8::Function> interfaceObject, v8::Local<v8::FunctionTemplate> interfaceTemplate)
 {
     V8TestInterface::preparePrototypeAndInterfaceObject(context, prototypeObject, interfaceObject, interfaceTemplate);
     v8::Isolate* isolate = context->GetIsolate();
     v8::Local<v8::Name> unscopablesSymbol(v8::Symbol::GetUnscopables(isolate));
     v8::Local<v8::Object> unscopeables;
     if (v8CallBoolean(prototypeObject->HasOwnProperty(context, unscopablesSymbol)))
         unscopeables = prototypeObject->Get(context, unscopablesSymbol).ToLocalChecked().As<v8::Object>();
     else
         unscopeables = v8::Object::New(isolate);
+    String errorMessage;
+    ALLOW_UNUSED_LOCAL(errorMessage);
     unscopeables->CreateDataProperty(context, v8AtomicString(isolate, "unscopeableVoidMethod"), v8::True(isolate)).FromJust();
     prototypeObject->CreateDataProperty(context, unscopablesSymbol, unscopeables).FromJust();
 }
 
 void V8TestInterfacePartial::initialize()
 {
     // Should be invoked from initModules.
     V8TestInterface::updateWrapperTypeInfo(
         &V8TestInterfacePartial::installV8TestInterfaceTemplate,
         &V8TestInterfacePartial::preparePrototypeAndInterfaceObject);
     V8TestInterface::registerVoidMethodPartialOverloadMethodForPartialInterface(&TestInterfaceImplementationPartialV8Internal::voidMethodPartialOverloadMethod);
     V8TestInterface::registerStaticVoidMethodPartialOverloadMethodForPartialInterface(&TestInterfaceImplementationPartialV8Internal::staticVoidMethodPartialOverloadMethod);
     V8TestInterface::registerPromiseMethodPartialOverloadMethodForPartialInterface(&TestInterfaceImplementationPartialV8Internal::promiseMethodPartialOverloadMethod);
     V8TestInterface::registerStaticPromiseMethodPartialOverloadMethodForPartialInterface(&TestInterfaceImplementationPartialV8Internal::staticPromiseMethodPartialOverloadMethod);
     V8TestInterface::registerPartial2VoidMethodMethodForPartialInterface(&TestInterfaceImplementationPartialV8Internal::partial2VoidMethodMethod);
     V8TestInterface::registerPartial2StaticVoidMethodMethodForPartialInterface(&TestInterfaceImplementationPartialV8Internal::partial2StaticVoidMethodMethod);
 }
 
 } // namespace blink
 #endif // ENABLE(CONDITION)