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

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: 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/templates/methods.cpp ('K') | « Source/bindings/tests/results/V8TestInterfaceWillBeGarbageCollected.cpp ('k') | Source/bindings/tests/results/V8TestSpecialOperations.cpp » ('j') | no next file with comments »
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..52b0513c604624d4f91f99bb5e3dba6fed1e73dd 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,11 @@ static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, stringArg, info[0]);
+ V8StringResource<> stringArg;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(stringArg, info[0]);
+ }
impl->voidMethodStringArg(stringArg);
}
@@ -4795,7 +4803,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 +4825,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 +4848,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 +4870,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 +4892,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 +4915,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 +4938,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 +4961,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 +4984,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 +5007,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 +5030,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 +5053,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 +5088,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 +5111,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 +5161,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 +5183,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 +5231,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 +5253,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 +5275,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 +5297,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 +5319,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 +5341,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 +5363,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 +5385,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 +5407,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 +5494,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 +5516,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 +5538,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 +5560,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 +5582,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 +5604,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 +5665,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 +5687,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 +5709,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 +5770,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 +5792,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 +5814,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 +5836,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 +5858,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 +5880,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 +5906,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 +5944,15 @@ 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;
+ {
+ v8::TryCatch block;
+ 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 +6036,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 +6063,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 +6086,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 +6108,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 +6135,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 +6158,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 +6180,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 +6203,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 +6223,15 @@ 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;
+ {
+ v8::TryCatch block;
+ 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 +6245,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 +6268,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 +6291,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 +6314,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 +6337,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 +6364,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 +6393,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 +6428,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 +6457,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 +6481,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 +6503,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 +6525,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 +6546,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 +6572,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 +6599,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 +6622,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 +6649,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 +6665,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 +6709,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 +6725,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 +6773,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 +6789,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 +6833,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 +6848,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 +6890,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 +6905,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 +6947,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 +6962,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 +7009,11 @@ static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<>, legacyOverloadStringStringArg, info[0]);
+ V8StringResource<> legacyOverloadStringStringArg;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(legacyOverloadStringStringArg, info[0]);
+ }
impl->overloadedMethodG(legacyOverloadStringStringArg);
}
@@ -6723,11 +7050,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 +7088,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 +7107,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 +7149,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 +7164,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 +7218,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 +7254,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 +7289,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 +7304,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 +7349,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 +7375,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 +7395,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 +7414,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 +7432,11 @@ 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;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(defaultUndefinedStringArg, info[0]);
+ }
impl->voidMethodDefaultUndefinedStringArg(defaultUndefinedStringArg);
}
@@ -7067,7 +7450,11 @@ 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;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(defaultNullStringStringArg, argumentOrNull(info, 0));
+ }
impl->voidMethodDefaultNullStringStringArg(defaultNullStringStringArg);
}
@@ -7086,7 +7473,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 +7495,11 @@ static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCal
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<WithNullCheck>, treatNullAsNullStringStringArg, info[0]);
+ V8StringResource<WithNullCheck> treatNullAsNullStringStringArg;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(treatNullAsNullStringStringArg, info[0]);
+ }
impl->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringArg);
}
@@ -7122,7 +7517,11 @@ static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe
return;
}
TestObject* impl = V8TestObject::toNative(info.Holder());
- TOSTRING_VOID(V8StringResource<WithUndefinedOrNullCheck>, treatNullAsNullStringStringArg, info[0]);
+ V8StringResource<WithUndefinedOrNullCheck> treatNullAsNullStringStringArg;
+ {
+ v8::TryCatch block;
+ TOSTRING_VOID_NO_DECL(treatNullAsNullStringStringArg, info[0]);
+ }
impl->voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg(treatNullAsNullStringStringArg);
}
@@ -7227,13 +7626,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 +7841,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 +7885,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 +7928,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 +7972,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 +8015,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 +8060,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 +8105,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 +8194,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 +8216,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 +8335,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 +8366,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 +8392,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 +8439,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 +8555,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 +8581,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 +8603,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 +8629,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 +8674,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 +8696,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 +8718,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 +8740,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/templates/methods.cpp ('K') | « Source/bindings/tests/results/V8TestInterfaceWillBeGarbageCollected.cpp ('k') | Source/bindings/tests/results/V8TestSpecialOperations.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698