Update union conversion algorithm

third_party/WebKit/Source/bindings/templates/union_container.cpp

 {% from 'utilities.cpp' import declare_enum_validation_variable %}
 {% include 'copyright_block.txt' %}
 #include "{{this_include_header_name}}.h"
 
 {% from 'utilities.cpp' import v8_value_to_local_cpp_value %}
 {% macro assign_and_return_if_hasinstance(member) %}
 if (V8{{member.type_name}}::hasInstance(v8Value, isolate)) {
     {{member.cpp_local_type}} cppValue = V8{{member.type_name}}::toImpl(v8::Local<v8::Object>::Cast(v8Value));
     impl.set{{member.type_name}}(cppValue);
     return;
@@ skipping 55 matching lines @@
 {
     if (v8Value.IsEmpty())
         return;
 
     {# The numbers in the following comments refer to the steps described in
        http://heycam.github.io/webidl/#es-union #}
     {# 1. null or undefined #}
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
-    {# 3. Platform objects (interfaces) #}
+    {% if dictionary_type %}
+    {# 3. Dictionaries for null or undefined #}
+    if (isUndefinedOrNull(v8Value)) {
+        {{v8_value_to_local_cpp_value(dictionary_type) | indent(8)}}
+        impl.set{{dictionary_type.type_name}}(cppValue);
+        return;
+    }
+
+    {% endif %}
+    {# 4. Platform objects (interfaces) #}
     {% for interface in interface_types %}
     {{assign_and_return_if_hasinstance(interface) | indent}}
 
     {% endfor %}
     {# 8. ArrayBuffer #}
     {% if array_buffer_type %}
     {{assign_and_return_if_hasinstance(array_buffer_type) | indent}}
 
     {% endif %}
     {# 9., 10. ArrayBufferView #}
     {# FIXME: Individual typed arrays (e.g. Uint8Array) aren't supported yet. #}
     {% if array_buffer_view_type %}
     {{assign_and_return_if_hasinstance(array_buffer_view_type) | indent}}
 
     {% endif %}
-    {% if dictionary_type %}
-    {# 12. Dictionaries #}
-    {# FIXME: This should also check "object but not Date or RegExp". Add checks
+    {% if array_or_sequence_type %}
+    {# 12.1, 12.2. Arrays and Sequences #}
+    {# FIXME: This should also check "object but not RegExp". Add checks
        when we implement conversions for Date and RegExp. #}
-    {# TODO(bashi): The spec doesn't say we should check !IsArray() but otherwise
-       we can't distinguish a sequence<T> and a dictionary.
-       https://github.com/heycam/webidl/issues/123 #}
-    if (isUndefinedOrNull(v8Value) || (v8Value->IsObject() && !v8Value->IsArray())) {
-        {{v8_value_to_local_cpp_value(dictionary_type) | indent(8)}}
-        impl.set{{dictionary_type.type_name}}(cppValue);
-        return;
-    }
-
-    {% endif %}
-    {% if array_or_sequence_type %}
-    {# 13.1, 13.2. Arrays and Sequences #}
-    {# FIXME: This should also check "object but not Date or RegExp". Add checks
-       when we implement conversions for Date and RegExp. #}
-    {# FIXME: Should check for sequences too, not just Array instances. #}
+    {# TODO(bashi): Should check @@iterator symbol instead. #}
     if (v8Value->IsArray()) {
         {{v8_value_to_local_cpp_value(array_or_sequence_type) | indent(8)}}
         impl.set{{array_or_sequence_type.type_name}}(cppValue);
         return;
     }
 
     {% endif %}
-    {# TODO(bashi): Support 13.3 Callback interface when we need it #}
-    {# 13.4. Objects #}
+    {% if dictionary_type %}
+    {# 12.3. Dictionaries #}
+    if (v8Value->IsObject()) {
+        {{v8_value_to_local_cpp_value(dictionary_type) | indent(8)}}
+        impl.set{{dictionary_type.type_name}}(cppValue);
+        return;
+    }
+
+    {% endif %}
+    {# TODO(bashi): Support 12.4 Callback interface when we need it #}
+    {# 12.5. Objects #}
     {% if object_type %}
     if (isUndefinedOrNull(v8Value) || v8Value->IsObject()) {
         {{v8_value_to_local_cpp_value(object_type) | indent(8)}}
         impl.set{{object_type.type_name}}(cppValue);
         return;
     }
 
     {% endif %}
     {# FIXME: In some cases, we can omit boolean and numeric type checks because
-       we have fallback conversions. (step 17 and 18) #}
+       we have fallback conversions. (step 16 and 17) #}
     {% if boolean_type %}
-    {# 14. Boolean #}
+    {# 13. Boolean #}
     if (v8Value->IsBoolean()) {
         impl.setBoolean(v8Value.As<v8::Boolean>()->Value());
         return;
     }
 
     {% endif %}
     {% if numeric_type %}
-    {# 15. Number #}
+    {# 14. Number #}
     if (v8Value->IsNumber()) {
         {{v8_value_to_local_cpp_value(numeric_type) | indent(8)}}
         impl.set{{numeric_type.type_name}}(cppValue);
         return;
     }
 
     {% endif %}
     {% if string_type %}
-    {# 16. String #}
+    {# 15. String #}
     {
         {{v8_value_to_local_cpp_value(string_type) | indent(8)}}
         {% if string_type.enum_values %}
         {{declare_enum_validation_variable(string_type.enum_values) | indent(8)}}
         if (!isValidEnum(cppValue, validValues, WTF_ARRAY_LENGTH(validValues), "{{string_type.type_name}}", exceptionState))
             return;
         {% endif %}
         impl.set{{string_type.type_name}}(cppValue);
         return;
     }
 
-    {# 17. Number (fallback) #}
+    {# 16. Number (fallback) #}
     {% elif numeric_type %}
     {
         {{v8_value_to_local_cpp_value(numeric_type) | indent(8)}}
         impl.set{{numeric_type.type_name}}(cppValue);
         return;
     }
 
-    {# 18. Boolean (fallback) #}
+    {# 17. Boolean (fallback) #}
     {% elif boolean_type %}
     {
         impl.setBoolean(v8Value->BooleanValue());
         return;
     }
 
     {% else %}
-    {# 19. TypeError #}
+    {# 18. TypeError #}
     exceptionState.throwTypeError("The provided value is not of type '{{type_string}}'");
     {% endif %}
 }
 
 v8::Local<v8::Value> toV8(const {{cpp_class}}& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     switch (impl.m_type) {
     case {{cpp_class}}::SpecificTypeNone:
         {# FIXME: We might want to return undefined in some cases #}
         return v8::Null(isolate);
     {% for member in members %}
     case {{cpp_class}}::{{member.specific_type_enum}}:
         return {{member.cpp_value_to_v8_value}};
     {% endfor %}
     default:
         ASSERT_NOT_REACHED();
     }
     return v8::Local<v8::Value>();
 }
 
 {{cpp_class}} NativeValueTraits<{{cpp_class}}>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     {{cpp_class}} impl;
     {{v8_class}}::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNullable, exceptionState);
     return impl;
 }
 
 } // namespace blink