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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2029423002: Clean up V8 bindings template code (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@2743
Patch Set: Created 4 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
« no previous file with comments | « third_party/WebKit/Source/bindings/templates/interface_base.cpp ('k') | third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionaryDerived.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp b/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
index 94d0bb88e640aaffd72242dfc2bad48f8eae3a6e..660836089f99c4eb733cb6d7aec2dd23f56e9ac6 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -41,327 +41,291 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- {
- v8::Local<v8::Value> anyMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "anyMember")).ToLocal(&anyMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
- return;
- }
- if (anyMemberValue.IsEmpty() || anyMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- ScriptValue anyMember = ScriptValue(ScriptState::current(isolate), anyMemberValue);
- impl.setAnyMember(anyMember);
- }
+ v8::Local<v8::Value> anyMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "anyMember")).ToLocal(&anyMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (anyMemberValue.IsEmpty() || anyMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ ScriptValue anyMember = ScriptValue(ScriptState::current(isolate), anyMemberValue);
+ impl.setAnyMember(anyMember);
}
- {
- v8::Local<v8::Value> booleanMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "booleanMember")).ToLocal(&booleanMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> booleanMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "booleanMember")).ToLocal(&booleanMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ bool booleanMember = toBoolean(isolate, booleanMemberValue, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- bool booleanMember = toBoolean(isolate, booleanMemberValue, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setBooleanMember(booleanMember);
- }
+ impl.setBooleanMember(booleanMember);
}
- {
- v8::Local<v8::Value> createValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "create")).ToLocal(&createValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> createValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "create")).ToLocal(&createValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (createValue.IsEmpty() || createValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ bool create = toBoolean(isolate, createValue, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (createValue.IsEmpty() || createValue->IsUndefined()) {
- // Do nothing.
- } else {
- bool create = toBoolean(isolate, createValue, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setCreateMember(create);
- }
+ impl.setCreateMember(create);
}
- {
- v8::Local<v8::Value> deprecatedCreateMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "deprecatedCreateMember")).ToLocal(&deprecatedCreateMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> deprecatedCreateMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "deprecatedCreateMember")).ToLocal(&deprecatedCreateMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (deprecatedCreateMemberValue.IsEmpty() || deprecatedCreateMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ Deprecation::countDeprecationIfNotPrivateScript(isolate, currentExecutionContext(isolate), UseCounter::CreateMember);
+ bool deprecatedCreateMember = toBoolean(isolate, deprecatedCreateMemberValue, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (deprecatedCreateMemberValue.IsEmpty() || deprecatedCreateMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- Deprecation::countDeprecationIfNotPrivateScript(isolate, currentExecutionContext(isolate), UseCounter::CreateMember);
- bool deprecatedCreateMember = toBoolean(isolate, deprecatedCreateMemberValue, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setCreateMember(deprecatedCreateMember);
- }
+ impl.setCreateMember(deprecatedCreateMember);
}
- {
- v8::Local<v8::Value> dictionaryMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "dictionaryMember")).ToLocal(&dictionaryMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> dictionaryMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "dictionaryMember")).ToLocal(&dictionaryMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (dictionaryMemberValue.IsEmpty() || dictionaryMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ Dictionary dictionaryMember = Dictionary(dictionaryMemberValue, isolate, exceptionState);
+ if (exceptionState.hadException())
+ return;
+ if (!dictionaryMember.isObject()) {
+ exceptionState.throwTypeError("member dictionaryMember is not an object.");
return;
}
- if (dictionaryMemberValue.IsEmpty() || dictionaryMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- Dictionary dictionaryMember = Dictionary(dictionaryMemberValue, isolate, exceptionState);
- if (exceptionState.hadException())
- return;
- if (!dictionaryMember.isObject()) {
- exceptionState.throwTypeError("member dictionaryMember is not an object.");
- return;
- }
- impl.setDictionaryMember(dictionaryMember);
- }
+ impl.setDictionaryMember(dictionaryMember);
}
- {
- v8::Local<v8::Value> doubleOrNullMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "doubleOrNullMember")).ToLocal(&doubleOrNullMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> doubleOrNullMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "doubleOrNullMember")).ToLocal(&doubleOrNullMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (doubleOrNullMemberValue->IsNull()) {
+ impl.setDoubleOrNullMemberToNull();
+ } else {
+ double doubleOrNullMember = toRestrictedDouble(isolate, doubleOrNullMemberValue, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
- // Do nothing.
- } else if (doubleOrNullMemberValue->IsNull()) {
- impl.setDoubleOrNullMemberToNull();
- } else {
- double doubleOrNullMember = toRestrictedDouble(isolate, doubleOrNullMemberValue, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setDoubleOrNullMember(doubleOrNullMember);
- }
+ impl.setDoubleOrNullMember(doubleOrNullMember);
}
- {
- v8::Local<v8::Value> doubleOrStringMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringMember")).ToLocal(&doubleOrStringMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> doubleOrStringMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringMember")).ToLocal(&doubleOrStringMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ DoubleOrString doubleOrStringMember;
+ V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, UnionTypeConversionMode::NotNullable, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- DoubleOrString doubleOrStringMember;
- V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, UnionTypeConversionMode::NotNullable, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setDoubleOrStringMember(doubleOrStringMember);
- }
+ impl.setDoubleOrStringMember(doubleOrStringMember);
}
- {
- v8::Local<v8::Value> doubleOrStringSequenceMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringSequenceMember")).ToLocal(&doubleOrStringSequenceMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> doubleOrStringSequenceMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringSequenceMember")).ToLocal(&doubleOrStringSequenceMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (doubleOrStringSequenceMemberValue.IsEmpty() || doubleOrStringSequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ HeapVector<DoubleOrString> doubleOrStringSequenceMember = toImplArray<HeapVector<DoubleOrString>>(doubleOrStringSequenceMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (doubleOrStringSequenceMemberValue.IsEmpty() || doubleOrStringSequenceMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- HeapVector<DoubleOrString> doubleOrStringSequenceMember = toImplArray<HeapVector<DoubleOrString>>(doubleOrStringSequenceMemberValue, 0, isolate, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setDoubleOrStringSequenceMember(doubleOrStringSequenceMember);
- }
+ impl.setDoubleOrStringSequenceMember(doubleOrStringSequenceMember);
}
- {
- v8::Local<v8::Value> elementOrNullMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "elementOrNullMember")).ToLocal(&elementOrNullMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> elementOrNullMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "elementOrNullMember")).ToLocal(&elementOrNullMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (elementOrNullMemberValue->IsNull()) {
+ impl.setElementOrNullMemberToNull();
+ } else {
+ Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
+ if (!elementOrNullMember && !elementOrNullMemberValue->IsNull()) {
+ exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
return;
}
- if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
- // Do nothing.
- } else if (elementOrNullMemberValue->IsNull()) {
- impl.setElementOrNullMemberToNull();
- } else {
- Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
- if (!elementOrNullMember && !elementOrNullMemberValue->IsNull()) {
- exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
- return;
- }
- impl.setElementOrNullMember(elementOrNullMember);
- }
+ impl.setElementOrNullMember(elementOrNullMember);
}
- {
- v8::Local<v8::Value> enumMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "enumMember")).ToLocal(&enumMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> enumMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "enumMember")).ToLocal(&enumMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ V8StringResource<> enumMember = enumMemberValue;
+ if (!enumMember.prepare(exceptionState))
return;
- }
- if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- V8StringResource<> enumMember = enumMemberValue;
- if (!enumMember.prepare(exceptionState))
- return;
- const char* validValues[] = {
- "",
- "EnumValue1",
- "EnumValue2",
- "EnumValue3",
- };
- if (!isValidEnum(enumMember, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", exceptionState))
- return;
- impl.setEnumMember(enumMember);
- }
+ const char* validValues[] = {
+ "",
+ "EnumValue1",
+ "EnumValue2",
+ "EnumValue3",
+ };
+ if (!isValidEnum(enumMember, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", exceptionState))
+ return;
+ impl.setEnumMember(enumMember);
}
- {
- v8::Local<v8::Value> enumSequenceMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "enumSequenceMember")).ToLocal(&enumSequenceMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> enumSequenceMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "enumSequenceMember")).ToLocal(&enumSequenceMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (enumSequenceMemberValue.IsEmpty() || enumSequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ Vector<String> enumSequenceMember = toImplArray<Vector<String>>(enumSequenceMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (enumSequenceMemberValue.IsEmpty() || enumSequenceMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- Vector<String> enumSequenceMember = toImplArray<Vector<String>>(enumSequenceMemberValue, 0, isolate, exceptionState);
- if (exceptionState.hadException())
- return;
- const char* validValues[] = {
- "",
- "EnumValue1",
- "EnumValue2",
- "EnumValue3",
- };
- if (!isValidEnum(enumSequenceMember, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", exceptionState))
- return;
- impl.setEnumSequenceMember(enumSequenceMember);
- }
+ const char* validValues[] = {
+ "",
+ "EnumValue1",
+ "EnumValue2",
+ "EnumValue3",
+ };
+ if (!isValidEnum(enumSequenceMember, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", exceptionState))
+ return;
+ impl.setEnumSequenceMember(enumSequenceMember);
}
- {
- v8::Local<v8::Value> eventTargetMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "eventTargetMember")).ToLocal(&eventTargetMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> eventTargetMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "eventTargetMember")).ToLocal(&eventTargetMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (eventTargetMemberValue.IsEmpty() || eventTargetMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ EventTarget* eventTargetMember = toEventTarget(isolate, eventTargetMemberValue);
+ if (!eventTargetMember && !eventTargetMemberValue->IsNull()) {
+ exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
return;
}
- if (eventTargetMemberValue.IsEmpty() || eventTargetMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- EventTarget* eventTargetMember = toEventTarget(isolate, eventTargetMemberValue);
- if (!eventTargetMember && !eventTargetMemberValue->IsNull()) {
- exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
- return;
- }
- impl.setEventTargetMember(eventTargetMember);
- }
+ impl.setEventTargetMember(eventTargetMember);
}
- {
- v8::Local<v8::Value> internalDictionarySequenceMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "internalDictionarySequenceMember")).ToLocal(&internalDictionarySequenceMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> internalDictionarySequenceMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "internalDictionarySequenceMember")).ToLocal(&internalDictionarySequenceMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ HeapVector<InternalDictionary> internalDictionarySequenceMember = toImplArray<HeapVector<InternalDictionary>>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- HeapVector<InternalDictionary> internalDictionarySequenceMember = toImplArray<HeapVector<InternalDictionary>>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
- }
+ impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
}
- {
- v8::Local<v8::Value> longMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "longMember")).ToLocal(&longMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> longMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "longMember")).ToLocal(&longMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ int longMember = toInt32(isolate, longMemberValue, NormalConversion, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- int longMember = toInt32(isolate, longMemberValue, NormalConversion, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setLongMember(longMember);
- }
+ impl.setLongMember(longMember);
}
- {
- v8::Local<v8::Value> objectMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "objectMember")).ToLocal(&objectMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> objectMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "objectMember")).ToLocal(&objectMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
+ if (!objectMember.isObject()) {
+ exceptionState.throwTypeError("member objectMember is not an object.");
return;
}
- if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
- if (!objectMember.isObject()) {
- exceptionState.throwTypeError("member objectMember is not an object.");
- return;
- }
- impl.setObjectMember(objectMember);
- }
+ impl.setObjectMember(objectMember);
}
- {
- v8::Local<v8::Value> objectOrNullMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "objectOrNullMember")).ToLocal(&objectOrNullMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> objectOrNullMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "objectOrNullMember")).ToLocal(&objectOrNullMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (objectOrNullMemberValue.IsEmpty() || objectOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (objectOrNullMemberValue->IsNull()) {
+ impl.setObjectOrNullMemberToNull();
+ } else {
+ ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
+ if (!objectOrNullMember.isObject()) {
+ exceptionState.throwTypeError("member objectOrNullMember is not an object.");
return;
}
- if (objectOrNullMemberValue.IsEmpty() || objectOrNullMemberValue->IsUndefined()) {
- // Do nothing.
- } else if (objectOrNullMemberValue->IsNull()) {
- impl.setObjectOrNullMemberToNull();
- } else {
- ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
- if (!objectOrNullMember.isObject()) {
- exceptionState.throwTypeError("member objectOrNullMember is not an object.");
- return;
- }
- impl.setObjectOrNullMember(objectOrNullMember);
- }
+ impl.setObjectOrNullMember(objectOrNullMember);
}
- {
- v8::Local<v8::Value> otherDoubleOrStringMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "otherDoubleOrStringMember")).ToLocal(&otherDoubleOrStringMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> otherDoubleOrStringMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "otherDoubleOrStringMember")).ToLocal(&otherDoubleOrStringMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ DoubleOrString otherDoubleOrStringMember;
+ V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, UnionTypeConversionMode::NotNullable, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- DoubleOrString otherDoubleOrStringMember;
- V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, UnionTypeConversionMode::NotNullable, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
- }
+ impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
}
- {
- v8::Local<v8::Value> restrictedDoubleMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "restrictedDoubleMember")).ToLocal(&restrictedDoubleMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> restrictedDoubleMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "restrictedDoubleMember")).ToLocal(&restrictedDoubleMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (restrictedDoubleMemberValue.IsEmpty() || restrictedDoubleMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ double restrictedDoubleMember = toRestrictedDouble(isolate, restrictedDoubleMemberValue, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (restrictedDoubleMemberValue.IsEmpty() || restrictedDoubleMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- double restrictedDoubleMember = toRestrictedDouble(isolate, restrictedDoubleMemberValue, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setRestrictedDoubleMember(restrictedDoubleMember);
- }
+ impl.setRestrictedDoubleMember(restrictedDoubleMember);
}
if (RuntimeEnabledFeatures::runtimeFeatureEnabled()) {
@@ -380,229 +344,203 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
}
}
- {
- v8::Local<v8::Value> stringArrayMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringArrayMember")).ToLocal(&stringArrayMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> stringArrayMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringArrayMember")).ToLocal(&stringArrayMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ Vector<String> stringArrayMember = toImplArray<Vector<String>>(stringArrayMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- Vector<String> stringArrayMember = toImplArray<Vector<String>>(stringArrayMemberValue, 0, isolate, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setStringArrayMember(stringArrayMember);
- }
+ impl.setStringArrayMember(stringArrayMember);
}
- {
- v8::Local<v8::Value> stringMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringMember")).ToLocal(&stringMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> stringMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringMember")).ToLocal(&stringMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ V8StringResource<> stringMember = stringMemberValue;
+ if (!stringMember.prepare(exceptionState))
return;
- }
- if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- V8StringResource<> stringMember = stringMemberValue;
- if (!stringMember.prepare(exceptionState))
- return;
- impl.setStringMember(stringMember);
- }
+ impl.setStringMember(stringMember);
}
- {
- v8::Local<v8::Value> stringOrNullMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringOrNullMember")).ToLocal(&stringOrNullMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> stringOrNullMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringOrNullMember")).ToLocal(&stringOrNullMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (stringOrNullMemberValue->IsNull()) {
+ impl.setStringOrNullMemberToNull();
+ } else {
+ V8StringResource<> stringOrNullMember = stringOrNullMemberValue;
+ if (!stringOrNullMember.prepare(exceptionState))
return;
- }
- if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
- // Do nothing.
- } else if (stringOrNullMemberValue->IsNull()) {
- impl.setStringOrNullMemberToNull();
- } else {
- V8StringResource<> stringOrNullMember = stringOrNullMemberValue;
- if (!stringOrNullMember.prepare(exceptionState))
- return;
- impl.setStringOrNullMember(stringOrNullMember);
- }
+ impl.setStringOrNullMember(stringOrNullMember);
}
- {
- v8::Local<v8::Value> stringSequenceMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringSequenceMember")).ToLocal(&stringSequenceMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> stringSequenceMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "stringSequenceMember")).ToLocal(&stringSequenceMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ Vector<String> stringSequenceMember = toImplArray<Vector<String>>(stringSequenceMemberValue, 0, isolate, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- Vector<String> stringSequenceMember = toImplArray<Vector<String>>(stringSequenceMemberValue, 0, isolate, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setStringSequenceMember(stringSequenceMember);
- }
+ impl.setStringSequenceMember(stringSequenceMember);
}
- {
- v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterface2OrUint8ArrayMember")).ToLocal(&testInterface2OrUint8ArrayMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterface2OrUint8ArrayMember")).ToLocal(&testInterface2OrUint8ArrayMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
+ V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, UnionTypeConversionMode::NotNullable, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
- V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, UnionTypeConversionMode::NotNullable, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
- }
+ impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
}
- {
- v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedMember")).ToLocal(&testInterfaceGarbageCollectedMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedMember")).ToLocal(&testInterfaceGarbageCollectedMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
+ if (!testInterfaceGarbageCollectedMember && !testInterfaceGarbageCollectedMemberValue->IsNull()) {
+ exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
return;
}
- if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
- if (!testInterfaceGarbageCollectedMember && !testInterfaceGarbageCollectedMemberValue->IsNull()) {
- exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
- return;
- }
- impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
- }
+ impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
}
- {
- v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedOrNullMember")).ToLocal(&testInterfaceGarbageCollectedOrNullMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedOrNullMember")).ToLocal(&testInterfaceGarbageCollectedOrNullMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
+ impl.setTestInterfaceGarbageCollectedOrNullMemberToNull();
+ } else {
+ TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
+ if (!testInterfaceGarbageCollectedOrNullMember && !testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
+ exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
return;
}
- if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
- // Do nothing.
- } else if (testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
- impl.setTestInterfaceGarbageCollectedOrNullMemberToNull();
- } else {
- TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
- if (!testInterfaceGarbageCollectedOrNullMember && !testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
- exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
- return;
- }
- impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
- }
+ impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
}
- {
- v8::Local<v8::Value> testInterfaceGarbageCollectedSequenceMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedSequenceMember")).ToLocal(&testInterfaceGarbageCollectedSequenceMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> testInterfaceGarbageCollectedSequenceMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedSequenceMember")).ToLocal(&testInterfaceGarbageCollectedSequenceMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (testInterfaceGarbageCollectedSequenceMemberValue.IsEmpty() || testInterfaceGarbageCollectedSequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ HeapVector<Member<TestInterfaceGarbageCollected>> testInterfaceGarbageCollectedSequenceMember = (toMemberNativeArray<TestInterfaceGarbageCollected>(testInterfaceGarbageCollectedSequenceMemberValue, 0, isolate, exceptionState));
+ if (exceptionState.hadException())
return;
- }
- if (testInterfaceGarbageCollectedSequenceMemberValue.IsEmpty() || testInterfaceGarbageCollectedSequenceMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- HeapVector<Member<TestInterfaceGarbageCollected>> testInterfaceGarbageCollectedSequenceMember = (toMemberNativeArray<TestInterfaceGarbageCollected>(testInterfaceGarbageCollectedSequenceMemberValue, 0, isolate, exceptionState));
- if (exceptionState.hadException())
- return;
- impl.setTestInterfaceGarbageCollectedSequenceMember(testInterfaceGarbageCollectedSequenceMember);
- }
+ impl.setTestInterfaceGarbageCollectedSequenceMember(testInterfaceGarbageCollectedSequenceMember);
}
- {
- v8::Local<v8::Value> testInterfaceMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceMember")).ToLocal(&testInterfaceMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> testInterfaceMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceMember")).ToLocal(&testInterfaceMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
+ if (!testInterfaceMember && !testInterfaceMemberValue->IsNull()) {
+ exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
return;
}
- if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
- if (!testInterfaceMember && !testInterfaceMemberValue->IsNull()) {
- exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
- return;
- }
- impl.setTestInterfaceMember(testInterfaceMember);
- }
+ impl.setTestInterfaceMember(testInterfaceMember);
}
- {
- v8::Local<v8::Value> testInterfaceOrNullMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceOrNullMember")).ToLocal(&testInterfaceOrNullMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> testInterfaceOrNullMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceOrNullMember")).ToLocal(&testInterfaceOrNullMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (testInterfaceOrNullMemberValue->IsNull()) {
+ impl.setTestInterfaceOrNullMemberToNull();
+ } else {
+ TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
+ if (!testInterfaceOrNullMember && !testInterfaceOrNullMemberValue->IsNull()) {
+ exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
return;
}
- if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
- // Do nothing.
- } else if (testInterfaceOrNullMemberValue->IsNull()) {
- impl.setTestInterfaceOrNullMemberToNull();
- } else {
- TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
- if (!testInterfaceOrNullMember && !testInterfaceOrNullMemberValue->IsNull()) {
- exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
- return;
- }
- impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
- }
+ impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
}
- {
- v8::Local<v8::Value> testInterfaceSequenceMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceSequenceMember")).ToLocal(&testInterfaceSequenceMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> testInterfaceSequenceMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceSequenceMember")).ToLocal(&testInterfaceSequenceMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (testInterfaceSequenceMemberValue.IsEmpty() || testInterfaceSequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ HeapVector<Member<TestInterfaceImplementation>> testInterfaceSequenceMember = (toMemberNativeArray<TestInterface>(testInterfaceSequenceMemberValue, 0, isolate, exceptionState));
+ if (exceptionState.hadException())
return;
- }
- if (testInterfaceSequenceMemberValue.IsEmpty() || testInterfaceSequenceMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- HeapVector<Member<TestInterfaceImplementation>> testInterfaceSequenceMember = (toMemberNativeArray<TestInterface>(testInterfaceSequenceMemberValue, 0, isolate, exceptionState));
- if (exceptionState.hadException())
- return;
- impl.setTestInterfaceSequenceMember(testInterfaceSequenceMember);
- }
+ impl.setTestInterfaceSequenceMember(testInterfaceSequenceMember);
}
- {
- v8::Local<v8::Value> uint8ArrayMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "uint8ArrayMember")).ToLocal(&uint8ArrayMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> uint8ArrayMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "uint8ArrayMember")).ToLocal(&uint8ArrayMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (uint8ArrayMemberValue.IsEmpty() || uint8ArrayMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ 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;
}
- if (uint8ArrayMemberValue.IsEmpty() || uint8ArrayMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- 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;
- }
- impl.setUint8ArrayMember(uint8ArrayMember);
- }
+ impl.setUint8ArrayMember(uint8ArrayMember);
}
- {
- v8::Local<v8::Value> unrestrictedDoubleMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "unrestrictedDoubleMember")).ToLocal(&unrestrictedDoubleMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
+ v8::Local<v8::Value> unrestrictedDoubleMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "unrestrictedDoubleMember")).ToLocal(&unrestrictedDoubleMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (unrestrictedDoubleMemberValue.IsEmpty() || unrestrictedDoubleMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ double unrestrictedDoubleMember = toDouble(isolate, unrestrictedDoubleMemberValue, exceptionState);
+ if (exceptionState.hadException())
return;
- }
- if (unrestrictedDoubleMemberValue.IsEmpty() || unrestrictedDoubleMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- double unrestrictedDoubleMember = toDouble(isolate, unrestrictedDoubleMemberValue, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
- }
+ impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
}
}
« no previous file with comments | « third_party/WebKit/Source/bindings/templates/interface_base.cpp ('k') | third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionaryDerived.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698