binding: Introduces ExceptionToPromiseScope.

third_party/WebKit/Source/bindings/tests/results/core/V8TestInterface.cpp

Index: third_party/WebKit/Source/bindings/tests/results/core/V8TestInterface.cpp
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/V8TestInterface.cpp b/third_party/WebKit/Source/bindings/tests/results/core/V8TestInterface.cpp
index 5e742730cf01650311e5931ddbf2132d06939a2e..8dc833dc103b5dfe23518f02af9b7b72c6f26939 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/V8TestInterface.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/V8TestInterface.cpp
@@ -1458,10 +1458,12 @@ static void partialSecureContextWorkerExposedRuntimeEnabledAttributeAttributeSet
 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (UNLIKELY(info.Length() < 1)) {
-        V8ThrowException::throwException(info.GetIsolate(), createMinimumArityTypeErrorForMethod(info.GetIsolate(), "voidMethodTestInterfaceEmptyArg", "TestInterface", 1, info.Length()));
+        throwMinimumArityErrorForMethod(info.GetIsolate(), "TestInterface", "voidMethodTestInterfaceEmptyArg", 1, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfaceEmpty* testInterfaceEmptyArg;
     {
         testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
@@ -1480,12 +1482,15 @@ static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
 
 static void voidMethodDoubleArgFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodDoubleArgFloatArg", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "voidMethodDoubleArgFloatArg");
+
     if (UNLIKELY(info.Length() < 2)) {
-        setMinimumArityTypeError(exceptionState, 2, info.Length());
+        throwMinimumArityError(exceptionState, 2, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     double doubleArg;
     float floatArg;
     {
@@ -1506,12 +1511,15 @@ static void voidMethodDoubleArgFloatArgMethodCallback(const v8::FunctionCallback
 
 static void voidMethodUnrestrictedDoubleArgUnrestrictedFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodUnrestrictedDoubleArgUnrestrictedFloatArg", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "voidMethodUnrestrictedDoubleArgUnrestrictedFloatArg");
+
     if (UNLIKELY(info.Length() < 2)) {
-        setMinimumArityTypeError(exceptionState, 2, info.Length());
+        throwMinimumArityError(exceptionState, 2, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     double unrestrictedDoubleArg;
     float unrestrictedFloatArg;
     {
@@ -1532,12 +1540,15 @@ static void voidMethodUnrestrictedDoubleArgUnrestrictedFloatArgMethodCallback(co
 
 static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodTestEnumArg", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "voidMethodTestEnumArg");
+
     if (UNLIKELY(info.Length() < 1)) {
-        setMinimumArityTypeError(exceptionState, 1, info.Length());
+        throwMinimumArityError(exceptionState, 1, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     V8StringResource<> testEnumArg;
     {
         testEnumArg = info[0];
@@ -1564,6 +1575,7 @@ static void voidMethodTestEnumArgMethodCallback(const v8::FunctionCallbackInfo<v
 static void voidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->voidMethod();
 }
 
@@ -1575,6 +1587,7 @@ static void voidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>&
 static void voidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->voidMethod();
 }
 
@@ -1586,6 +1599,7 @@ static void voidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<
 static void alwaysExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->alwaysExposedMethod();
 }
 
@@ -1597,6 +1611,7 @@ static void alwaysExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8:
 static void workerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->workerExposedMethod();
 }
 
@@ -1608,6 +1623,7 @@ static void workerExposedMethodMethodCallback(const v8::FunctionCallbackInfo<v8:
 static void windowExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->windowExposedMethod();
 }
 
@@ -1659,6 +1675,7 @@ static void staticReturnDOMWrapperMethodMethodCallback(const v8::FunctionCallbac
 static void methodWithExposedAndRuntimeEnabledFlagMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->methodWithExposedAndRuntimeEnabledFlag();
 }
 
@@ -1669,8 +1686,10 @@ static void methodWithExposedAndRuntimeEnabledFlagMethodCallback(const v8::Funct
 
 static void overloadMethodWithExposedAndRuntimeEnabledFlag1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadMethodWithExposedAndRuntimeEnabledFlag", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "overloadMethodWithExposedAndRuntimeEnabledFlag");
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     int longArg;
     {
         longArg = toInt32(info.GetIsolate(), info[0], NormalConversion, exceptionState);
@@ -1683,6 +1702,7 @@ static void overloadMethodWithExposedAndRuntimeEnabledFlag1Method(const v8::Func
 static void overloadMethodWithExposedAndRuntimeEnabledFlag2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     V8StringResource<> string;
     {
         string = info[0];
@@ -1695,6 +1715,7 @@ static void overloadMethodWithExposedAndRuntimeEnabledFlag2Method(const v8::Func
 static void overloadMethodWithExposedAndRuntimeEnabledFlag3Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     DOMWindow* window;
     {
         window = toDOMWindow(info.GetIsolate(), info[0]);
@@ -1740,7 +1761,6 @@ static void overloadMethodWithExposedAndRuntimeEnabledFlagMethod(const v8::Funct
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
-    return;
 }
 
 static void overloadMethodWithExposedAndRuntimeEnabledFlagMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ -1751,6 +1771,7 @@ static void overloadMethodWithExposedAndRuntimeEnabledFlagMethodCallback(const v
 static void methodWithExposedHavingRuntimeEnabldFlagMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->methodWithExposedHavingRuntimeEnabldFlag();
 }
 
@@ -1762,6 +1783,7 @@ static void methodWithExposedHavingRuntimeEnabldFlagMethodCallback(const v8::Fun
 static void windowAndServiceWorkerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->windowAndServiceWorkerExposedMethod();
 }
 
@@ -1773,13 +1795,16 @@ static void windowAndServiceWorkerExposedMethodMethodCallback(const v8::Function
 static void voidMethodPartialOverload1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->voidMethodPartialOverload();
 }
 
 static void voidMethodPartialOverload2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodPartialOverload", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "voidMethodPartialOverload");
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     double doubleArg;
     {
         doubleArg = toRestrictedDouble(info.GetIsolate(), info[0], exceptionState);
@@ -1797,17 +1822,19 @@ static void staticVoidMethodPartialOverload1Method(const v8::FunctionCallbackInf
 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)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     DOMWindow* window;
     {
         window = toDOMWindow(info.GetIsolate(), info[0]);
         if (!window) {
-            v8SetReturnValue(info, ScriptPromise::rejectRaw(ScriptState::current(info.GetIsolate()), V8ThrowException::createTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("promiseMethodPartialOverload", "TestInterface", "parameter 1 is not of type 'Window'."))));
+            V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("promiseMethodPartialOverload", "TestInterface", "parameter 1 is not of type 'Window'."));
             return;
         }
     }
@@ -1822,10 +1849,12 @@ static void staticPromiseMethodPartialOverload1Method(const v8::FunctionCallback
 static void legacyInterfaceTypeCheckingMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (UNLIKELY(info.Length() < 1)) {
-        V8ThrowException::throwException(info.GetIsolate(), createMinimumArityTypeErrorForMethod(info.GetIsolate(), "legacyInterfaceTypeCheckingMethod", "TestInterface", 1, info.Length()));
+        throwMinimumArityErrorForMethod(info.GetIsolate(), "TestInterface", "legacyInterfaceTypeCheckingMethod", 1, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfaceEmpty* testInterfaceEmptyArg;
     {
         testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
@@ -1841,6 +1870,7 @@ static void legacyInterfaceTypeCheckingMethodMethodCallback(const v8::FunctionCa
 static void secureContextMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->secureContextMethod();
 }
 
@@ -1852,6 +1882,7 @@ static void secureContextMethodMethodCallback(const v8::FunctionCallbackInfo<v8:
 static void secureContextRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->secureContextRuntimeEnabledMethod();
 }
 
@@ -1863,6 +1894,7 @@ static void secureContextRuntimeEnabledMethodMethodCallback(const v8::FunctionCa
 static void secureContextWindowExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->secureContextWindowExposedMethod();
 }
 
@@ -1874,6 +1906,7 @@ static void secureContextWindowExposedMethodMethodCallback(const v8::FunctionCal
 static void secureContextWorkerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->secureContextWorkerExposedMethod();
 }
 
@@ -1885,6 +1918,7 @@ static void secureContextWorkerExposedMethodMethodCallback(const v8::FunctionCal
 static void secureContextWindowExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->secureContextWindowExposedRuntimeEnabledMethod();
 }
 
@@ -1896,6 +1930,7 @@ static void secureContextWindowExposedRuntimeEnabledMethodMethodCallback(const v
 static void secureContextWorkerExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->secureContextWorkerExposedRuntimeEnabledMethod();
 }
 
@@ -1907,6 +1942,7 @@ static void secureContextWorkerExposedRuntimeEnabledMethodMethodCallback(const v
 static void implementsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     impl->implementsVoidMethod();
 }
 
@@ -1917,12 +1953,15 @@ static void implementsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8
 
 static void implementsComplexMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "implementsComplexMethod", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "implementsComplexMethod");
+
     if (UNLIKELY(info.Length() < 2)) {
-        setMinimumArityTypeError(exceptionState, 2, info.Length());
+        throwMinimumArityError(exceptionState, 2, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     V8StringResource<> strArg;
     TestInterfaceEmpty* testInterfaceEmptyArg;
     {
@@ -1966,6 +2005,7 @@ static void implementsStaticVoidMethodMethodCallback(const v8::FunctionCallbackI
 static void implements2VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestImplements2::implements2VoidMethod(*impl);
 }
 
@@ -1977,6 +2017,7 @@ static void implements2VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v
 static void implements3VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestImplements3Implementation::implements3VoidMethod(*impl);
 }
 
@@ -1998,6 +2039,7 @@ static void implements3StaticVoidMethodMethodCallback(const v8::FunctionCallback
 static void partialVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartial::partialVoidMethod(*impl);
 }
 
@@ -2018,12 +2060,15 @@ static void partialStaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo
 
 static void partialVoidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "partialVoidMethodLongArg", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "partialVoidMethodLongArg");
+
     if (UNLIKELY(info.Length() < 1)) {
-        setMinimumArityTypeError(exceptionState, 1, info.Length());
+        throwMinimumArityError(exceptionState, 1, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     int longArg;
     {
         longArg = toInt32(info.GetIsolate(), info[0], NormalConversion, exceptionState);
@@ -2040,8 +2085,10 @@ static void partialVoidMethodLongArgMethodCallback(const v8::FunctionCallbackInf
 
 static void partialCallWithExecutionContextRaisesExceptionVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "partialCallWithExecutionContextRaisesExceptionVoidMethod", "TestInterface", info.Holder(), info.GetIsolate());
+    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()) {
@@ -2057,10 +2104,12 @@ static void partialCallWithExecutionContextRaisesExceptionVoidMethodMethodCallba
 static void partialVoidMethodPartialCallbackTypeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (UNLIKELY(info.Length() < 1)) {
-        V8ThrowException::throwException(info.GetIsolate(), createMinimumArityTypeErrorForMethod(info.GetIsolate(), "partialVoidMethodPartialCallbackTypeArg", "TestInterface", 1, info.Length()));
+        throwMinimumArityErrorForMethod(info.GetIsolate(), "TestInterface", "partialVoidMethodPartialCallbackTypeArg", 1, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     ScriptValue partialCallbackTypeArg;
     {
         if (!info[0]->IsFunction()) {
@@ -2079,12 +2128,15 @@ static void partialVoidMethodPartialCallbackTypeArgMethodCallback(const v8::Func
 
 static void shortMethodWithShortArgumentImplementedInPrivateScriptMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "shortMethodWithShortArgumentImplementedInPrivateScript", "TestInterface", info.Holder(), info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "TestInterface", "shortMethodWithShortArgumentImplementedInPrivateScript");
+
     if (UNLIKELY(info.Length() < 1)) {
-        setMinimumArityTypeError(exceptionState, 1, info.Length());
+        throwMinimumArityError(exceptionState, 1, info.Length());
         return;
     }
+
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     int value;
     {
         value = toInt16(info.GetIsolate(), info[0], NormalConversion, exceptionState);
@@ -2105,6 +2157,7 @@ static void shortMethodWithShortArgumentImplementedInPrivateScriptMethodCallback
 static void partial2VoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartial2Implementation::partial2VoidMethod(*impl);
 }
 
@@ -2116,6 +2169,7 @@ static void partial2StaticVoidMethod1Method(const v8::FunctionCallbackInfo<v8::V
 static void partial2SecureContextMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartial2Implementation::partial2SecureContextMethod(*impl);
 }
 
@@ -2127,6 +2181,7 @@ static void partial2SecureContextMethodMethodCallback(const v8::FunctionCallback
 static void partialSecureContextMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartialSecureContext::partialSecureContextMethod(*impl);
 }
 
@@ -2138,6 +2193,7 @@ static void partialSecureContextMethodMethodCallback(const v8::FunctionCallbackI
 static void partialSecureContextRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartialSecureContext::partialSecureContextRuntimeEnabledMethod(*impl);
 }
 
@@ -2149,6 +2205,7 @@ static void partialSecureContextRuntimeEnabledMethodMethodCallback(const v8::Fun
 static void partialSecureContextWindowExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartialSecureContext::partialSecureContextWindowExposedMethod(*impl);
 }
 
@@ -2160,6 +2217,7 @@ static void partialSecureContextWindowExposedMethodMethodCallback(const v8::Func
 static void partialSecureContextWorkerExposedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartialSecureContext::partialSecureContextWorkerExposedMethod(*impl);
 }
 
@@ -2171,6 +2229,7 @@ static void partialSecureContextWorkerExposedMethodMethodCallback(const v8::Func
 static void partialSecureContextWindowExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartialSecureContext::partialSecureContextWindowExposedRuntimeEnabledMethod(*impl);
 }
 
@@ -2182,6 +2241,7 @@ static void partialSecureContextWindowExposedRuntimeEnabledMethodMethodCallback(
 static void partialSecureContextWorkerExposedRuntimeEnabledMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     TestInterfacePartialSecureContext::partialSecureContextWorkerExposedRuntimeEnabledMethod(*impl);
 }
 
@@ -2336,8 +2396,10 @@ static void partial2StaticVoidMethodMethodCallback(const v8::FunctionCallbackInf
 
 static void toJSONMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "toJSON", "TestInterface", info.Holder(), info.GetIsolate());
+    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()) {
@@ -2354,6 +2416,7 @@ static void toJSONMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info
 static void toStringMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestInterfaceImplementation* impl = V8TestInterface::toImpl(info.Holder());
+
     v8SetReturnValueString(info, impl->toString(), info.GetIsolate());
 }
 
@@ -2364,8 +2427,10 @@ static void toStringMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& in
 
 static void iteratorMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "iterator", "TestInterface", info.Holder(), info.GetIsolate());
+    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()) {