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

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
 
 #include "config.h"
 #include "V8TestDictionary.h"
 
 #include "bindings/core/v8/ExceptionState.h"
@@ skipping 12 matching lines @@
     if (isUndefinedOrNull(v8Value))
         return;
     if (!v8Value->IsObject()) {
         exceptionState.throwTypeError("cannot convert to dictionary.");
         return;
     }
 
     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()) {
+    }
+
+    v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
-    if (!elementOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(elementOrNullMemberValue)) {
+    if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else if (elementOrNullMemberValue->IsNull()) {
+        impl.setElementOrNullMemberToNull();
+    } else {
         Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
         impl.setElementOrNullMember(elementOrNullMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> enumMemberValue = v8Object->Get(v8String(isolate, "enumMember"));
+    if (block.HasCaught()) {
         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()) {
+        // Do nothing.
+    } else {
         TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
         String string = enumMember;
         if (!(string == "foo" || string == "bar" || string == "baz")) {
             exceptionState.throwTypeError("member enumMember ('" + string + "') is not a valid enum value.");
             return;
         }
         impl.setEnumMember(enumMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
-    if (!internalDictionarySequenceMemberValue.IsEmpty() && !isUndefinedOrNull(internalDictionarySequenceMemberValue)) {
+    if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else {
         TONATIVE_VOID_EXCEPTIONSTATE(Vector<InternalDictionary>, internalDictionarySequenceMember, toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState);
         impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
-    if (!longMemberValue.IsEmpty() && !isUndefinedOrNull(longMemberValue)) {
+    if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else {
         TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
         impl.setLongMember(longMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
-    if (!objectMemberValue.IsEmpty() && !isUndefinedOrNull(objectMemberValue)) {
+    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()) {
+    }
+
+    v8::Local<v8::Value> objectOrNullMemberValue = v8Object->Get(v8String(isolate, "objectOrNullMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> objectOrNullMemberValue = v8Object->Get(v8String(isolate, "objectOrNullMember"));
-    if (!objectOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(objectOrNullMemberValue)) {
+    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()) {
+    }
+
+    v8::Local<v8::Value> stringArrayMemberValue = v8Object->Get(v8String(isolate, "stringArrayMember"));
+    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()) {
+        // Do nothing.
+    } else {
         TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
         impl.setStringArrayMember(stringArrayMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
-    if (!stringMemberValue.IsEmpty() && !isUndefinedOrNull(stringMemberValue)) {
+    if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else {
         TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
         impl.setStringMember(stringMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
-    if (!stringOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(stringOrNullMemberValue)) {
+    if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else if (stringOrNullMemberValue->IsNull()) {
+        impl.setStringOrNullMemberToNull();
+    } else {
         TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
         impl.setStringOrNullMember(stringOrNullMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> stringSequenceMemberValue = v8Object->Get(v8String(isolate, "stringSequenceMember"));
+    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()) {
+        // Do nothing.
+    } else {
         TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
         impl.setStringSequenceMember(stringSequenceMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
-    if (!testInterfaceGarbageCollectedMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceGarbageCollectedMemberValue)) {
+    if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else {
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
         impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"));
-    if (!testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceGarbageCollectedOrNullMemberValue)) {
+    if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else if (testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
+        impl.setTestInterfaceGarbageCollectedOrNullMemberToNull();
+    } else {
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
         impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> testInterfaceMemberValue = v8Object->Get(v8String(isolate, "testInterfaceMember"));
+    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()) {
+        // Do nothing.
+    } else {
         TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
         impl.setTestInterfaceMember(testInterfaceMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> testInterfaceOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceOrNullMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> testInterfaceOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceOrNullMember"));
-    if (!testInterfaceOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceOrNullMemberValue)) {
+    if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else if (testInterfaceOrNullMemberValue->IsNull()) {
+        impl.setTestInterfaceOrNullMemberToNull();
+    } else {
         TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
         impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"));
+    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()) {
+        // Do nothing.
+    } else {
         TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
         impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
-    } else if (block.HasCaught()) {
+    }
+
+    v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"));
+    if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-
-    v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"));
-    if (!testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() && !isUndefinedOrNull(testInterfaceWillBeGarbageCollectedOrNullMemberValue)) {
+    if (testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsUndefined()) {
+        // Do nothing.
+    } else if (testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsNull()) {
+        impl.setTestInterfaceWillBeGarbageCollectedOrNullMemberToNull();
+    } else {
         TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
         impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
-    } else if (block.HasCaught()) {
-        exceptionState.rethrowV8Exception(block.Exception());
-        return;
     }
 
 }
 
 v8::Handle<v8::Value> toV8(const TestDictionary& impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     v8::Handle<v8::Object> v8Object = v8::Object::New(isolate);
     toV8TestDictionary(impl, v8Object, creationContext, isolate);
     return v8Object;
 }
@@ skipping 99 matching lines @@
 }
 
 TestDictionary NativeValueTraits<TestDictionary>::nativeValue(const v8::Handle<v8::Value>& value, v8::Isolate* isolate, ExceptionState& exceptionState)
 {
     TestDictionary impl;
     V8TestDictionary::toImpl(isolate, value, impl, exceptionState);
     return impl;
 }
 
 } // namespace blink