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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 765673005: IDL: Null values should be converted for non-nullable dictionary members (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: GN fix Created 6 years 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 | « Source/bindings/tests/results/core/TestDictionary.h ('k') | 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: Source/bindings/tests/results/core/V8TestDictionary.cpp
diff --git a/Source/bindings/tests/results/core/V8TestDictionary.cpp b/Source/bindings/tests/results/core/V8TestDictionary.cpp
index d1c686363dd8049f0717f3b8016217a4efe37429..88701ccda6fd1db612c79fb3321f45a6dfcb4c6a 100644
--- a/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -30,53 +30,78 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
v8::Local<v8::Object> v8Object = v8Value->ToObject(isolate);
v8::TryCatch block;
v8::Local<v8::Value> booleanMemberValue = v8Object->Get(v8String(isolate, "booleanMember"));
- if (!booleanMemberValue.IsEmpty() && !isUndefinedOrNull(booleanMemberValue)) {
- bool booleanMember = booleanMemberValue->BooleanValue();
- impl.setBooleanMember(booleanMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ bool booleanMember = booleanMemberValue->BooleanValue();
+ impl.setBooleanMember(booleanMember);
+ }
v8::Local<v8::Value> createValue = v8Object->Get(v8String(isolate, "create"));
- if (!createValue.IsEmpty() && !isUndefinedOrNull(createValue)) {
- bool create = createValue->BooleanValue();
- impl.setCreateMember(create);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (createValue.IsEmpty() || createValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ bool create = createValue->BooleanValue();
+ impl.setCreateMember(create);
+ }
v8::Local<v8::Value> doubleOrNullMemberValue = v8Object->Get(v8String(isolate, "doubleOrNullMember"));
- if (!doubleOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(doubleOrNullMemberValue)) {
- TONATIVE_VOID_EXCEPTIONSTATE(double, doubleOrNullMember, toDouble(doubleOrNullMemberValue, exceptionState), exceptionState);
- impl.setDoubleOrNullMember(doubleOrNullMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (doubleOrNullMemberValue->IsNull()) {
+ impl.setDoubleOrNullMemberToNull();
+ } else {
+ TONATIVE_VOID_EXCEPTIONSTATE(double, doubleOrNullMember, toDouble(doubleOrNullMemberValue, exceptionState), exceptionState);
+ impl.setDoubleOrNullMember(doubleOrNullMember);
+ }
v8::Local<v8::Value> doubleOrStringMemberValue = v8Object->Get(v8String(isolate, "doubleOrStringMember"));
- if (!doubleOrStringMemberValue.IsEmpty() && !isUndefinedOrNull(doubleOrStringMemberValue)) {
+ if (block.HasCaught()) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
DoubleOrString doubleOrStringMember;
TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState), exceptionState);
impl.setDoubleOrStringMember(doubleOrStringMember);
- } else if (block.HasCaught()) {
- exceptionState.rethrowV8Exception(block.Exception());
- return;
}
v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
- if (!elementOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(elementOrNullMemberValue)) {
- Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
- impl.setElementOrNullMember(elementOrNullMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
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);
+ impl.setElementOrNullMember(elementOrNullMember);
+ }
v8::Local<v8::Value> enumMemberValue = v8Object->Get(v8String(isolate, "enumMember"));
- if (!enumMemberValue.IsEmpty() && !isUndefinedOrNull(enumMemberValue)) {
+ if (block.HasCaught()) {
+ exceptionState.rethrowV8Exception(block.Exception());
+ return;
+ }
+ if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
String string = enumMember;
if (!(string == "foo" || string == "bar" || string == "baz")) {
@@ -84,144 +109,193 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
return;
}
impl.setEnumMember(enumMember);
- } else if (block.HasCaught()) {
- exceptionState.rethrowV8Exception(block.Exception());
- return;
}
v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
- if (!internalDictionarySequenceMemberValue.IsEmpty() && !isUndefinedOrNull(internalDictionarySequenceMemberValue)) {
- TONATIVE_VOID_EXCEPTIONSTATE(Vector<InternalDictionary>, internalDictionarySequenceMember, toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState);
- impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TONATIVE_VOID_EXCEPTIONSTATE(Vector<InternalDictionary>, internalDictionarySequenceMember, toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+ impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
+ }
v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
- if (!longMemberValue.IsEmpty() && !isUndefinedOrNull(longMemberValue)) {
- TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
- impl.setLongMember(longMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
+ impl.setLongMember(longMember);
+ }
v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
- if (!objectMemberValue.IsEmpty() && !isUndefinedOrNull(objectMemberValue)) {
+ if (block.HasCaught()) {
+ 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);
- } else if (block.HasCaught()) {
- exceptionState.rethrowV8Exception(block.Exception());
- return;
}
v8::Local<v8::Value> objectOrNullMemberValue = v8Object->Get(v8String(isolate, "objectOrNullMember"));
- if (!objectOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(objectOrNullMemberValue)) {
+ if (block.HasCaught()) {
+ 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);
- } else if (block.HasCaught()) {
- exceptionState.rethrowV8Exception(block.Exception());
- return;
}
v8::Local<v8::Value> stringArrayMemberValue = v8Object->Get(v8String(isolate, "stringArrayMember"));
- if (!stringArrayMemberValue.IsEmpty() && !isUndefinedOrNull(stringArrayMemberValue)) {
- TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
- impl.setStringArrayMember(stringArrayMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
+ impl.setStringArrayMember(stringArrayMember);
+ }
v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
- if (!stringMemberValue.IsEmpty() && !isUndefinedOrNull(stringMemberValue)) {
- TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
- impl.setStringMember(stringMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
+ impl.setStringMember(stringMember);
+ }
v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
- if (!stringOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(stringOrNullMemberValue)) {
- TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
- impl.setStringOrNullMember(stringOrNullMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (stringOrNullMemberValue->IsNull()) {
+ impl.setStringOrNullMemberToNull();
+ } else {
+ TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
+ impl.setStringOrNullMember(stringOrNullMember);
+ }
v8::Local<v8::Value> stringSequenceMemberValue = v8Object->Get(v8String(isolate, "stringSequenceMember"));
- if (!stringSequenceMemberValue.IsEmpty() && !isUndefinedOrNull(stringSequenceMemberValue)) {
- TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
- impl.setStringSequenceMember(stringSequenceMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+ impl.setStringSequenceMember(stringSequenceMember);
+ }
v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
- if (!testInterfaceGarbageCollectedMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceGarbageCollectedMemberValue)) {
- TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
- impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
+ impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
+ }
v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"));
- if (!testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceGarbageCollectedOrNullMemberValue)) {
- TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
- impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
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);
+ impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
+ }
v8::Local<v8::Value> testInterfaceMemberValue = v8Object->Get(v8String(isolate, "testInterfaceMember"));
- if (!testInterfaceMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceMemberValue)) {
- TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
- impl.setTestInterfaceMember(testInterfaceMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
+ impl.setTestInterfaceMember(testInterfaceMember);
+ }
v8::Local<v8::Value> testInterfaceOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceOrNullMember"));
- if (!testInterfaceOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceOrNullMemberValue)) {
- TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
- impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
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);
+ impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
+ }
v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"));
- if (!testInterfaceWillBeGarbageCollectedMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceWillBeGarbageCollectedMemberValue)) {
- TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
- impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (testInterfaceWillBeGarbageCollectedMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else {
+ TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
+ impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
+ }
v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"));
- if (!testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceWillBeGarbageCollectedOrNullMemberValue)) {
- TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
- impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
- } else if (block.HasCaught()) {
+ if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
+ if (testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsUndefined()) {
+ // Do nothing.
+ } else if (testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsNull()) {
+ impl.setTestInterfaceWillBeGarbageCollectedOrNullMemberToNull();
+ } else {
+ TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
+ impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
+ }
}
« no previous file with comments | « Source/bindings/tests/results/core/TestDictionary.h ('k') | Source/bindings/tests/results/core/V8TestDictionaryDerived.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698