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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: Source/bindings/tests/results/core/V8TestDictionary.cpp

Issue 946973005: IDL: Drop value conversion (V8 -> C++) macros from generated code (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: minor cleanup Created 5 years, 10 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/tests/results/core/UnionTypesCore.cpp ('K') | « Source/bindings/tests/results/core/V8TestDictionary.h ('k') | Source/bindings/tests/results/core/V8TestDictionaryDerived.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: Source/bindings/tests/results/core/V8TestDictionary.cpp
diff --git a/Source/bindings/tests/results/core/V8TestDictionary.cpp b/Source/bindings/tests/results/core/V8TestDictionary.cpp
index 70e599ef997c57c070221fdb26795c9dcac46c96..06c48545a2cf1f1ffd463f3d9859a85c2af79d06 100644
--- a/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -22,13 +22,13 @@
namespace blink {
-void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
+bool V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
{
if (isUndefinedOrNull(v8Value))
- return;
+ return true;
if (!v8Value->IsObject()) {
exceptionState.throwTypeError("cannot convert to dictionary.");
- return;
+ return false;
}
v8::Local<v8::Object> v8Object = v8Value->ToObject(isolate);
@@ -36,7 +36,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> booleanMemberValue = v8Object->Get(v8String(isolate, "booleanMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
// Do nothing.
@@ -48,7 +48,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> createValue = v8Object->Get(v8String(isolate, "create"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (createValue.IsEmpty() || createValue->IsUndefined()) {
// Do nothing.
@@ -60,7 +60,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> deprecatedCreateMemberValue = v8Object->Get(v8String(isolate, "deprecatedCreateMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (deprecatedCreateMemberValue.IsEmpty() || deprecatedCreateMemberValue->IsUndefined()) {
// Do nothing.
@@ -73,34 +73,37 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> doubleOrNullMemberValue = v8Object->Get(v8String(isolate, "doubleOrNullMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
// Do nothing.
} else if (doubleOrNullMemberValue->IsNull()) {
impl.setDoubleOrNullMemberToNull();
} else {
- TONATIVE_VOID_EXCEPTIONSTATE(double, doubleOrNullMember, toDouble(doubleOrNullMemberValue, exceptionState), exceptionState);
+ double doubleOrNullMember = toDouble(doubleOrNullMemberValue, exceptionState);
+ if (exceptionState.hadException())
+ return false;
impl.setDoubleOrNullMember(doubleOrNullMember);
}
v8::Local<v8::Value> doubleOrStringMemberValue = v8Object->Get(v8String(isolate, "doubleOrStringMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
// Do nothing.
} else {
DoubleOrString doubleOrStringMember;
- TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState), exceptionState);
+ if (!V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState))
+ return false;
impl.setDoubleOrStringMember(doubleOrStringMember);
}
v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
// Do nothing.
@@ -110,7 +113,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
if (!elementOrNullMember && !elementOrNullMemberValue->IsNull()) {
exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
- return;
+ return false;
}
impl.setElementOrNullMember(elementOrNullMember);
}
@@ -118,16 +121,18 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> enumMemberValue = v8Object->Get(v8String(isolate, "enumMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
+ V8StringResource<> enumMember = enumMemberValue;
+ if (!enumMember.prepare(exceptionState))
+ return false;
String string = enumMember;
if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
exceptionState.throwTypeError("member enumMember ('" + string + "') is not a valid enum value.");
- return;
+ return false;
}
impl.setEnumMember(enumMember);
}
@@ -135,7 +140,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> eventTargetMemberValue = v8Object->Get(v8String(isolate, "eventTargetMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (eventTargetMemberValue.IsEmpty() || eventTargetMemberValue->IsUndefined()) {
// Do nothing.
@@ -143,7 +148,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
EventTarget* eventTargetMember = toEventTarget(isolate, eventTargetMemberValue);
if (!eventTargetMember && !eventTargetMemberValue->IsNull()) {
exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
- return;
+ return false;
}
impl.setEventTargetMember(eventTargetMember);
}
@@ -151,31 +156,35 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TONATIVE_VOID_EXCEPTIONSTATE(Vector<InternalDictionary>, internalDictionarySequenceMember, toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+ Vector<InternalDictionary> internalDictionarySequenceMember = toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
+ return false;
impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
}
v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
+ int longMember = toInt32(longMemberValue, exceptionState);
+ if (exceptionState.hadException())
+ return false;
impl.setLongMember(longMember);
}
v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
// Do nothing.
@@ -183,7 +192,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
if (!objectMember.isObject()) {
exceptionState.throwTypeError("member objectMember is not an object.");
- return;
+ return false;
}
impl.setObjectMember(objectMember);
}
@@ -191,7 +200,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> objectOrNullMemberValue = v8Object->Get(v8String(isolate, "objectOrNullMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (objectOrNullMemberValue.IsEmpty() || objectOrNullMemberValue->IsUndefined()) {
// Do nothing.
@@ -201,7 +210,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
if (!objectOrNullMember.isObject()) {
exceptionState.throwTypeError("member objectOrNullMember is not an object.");
- return;
+ return false;
}
impl.setObjectOrNullMember(objectOrNullMember);
}
@@ -209,95 +218,107 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> otherDoubleOrStringMemberValue = v8Object->Get(v8String(isolate, "otherDoubleOrStringMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
// Do nothing.
} else {
DoubleOrString otherDoubleOrStringMember;
- TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState), exceptionState);
+ if (!V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState))
+ return false;
impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
}
v8::Local<v8::Value> restrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "restrictedDoubleMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (restrictedDoubleMemberValue.IsEmpty() || restrictedDoubleMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TONATIVE_VOID_EXCEPTIONSTATE(double, restrictedDoubleMember, toRestrictedDouble(restrictedDoubleMemberValue, exceptionState), exceptionState);
+ double restrictedDoubleMember = toRestrictedDouble(restrictedDoubleMemberValue, exceptionState);
+ if (exceptionState.hadException())
+ return false;
impl.setRestrictedDoubleMember(restrictedDoubleMember);
}
v8::Local<v8::Value> stringArrayMemberValue = v8Object->Get(v8String(isolate, "stringArrayMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
+ Vector<String> stringArrayMember = toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
+ return false;
impl.setStringArrayMember(stringArrayMember);
}
v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
+ V8StringResource<> stringMember = stringMemberValue;
+ if (!stringMember.prepare(exceptionState))
+ return false;
impl.setStringMember(stringMember);
}
v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
// Do nothing.
} else if (stringOrNullMemberValue->IsNull()) {
impl.setStringOrNullMemberToNull();
} else {
- TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
+ V8StringResource<> stringOrNullMember = stringOrNullMemberValue;
+ if (!stringOrNullMember.prepare(exceptionState))
+ return false;
impl.setStringOrNullMember(stringOrNullMember);
}
v8::Local<v8::Value> stringSequenceMemberValue = v8Object->Get(v8String(isolate, "stringSequenceMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+ Vector<String> stringSequenceMember = toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
+ return false;
impl.setStringSequenceMember(stringSequenceMember);
}
v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue = v8Object->Get(v8String(isolate, "testInterface2OrUint8ArrayMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
// Do nothing.
} else {
TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
- TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState), exceptionState);
+ if (!V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState))
+ return false;
impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
}
v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
// Do nothing.
@@ -305,7 +326,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
if (!testInterfaceGarbageCollectedMember && !testInterfaceGarbageCollectedMemberValue->IsNull()) {
exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
- return;
+ return false;
}
impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
}
@@ -313,7 +334,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
// Do nothing.
@@ -323,7 +344,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
if (!testInterfaceGarbageCollectedOrNullMember && !testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
- return;
+ return false;
}
impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
}
@@ -331,7 +352,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> testInterfaceMemberValue = v8Object->Get(v8String(isolate, "testInterfaceMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
// Do nothing.
@@ -339,7 +360,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
if (!testInterfaceMember && !testInterfaceMemberValue->IsNull()) {
exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
- return;
+ return false;
}
impl.setTestInterfaceMember(testInterfaceMember);
}
@@ -347,7 +368,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> testInterfaceOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceOrNullMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
// Do nothing.
@@ -357,7 +378,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
if (!testInterfaceOrNullMember && !testInterfaceOrNullMemberValue->IsNull()) {
exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
- return;
+ return false;
}
impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
}
@@ -365,7 +386,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (testInterfaceWillBeGarbageCollectedMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedMemberValue->IsUndefined()) {
// Do nothing.
@@ -373,7 +394,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
if (!testInterfaceWillBeGarbageCollectedMember && !testInterfaceWillBeGarbageCollectedMemberValue->IsNull()) {
exceptionState.throwTypeError("member testInterfaceWillBeGarbageCollectedMember is not of type TestInterfaceWillBeGarbageCollected.");
- return;
+ return false;
}
impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
}
@@ -381,7 +402,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsUndefined()) {
// Do nothing.
@@ -391,7 +412,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
if (!testInterfaceWillBeGarbageCollectedOrNullMember && !testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsNull()) {
exceptionState.throwTypeError("member testInterfaceWillBeGarbageCollectedOrNullMember is not of type TestInterfaceWillBeGarbageCollected.");
- return;
+ return false;
}
impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
}
@@ -399,7 +420,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> uint8ArrayMemberValue = v8Object->Get(v8String(isolate, "uint8ArrayMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (uint8ArrayMemberValue.IsEmpty() || uint8ArrayMemberValue->IsUndefined()) {
// Do nothing.
@@ -407,7 +428,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
DOMUint8Array* uint8ArrayMember = uint8ArrayMemberValue->IsUint8Array() ? V8Uint8Array::toImpl(v8::Local<v8::Uint8Array>::Cast(uint8ArrayMemberValue)) : 0;
if (!uint8ArrayMember && !uint8ArrayMemberValue->IsNull()) {
exceptionState.throwTypeError("member uint8ArrayMember is not of type Uint8Array.");
- return;
+ return false;
}
impl.setUint8ArrayMember(uint8ArrayMember);
}
@@ -415,15 +436,18 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
v8::Local<v8::Value> unrestrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "unrestrictedDoubleMember"));
if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
- return;
+ return false;
}
if (unrestrictedDoubleMemberValue.IsEmpty() || unrestrictedDoubleMemberValue->IsUndefined()) {
// Do nothing.
} else {
- TONATIVE_VOID_EXCEPTIONSTATE(double, unrestrictedDoubleMember, toDouble(unrestrictedDoubleMemberValue, exceptionState), exceptionState);
+ double unrestrictedDoubleMember = toDouble(unrestrictedDoubleMemberValue, exceptionState);
+ if (exceptionState.hadException())
+ return false;
impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
}
+ return true;
}
v8::Local<v8::Value> toV8(const TestDictionary& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
« Source/bindings/tests/results/core/UnionTypesCore.cpp ('K') | « Source/bindings/tests/results/core/V8TestDictionary.h ('k') | Source/bindings/tests/results/core/V8TestDictionaryDerived.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698