Treat null dictionary members as missing per WebIDL

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

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 efcb9bbccbd741bb0ffca4384335472c07483ca8..ac1f4c316e2abd0aeeab5f8f93af0e9c6ff94560 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -28,6 +28,7 @@ namespace blink {
 void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
 {
     if (isUndefinedOrNull(v8Value)) {
+        exceptionState.throwTypeError("Missing required member(s): requiredElementMember.");
         return;
     }
     if (!v8Value->IsObject()) {
@@ -46,7 +47,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (anyMemberValue.IsEmpty() || anyMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(anyMemberValue)) {
         // Do nothing.
     } else {
         ScriptValue anyMember = ScriptValue(ScriptState::current(isolate), anyMemberValue);
@@ -58,7 +59,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(booleanMemberValue)) {
         // Do nothing.
     } else {
         bool booleanMember = toBoolean(isolate, booleanMemberValue, exceptionState);
@@ -72,7 +73,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (createValue.IsEmpty() || createValue->IsUndefined()) {
+    if (isUndefinedOrNull(createValue)) {
         // Do nothing.
     } else {
         bool create = toBoolean(isolate, createValue, exceptionState);
@@ -86,7 +87,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (deprecatedCreateMemberValue.IsEmpty() || deprecatedCreateMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(deprecatedCreateMemberValue)) {
         // Do nothing.
     } else {
         Deprecation::countDeprecationIfNotPrivateScript(isolate, currentExecutionContext(isolate), UseCounter::CreateMember);
@@ -101,7 +102,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (dictionaryMemberValue.IsEmpty() || dictionaryMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(dictionaryMemberValue)) {
         // Do nothing.
     } else {
         Dictionary dictionaryMember = Dictionary(dictionaryMemberValue, isolate, exceptionState);
@@ -119,10 +120,8 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(doubleOrNullMemberValue)) {
         // Do nothing.
-    } else if (doubleOrNullMemberValue->IsNull()) {
-        impl.setDoubleOrNullMemberToNull();
     } else {
         double doubleOrNullMember = toRestrictedDouble(isolate, doubleOrNullMemberValue, exceptionState);
         if (exceptionState.hadException())
@@ -135,7 +134,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(doubleOrStringMemberValue)) {
         // Do nothing.
     } else {
         DoubleOrString doubleOrStringMember;
@@ -150,7 +149,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (doubleOrStringSequenceMemberValue.IsEmpty() || doubleOrStringSequenceMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(doubleOrStringSequenceMemberValue)) {
         // Do nothing.
     } else {
         HeapVector<DoubleOrString> doubleOrStringSequenceMember = toImplArray<HeapVector<DoubleOrString>>(doubleOrStringSequenceMemberValue, 0, isolate, exceptionState);
@@ -164,13 +163,11 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(elementOrNullMemberValue)) {
         // Do nothing.
-    } else if (elementOrNullMemberValue->IsNull()) {
-        impl.setElementOrNullMemberToNull();
     } else {
         Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
-        if (!elementOrNullMember && !elementOrNullMemberValue->IsNull()) {
+        if (!elementOrNullMember) {
             exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
             return;
         }
@@ -182,7 +179,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(enumMemberValue)) {
         // Do nothing.
     } else {
         V8StringResource<> enumMember = enumMemberValue;
@@ -204,7 +201,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (enumSequenceMemberValue.IsEmpty() || enumSequenceMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(enumSequenceMemberValue)) {
         // Do nothing.
     } else {
         Vector<String> enumSequenceMember = toImplArray<Vector<String>>(enumSequenceMemberValue, 0, isolate, exceptionState);
@@ -226,11 +223,11 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (eventTargetMemberValue.IsEmpty() || eventTargetMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(eventTargetMemberValue)) {
         // Do nothing.
     } else {
         EventTarget* eventTargetMember = toEventTarget(isolate, eventTargetMemberValue);
-        if (!eventTargetMember && !eventTargetMemberValue->IsNull()) {
+        if (!eventTargetMember) {
             exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
             return;
         }
@@ -242,7 +239,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(internalDictionarySequenceMemberValue)) {
         // Do nothing.
     } else {
         HeapVector<InternalDictionary> internalDictionarySequenceMember = toImplArray<HeapVector<InternalDictionary>>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState);
@@ -256,7 +253,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(longMemberValue)) {
         // Do nothing.
     } else {
         int longMember = toInt32(isolate, longMemberValue, NormalConversion, exceptionState);
@@ -270,7 +267,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(objectMemberValue)) {
         // Do nothing.
     } else {
         ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
@@ -286,10 +283,8 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (objectOrNullMemberValue.IsEmpty() || objectOrNullMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(objectOrNullMemberValue)) {
         // Do nothing.
-    } else if (objectOrNullMemberValue->IsNull()) {
-        impl.setObjectOrNullMemberToNull();
     } else {
         ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
         if (!objectOrNullMember.isObject()) {
@@ -304,7 +299,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(otherDoubleOrStringMemberValue)) {
         // Do nothing.
     } else {
         DoubleOrString otherDoubleOrStringMember;
@@ -314,12 +309,29 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
     }
 
+    v8::Local<v8::Value> requiredElementMemberValue;
+    if (!v8Object->Get(isolate->GetCurrentContext(), v8String(isolate, "requiredElementMember")).ToLocal(&requiredElementMemberValue)) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return;
+    }
+    if (isUndefinedOrNull(requiredElementMemberValue)) {
+        exceptionState.throwTypeError("required member requiredElementMember is undefined.");
+        return;
+    } else {
+        Element* requiredElementMember = V8Element::toImplWithTypeCheck(isolate, requiredElementMemberValue);
+        if (!requiredElementMember) {
+            exceptionState.throwTypeError("member requiredElementMember is not of type Element.");
+            return;
+        }
+        impl.setRequiredElementMember(requiredElementMember);
+    }
+
     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()) {
+    if (isUndefinedOrNull(restrictedDoubleMemberValue)) {
         // Do nothing.
     } else {
         double restrictedDoubleMember = toRestrictedDouble(isolate, restrictedDoubleMemberValue, exceptionState);
@@ -334,7 +346,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
             exceptionState.rethrowV8Exception(block.Exception());
             return;
         }
-        if (runtimeMemberValue.IsEmpty() || runtimeMemberValue->IsUndefined()) {
+        if (isUndefinedOrNull(runtimeMemberValue)) {
             // Do nothing.
         } else {
             bool runtimeMember = toBoolean(isolate, runtimeMemberValue, exceptionState);
@@ -349,7 +361,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(stringArrayMemberValue)) {
         // Do nothing.
     } else {
         Vector<String> stringArrayMember = toImplArray<Vector<String>>(stringArrayMemberValue, 0, isolate, exceptionState);
@@ -363,7 +375,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(stringMemberValue)) {
         // Do nothing.
     } else {
         V8StringResource<> stringMember = stringMemberValue;
@@ -377,10 +389,8 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(stringOrNullMemberValue)) {
         // Do nothing.
-    } else if (stringOrNullMemberValue->IsNull()) {
-        impl.setStringOrNullMemberToNull();
     } else {
         V8StringResource<> stringOrNullMember = stringOrNullMemberValue;
         if (!stringOrNullMember.prepare(exceptionState))
@@ -393,7 +403,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(stringSequenceMemberValue)) {
         // Do nothing.
     } else {
         Vector<String> stringSequenceMember = toImplArray<Vector<String>>(stringSequenceMemberValue, 0, isolate, exceptionState);
@@ -407,7 +417,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(testInterface2OrUint8ArrayMemberValue)) {
         // Do nothing.
     } else {
         TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
@@ -422,11 +432,11 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(testInterfaceGarbageCollectedMemberValue)) {
         // Do nothing.
     } else {
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
-        if (!testInterfaceGarbageCollectedMember && !testInterfaceGarbageCollectedMemberValue->IsNull()) {
+        if (!testInterfaceGarbageCollectedMember) {
             exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
             return;
         }
@@ -438,13 +448,11 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(testInterfaceGarbageCollectedOrNullMemberValue)) {
         // Do nothing.
-    } else if (testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
-        impl.setTestInterfaceGarbageCollectedOrNullMemberToNull();
     } else {
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
-        if (!testInterfaceGarbageCollectedOrNullMember && !testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
+        if (!testInterfaceGarbageCollectedOrNullMember) {
             exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
             return;
         }
@@ -456,7 +464,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (testInterfaceGarbageCollectedSequenceMemberValue.IsEmpty() || testInterfaceGarbageCollectedSequenceMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(testInterfaceGarbageCollectedSequenceMemberValue)) {
         // Do nothing.
     } else {
         HeapVector<Member<TestInterfaceGarbageCollected>> testInterfaceGarbageCollectedSequenceMember = (toMemberNativeArray<TestInterfaceGarbageCollected>(testInterfaceGarbageCollectedSequenceMemberValue, 0, isolate, exceptionState));
@@ -470,11 +478,11 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(testInterfaceMemberValue)) {
         // Do nothing.
     } else {
         TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
-        if (!testInterfaceMember && !testInterfaceMemberValue->IsNull()) {
+        if (!testInterfaceMember) {
             exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
             return;
         }
@@ -486,13 +494,11 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(testInterfaceOrNullMemberValue)) {
         // Do nothing.
-    } else if (testInterfaceOrNullMemberValue->IsNull()) {
-        impl.setTestInterfaceOrNullMemberToNull();
     } else {
         TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
-        if (!testInterfaceOrNullMember && !testInterfaceOrNullMemberValue->IsNull()) {
+        if (!testInterfaceOrNullMember) {
             exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
             return;
         }
@@ -504,7 +510,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (testInterfaceSequenceMemberValue.IsEmpty() || testInterfaceSequenceMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(testInterfaceSequenceMemberValue)) {
         // Do nothing.
     } else {
         HeapVector<Member<TestInterfaceImplementation>> testInterfaceSequenceMember = (toMemberNativeArray<TestInterface>(testInterfaceSequenceMemberValue, 0, isolate, exceptionState));
@@ -518,11 +524,11 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (uint8ArrayMemberValue.IsEmpty() || uint8ArrayMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(uint8ArrayMemberValue)) {
         // Do nothing.
     } else {
         DOMUint8Array* uint8ArrayMember = uint8ArrayMemberValue->IsUint8Array() ? V8Uint8Array::toImpl(v8::Local<v8::Uint8Array>::Cast(uint8ArrayMemberValue)) : 0;
-        if (!uint8ArrayMember && !uint8ArrayMemberValue->IsNull()) {
+        if (!uint8ArrayMember) {
             exceptionState.throwTypeError("member uint8ArrayMember is not of type Uint8Array.");
             return;
         }
@@ -534,7 +540,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         exceptionState.rethrowV8Exception(block.Exception());
         return;
     }
-    if (unrestrictedDoubleMemberValue.IsEmpty() || unrestrictedDoubleMemberValue->IsUndefined()) {
+    if (isUndefinedOrNull(unrestrictedDoubleMemberValue)) {
         // Do nothing.
     } else {
         double unrestrictedDoubleMember = toDouble(isolate, unrestrictedDoubleMemberValue, exceptionState);
@@ -666,6 +672,13 @@ bool toV8TestDictionary(const TestDictionary& impl, v8::Local<v8::Object> dictio
             return false;
     }
 
+    if (impl.hasRequiredElementMember()) {
+        if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "requiredElementMember"), toV8(impl.requiredElementMember(), creationContext, isolate))))
+            return false;
+    } else {
+        ASSERT_NOT_REACHED();
+    }
+
     if (impl.hasRestrictedDoubleMember()) {
         if (!v8CallBoolean(dictionary->CreateDataProperty(isolate->GetCurrentContext(), v8String(isolate, "restrictedDoubleMember"), v8::Number::New(isolate, impl.restrictedDoubleMember()))))
             return false;