IDL: Null values should be converted for non-nullable dictionary members

Source/bindings/tests/results/core/V8TestDictionary.cpp

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..6c977bd538d88447c059e455aba50e709f0d1139 100644
--- a/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -30,7 +30,7 @@ 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)) {
+    if (!booleanMemberValue.IsEmpty() && !booleanMemberValue->IsUndefined()) {
         bool booleanMember = booleanMemberValue->BooleanValue();
         impl.setBooleanMember(booleanMember);
     } else if (block.HasCaught()) {
@@ -39,7 +39,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> createValue = v8Object->Get(v8String(isolate, "create"));
-    if (!createValue.IsEmpty() && !isUndefinedOrNull(createValue)) {
+    if (!createValue.IsEmpty() && !createValue->IsUndefined()) {
         bool create = createValue->BooleanValue();
         impl.setCreateMember(create);
     } else if (block.HasCaught()) {
@@ -48,16 +48,20 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     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);
+    if (!doubleOrNullMemberValue.IsEmpty() && !doubleOrNullMemberValue->IsUndefined()) {
+        if (doubleOrNullMemberValue->IsNull()) {
+            impl.resetDoubleOrNullMember();
+        } else {
+            TONATIVE_VOID_EXCEPTIONSTATE(double, doubleOrNullMember, toDouble(doubleOrNullMemberValue, exceptionState), exceptionState);
+            impl.setDoubleOrNullMember(doubleOrNullMember);
+        }
     } else if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
 
     v8::Local<v8::Value> doubleOrStringMemberValue = v8Object->Get(v8String(isolate, "doubleOrStringMember"));
-    if (!doubleOrStringMemberValue.IsEmpty() && !isUndefinedOrNull(doubleOrStringMemberValue)) {
+    if (!doubleOrStringMemberValue.IsEmpty() && !doubleOrStringMemberValue->IsUndefined()) {
         DoubleOrString doubleOrStringMember;
         TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState), exceptionState);
         impl.setDoubleOrStringMember(doubleOrStringMember);
@@ -67,16 +71,20 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
-    if (!elementOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(elementOrNullMemberValue)) {
-        Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
-        impl.setElementOrNullMember(elementOrNullMember);
+    if (!elementOrNullMemberValue.IsEmpty() && !elementOrNullMemberValue->IsUndefined()) {
+        if (elementOrNullMemberValue->IsNull()) {
+            impl.resetElementOrNullMember();
+        } else {
+            Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
+            impl.setElementOrNullMember(elementOrNullMember);
+        }
     } else if (block.HasCaught()) {

[haraken, 2014/11/28 05:50:24]

Not related to this CL, I'm a bit confused with these branches. Would it be
probably better to reorder the branches like this?

if (block.HasCaught()) {
  exceptionState.rethrowV8Exception();
  return;
}
if (value.IsEmpty() || value->IsUndefined()) {
  // Do nothing.
} else if (value->IsNull()) {
  impl.resetMember();
} else {
  impl.setMember();
}

You can address it in a follow-up CL.

[bashi, 2014/11/28 10:52:48]

Done.

         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
 
     v8::Local<v8::Value> enumMemberValue = v8Object->Get(v8String(isolate, "enumMember"));
-    if (!enumMemberValue.IsEmpty() && !isUndefinedOrNull(enumMemberValue)) {
+    if (!enumMemberValue.IsEmpty() && !enumMemberValue->IsUndefined()) {
         TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
         String string = enumMember;
         if (!(string == "foo" || string == "bar" || string == "baz")) {
@@ -90,7 +98,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
-    if (!internalDictionarySequenceMemberValue.IsEmpty() && !isUndefinedOrNull(internalDictionarySequenceMemberValue)) {
+    if (!internalDictionarySequenceMemberValue.IsEmpty() && !internalDictionarySequenceMemberValue->IsUndefined()) {
         TONATIVE_VOID_EXCEPTIONSTATE(Vector<InternalDictionary>, internalDictionarySequenceMember, toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState);
         impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
     } else if (block.HasCaught()) {
@@ -99,7 +107,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
-    if (!longMemberValue.IsEmpty() && !isUndefinedOrNull(longMemberValue)) {
+    if (!longMemberValue.IsEmpty() && !longMemberValue->IsUndefined()) {
         TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
         impl.setLongMember(longMember);
     } else if (block.HasCaught()) {
@@ -108,7 +116,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
-    if (!objectMemberValue.IsEmpty() && !isUndefinedOrNull(objectMemberValue)) {
+    if (!objectMemberValue.IsEmpty() && !objectMemberValue->IsUndefined()) {
         ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
         if (!objectMember.isObject()) {
             exceptionState.throwTypeError("member objectMember is not an object.");
@@ -121,20 +129,24 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> objectOrNullMemberValue = v8Object->Get(v8String(isolate, "objectOrNullMember"));
-    if (!objectOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(objectOrNullMemberValue)) {
-        ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
-        if (!objectOrNullMember.isObject()) {
-            exceptionState.throwTypeError("member objectOrNullMember is not an object.");
-            return;
+    if (!objectOrNullMemberValue.IsEmpty() && !objectOrNullMemberValue->IsUndefined()) {
+        if (objectOrNullMemberValue->IsNull()) {
+            impl.resetObjectOrNullMember();
+        } 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);
     } else if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
 
     v8::Local<v8::Value> stringArrayMemberValue = v8Object->Get(v8String(isolate, "stringArrayMember"));
-    if (!stringArrayMemberValue.IsEmpty() && !isUndefinedOrNull(stringArrayMemberValue)) {
+    if (!stringArrayMemberValue.IsEmpty() && !stringArrayMemberValue->IsUndefined()) {
         TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
         impl.setStringArrayMember(stringArrayMember);
     } else if (block.HasCaught()) {
@@ -143,7 +155,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
-    if (!stringMemberValue.IsEmpty() && !isUndefinedOrNull(stringMemberValue)) {
+    if (!stringMemberValue.IsEmpty() && !stringMemberValue->IsUndefined()) {
         TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
         impl.setStringMember(stringMember);
     } else if (block.HasCaught()) {
@@ -152,16 +164,20 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
-    if (!stringOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(stringOrNullMemberValue)) {
-        TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
-        impl.setStringOrNullMember(stringOrNullMember);
+    if (!stringOrNullMemberValue.IsEmpty() && !stringOrNullMemberValue->IsUndefined()) {
+        if (stringOrNullMemberValue->IsNull()) {
+            impl.resetStringOrNullMember();
+        } else {
+            TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
+            impl.setStringOrNullMember(stringOrNullMember);
+        }
     } else if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
 
     v8::Local<v8::Value> stringSequenceMemberValue = v8Object->Get(v8String(isolate, "stringSequenceMember"));
-    if (!stringSequenceMemberValue.IsEmpty() && !isUndefinedOrNull(stringSequenceMemberValue)) {
+    if (!stringSequenceMemberValue.IsEmpty() && !stringSequenceMemberValue->IsUndefined()) {
         TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
         impl.setStringSequenceMember(stringSequenceMember);
     } else if (block.HasCaught()) {
@@ -170,7 +186,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
-    if (!testInterfaceGarbageCollectedMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceGarbageCollectedMemberValue)) {
+    if (!testInterfaceGarbageCollectedMemberValue.IsEmpty() && !testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
         impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
     } else if (block.HasCaught()) {
@@ -179,16 +195,20 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"));
-    if (!testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceGarbageCollectedOrNullMemberValue)) {
-        TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
-        impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
+    if (!testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() && !testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
+        if (testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
+            impl.resetTestInterfaceGarbageCollectedOrNullMember();
+        } else {
+            TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
+            impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
+        }
     } else if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
 
     v8::Local<v8::Value> testInterfaceMemberValue = v8Object->Get(v8String(isolate, "testInterfaceMember"));
-    if (!testInterfaceMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceMemberValue)) {
+    if (!testInterfaceMemberValue.IsEmpty() && !testInterfaceMemberValue->IsUndefined()) {
         TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
         impl.setTestInterfaceMember(testInterfaceMember);
     } else if (block.HasCaught()) {
@@ -197,16 +217,20 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> testInterfaceOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceOrNullMember"));
-    if (!testInterfaceOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceOrNullMemberValue)) {
-        TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
-        impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
+    if (!testInterfaceOrNullMemberValue.IsEmpty() && !testInterfaceOrNullMemberValue->IsUndefined()) {
+        if (testInterfaceOrNullMemberValue->IsNull()) {
+            impl.resetTestInterfaceOrNullMember();
+        } else {
+            TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
+            impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
+        }
     } else if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
 
     v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"));
-    if (!testInterfaceWillBeGarbageCollectedMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceWillBeGarbageCollectedMemberValue)) {
+    if (!testInterfaceWillBeGarbageCollectedMemberValue.IsEmpty() && !testInterfaceWillBeGarbageCollectedMemberValue->IsUndefined()) {
         TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
         impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
     } else if (block.HasCaught()) {
@@ -215,9 +239,13 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
     }
 
     v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"));
-    if (!testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceWillBeGarbageCollectedOrNullMemberValue)) {
-        TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
-        impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
+    if (!testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() && !testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsUndefined()) {
+        if (testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsNull()) {
+            impl.resetTestInterfaceWillBeGarbageCollectedOrNullMember();
+        } else {
+            TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
+            impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
+        }
     } else if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;