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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2452403002: [Bindings] Reformat template files (4/4) (Closed)
Patch Set: Rebase Created 4 years, 2 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/tests/results/core/V8TestDictionary.h ('k') | third_party/WebKit/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: 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 0131bddcd8b6ed88cea96ca9fc521f5a3fc809db..da4216444f0383ab151f4e90f4a718885471557e 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -26,754 +26,750 @@
namespace blink {
-void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
-{
- if (isUndefinedOrNull(v8Value)) {
- return;
- }
- if (!v8Value->IsObject()) {
- exceptionState.throwTypeError("cannot convert to dictionary.");
- return;
- }
-
- v8::TryCatch block(isolate);
- v8::Local<v8::Object> v8Object;
- if (!v8Call(v8Value->ToObject(isolate->GetCurrentContext()), v8Object, block)) {
- 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> 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;
- impl.setBooleanMember(booleanMember);
- }
-
- 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;
- impl.setCreateMember(create);
- }
-
- 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;
- impl.setCreateMember(deprecatedCreateMember);
- }
-
- 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;
- }
- impl.setDictionaryMember(dictionaryMember);
- }
-
- 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;
- impl.setDoubleOrNullMember(doubleOrNullMember);
- }
-
- 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;
- impl.setDoubleOrStringMember(doubleOrStringMember);
- }
-
- 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;
- impl.setDoubleOrStringSequenceMember(doubleOrStringSequenceMember);
- }
-
- 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) {
- exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
- return;
- }
- impl.setElementOrNullMember(elementOrNullMember);
- }
-
- 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;
- 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());
- return;
- }
- if (enumSequenceMemberValue.IsEmpty() || enumSequenceMemberValue->IsUndefined()) {
+void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState) {
+ if (isUndefinedOrNull(v8Value)) {
+ return;
+ }
+ if (!v8Value->IsObject()) {
+ exceptionState.throwTypeError("cannot convert to dictionary.");
+ return;
+ }
+
+ v8::TryCatch block(isolate);
+ v8::Local<v8::Object> v8Object;
+ if (!v8Call(v8Value->ToObject(isolate->GetCurrentContext()), v8Object, block)) {
+ 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> 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;
+ impl.setBooleanMember(booleanMember);
+ }
+
+ 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;
+ impl.setCreateMember(create);
+ }
+
+ 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;
+ impl.setCreateMember(deprecatedCreateMember);
+ }
+
+ 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;
+ }
+ impl.setDictionaryMember(dictionaryMember);
+ }
+
+ 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;
+ impl.setDoubleOrNullMember(doubleOrNullMember);
+ }
+
+ 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;
+ impl.setDoubleOrStringMember(doubleOrStringMember);
+ }
+
+ 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;
+ impl.setDoubleOrStringSequenceMember(doubleOrStringSequenceMember);
+ }
+
+ 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) {
+ exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
+ return;
+ }
+ impl.setElementOrNullMember(elementOrNullMember);
+ }
+
+ 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;
+ 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());
+ 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);
+ }
+
+ 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) {
+ exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
+ return;
+ }
+ impl.setEventTargetMember(eventTargetMember);
+ }
+
+ 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;
+ impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
+ }
+
+ 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;
+ impl.setLongMember(longMember);
+ }
+
+ 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;
+ }
+ impl.setObjectMember(objectMember);
+ }
+
+ 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;
+ }
+ impl.setObjectOrNullMember(objectOrNullMember);
+ }
+
+ 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;
+ impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
+ }
+
+ 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;
+ impl.setRestrictedDoubleMember(restrictedDoubleMember);
+ }
+
+ if (RuntimeEnabledFeatures::runtimeFeatureEnabled()) {
+ v8::Local<v8::Value> runtimeMemberValue;
+ if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "runtimeMember")).ToLocal(&runtimeMemberValue)) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (runtimeMemberValue.IsEmpty() || runtimeMemberValue->IsUndefined()) {
// Do nothing.
- } else {
- Vector<String> enumSequenceMember = toImplArray<Vector<String>>(enumSequenceMemberValue, 0, isolate, exceptionState);
+ } else {
+ bool runtimeMember = toBoolean(isolate, runtimeMemberValue, 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);
- }
-
- 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) {
- exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
- return;
- }
- impl.setEventTargetMember(eventTargetMember);
- }
-
- 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;
- impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
- }
-
- 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;
- impl.setLongMember(longMember);
- }
-
- 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;
- }
- impl.setObjectMember(objectMember);
- }
-
- 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;
- }
- impl.setObjectOrNullMember(objectOrNullMember);
- }
-
- 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;
- impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
- }
-
- 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;
- impl.setRestrictedDoubleMember(restrictedDoubleMember);
- }
-
- if (RuntimeEnabledFeatures::runtimeFeatureEnabled()) {
- v8::Local<v8::Value> runtimeMemberValue;
- if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "runtimeMember")).ToLocal(&runtimeMemberValue)) {
- exceptionState.rethrowV8Exception(block.Exception());
- return;
- }
- if (runtimeMemberValue.IsEmpty() || runtimeMemberValue->IsUndefined()) {
- // Do nothing.
- } else {
- bool runtimeMember = toBoolean(isolate, runtimeMemberValue, exceptionState);
- if (exceptionState.hadException())
- return;
- impl.setRuntimeMember(runtimeMember);
- }
- }
-
- 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;
- impl.setStringArrayMember(stringArrayMember);
- }
-
- 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;
- impl.setStringMember(stringMember);
- }
-
- 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;
- impl.setStringOrNullMember(stringOrNullMember);
- }
-
- 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;
- impl.setStringSequenceMember(stringSequenceMember);
- }
-
- 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;
- impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
- }
-
- 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) {
- exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
- return;
- }
- impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
- }
-
- 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) {
- exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
- return;
- }
- impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
- }
-
- 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;
- impl.setTestInterfaceGarbageCollectedSequenceMember(testInterfaceGarbageCollectedSequenceMember);
- }
-
- 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) {
- exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
- return;
- }
- impl.setTestInterfaceMember(testInterfaceMember);
- }
-
- 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) {
- exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
- return;
- }
- impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
- }
-
- 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;
- impl.setTestInterfaceSequenceMember(testInterfaceSequenceMember);
- }
-
- 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) {
- exceptionState.throwTypeError("member uint8ArrayMember is not of type Uint8Array.");
- return;
- }
- impl.setUint8ArrayMember(uint8ArrayMember);
- }
-
- 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;
- impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
- }
+ return;
+ impl.setRuntimeMember(runtimeMember);
+ }
+ }
+
+ 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;
+ impl.setStringArrayMember(stringArrayMember);
+ }
+
+ 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;
+ impl.setStringMember(stringMember);
+ }
+
+ 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;
+ impl.setStringOrNullMember(stringOrNullMember);
+ }
+
+ 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;
+ impl.setStringSequenceMember(stringSequenceMember);
+ }
+
+ 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;
+ impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
+ }
+
+ 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) {
+ exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
+ return;
+ }
+ impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
+ }
+
+ 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) {
+ exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
+ return;
+ }
+ impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
+ }
+
+ 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;
+ impl.setTestInterfaceGarbageCollectedSequenceMember(testInterfaceGarbageCollectedSequenceMember);
+ }
+
+ 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) {
+ exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
+ return;
+ }
+ impl.setTestInterfaceMember(testInterfaceMember);
+ }
+
+ 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) {
+ exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
+ return;
+ }
+ impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
+ }
+
+ 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;
+ impl.setTestInterfaceSequenceMember(testInterfaceSequenceMember);
+ }
+
+ 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) {
+ exceptionState.throwTypeError("member uint8ArrayMember is not of type Uint8Array.");
+ return;
+ }
+ impl.setUint8ArrayMember(uint8ArrayMember);
+ }
+
+ 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;
+ impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
+ }
}
-v8::Local<v8::Value> TestDictionary::toV8Impl(v8::Local<v8::Object> creationContext, v8::Isolate* isolate) const
-{
- v8::Local<v8::Object> v8Object = v8::Object::New(isolate);
- if (!toV8TestDictionary(*this, v8Object, creationContext, isolate))
- return v8::Undefined(isolate);
- return v8Object;
+v8::Local<v8::Value> TestDictionary::toV8Impl(v8::Local<v8::Object> creationContext, v8::Isolate* isolate) const {
+ v8::Local<v8::Object> v8Object = v8::Object::New(isolate);
+ if (!toV8TestDictionary(*this, v8Object, creationContext, isolate))
+ return v8::Undefined(isolate);
+ return v8Object;
}
-bool toV8TestDictionary(const TestDictionary& impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
-{
- if (impl.hasAnyMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "anyMember"), impl.anyMember().v8Value())))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "anyMember"), v8::Null(isolate))))
- return false;
- }
-
- if (impl.hasBooleanMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "booleanMember"), v8Boolean(impl.booleanMember(), isolate))))
- return false;
- }
-
- if (impl.hasCreateMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "create"), v8Boolean(impl.createMember(), isolate))))
- return false;
- }
-
- if (impl.hasCreateMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "deprecatedCreateMember"), v8Boolean(impl.createMember(), isolate))))
- return false;
- }
-
- if (impl.hasDictionaryMember()) {
- ASSERT(impl.dictionaryMember().isObject());
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "dictionaryMember"), impl.dictionaryMember().v8Value())))
- return false;
- }
-
- if (impl.hasDoubleOrNullMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrNullMember"), v8::Number::New(isolate, impl.doubleOrNullMember()))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrNullMember"), v8::Null(isolate))))
- return false;
- }
-
- if (impl.hasDoubleOrStringMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringMember"), toV8(impl.doubleOrStringMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringMember"), toV8(DoubleOrString::fromDouble(3.14), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasDoubleOrStringSequenceMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringSequenceMember"), toV8(impl.doubleOrStringSequenceMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasElementOrNullMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "elementOrNullMember"), toV8(impl.elementOrNullMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "elementOrNullMember"), v8::Null(isolate))))
- return false;
- }
-
- if (impl.hasEnumMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "enumMember"), v8String(isolate, impl.enumMember()))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "enumMember"), v8String(isolate, String("foo")))))
- return false;
- }
-
- if (impl.hasEnumSequenceMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "enumSequenceMember"), toV8(impl.enumSequenceMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasEventTargetMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "eventTargetMember"), toV8(impl.eventTargetMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasInternalDictionarySequenceMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "internalDictionarySequenceMember"), toV8(impl.internalDictionarySequenceMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasLongMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "longMember"), v8::Integer::New(isolate, impl.longMember()))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "longMember"), v8::Integer::New(isolate, 1))))
- return false;
- }
-
- if (impl.hasObjectMember()) {
- ASSERT(impl.objectMember().isObject());
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "objectMember"), impl.objectMember().v8Value())))
- return false;
- }
-
- if (impl.hasObjectOrNullMember()) {
- ASSERT(impl.objectOrNullMember().isObject());
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "objectOrNullMember"), impl.objectOrNullMember().v8Value())))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "objectOrNullMember"), v8::Null(isolate))))
- return false;
- }
-
- if (impl.hasOtherDoubleOrStringMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "otherDoubleOrStringMember"), toV8(impl.otherDoubleOrStringMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "otherDoubleOrStringMember"), toV8(DoubleOrString::fromString(String("default string value")), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasRestrictedDoubleMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "restrictedDoubleMember"), v8::Number::New(isolate, impl.restrictedDoubleMember()))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "restrictedDoubleMember"), v8::Number::New(isolate, 3.14))))
- return false;
- }
-
- if (impl.hasRuntimeMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "runtimeMember"), v8Boolean(impl.runtimeMember(), isolate))))
- return false;
- }
-
- if (impl.hasStringArrayMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringArrayMember"), toV8(impl.stringArrayMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasStringMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringMember"), v8String(isolate, impl.stringMember()))))
- return false;
- }
-
- if (impl.hasStringOrNullMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringOrNullMember"), v8String(isolate, impl.stringOrNullMember()))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringOrNullMember"), v8String(isolate, String("default string value")))))
- return false;
- }
-
- if (impl.hasStringSequenceMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringSequenceMember"), toV8(impl.stringSequenceMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringSequenceMember"), toV8(Vector<String>(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasTestInterface2OrUint8ArrayMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterface2OrUint8ArrayMember"), toV8(impl.testInterface2OrUint8ArrayMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasTestInterfaceGarbageCollectedMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedMember"), toV8(impl.testInterfaceGarbageCollectedMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasTestInterfaceGarbageCollectedOrNullMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"), toV8(impl.testInterfaceGarbageCollectedOrNullMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"), v8::Null(isolate))))
- return false;
- }
-
- if (impl.hasTestInterfaceGarbageCollectedSequenceMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedSequenceMember"), toV8(impl.testInterfaceGarbageCollectedSequenceMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedSequenceMember"), toV8(HeapVector<Member<TestInterfaceGarbageCollected>>(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasTestInterfaceMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceMember"), toV8(impl.testInterfaceMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasTestInterfaceOrNullMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceOrNullMember"), toV8(impl.testInterfaceOrNullMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceOrNullMember"), v8::Null(isolate))))
- return false;
- }
-
- if (impl.hasTestInterfaceSequenceMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceSequenceMember"), toV8(impl.testInterfaceSequenceMember(), creationContext, isolate))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceSequenceMember"), toV8(HeapVector<Member<TestInterfaceImplementation>>(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasUint8ArrayMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "uint8ArrayMember"), toV8(impl.uint8ArrayMember(), creationContext, isolate))))
- return false;
- }
-
- if (impl.hasUnrestrictedDoubleMember()) {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "unrestrictedDoubleMember"), v8::Number::New(isolate, impl.unrestrictedDoubleMember()))))
- return false;
- } else {
- if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "unrestrictedDoubleMember"), v8::Number::New(isolate, 3.14))))
- return false;
- }
-
- return true;
+bool toV8TestDictionary(const TestDictionary& impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
+ if (impl.hasAnyMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "anyMember"), impl.anyMember().v8Value())))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "anyMember"), v8::Null(isolate))))
+ return false;
+ }
+
+ if (impl.hasBooleanMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "booleanMember"), v8Boolean(impl.booleanMember(), isolate))))
+ return false;
+ }
+
+ if (impl.hasCreateMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "create"), v8Boolean(impl.createMember(), isolate))))
+ return false;
+ }
+
+ if (impl.hasCreateMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "deprecatedCreateMember"), v8Boolean(impl.createMember(), isolate))))
+ return false;
+ }
+
+ if (impl.hasDictionaryMember()) {
+ DCHECK(impl.dictionaryMember().isObject());
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "dictionaryMember"), impl.dictionaryMember().v8Value())))
+ return false;
+ }
+
+ if (impl.hasDoubleOrNullMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrNullMember"), v8::Number::New(isolate, impl.doubleOrNullMember()))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrNullMember"), v8::Null(isolate))))
+ return false;
+ }
+
+ if (impl.hasDoubleOrStringMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringMember"), toV8(impl.doubleOrStringMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringMember"), toV8(DoubleOrString::fromDouble(3.14), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasDoubleOrStringSequenceMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "doubleOrStringSequenceMember"), toV8(impl.doubleOrStringSequenceMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasElementOrNullMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "elementOrNullMember"), toV8(impl.elementOrNullMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "elementOrNullMember"), v8::Null(isolate))))
+ return false;
+ }
+
+ if (impl.hasEnumMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "enumMember"), v8String(isolate, impl.enumMember()))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "enumMember"), v8String(isolate, String("foo")))))
+ return false;
+ }
+
+ if (impl.hasEnumSequenceMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "enumSequenceMember"), toV8(impl.enumSequenceMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasEventTargetMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "eventTargetMember"), toV8(impl.eventTargetMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasInternalDictionarySequenceMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "internalDictionarySequenceMember"), toV8(impl.internalDictionarySequenceMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasLongMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "longMember"), v8::Integer::New(isolate, impl.longMember()))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "longMember"), v8::Integer::New(isolate, 1))))
+ return false;
+ }
+
+ if (impl.hasObjectMember()) {
+ DCHECK(impl.objectMember().isObject());
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "objectMember"), impl.objectMember().v8Value())))
+ return false;
+ }
+
+ if (impl.hasObjectOrNullMember()) {
+ DCHECK(impl.objectOrNullMember().isObject());
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "objectOrNullMember"), impl.objectOrNullMember().v8Value())))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "objectOrNullMember"), v8::Null(isolate))))
+ return false;
+ }
+
+ if (impl.hasOtherDoubleOrStringMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "otherDoubleOrStringMember"), toV8(impl.otherDoubleOrStringMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "otherDoubleOrStringMember"), toV8(DoubleOrString::fromString(String("default string value")), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasRestrictedDoubleMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "restrictedDoubleMember"), v8::Number::New(isolate, impl.restrictedDoubleMember()))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "restrictedDoubleMember"), v8::Number::New(isolate, 3.14))))
+ return false;
+ }
+
+ if (impl.hasRuntimeMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "runtimeMember"), v8Boolean(impl.runtimeMember(), isolate))))
+ return false;
+ }
+
+ if (impl.hasStringArrayMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringArrayMember"), toV8(impl.stringArrayMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasStringMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringMember"), v8String(isolate, impl.stringMember()))))
+ return false;
+ }
+
+ if (impl.hasStringOrNullMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringOrNullMember"), v8String(isolate, impl.stringOrNullMember()))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringOrNullMember"), v8String(isolate, String("default string value")))))
+ return false;
+ }
+
+ if (impl.hasStringSequenceMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringSequenceMember"), toV8(impl.stringSequenceMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "stringSequenceMember"), toV8(Vector<String>(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasTestInterface2OrUint8ArrayMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterface2OrUint8ArrayMember"), toV8(impl.testInterface2OrUint8ArrayMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasTestInterfaceGarbageCollectedMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedMember"), toV8(impl.testInterfaceGarbageCollectedMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasTestInterfaceGarbageCollectedOrNullMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"), toV8(impl.testInterfaceGarbageCollectedOrNullMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"), v8::Null(isolate))))
+ return false;
+ }
+
+ if (impl.hasTestInterfaceGarbageCollectedSequenceMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedSequenceMember"), toV8(impl.testInterfaceGarbageCollectedSequenceMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceGarbageCollectedSequenceMember"), toV8(HeapVector<Member<TestInterfaceGarbageCollected>>(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasTestInterfaceMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceMember"), toV8(impl.testInterfaceMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasTestInterfaceOrNullMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceOrNullMember"), toV8(impl.testInterfaceOrNullMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceOrNullMember"), v8::Null(isolate))))
+ return false;
+ }
+
+ if (impl.hasTestInterfaceSequenceMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceSequenceMember"), toV8(impl.testInterfaceSequenceMember(), creationContext, isolate))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "testInterfaceSequenceMember"), toV8(HeapVector<Member<TestInterfaceImplementation>>(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasUint8ArrayMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "uint8ArrayMember"), toV8(impl.uint8ArrayMember(), creationContext, isolate))))
+ return false;
+ }
+
+ if (impl.hasUnrestrictedDoubleMember()) {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "unrestrictedDoubleMember"), v8::Number::New(isolate, impl.unrestrictedDoubleMember()))))
+ return false;
+ } else {
+ if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "unrestrictedDoubleMember"), v8::Number::New(isolate, 3.14))))
+ return false;
+ }
+
+ return true;
}
-TestDictionary NativeValueTraits<TestDictionary>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
-{
- TestDictionary impl;
- V8TestDictionary::toImpl(isolate, value, impl, exceptionState);
- return impl;
+TestDictionary NativeValueTraits<TestDictionary>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState) {
+ TestDictionary impl;
+ V8TestDictionary::toImpl(isolate, value, impl, exceptionState);
+ return impl;
}
-} // namespace blink
+} // namespace blink
« no previous file with comments | « third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.h ('k') | third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionaryDerived.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698