Bindings: Rebaseline run-bindings-tests results

third_party/WebKit/Source/bindings/tests/results/core/V8TestInterface.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!
 
 // clang-format off
 #include "V8TestInterface.h"
 
 #include "bindings/core/v8/ExceptionState.h"
@@ skipping 1786 matching lines @@
     testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     if (!testInterfaceEmptyArg) {
         V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("voidMethodTestInterfaceEmptyArg", "TestInterface", "parameter 1 is not of type 'TestInterfaceEmpty'."));
 
         return;
     }
 
     impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
 }
 
-static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::voidMethodTestInterfaceEmptyArgMethod(info);
 }
 
 static void voidMethodDoubleArgFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "voidMethodDoubleArgFloatArg");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     if (UNLIKELY(info.Length() < 2)) {
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
         return;
     }
 
     double doubleArg;
     float floatArg;
     doubleArg = toRestrictedDouble(info.GetIsolate(), info[0], exceptionState);
     if (exceptionState.hadException())
         return;
 
     floatArg = toRestrictedFloat(info.GetIsolate(), info[1], exceptionState);
     if (exceptionState.hadException())
         return;
 
     impl->voidMethodDoubleArgFloatArg(doubleArg, floatArg);
 }
 
-static void voidMethodDoubleArgFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void voidMethodDoubleArgFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::voidMethodDoubleArgFloatArgMethod(info);
 }
 
 static void voidMethodUnrestrictedDoubleArgUnrestrictedFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "voidMethodUnrestrictedDoubleArgUnrestrictedFloatArg");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     if (UNLIKELY(info.Length() < 2)) {
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
         return;
     }
 
     double unrestrictedDoubleArg;
     float unrestrictedFloatArg;
     unrestrictedDoubleArg = toDouble(info.GetIsolate(), info[0], exceptionState);
     if (exceptionState.hadException())
         return;
 
     unrestrictedFloatArg = toFloat(info.GetIsolate(), info[1], exceptionState);
     if (exceptionState.hadException())
         return;
 
     impl->voidMethodUnrestrictedDoubleArgUnrestrictedFloatArg(unrestrictedDoubleArg, unrestrictedFloatArg);
 }
 
-static void voidMethodUnrestrictedDoubleArgUnrestrictedFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void voidMethodUnrestrictedDoubleArgUnrestrictedFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::voidMethodUnrestrictedDoubleArgUnrestrictedFloatArgMethod(info);
 }
 
 static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "voidMethodTestEnumArg");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
@@ skipping 12 matching lines @@
         "EnumValue2",
         "EnumValue3",
     };
     if (!isValidEnum(testEnumArg, validTestEnumArgValues, WTF_ARRAY_LENGTH(validTestEnumArgValues), "TestEnum", exceptionState)) {
         return;
     }
 
     impl->voidMethodTestEnumArg(testEnumArg);
 }
 
-static void voidMethodTestEnumArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void voidMethodTestEnumArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::voidMethodTestEnumArgMethod(info);
 }
 
 static void voidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->voidMethod();
 }
 
-static void voidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void voidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::voidMethodMethod(info);
 }
 
 static void voidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->voidMethod();
 }
 
-static void voidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
+void voidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::voidMethodMethodForMainWorld(info);
 }
 
 static void alwaysExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->alwaysExposedMethod();
 }
 
-static void alwaysExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void alwaysExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::alwaysExposedMethodMethod(info);
 }
 
 static void workerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->workerExposedMethod();
 }
 
-static void workerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void workerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::workerExposedMethodMethod(info);
 }
 
 static void windowExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->windowExposedMethod();
 }
 
-static void windowExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void windowExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::windowExposedMethodMethod(info);
 }
 
 static void alwaysExposedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation::alwaysExposedStaticMethod();
 }
 
-static void alwaysExposedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void alwaysExposedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::alwaysExposedStaticMethodMethod(info);
 }
 
 static void workerExposedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation::workerExposedStaticMethod();
 }
 
-static void workerExposedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void workerExposedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::workerExposedStaticMethodMethod(info);
 }
 
 static void windowExposedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation::windowExposedStaticMethod();
 }
 
-static void windowExposedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void windowExposedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::windowExposedStaticMethodMethod(info);
 }
 
 static void staticReturnDOMWrapperMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8SetReturnValue(info, TestInterfaceImplementation::staticReturnDOMWrapperMethod(), info.GetIsolate()->GetCurrentContext()->Global());
 }
 
-static void staticReturnDOMWrapperMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void staticReturnDOMWrapperMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::staticReturnDOMWrapperMethodMethod(info);
 }
 
 static void methodWithExposedAndRuntimeEnabledFlagMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->methodWithExposedAndRuntimeEnabledFlag();
 }
 
-static void methodWithExposedAndRuntimeEnabledFlagMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void methodWithExposedAndRuntimeEnabledFlagMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::methodWithExposedAndRuntimeEnabledFlagMethod(info);
 }
 
 static void overloadMethodWithExposedAndRuntimeEnabledFlag1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "overloadMethodWithExposedAndRuntimeEnabledFlag");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
@@ skipping 66 matching lines @@
 
     if (isArityError) {
         if (info.Length() < 1) {
             exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
             return;
         }
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
 }
 
-static void overloadMethodWithExposedAndRuntimeEnabledFlagMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void overloadMethodWithExposedAndRuntimeEnabledFlagMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::overloadMethodWithExposedAndRuntimeEnabledFlagMethod(info);
 }
 
 static void methodWithExposedHavingRuntimeEnabldFlagMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->methodWithExposedHavingRuntimeEnabldFlag();
 }
 
-static void methodWithExposedHavingRuntimeEnabldFlagMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void methodWithExposedHavingRuntimeEnabldFlagMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::methodWithExposedHavingRuntimeEnabldFlagMethod(info);
 }
 
 static void windowAndServiceWorkerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->windowAndServiceWorkerExposedMethod();
 }
 
-static void windowAndServiceWorkerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void windowAndServiceWorkerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::windowAndServiceWorkerExposedMethodMethod(info);
 }
 
 static void voidMethodPartialOverload1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->voidMethodPartialOverload();
 }
@@ skipping 20 matching lines @@
 static void promiseMethodPartialOverload1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     v8SetReturnValue(info, impl->promiseMethodPartialOverload().v8Value());
 }
 
 static void promiseMethodPartialOverload2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "promiseMethodPartialOverload");
-    ScriptState* scriptState = ScriptState::forReceiverObject(info);
-    ExceptionToRejectPromiseScope rejectPromiseScope(info, scriptState, exceptionState);
+    ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     DOMWindow* window;
     window = toDOMWindow(info.GetIsolate(), info[0]);
     if (!window) {
         exceptionState.throwTypeError("parameter 1 is not of type 'Window'.");
 
         return;
     }
@@ skipping 14 matching lines @@
         V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("legacyInterfaceTypeCheckingMethod", "TestInterface", ExceptionMessages::notEnoughArguments(1, info.Length())));
         return;
     }
 
     TestInterfaceEmpty* testInterfaceEmptyArg;
     testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
 
     impl->legacyInterfaceTypeCheckingMethod(testInterfaceEmptyArg);
 }
 
-static void legacyInterfaceTypeCheckingMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void legacyInterfaceTypeCheckingMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::legacyInterfaceTypeCheckingMethodMethod(info);
 }
 
 static void secureContextMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->secureContextMethod();
 }
 
-static void secureContextMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void secureContextMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::secureContextMethodMethod(info);
 }
 
 static void secureContextRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->secureContextRuntimeEnabledMethod();
 }
 
-static void secureContextRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void secureContextRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::secureContextRuntimeEnabledMethodMethod(info);
 }
 
 static void secureContextWindowExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->secureContextWindowExposedMethod();
 }
 
-static void secureContextWindowExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void secureContextWindowExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::secureContextWindowExposedMethodMethod(info);
 }
 
 static void secureContextWorkerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->secureContextWorkerExposedMethod();
 }
 
-static void secureContextWorkerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void secureContextWorkerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::secureContextWorkerExposedMethodMethod(info);
 }
 
 static void secureContextWindowExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->secureContextWindowExposedRuntimeEnabledMethod();
 }
 
-static void secureContextWindowExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void secureContextWindowExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::secureContextWindowExposedRuntimeEnabledMethodMethod(info);
 }
 
 static void secureContextWorkerExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->secureContextWorkerExposedRuntimeEnabledMethod();
 }
 
-static void secureContextWorkerExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void secureContextWorkerExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::secureContextWorkerExposedRuntimeEnabledMethodMethod(info);
 }
 
 static void implementsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     impl->implementsVoidMethod();
 }
 
-static void implementsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void implementsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::implementsVoidMethodMethod(info);
 }
 
 static void implementsComplexMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "implementsComplexMethod");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
@@ skipping 16 matching lines @@
     }
 
     ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
     TestInterfaceEmpty* result = impl->implementsComplexMethod(executionContext, strArg, testInterfaceEmptyArg, exceptionState);
     if (exceptionState.hadException()) {
         return;
     }
     v8SetReturnValue(info, result);
 }
 
-static void implementsComplexMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void implementsComplexMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::implementsComplexMethodMethod(info);
 }
 
-static void implementsCustomVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void implementsCustomVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     V8TestInterface::implementsCustomVoidMethodMethodCustom(info);
 }
 
 static void implementsStaticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation::implementsStaticVoidMethod();
 }
 
-static void implementsStaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void implementsStaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::implementsStaticVoidMethodMethod(info);
 }
 
 static void implements2VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestImplements2::implements2VoidMethod(*impl);
 }
 
-static void implements2VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void implements2VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::implements2VoidMethodMethod(info);
 }
 
 static void implements3VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestImplements3Implementation::implements3VoidMethod(*impl);
 }
 
-static void implements3VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void implements3VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::implements3VoidMethodMethod(info);
 }
 
 static void implements3StaticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestImplements3Implementation::implements3StaticVoidMethod();
 }
 
-static void implements3StaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void implements3StaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::implements3StaticVoidMethodMethod(info);
 }
 
 static void partialVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartial::partialVoidMethod(*impl);
 }
 
-static void partialVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialVoidMethodMethod(info);
 }
 
 static void partialStaticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfacePartial::partialStaticVoidMethod();
 }
 
-static void partialStaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialStaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialStaticVoidMethodMethod(info);
 }
 
 static void partialVoidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "partialVoidMethodLongArg");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     if (UNLIKELY(info.Length() < 1)) {
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         return;
     }
 
     int longArg;
     longArg = toInt32(info.GetIsolate(), info[0], NormalConversion, exceptionState);
     if (exceptionState.hadException())
         return;
 
     TestInterfacePartial::partialVoidMethodLongArg(*impl, longArg);
 }
 
-static void partialVoidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialVoidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialVoidMethodLongArgMethod(info);
 }
 
 static void partialCallWithExecutionContextRaisesExceptionVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "partialCallWithExecutionContextRaisesExceptionVoidMethod");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
     TestInterfacePartial::partialCallWithExecutionContextRaisesExceptionVoidMethod(executionContext, *impl, exceptionState);
     if (exceptionState.hadException()) {
         return;
     }
 }
 
-static void partialCallWithExecutionContextRaisesExceptionVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialCallWithExecutionContextRaisesExceptionVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialCallWithExecutionContextRaisesExceptionVoidMethodMethod(info);
 }
 
 static void partialVoidMethodPartialCallbackTypeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     if (UNLIKELY(info.Length() < 1)) {
         V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("partialVoidMethodPartialCallbackTypeArg", "TestInterface", ExceptionMessages::notEnoughArguments(1, info.Length())));
         return;
     }
 
     ScriptValue partialCallbackTypeArg;
     if (!info[0]->IsFunction()) {
         V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("partialVoidMethodPartialCallbackTypeArg", "TestInterface", "The callback provided as parameter 1 is not a function."));
 
         return;
     }
     partialCallbackTypeArg = ScriptValue(ScriptState::current(info.GetIsolate()), info[0]);
 
     TestInterfacePartial::partialVoidMethodPartialCallbackTypeArg(*impl, partialCallbackTypeArg);
 }
 
-static void partialVoidMethodPartialCallbackTypeArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialVoidMethodPartialCallbackTypeArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialVoidMethodPartialCallbackTypeArgMethod(info);
 }
 
 static void shortMethodWithShortArgumentImplementedInPrivateScriptMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "shortMethodWithShortArgumentImplementedInPrivateScript");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     if (UNLIKELY(info.Length() < 1)) {
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         return;
     }
 
     int value;
     value = toInt16(info.GetIsolate(), info[0], NormalConversion, exceptionState);
     if (exceptionState.hadException())
         return;
 
     int result = 0;
     if (!V8TestInterface::PrivateScript::shortMethodWithShortArgumentImplementedInPrivateScriptMethod(toLocalFrame(toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext())), impl, value, &result))
         return;
     v8SetReturnValueInt(info, result);
 }
 
-static void shortMethodWithShortArgumentImplementedInPrivateScriptMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void shortMethodWithShortArgumentImplementedInPrivateScriptMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::shortMethodWithShortArgumentImplementedInPrivateScriptMethod(info);
 }
 
 static void partial2VoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartial2Implementation::partial2VoidMethod(*impl);
 }
 
 static void partial2StaticVoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfacePartial2Implementation::partial2StaticVoidMethod();
 }
 
 static void partial2SecureContextMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartial2Implementation::partial2SecureContextMethod(*impl);
 }
 
-static void partial2SecureContextMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partial2SecureContextMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partial2SecureContextMethodMethod(info);
 }
 
 static void partialSecureContextMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartialSecureContext::partialSecureContextMethod(*impl);
 }
 
-static void partialSecureContextMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialSecureContextMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialSecureContextMethodMethod(info);
 }
 
 static void partialSecureContextRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartialSecureContext::partialSecureContextRuntimeEnabledMethod(*impl);
 }
 
-static void partialSecureContextRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialSecureContextRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialSecureContextRuntimeEnabledMethodMethod(info);
 }
 
 static void partialSecureContextWindowExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartialSecureContext::partialSecureContextWindowExposedMethod(*impl);
 }
 
-static void partialSecureContextWindowExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialSecureContextWindowExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialSecureContextWindowExposedMethodMethod(info);
 }
 
 static void partialSecureContextWorkerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartialSecureContext::partialSecureContextWorkerExposedMethod(*impl);
 }
 
-static void partialSecureContextWorkerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialSecureContextWorkerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialSecureContextWorkerExposedMethodMethod(info);
 }
 
 static void partialSecureContextWindowExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartialSecureContext::partialSecureContextWindowExposedRuntimeEnabledMethod(*impl);
 }
 
-static void partialSecureContextWindowExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialSecureContextWindowExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialSecureContextWindowExposedRuntimeEnabledMethodMethod(info);
 }
 
 static void partialSecureContextWorkerExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     TestInterfacePartialSecureContext::partialSecureContextWorkerExposedRuntimeEnabledMethod(*impl);
 }
 
-static void partialSecureContextWorkerExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partialSecureContextWorkerExposedRuntimeEnabledMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partialSecureContextWorkerExposedRuntimeEnabledMethodMethod(info);
 }
 
 static void voidMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             voidMethodPartialOverload1Method(info);
             return;
         }
         break;
     case 1:
         if (info[0]->IsNumber()) {
             voidMethodPartialOverload2Method(info);
             return;
         }
         if (true) {
             voidMethodPartialOverload2Method(info);
             return;
         }
         break;
     }
 
     DCHECK(voidMethodPartialOverloadMethodForPartialInterface);
     (voidMethodPartialOverloadMethodForPartialInterface)(info);
 }
 
-static void voidMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void voidMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::voidMethodPartialOverloadMethod(info);
 }
 
 static void staticVoidMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             staticVoidMethodPartialOverload1Method(info);
             return;
         }
         break;
     case 1:
         break;
     }
 
     DCHECK(staticVoidMethodPartialOverloadMethodForPartialInterface);
     (staticVoidMethodPartialOverloadMethodForPartialInterface)(info);
 }
 
-static void staticVoidMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void staticVoidMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::staticVoidMethodPartialOverloadMethod(info);
 }
 
 static void promiseMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             promiseMethodPartialOverload1Method(info);
             return;
         }
         break;
     case 1:
         if (V8Window::hasInstance(info[0], info.GetIsolate())) {
             promiseMethodPartialOverload2Method(info);
             return;
         }
         break;
     }
 
     DCHECK(promiseMethodPartialOverloadMethodForPartialInterface);
     (promiseMethodPartialOverloadMethodForPartialInterface)(info);
 }
 
-static void promiseMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void promiseMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::promiseMethodPartialOverloadMethod(info);
 }
 
 static void staticPromiseMethodPartialOverloadMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             staticPromiseMethodPartialOverload1Method(info);
             return;
         }
         break;
     case 1:
         break;
     }
 
     DCHECK(staticPromiseMethodPartialOverloadMethodForPartialInterface);
     (staticPromiseMethodPartialOverloadMethodForPartialInterface)(info);
 }
 
-static void staticPromiseMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void staticPromiseMethodPartialOverloadMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::staticPromiseMethodPartialOverloadMethod(info);
 }
 
 static void partial2VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             partial2VoidMethod1Method(info);
             return;
         }
         break;
     case 1:
         break;
     }
 
     DCHECK(partial2VoidMethodMethodForPartialInterface);
     (partial2VoidMethodMethodForPartialInterface)(info);
 }
 
-static void partial2VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partial2VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partial2VoidMethodMethod(info);
 }
 
 static void partial2StaticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             partial2StaticVoidMethod1Method(info);
             return;
         }
         break;
     case 1:
         break;
     }
 
     DCHECK(partial2StaticVoidMethodMethodForPartialInterface);
     (partial2StaticVoidMethodMethodForPartialInterface)(info);
 }
 
-static void partial2StaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void partial2StaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::partial2StaticVoidMethodMethod(info);
 }
 
 static void toJSONMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "toJSON");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     ScriptState* scriptState = ScriptState::forReceiverObject(info);
 
     ScriptValue result = impl->toJSONForBinding(scriptState, exceptionState);
     if (exceptionState.hadException()) {
         return;
     }
     v8SetReturnValue(info, result.v8Value());
 }
 
-static void toJSONMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void toJSONMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::toJSONMethod(info);
 }
 
 static void toStringMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     v8SetReturnValueString(info, impl->toString(), info.GetIsolate());
 }
 
-static void toStringMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void toStringMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::toStringMethod(info);
 }
 
 static void iteratorMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "iterator");
 
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
 
     ScriptState* scriptState = ScriptState::forReceiverObject(info);
 
     Iterator* result = impl->iterator(scriptState, exceptionState);
     if (exceptionState.hadException()) {
         return;
     }
     v8SetReturnValue(info, result);
 }
 
-static void iteratorMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+void iteratorMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementationV8Internal::iteratorMethod(info);
 }
 
 static void namedPropertyGetter(const AtomicString& name, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
     String result = impl->anonymousNamedGetter(name);
     if (result.isNull())
         return;
@@ skipping 681 matching lines @@
 {
     TestInterfaceImplementationV8Internal::partial2VoidMethodMethodForPartialInterface = method;
 }
 
 void V8TestInterface::registerPartial2StaticVoidMethodMethodForPartialInterface(void (*method)(const v8::FunctionCallbackInfo<v8::Value>&))
 {
     TestInterfaceImplementationV8Internal::partial2StaticVoidMethodMethodForPartialInterface = method;
 }
 
 } // namespace blink