Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(206)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: Source/bindings/tests/results/V8TestObject.cpp

Issue 265293004: Create fewer local v8::TryCatch objects in generated bindings code (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: avoid some unused v8::TryCatch objects Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« Source/bindings/scripts/v8_methods.py ('K') | « Source/bindings/tests/results/V8TestInterfaceWillBeGarbageCollected.cpp ('k') | Source/bindings/tests/results/V8TestSpecialOperations.cpp » ('j') | Source/bindings/v8/V8BindingMacros.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: Source/bindings/tests/results/V8TestObject.cpp
diff --git a/Source/bindings/tests/results/V8TestObject.cpp b/Source/bindings/tests/results/V8TestObject.cpp
index 7b5316d46d48a518cefdafb4a3518dbfa540e400..0dfe6f126bd3982ace7470c17f71c1d2a26e745e 100644
--- a/Source/bindings/tests/results/V8TestObject.cpp
+++ b/Source/bindings/tests/results/V8TestObject.cpp
@@ -4758,7 +4758,11 @@ static void voidMethodDateArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(double, dateArg, toCoreDate(info[0]));
+ double dateArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(dateArg, toCoreDate(info[0]));
+ }
impl->voidMethodDateArg(dateArg);
}
@@ -4776,7 +4780,10 @@ static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, stringArg, info[0]);
+ V8StringResource<> stringArg;
+ {
+ TOSTRING_VOID_NO_DECL(stringArg, info[0]);
+ }
impl->voidMethodStringArg(stringArg);
}
@@ -4795,7 +4802,11 @@ static void voidMethodDOMTimeStampArgMethod(const v8::FunctionCallbackInfo<v8::V
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(unsigned long long, domTimeStampArg, toUInt64(info[0], exceptionState), exceptionState);
+ unsigned long long domTimeStampArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(domTimeStampArg, toUInt64(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodDOMTimeStampArg(domTimeStampArg);
}
@@ -4813,7 +4824,11 @@ static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(bool, booleanArg, info[0]->BooleanValue());
+ bool booleanArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(booleanArg, info[0]->BooleanValue());
+ }
impl->voidMethodBooleanArg(booleanArg);
}
@@ -4832,7 +4847,11 @@ static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, byteArg, toInt8(info[0], exceptionState), exceptionState);
+ int byteArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(byteArg, toInt8(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodByteArg(byteArg);
}
@@ -4850,7 +4869,11 @@ static void voidMethodDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(double, doubleArg, static_cast<double>(info[0]->NumberValue()));
+ double doubleArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(doubleArg, static_cast<double>(info[0]->NumberValue()));
+ }
impl->voidMethodDoubleArg(doubleArg);
}
@@ -4868,7 +4891,11 @@ static void voidMethodFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(float, floatArg, static_cast<float>(info[0]->NumberValue()));
+ float floatArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(floatArg, static_cast<float>(info[0]->NumberValue()));
+ }
impl->voidMethodFloatArg(floatArg);
}
@@ -4887,7 +4914,11 @@ static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodLongArg(longArg);
}
@@ -4906,7 +4937,11 @@ static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(long long, longLongArg, toInt64(info[0], exceptionState), exceptionState);
+ long long longLongArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longLongArg, toInt64(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodLongLongArg(longLongArg);
}
@@ -4925,7 +4960,11 @@ static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(unsigned, octetArg, toUInt8(info[0], exceptionState), exceptionState);
+ unsigned octetArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(octetArg, toUInt8(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodOctetArg(octetArg);
}
@@ -4944,7 +4983,11 @@ static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, shortArg, toInt16(info[0], exceptionState), exceptionState);
+ int shortArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(shortArg, toInt16(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodShortArg(shortArg);
}
@@ -4963,7 +5006,11 @@ static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::V
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(unsigned, unsignedLongArg, toUInt32(info[0], exceptionState), exceptionState);
+ unsigned unsignedLongArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(unsignedLongArg, toUInt32(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodUnsignedLongArg(unsignedLongArg);
}
@@ -4982,7 +5029,11 @@ static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(unsigned long long, unsignedLongLongArg, toUInt64(info[0], exceptionState), exceptionState);
+ unsigned long long unsignedLongLongArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(unsignedLongLongArg, toUInt64(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodUnsignedLongLongArg(unsignedLongLongArg);
}
@@ -5001,7 +5052,11 @@ static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(unsigned, unsignedShortArg, toUInt16(info[0], exceptionState), exceptionState);
+ unsigned unsignedShortArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(unsignedShortArg, toUInt16(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodUnsignedShortArg(unsignedShortArg);
}
@@ -5032,7 +5087,11 @@ static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
}
@@ -5051,8 +5110,13 @@ static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
+ int longArg;
+ TestInterfaceEmpty* testInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
+ }
impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg);
}
@@ -5096,7 +5160,11 @@ static void voidMethodVoidCallbackFunctionArgMethod(const v8::FunctionCallbackIn
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(ScriptValue, voidCallbackFunctionArg, ScriptValue(ScriptState::current(info.GetIsolate()), info[0]));
+ ScriptValue voidCallbackFunctionArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(voidCallbackFunctionArg, ScriptValue(ScriptState::current(info.GetIsolate()), info[0]));
+ }
impl->voidMethodVoidCallbackFunctionArg(voidCallbackFunctionArg);
}
@@ -5114,7 +5182,11 @@ static void voidMethodAnyCallbackFunctionOptionalAnyArgMethod(const v8::Function
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(ScriptValue, anyCallbackFunctionOptionalAnyArgArg, ScriptValue(ScriptState::current(info.GetIsolate()), info[0]));
+ ScriptValue anyCallbackFunctionOptionalAnyArgArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(anyCallbackFunctionOptionalAnyArgArg, ScriptValue(ScriptState::current(info.GetIsolate()), info[0]));
+ }
impl->voidMethodAnyCallbackFunctionOptionalAnyArg(anyCallbackFunctionOptionalAnyArgArg);
}
@@ -5158,7 +5230,11 @@ static void voidMethodCompareHowArgMethod(const v8::FunctionCallbackInfo<v8::Val
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Range::CompareHow, compareHowArg, static_cast<Range::CompareHow>(info[0]->Int32Value()));
+ Range::CompareHow compareHowArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(compareHowArg, static_cast<Range::CompareHow>(info[0]->Int32Value()));
+ }
impl->voidMethodCompareHowArg(compareHowArg);
}
@@ -5176,7 +5252,11 @@ static void voidMethodEventTargetArgMethod(const v8::FunctionCallbackInfo<v8::Va
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(EventTarget*, eventTargetArg, V8DOMWrapper::isDOMWrapper(info[0]) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast(info[0]))->toEventTarget(v8::Handle<v8::Object>::Cast(info[0])) : 0);
+ EventTarget* eventTargetArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(eventTargetArg, V8DOMWrapper::isDOMWrapper(info[0]) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast(info[0]))->toEventTarget(v8::Handle<v8::Object>::Cast(info[0])) : 0);
+ }
impl->voidMethodEventTargetArg(eventTargetArg);
}
@@ -5194,7 +5274,11 @@ static void voidMethodMediaQueryListListenerArgMethod(const v8::FunctionCallback
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(RefPtrWillBeRawPtr<MediaQueryListListener>, mediaQueryListListenerArg, MediaQueryListListener::create(ScriptValue(ScriptState::current(info.GetIsolate()), info[0])));
+ RefPtrWillBeRawPtr<MediaQueryListListener> mediaQueryListListenerArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(mediaQueryListListenerArg, MediaQueryListListener::create(ScriptValue(ScriptState::current(info.GetIsolate()), info[0])));
+ }
impl->voidMethodMediaQueryListListenerArg(mediaQueryListListenerArg);
}
@@ -5212,7 +5296,11 @@ static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& in
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(ScriptValue, anyArg, ScriptValue(ScriptState::current(info.GetIsolate()), info[0]));
+ ScriptValue anyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(anyArg, ScriptValue(ScriptState::current(info.GetIsolate()), info[0]));
+ }
impl->voidMethodAnyArg(anyArg);
}
@@ -5230,7 +5318,11 @@ static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Attr*, attrArg, V8Attr::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ Attr* attrArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(attrArg, V8Attr::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodAttrArg(attrArg);
}
@@ -5248,7 +5340,11 @@ static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Document*, documentArg, V8Document::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ Document* documentArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(documentArg, V8Document::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodDocumentArg(documentArg);
}
@@ -5266,7 +5362,11 @@ static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(DocumentType*, documentTypeArg, V8DocumentType::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ DocumentType* documentTypeArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(documentTypeArg, V8DocumentType::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodDocumentTypeArg(documentTypeArg);
}
@@ -5284,7 +5384,11 @@ static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Element*, elementArg, V8Element::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ Element* elementArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(elementArg, V8Element::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodElementArg(elementArg);
}
@@ -5302,7 +5406,11 @@ static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Node*, nodeArg, V8Node::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ Node* nodeArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(nodeArg, V8Node::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodNodeArg(nodeArg);
}
@@ -5385,7 +5493,11 @@ static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Va
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8ArrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
+ ArrayBuffer* arrayBufferArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(arrayBufferArg, info[0]->IsArrayBuffer() ? V8ArrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
+ }
impl->voidMethodArrayBufferArg(arrayBufferArg);
}
@@ -5403,7 +5515,11 @@ static void voidMethodArrayBufferOrNullArgMethod(const v8::FunctionCallbackInfo<
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8ArrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
+ ArrayBuffer* arrayBufferArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(arrayBufferArg, info[0]->IsArrayBuffer() ? V8ArrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
+ }
impl->voidMethodArrayBufferOrNullArg(arrayBufferArg);
}
@@ -5421,7 +5537,11 @@ static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(ArrayBufferView*, arrayBufferViewArg, info[0]->IsArrayBufferView() ? V8ArrayBufferView::toNative(v8::Handle<v8::ArrayBufferView>::Cast(info[0])) : 0);
+ ArrayBufferView* arrayBufferViewArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(arrayBufferViewArg, info[0]->IsArrayBufferView() ? V8ArrayBufferView::toNative(v8::Handle<v8::ArrayBufferView>::Cast(info[0])) : 0);
+ }
impl->voidMethodArrayBufferViewArg(arrayBufferViewArg);
}
@@ -5439,7 +5559,11 @@ static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::V
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Float32Array*, float32ArrayArg, info[0]->IsFloat32Array() ? V8Float32Array::toNative(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0);
+ Float32Array* float32ArrayArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(float32ArrayArg, info[0]->IsFloat32Array() ? V8Float32Array::toNative(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0);
+ }
impl->voidMethodFloat32ArrayArg(float32ArrayArg);
}
@@ -5457,7 +5581,11 @@ static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Int32Array*, int32ArrayArg, info[0]->IsInt32Array() ? V8Int32Array::toNative(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0);
+ Int32Array* int32ArrayArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(int32ArrayArg, info[0]->IsInt32Array() ? V8Int32Array::toNative(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0);
+ }
impl->voidMethodInt32ArrayArg(int32ArrayArg);
}
@@ -5475,7 +5603,11 @@ static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Uint8Array*, uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint8Array::toNative(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0);
+ Uint8Array* uint8ArrayArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint8Array::toNative(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0);
+ }
impl->voidMethodUint8ArrayArg(uint8ArrayArg);
}
@@ -5532,7 +5664,11 @@ static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Valu
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<int>, arrayLongArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
+ Vector<int> arrayLongArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(arrayLongArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
+ }
impl->voidMethodArrayLongArg(arrayLongArg);
}
@@ -5550,7 +5686,11 @@ static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Va
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<String>, arrayStringArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
+ Vector<String> arrayStringArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(arrayStringArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
+ }
impl->voidMethodArrayStringArg(arrayStringArg);
}
@@ -5568,7 +5708,11 @@ static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbac
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<RefPtr<TestInterfaceEmpty> >, arrayTestInterfaceEmptyArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
+ Vector<RefPtr<TestInterfaceEmpty> > arrayTestInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(arrayTestInterfaceEmptyArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
+ }
impl->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg);
}
@@ -5625,7 +5769,11 @@ static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::V
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<int>, longSequenceArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
+ Vector<int> longSequenceArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(longSequenceArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
+ }
impl->voidMethodSequenceLongArg(longSequenceArg);
}
@@ -5643,7 +5791,11 @@ static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8:
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<String>, stringSequenceArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
+ Vector<String> stringSequenceArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(stringSequenceArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
+ }
impl->voidMethodSequenceStringArg(stringSequenceArg);
}
@@ -5661,7 +5813,11 @@ static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCall
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<RefPtr<TestInterfaceEmpty> >, testInterfaceEmptySequenceArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
+ Vector<RefPtr<TestInterfaceEmpty> > testInterfaceEmptySequenceArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptySequenceArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
+ }
impl->voidMethodSequenceTestInterfaceEmptyArg(testInterfaceEmptySequenceArg);
}
@@ -5679,7 +5835,11 @@ static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, nullableTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* nullableTestInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(nullableTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg);
}
@@ -5697,11 +5857,14 @@ static void voidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackI
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (info.Length() <= 0 || !info[0]->IsFunction()) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
- return;
+ OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
+ {
+ if (info.Length() <= 0 || !info[0]->IsFunction()) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
+ return;
+ }
+ testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
- OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
impl->voidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release());
}
@@ -5716,12 +5879,14 @@ static void voidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionC
{
TestObject* impl = V8TestObject::toNative(info.Holder());
OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg;
- if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
- if (!info[0]->IsFunction()) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
- return;
+ {
+ if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
+ if (!info[0]->IsFunction()) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
+ return;
+ }
+ optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
- optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
impl->voidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg.release());
}
@@ -5740,11 +5905,14 @@ static void voidMethodTestCallbackInterfaceOrNullArgMethod(const v8::FunctionCal
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (info.Length() <= 0 || !(info[0]->IsFunction() || info[0]->IsNull())) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceOrNullArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
- return;
+ OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
+ {
+ if (info.Length() <= 0 || !(info[0]->IsFunction() || info[0]->IsNull())) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceOrNullArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
+ return;
+ }
+ testCallbackInterfaceArg = info[0]->IsNull() ? nullptr : V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
- OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = info[0]->IsNull() ? nullptr : V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
impl->voidMethodTestCallbackInterfaceOrNullArg(testCallbackInterfaceArg.release());
}
@@ -5775,11 +5943,14 @@ static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, testEnumTypeArg, info[0]);
- String string = testEnumTypeArg;
- if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg", "TestObject", "parameter 1 ('" + string + "') is not a valid enum value."), info.GetIsolate());
- return;
+ V8StringResource<> testEnumTypeArg;
+ {
+ TOSTRING_VOID_NO_DECL(testEnumTypeArg, info[0]);
+ String string = testEnumTypeArg;
+ if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg", "TestObject", "parameter 1 ('" + string + "') is not a valid enum value."), info.GetIsolate());
+ return;
+ }
}
impl->voidMethodTestEnumArg(testEnumTypeArg);
}
@@ -5863,10 +6034,14 @@ static void voidMethodDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Val
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Dictionary, dictionaryArg, Dictionary(info[0], info.GetIsolate()));
- if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryArg", "TestObject", "parameter 1 ('dictionaryArg') is not an object."), info.GetIsolate());
- return;
+ Dictionary dictionaryArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(dictionaryArg, Dictionary(info[0], info.GetIsolate()));
+ if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryArg", "TestObject", "parameter 1 ('dictionaryArg') is not an object."), info.GetIsolate());
+ return;
+ }
}
impl->voidMethodDictionaryArg(dictionaryArg);
}
@@ -5886,7 +6061,10 @@ static void voidMethodEventListenerArgMethod(const v8::FunctionCallbackInfo<v8::
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- RefPtr<EventListener> eventListenerArg = V8EventListenerList::getEventListener(info[1], false, ListenerFindOrCreate);
+ RefPtr<EventListener> eventListenerArg;
+ {
+ eventListenerArg = V8EventListenerList::getEventListener(info[1], false, ListenerFindOrCreate);
+ }
impl->voidMethodEventListenerArg(eventListenerArg);
if (listener && !impl->toNode())
removeHiddenValueFromArray(info.Holder(), info[1], V8TestObject::eventListenerCacheIndex, info.GetIsolate());
@@ -5906,7 +6084,11 @@ static void voidMethodNodeFilterArgMethod(const v8::FunctionCallbackInfo<v8::Val
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(RefPtr<NodeFilter>, nodeFilterArg, toNodeFilter(info[0], info.GetIsolate()));
+ RefPtr<NodeFilter> nodeFilterArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(nodeFilterArg, toNodeFilter(info[0], info.GetIsolate()));
+ }
impl->voidMethodNodeFilterArg(nodeFilterArg.release());
}
@@ -5924,10 +6106,14 @@ static void voidMethodPromiseArgMethod(const v8::FunctionCallbackInfo<v8::Value>
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(ScriptPromise, promiseArg, ScriptPromise(info[0], info.GetIsolate()));
- if (!promiseArg.isUndefinedOrNull() && !promiseArg.isObject()) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg", "TestObject", "parameter 1 ('promiseArg') is not an object."), info.GetIsolate());
- return;
+ ScriptPromise promiseArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(promiseArg, ScriptPromise(info[0], info.GetIsolate()));
+ if (!promiseArg.isUndefinedOrNull() && !promiseArg.isObject()) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg", "TestObject", "parameter 1 ('promiseArg') is not an object."), info.GetIsolate());
+ return;
+ }
}
impl->voidMethodPromiseArg(promiseArg);
}
@@ -5947,9 +6133,12 @@ static void voidMethodSerializedScriptValueArgMethod(const v8::FunctionCallbackI
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- RefPtr<SerializedScriptValue> serializedScriptValueArg = SerializedScriptValue::create(info[0], 0, 0, exceptionState, info.GetIsolate());
- if (exceptionState.throwIfNeeded())
- return;
+ RefPtr<SerializedScriptValue> serializedScriptValueArg;
+ {
+ serializedScriptValueArg = SerializedScriptValue::create(info[0], 0, 0, exceptionState, info.GetIsolate());
+ if (exceptionState.throwIfNeeded())
+ return;
+ }
impl->voidMethodSerializedScriptValueArg(serializedScriptValueArg);
}
@@ -5967,7 +6156,11 @@ static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(RefPtrWillBeRawPtr<XPathNSResolver>, xPathNSResolverArg, toXPathNSResolver(info[0], info.GetIsolate()));
+ RefPtrWillBeRawPtr<XPathNSResolver> xPathNSResolverArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(xPathNSResolverArg, toXPathNSResolver(info[0], info.GetIsolate()));
+ }
impl->voidMethodXPathNSResolverArg(xPathNSResolverArg.release());
}
@@ -5985,7 +6178,11 @@ static void voidMethodDictionarySequenceArgMethod(const v8::FunctionCallbackInfo
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<Dictionary>, dictionarySequenceArg, toNativeArray<Dictionary>(info[0], 1, info.GetIsolate()));
+ Vector<Dictionary> dictionarySequenceArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(dictionarySequenceArg, toNativeArray<Dictionary>(info[0], 1, info.GetIsolate()));
+ }
impl->voidMethodDictionarySequenceArg(dictionarySequenceArg);
}
@@ -6004,8 +6201,13 @@ static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8::
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, stringArg, info[0]);
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[1], exceptionState), exceptionState);
+ V8StringResource<> stringArg;
+ int longArg;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(stringArg, info[0]);
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[1], exceptionState), exceptionState);
+ }
impl->voidMethodStringArgLongArg(stringArg, longArg);
}
@@ -6019,11 +6221,14 @@ static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackI
static void voidMethodOptionalStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- impl->voidMethodOptionalStringArg();
- return;
+ V8StringResource<> optionalStringArg;
+ {
+ if (UNLIKELY(info.Length() <= 0)) {
+ impl->voidMethodOptionalStringArg();
+ return;
+ }
+ TOSTRING_VOID_NO_DECL(optionalStringArg, info[0]);
}
- TOSTRING_VOID(V8StringResource<>, optionalStringArg, info[0]);
impl->voidMethodOptionalStringArg(optionalStringArg);
}
@@ -6037,11 +6242,15 @@ static void voidMethodOptionalStringArgMethodCallback(const v8::FunctionCallback
static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- impl->voidMethodOptionalTestInterfaceEmptyArg();
- return;
+ TestInterfaceEmpty* optionalTestInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ if (UNLIKELY(info.Length() <= 0)) {
+ impl->voidMethodOptionalTestInterfaceEmptyArg();
+ return;
+ }
+ TONATIVE_VOID_NO_DECL(optionalTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
}
- TONATIVE_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg);
}
@@ -6056,11 +6265,15 @@ static void voidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- impl->voidMethodOptionalLongArg();
- return;
+ int optionalLongArg;
+ {
+ v8::TryCatch block;
+ if (UNLIKELY(info.Length() <= 0)) {
+ impl->voidMethodOptionalLongArg();
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
impl->voidMethodOptionalLongArg(optionalLongArg);
}
@@ -6075,11 +6288,15 @@ static void stringMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8:
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "stringMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(), info.GetIsolate());
- return;
+ int optionalLongArg;
+ {
+ v8::TryCatch block;
+ if (UNLIKELY(info.Length() <= 0)) {
+ v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(), info.GetIsolate());
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(optionalLongArg), info.GetIsolate());
}
@@ -6094,11 +6311,15 @@ static void testInterfaceEmptyMethodOptionalLongArgMethod(const v8::FunctionCall
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "testInterfaceEmptyMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg());
- return;
+ int optionalLongArg;
+ {
+ v8::TryCatch block;
+ if (UNLIKELY(info.Length() <= 0)) {
+ v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg());
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg(optionalLongArg));
}
@@ -6113,11 +6334,15 @@ static void longMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "longMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- v8SetReturnValueInt(info, impl->longMethodOptionalLongArg());
- return;
+ int optionalLongArg;
+ {
+ v8::TryCatch block;
+ if (UNLIKELY(info.Length() <= 0)) {
+ v8SetReturnValueInt(info, impl->longMethodOptionalLongArg());
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
v8SetReturnValueInt(info, impl->longMethodOptionalLongArg(optionalLongArg));
}
@@ -6136,12 +6361,17 @@ static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInf
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
- if (UNLIKELY(info.Length() <= 1)) {
- impl->voidMethodLongArgOptionalLongArg(longArg);
- return;
+ int longArg;
+ int optionalLongArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->voidMethodLongArgOptionalLongArg(longArg);
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[1], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[1], exceptionState), exceptionState);
impl->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg);
}
@@ -6160,17 +6390,23 @@ static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::Func
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
- if (UNLIKELY(info.Length() <= 1)) {
- impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg);
- return;
- }
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg1, toInt32(info[1], exceptionState), exceptionState);
- if (UNLIKELY(info.Length() <= 2)) {
- impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongArg1);
- return;
+ int longArg;
+ int optionalLongArg1;
+ int optionalLongArg2;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg);
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg1, toInt32(info[1], exceptionState), exceptionState);
+ if (UNLIKELY(info.Length() <= 2)) {
+ impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongArg1);
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg2, toInt32(info[2], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg2, toInt32(info[2], exceptionState), exceptionState);
impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongArg1, optionalLongArg2);
}
@@ -6189,12 +6425,17 @@ static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
- if (UNLIKELY(info.Length() <= 1)) {
- impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg);
- return;
+ int longArg;
+ TestInterfaceEmpty* optionalTestInterfaceEmpty;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg);
+ return;
+ }
+ TONATIVE_VOID_NO_DECL(optionalTestInterfaceEmpty, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
}
- TONATIVE_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInterfaceEmpty);
}
@@ -6213,12 +6454,17 @@ static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
- if (UNLIKELY(info.Length() <= 1)) {
- impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty);
- return;
+ TestInterfaceEmpty* optionalTestInterfaceEmpty;
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(optionalTestInterfaceEmpty, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty);
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[1], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[1], exceptionState), exceptionState);
impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty, longArg);
}
@@ -6232,10 +6478,14 @@ static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v
static void voidMethodOptionalDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Dictionary, optionalDictionaryArg, Dictionary(info[0], info.GetIsolate()));
- if (!optionalDictionaryArg.isUndefinedOrNull() && !optionalDictionaryArg.isObject()) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalDictionaryArg", "TestObject", "parameter 1 ('optionalDictionaryArg') is not an object."), info.GetIsolate());
- return;
+ Dictionary optionalDictionaryArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(optionalDictionaryArg, Dictionary(info[0], info.GetIsolate()));
+ if (!optionalDictionaryArg.isUndefinedOrNull() && !optionalDictionaryArg.isObject()) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalDictionaryArg", "TestObject", "parameter 1 ('optionalDictionaryArg') is not an object."), info.GetIsolate());
+ return;
+ }
}
impl->voidMethodOptionalDictionaryArg(optionalDictionaryArg);
}
@@ -6250,7 +6500,11 @@ static void voidMethodOptionalDictionaryArgMethodCallback(const v8::FunctionCall
static void voidMethodVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String>(info, 0));
+ Vector<String> variadicStringArgs;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(variadicStringArgs, toNativeArguments<String>(info, 0));
+ }
impl->voidMethodVariadicStringArg(variadicStringArgs);
}
@@ -6268,8 +6522,13 @@ static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbac
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, stringArg, info[0]);
- TONATIVE_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String>(info, 1));
+ V8StringResource<> stringArg;
+ Vector<String> variadicStringArgs;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(stringArg, info[0]);
+ TONATIVE_VOID_NO_DECL(variadicStringArgs, toNativeArguments<String>(info, 1));
+ }
impl->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs);
}
@@ -6284,12 +6543,14 @@ static void voidMethodVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCall
{
TestObject* impl = V8TestObject::toNative(info.Holder());
Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs;
- for (int i = 0; i < info.Length(); ++i) {
- if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
- return;
+ {
+ for (int i = 0; i < info.Length(); ++i) {
+ if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
+ return;
+ }
+ variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
- variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
impl->voidMethodVariadicTestInterfaceEmptyArg(variadicTestInterfaceEmptyArgs);
}
@@ -6308,14 +6569,18 @@ static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyArg;
Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs;
- for (int i = 1; i < info.Length(); ++i) {
- if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
- return;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ for (int i = 1; i < info.Length(); ++i) {
+ if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
+ return;
+ }
+ variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
- variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInterfaceEmptyArg, variadicTestInterfaceEmptyArgs);
}
@@ -6331,12 +6596,14 @@ static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethod(const v8::F
{
TestObject* impl = V8TestObject::toNative(info.Holder());
HeapVector<Member<TestInterfaceGarbageCollected> > variadicTestInterfaceGarbageCollectedArg;
- for (int i = 0; i < info.Length(); ++i) {
- if (!V8TestInterfaceGarbageCollected::hasInstance(info[i], info.GetIsolate())) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceGarbageCollectedArg", "TestObject", "parameter 1 is not of type 'TestInterfaceGarbageCollected'."), info.GetIsolate());
- return;
+ {
+ for (int i = 0; i < info.Length(); ++i) {
+ if (!V8TestInterfaceGarbageCollected::hasInstance(info[i], info.GetIsolate())) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceGarbageCollectedArg", "TestObject", "parameter 1 is not of type 'TestInterfaceGarbageCollected'."), info.GetIsolate());
+ return;
+ }
+ variadicTestInterfaceGarbageCollectedArg.append(V8TestInterfaceGarbageCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
- variadicTestInterfaceGarbageCollectedArg.append(V8TestInterfaceGarbageCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
impl->voidMethodVariadicTestInterfaceGarbageCollectedArg(variadicTestInterfaceGarbageCollectedArg);
}
@@ -6352,12 +6619,14 @@ static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(const
{
TestObject* impl = V8TestObject::toNative(info.Holder());
WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > variadicTestInterfaceWillBeGarbageCollectedArg;
- for (int i = 0; i < info.Length(); ++i) {
- if (!V8TestInterfaceWillBeGarbageCollected::hasInstance(info[i], info.GetIsolate())) {
- throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg", "TestObject", "parameter 1 is not of type 'TestInterfaceWillBeGarbageCollected'."), info.GetIsolate());
- return;
+ {
+ for (int i = 0; i < info.Length(); ++i) {
+ if (!V8TestInterfaceWillBeGarbageCollected::hasInstance(info[i], info.GetIsolate())) {
+ throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg", "TestObject", "parameter 1 is not of type 'TestInterfaceWillBeGarbageCollected'."), info.GetIsolate());
+ return;
+ }
+ variadicTestInterfaceWillBeGarbageCollectedArg.append(V8TestInterfaceWillBeGarbageCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
- variadicTestInterfaceWillBeGarbageCollectedArg.append(V8TestInterfaceWillBeGarbageCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
}
impl->voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(variadicTestInterfaceWillBeGarbageCollectedArg);
}
@@ -6377,7 +6646,11 @@ static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedMethodA(longArg);
}
@@ -6389,8 +6662,13 @@ static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg1, toInt32(info[0], exceptionState), exceptionState);
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg2, toInt32(info[1], exceptionState), exceptionState);
+ int longArg1;
+ int longArg2;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg1, toInt32(info[0], exceptionState), exceptionState);
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg2, toInt32(info[1], exceptionState), exceptionState);
+ }
impl->overloadedMethodA(longArg1, longArg2);
}
@@ -6428,7 +6706,11 @@ static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedMethodB(longArg);
}
@@ -6440,12 +6722,17 @@ static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg1, toInt32(info[0], exceptionState), exceptionState);
- if (UNLIKELY(info.Length() <= 1)) {
- impl->overloadedMethodB(longArg1);
- return;
+ int longArg1;
+ int longArg2;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg1, toInt32(info[0], exceptionState), exceptionState);
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->overloadedMethodB(longArg1);
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg2, toInt32(info[1], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg2, toInt32(info[1], exceptionState), exceptionState);
impl->overloadedMethodB(longArg1, longArg2);
}
@@ -6483,7 +6770,11 @@ static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedMethodC(longArg);
}
@@ -6495,8 +6786,13 @@ static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
- TONATIVE_VOID(Vector<int>, longArgs, toNativeArguments<int>(info, 1));
+ int longArg;
+ Vector<int> longArgs;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ TONATIVE_VOID_NO_DECL(longArgs, toNativeArguments<int>(info, 1));
+ }
impl->overloadedMethodC(longArg, longArgs);
}
@@ -6534,7 +6830,11 @@ static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedMethodD(longArg);
}
@@ -6545,7 +6845,11 @@ static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->overloadedMethodD(testInterfaceEmptyArg);
}
@@ -6583,7 +6887,11 @@ static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedMethodE(longArg);
}
@@ -6594,7 +6902,11 @@ static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Vector<int>, longArrayArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
+ Vector<int> longArrayArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(longArrayArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
+ }
impl->overloadedMethodE(longArrayArg);
}
@@ -6632,7 +6944,11 @@ static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedMethodF(longArg);
}
@@ -6643,7 +6959,11 @@ static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->overloadedMethodF(testInterfaceEmptyOrNullArg);
}
@@ -6686,7 +7006,10 @@ static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, legacyOverloadStringStringArg, info[0]);
+ V8StringResource<> legacyOverloadStringStringArg;
+ {
+ TOSTRING_VOID_NO_DECL(legacyOverloadStringStringArg, info[0]);
+ }
impl->overloadedMethodG(legacyOverloadStringStringArg);
}
@@ -6723,11 +7046,14 @@ static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (info.Length() <= 0 || !info[0]->IsFunction()) {
- throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodH", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
- return;
+ OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
+ {
+ if (info.Length() <= 0 || !info[0]->IsFunction()) {
+ throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodH", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
+ return;
+ }
+ testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
- OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
impl->overloadedMethodH(testCallbackInterfaceArg.release());
}
@@ -6758,10 +7084,14 @@ static void overloadedMethodI1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(Dictionary, dictionaryArg, Dictionary(info[0], info.GetIsolate()));
- if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) {
- throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodI", "TestObject", "parameter 1 ('dictionaryArg') is not an object."), info.GetIsolate());
- return;
+ Dictionary dictionaryArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(dictionaryArg, Dictionary(info[0], info.GetIsolate()));
+ if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) {
+ throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodI", "TestObject", "parameter 1 ('dictionaryArg') is not an object."), info.GetIsolate());
+ return;
+ }
}
impl->overloadedMethodI(dictionaryArg);
}
@@ -6773,7 +7103,11 @@ static void overloadedMethodI2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(double, doubleArg, static_cast<double>(info[0]->NumberValue()));
+ double doubleArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(doubleArg, static_cast<double>(info[0]->NumberValue()));
+ }
impl->overloadedMethodI(doubleArg);
}
@@ -6811,7 +7145,11 @@ static void overloadedMethodJ1Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedMethodJ(longArg);
}
@@ -6822,7 +7160,11 @@ static void overloadedMethodJ2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->overloadedMethodJ(testInterfaceEmptyOrNullArg);
}
@@ -6872,7 +7214,11 @@ static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackIn
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedPerWorldBindingsMethod(longArg);
}
@@ -6904,7 +7250,11 @@ static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::Functi
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->overloadedPerWorldBindingsMethod(longArg);
}
@@ -6935,7 +7285,11 @@ static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Val
throwArityTypeError(exceptionState, 1, info.Length());
return;
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
TestObject::overloadedStaticMethod(longArg);
}
@@ -6946,8 +7300,13 @@ static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Val
throwArityTypeError(exceptionState, 2, info.Length());
return;
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg1, toInt32(info[0], exceptionState), exceptionState);
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg2, toInt32(info[1], exceptionState), exceptionState);
+ int longArg1;
+ int longArg2;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg1, toInt32(info[0], exceptionState), exceptionState);
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg2, toInt32(info[1], exceptionState), exceptionState);
+ }
TestObject::overloadedStaticMethod(longArg1, longArg2);
}
@@ -6986,9 +7345,13 @@ static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo
}
TestObject* impl = V8TestObject::toNative(info.Holder());
unsigned clampUnsignedShortArg = 0;
- TONATIVE_VOID(double, clampUnsignedShortArgNativeValue, info[0]->NumberValue());
- if (!std::isnan(clampUnsignedShortArgNativeValue))
- clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNativeValue);
+ {
+ v8::TryCatch block;
+ double clampUnsignedShortArgNativeValue;
+ TONATIVE_VOID_NO_DECL(clampUnsignedShortArgNativeValue, info[0]->NumberValue());
+ if (!std::isnan(clampUnsignedShortArgNativeValue))
+ clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNativeValue);
+ }
impl->voidMethodClampUnsignedShortArg(clampUnsignedShortArg);
}
@@ -7008,9 +7371,13 @@ static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo<
}
TestObject* impl = V8TestObject::toNative(info.Holder());
unsigned clampUnsignedLongArg = 0;
- TONATIVE_VOID(double, clampUnsignedLongArgNativeValue, info[0]->NumberValue());
- if (!std::isnan(clampUnsignedLongArgNativeValue))
- clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNativeValue);
+ {
+ v8::TryCatch block;
+ double clampUnsignedLongArgNativeValue;
+ TONATIVE_VOID_NO_DECL(clampUnsignedLongArgNativeValue, info[0]->NumberValue());
+ if (!std::isnan(clampUnsignedLongArgNativeValue))
+ clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNativeValue);
+ }
impl->voidMethodClampUnsignedLongArg(clampUnsignedLongArg);
}
@@ -7024,7 +7391,11 @@ static void voidMethodClampUnsignedLongArgMethodCallback(const v8::FunctionCallb
static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, defaultUndefinedTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(defaultUndefinedTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestInterfaceEmptyArg);
}
@@ -7039,7 +7410,11 @@ static void voidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackIn
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodDefaultUndefinedLongArg", "TestObject", info.Holder(), info.GetIsolate());
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, defaultUndefinedLongArg, toInt32(info[0], exceptionState), exceptionState);
+ int defaultUndefinedLongArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(defaultUndefinedLongArg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->voidMethodDefaultUndefinedLongArg(defaultUndefinedLongArg);
}
@@ -7053,7 +7428,10 @@ static void voidMethodDefaultUndefinedLongArgMethodCallback(const v8::FunctionCa
static void voidMethodDefaultUndefinedStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, defaultUndefinedStringArg, info[0]);
+ V8StringResource<> defaultUndefinedStringArg;
+ {
+ TOSTRING_VOID_NO_DECL(defaultUndefinedStringArg, info[0]);
+ }
impl->voidMethodDefaultUndefinedStringArg(defaultUndefinedStringArg);
}
@@ -7067,7 +7445,10 @@ static void voidMethodDefaultUndefinedStringArgMethodCallback(const v8::Function
static void voidMethodDefaultNullStringStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, defaultNullStringStringArg, argumentOrNull(info, 0));
+ V8StringResource<> defaultNullStringStringArg;
+ {
+ TOSTRING_VOID_NO_DECL(defaultNullStringStringArg, argumentOrNull(info, 0));
+ }
impl->voidMethodDefaultNullStringStringArg(defaultNullStringStringArg);
}
@@ -7086,7 +7467,11 @@ static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, enforceRangeLongArg, toInt32(info[0], EnforceRange, exceptionState), exceptionState);
+ int enforceRangeLongArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(enforceRangeLongArg, toInt32(info[0], EnforceRange, exceptionState), exceptionState);
+ }
impl->voidMethodEnforceRangeLongArg(enforceRangeLongArg);
}
@@ -7104,7 +7489,10 @@ static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCal
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<WithNullCheck>, treatNullAsNullStringStringArg, info[0]);
+ V8StringResource<WithNullCheck> treatNullAsNullStringStringArg;
+ {
+ TOSTRING_VOID_NO_DECL(treatNullAsNullStringStringArg, info[0]);
+ }
impl->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringArg);
}
@@ -7122,7 +7510,10 @@ static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<WithUndefinedOrNullCheck>, treatNullAsNullStringStringArg, info[0]);
+ V8StringResource<WithUndefinedOrNullCheck> treatNullAsNullStringStringArg;
+ {
+ TOSTRING_VOID_NO_DECL(treatNullAsNullStringStringArg, info[0]);
+ }
impl->voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg(treatNullAsNullStringStringArg);
}
@@ -7227,13 +7618,17 @@ static void callWithScriptStateScriptArgumentsVoidMethodMethodCallback(const v8:
static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- ScriptState* state = ScriptState::current(info.GetIsolate());
- RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1));
- impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(state, scriptArguments.release());
- return;
+ bool optionalBooleanArg;
+ {
+ v8::TryCatch block;
+ if (UNLIKELY(info.Length() <= 0)) {
+ ScriptState* state = ScriptState::current(info.GetIsolate());
+ RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1));
+ impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(state, scriptArguments.release());
+ return;
+ }
+ TONATIVE_VOID_NO_DECL(optionalBooleanArg, info[0]->BooleanValue());
}
- TONATIVE_VOID(bool, optionalBooleanArg, info[0]->BooleanValue());
ScriptState* state = ScriptState::current(info.GetIsolate());
RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1));
impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(state, scriptArguments.release(), optionalBooleanArg);
@@ -7438,7 +7833,11 @@ static void DeprecateAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exceptionState);
+ int arg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->DeprecateAsOverloadedMethod(arg);
}
@@ -7478,7 +7877,11 @@ static void DeprecateAsSameValueOverloadedMethod2Method(const v8::FunctionCallba
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exceptionState);
+ int arg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->DeprecateAsSameValueOverloadedMethod(arg);
}
@@ -7517,7 +7920,11 @@ static void measureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exceptionState);
+ int arg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->measureAsOverloadedMethod(arg);
}
@@ -7557,7 +7964,11 @@ static void measureAsSameValueOverloadedMethod2Method(const v8::FunctionCallback
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exceptionState);
+ int arg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->measureAsSameValueOverloadedMethod(arg);
}
@@ -7596,7 +8007,11 @@ static void deprecateAsMeasureAsSameValueOverloadedMethod2Method(const v8::Funct
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exceptionState);
+ int arg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->deprecateAsMeasureAsSameValueOverloadedMethod(arg);
}
@@ -7637,7 +8052,11 @@ static void deprecateAsSameValueMeasureAsOverloadedMethod2Method(const v8::Funct
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exceptionState);
+ int arg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->deprecateAsSameValueMeasureAsOverloadedMethod(arg);
}
@@ -7678,7 +8097,11 @@ static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(const
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exceptionState);
+ int arg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionState), exceptionState);
+ }
impl->deprecateAsSameValueMeasureAsSameValueOverloadedMethod(arg);
}
@@ -7763,7 +8186,11 @@ static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
}
@@ -7781,7 +8208,11 @@ static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
}
@@ -7896,13 +8327,17 @@ static void raisesExceptionVoidMethodOptionalLongArgMethod(const v8::FunctionCal
{
ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionVoidMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (UNLIKELY(info.Length() <= 0)) {
- impl->raisesExceptionVoidMethodOptionalLongArg(exceptionState);
- if (exceptionState.throwIfNeeded())
+ int optionalLongArg;
+ {
+ v8::TryCatch block;
+ if (UNLIKELY(info.Length() <= 0)) {
+ impl->raisesExceptionVoidMethodOptionalLongArg(exceptionState);
+ if (exceptionState.throwIfNeeded())
+ return;
return;
- return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
}
- TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
impl->raisesExceptionVoidMethodOptionalLongArg(optionalLongArg, exceptionState);
if (exceptionState.throwIfNeeded())
return;
@@ -7923,12 +8358,15 @@ static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(const v8::Fu
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (info.Length() <= 0 || !info[0]->IsFunction()) {
- exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
- exceptionState.throwIfNeeded();
- return;
+ OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
+ {
+ if (info.Length() <= 0 || !info[0]->IsFunction()) {
+ exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
- OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
impl->raisesExceptionVoidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release(), exceptionState);
if (exceptionState.throwIfNeeded())
return;
@@ -7946,13 +8384,15 @@ static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(cons
ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg", "TestObject", info.Holder(), info.GetIsolate());
TestObject* impl = V8TestObject::toNative(info.Holder());
OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg;
- if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
- if (!info[0]->IsFunction()) {
- exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
- exceptionState.throwIfNeeded();
- return;
+ {
+ if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
+ if (!info[0]->IsFunction()) {
+ exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
- optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
}
impl->raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg.release(), exceptionState);
if (exceptionState.throwIfNeeded())
@@ -7991,7 +8431,11 @@ static void callWithExecutionContextRaisesExceptionVoidMethodLongArgMethod(const
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState);
+ int longArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exceptionState), exceptionState);
+ }
ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
impl->callWithExecutionContextRaisesExceptionVoidMethodLongArg(scriptContext, longArg, exceptionState);
if (exceptionState.throwIfNeeded())
@@ -8103,11 +8547,15 @@ static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethod(const v8:
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
- throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
- return;
+ TestInterfaceEmpty* testInterfaceEmptyArg;
+ {
+ v8::TryCatch block;
+ if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
+ throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
+ return;
+ }
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
}
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
}
@@ -8125,7 +8573,11 @@ static void typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArgMethod(cons
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
+ }
impl->typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArg(testInterfaceEmptyOrNullArg);
}
@@ -8143,11 +8595,15 @@ static void typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArgMe
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- if (info.Length() > 0 && !isUndefinedOrNull(info[0]) && !V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
- throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
- return;
+ TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
+ {
+ v8::TryCatch block;
+ if (info.Length() > 0 && !isUndefinedOrNull(info[0]) && !V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
+ throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
+ return;
+ }
+ TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
}
- TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
impl->typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArg(testInterfaceEmptyOrNullArg);
}
@@ -8165,15 +8621,20 @@ static void typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMethod(const v8::
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(float, floatArg, static_cast<float>(info[0]->NumberValue()));
- if (!std::isfinite(floatArg)) {
- throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg", "TestObject", "float parameter 1 is non-finite."), info.GetIsolate());
- return;
- }
- TONATIVE_VOID(double, doubleArg, static_cast<double>(info[1]->NumberValue()));
- if (!std::isfinite(doubleArg)) {
- throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg", "TestObject", "double parameter 2 is non-finite."), info.GetIsolate());
- return;
+ float floatArg;
+ double doubleArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(floatArg, static_cast<float>(info[0]->NumberValue()));
+ if (!std::isfinite(floatArg)) {
+ throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg", "TestObject", "float parameter 1 is non-finite."), info.GetIsolate());
+ return;
+ }
+ TONATIVE_VOID_NO_DECL(doubleArg, static_cast<double>(info[1]->NumberValue()));
+ if (!std::isfinite(doubleArg)) {
+ throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg", "TestObject", "double parameter 2 is non-finite."), info.GetIsolate());
+ return;
+ }
}
impl->typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg(floatArg, doubleArg);
}
@@ -8205,7 +8666,11 @@ static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethod(const v8::F
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(HeapVector<Member<TestInterfaceGarbageCollected> >, testInterfaceGarbageCollectedSequenceArg, (toMemberNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(info[0], 1, info.GetIsolate())));
+ HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageCollectedSequenceArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceGarbageCollectedSequenceArg, (toMemberNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(info[0], 1, info.GetIsolate())));
+ }
impl->voidMethodTestInterfaceGarbageCollectedSequenceArg(testInterfaceGarbageCollectedSequenceArg);
}
@@ -8223,7 +8688,11 @@ static void voidMethodTestInterfaceGarbageCollectedArrayArgMethod(const v8::Func
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(HeapVector<Member<TestInterfaceGarbageCollected> >, testInterfaceGarbageCollectedArrayArg, (toMemberNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(info[0], 1, info.GetIsolate())));
+ HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageCollectedArrayArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceGarbageCollectedArrayArg, (toMemberNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(info[0], 1, info.GetIsolate())));
+ }
impl->voidMethodTestInterfaceGarbageCollectedArrayArg(testInterfaceGarbageCollectedArrayArg);
}
@@ -8241,7 +8710,11 @@ static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethod(const
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> >, testInterfaceWillBeGarbageCollectedSequenceArg, (toRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
+ WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > testInterfaceWillBeGarbageCollectedSequenceArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceWillBeGarbageCollectedSequenceArg, (toRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
+ }
impl->voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg(testInterfaceWillBeGarbageCollectedSequenceArg);
}
@@ -8259,7 +8732,11 @@ static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethod(const v8
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TONATIVE_VOID(WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> >, testInterfaceWillBeGarbageCollectedArrayArg, (toRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
+ WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > testInterfaceWillBeGarbageCollectedArrayArg;
+ {
+ v8::TryCatch block;
+ TONATIVE_VOID_NO_DECL(testInterfaceWillBeGarbageCollectedArrayArg, (toRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
+ }
impl->voidMethodTestInterfaceWillBeGarbageCollectedArrayArg(testInterfaceWillBeGarbageCollectedArrayArg);
}
« Source/bindings/scripts/v8_methods.py ('K') | « Source/bindings/tests/results/V8TestInterfaceWillBeGarbageCollected.cpp ('k') | Source/bindings/tests/results/V8TestSpecialOperations.cpp » ('j') | Source/bindings/v8/V8BindingMacros.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698