bindings: Add support for the record<K,V> WebIDL type.

third_party/WebKit/Source/bindings/scripts/v8_types.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 23 matching lines @@
 class methods.
 
 Spec:
 http://www.w3.org/TR/WebIDL/#es-type-mapping
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler
 """
 
 import posixpath
 
-from idl_types import IdlTypeBase, IdlType, IdlUnionType, IdlArrayOrSequenceType, IdlNullableType
+from idl_types import IdlArrayOrSequenceType
+from idl_types import IdlNullableType
+from idl_types import IdlRecordType
+from idl_types import IdlType
+from idl_types import IdlTypeBase
+from idl_types import IdlUnionType
 import v8_attributes  # for IdlType.constructor_type_name
 from v8_globals import includes
 from v8_utilities import extended_attribute_value_contains
 
 
 ################################################################################
 # V8-specific handling of IDL types
 ################################################################################
 
 NON_WRAPPER_TYPES = frozenset([
@@ skipping 78 matching lines @@
             IdlType
         raw_type:
             bool, True if idl_type's raw/primitive C++ type should be returned.
         used_as_rvalue_type:
             bool, True if the C++ type is used as an argument or the return
             type of a method.
         used_as_variadic_argument:
             bool, True if the C++ type is used as a variadic argument of a method.
         used_in_cpp_sequence:
             bool, True if the C++ type is used as an element of a container.
-            Containers can be an array, a sequence or a dictionary.
+            Containers can be an array, a sequence, a dictionary or a record.
     """
     def string_mode():
         if idl_type.is_nullable:
             return 'TreatNullAndUndefinedAsNullString'
         if extended_attributes.get('TreatNullAs') == 'EmptyString':
             return 'TreatNullAsEmptyString'
         if extended_attributes.get('TreatNullAs') == 'NullString':
             return 'TreatNullAsNullString'
         return ''
 
     extended_attributes = extended_attributes or {}
     idl_type = idl_type.preprocessed_type
 
     # Array or sequence types
     if used_as_variadic_argument:
         native_array_element_type = idl_type
     else:
         native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         vector_type = cpp_ptr_type('Vector', 'HeapVector', native_array_element_type.is_gc_type)
         vector_template_type = cpp_template_type(vector_type, native_array_element_type.cpp_type_args(used_in_cpp_sequence=True))
         if used_as_rvalue_type:
             return 'const %s&' % vector_template_type
         return vector_template_type
 
+    # Record types.
+    if idl_type.is_record_type:
+        vector_type = cpp_ptr_type('Vector', 'HeapVector', idl_type.value_type.is_gc_type)
+        value_type = idl_type.value_type.cpp_type_args(used_in_cpp_sequence=True)
+        vector_template_type = cpp_template_type(vector_type,
+                                                 'std::pair<String, %s>' % value_type)
+        if used_as_rvalue_type:
+            return 'const %s&' % vector_template_type
+        return vector_template_type
+
     # Simple types
     base_idl_type = idl_type.base_type
 
     if base_idl_type in CPP_TYPE_SAME_AS_IDL_TYPE:
         return base_idl_type
     if base_idl_type in CPP_INTEGER_CONVERSION_RULES:
         return CPP_INTEGER_CONVERSION_RULES[base_idl_type]
     if base_idl_type in CPP_SPECIAL_CONVERSION_RULES:
         return CPP_SPECIAL_CONVERSION_RULES[base_idl_type]
 
@@ skipping 131 matching lines @@
 IdlTypeBase.is_gc_type = property(is_gc_type)
 
 
 def is_traceable(idl_type):
     return (idl_type.is_garbage_collected or idl_type.is_dictionary)
 
 IdlTypeBase.is_traceable = property(is_traceable)
 IdlUnionType.is_traceable = property(lambda self: True)
 IdlArrayOrSequenceType.is_traceable = property(
     lambda self: self.element_type.is_traceable)
+IdlRecordType.is_traceable = property(
+    lambda self: self.value_type.is_traceable)
 
 
 ################################################################################
 # Includes
 ################################################################################
 
 INCLUDES_FOR_TYPE = {
     'object': set(),
     'ArrayBufferView': set(['bindings/core/v8/V8ArrayBufferView.h',
                             'core/dom/FlexibleArrayBufferView.h']),
@@ skipping 66 matching lines @@
 
 IdlUnionType.includes_for_type = includes_for_union_type
 
 
 def includes_for_array_or_sequence_type(idl_type, extended_attributes=None):
     return idl_type.element_type.includes_for_type(extended_attributes)
 
 IdlArrayOrSequenceType.includes_for_type = includes_for_array_or_sequence_type
 
 
+def includes_for_record_type(idl_type, extended_attributes=None):
+    return set.union(idl_type.key_type.includes_for_type(extended_attributes),
+                     idl_type.value_type.includes_for_type(extended_attributes))
+
+IdlRecordType.includes_for_type = includes_for_record_type
+
+
 def add_includes_for_type(idl_type, extended_attributes=None):
     includes.update(idl_type.includes_for_type(extended_attributes))
 
 IdlTypeBase.add_includes_for_type = add_includes_for_type
 
 
 def includes_for_interface(interface_name):
     return IdlType(interface_name).includes_for_type()
 
 
@@ skipping 76 matching lines @@
 
 
 def v8_conversion_needs_exception_state(idl_type):
     return (idl_type.is_numeric_type or
             idl_type.is_enum or
             idl_type.is_dictionary or
             idl_type.name in ('Boolean', 'ByteString', 'Date', 'Dictionary', 'USVString', 'SerializedScriptValue'))
 
 IdlType.v8_conversion_needs_exception_state = property(v8_conversion_needs_exception_state)
 IdlArrayOrSequenceType.v8_conversion_needs_exception_state = True
+IdlRecordType.v8_conversion_needs_exception_state = True
 IdlUnionType.v8_conversion_needs_exception_state = True
 
 
 TRIVIAL_CONVERSIONS = frozenset([
     'any',
     'boolean',
     'Date',
     'Dictionary',
     'NodeFilter',
     'XPathNSResolver',
     'Promise'
 ])
 
 
 def v8_conversion_is_trivial(idl_type):
     # The conversion is a simple expression that returns the converted value and
     # cannot raise an exception.
     return (idl_type.base_type in TRIVIAL_CONVERSIONS or
             idl_type.is_wrapper_type)
 
 IdlType.v8_conversion_is_trivial = property(v8_conversion_is_trivial)
 
 
+def native_value_traits_type_name(idl_type):
+    if idl_type.is_nullable:
+        idl_type = idl_type.inner_type
+
+    if idl_type.native_array_element_type:
+        name = 'IDLSequence<%s>' % native_value_traits_type_name(idl_type.native_array_element_type)
+    elif idl_type.is_record_type:
+        name = 'IDLRecord<%s, %s>' % (native_value_traits_type_name(idl_type.key_type),
+                                      native_value_traits_type_name(idl_type.value_type))
+    elif idl_type.is_basic_type or idl_type.name in ('Date', 'Promise'):

[haraken, 2017/03/09 12:52:55]

I think Date is included in basic types.

[Raphael Kubo da Costa (rakuco), 2017/03/09 16:08:34]

Indeed. I'll fix this.

+        name = 'IDL%s' % idl_type.name
+    elif idl_type.implemented_as is not None:
+        name = idl_type.implemented_as
+    else:
+        name = idl_type.name
+    return name
+
+
 def v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index, isolate):
     if idl_type.name == 'void':
         return ''
 
     # Array or sequence types
     native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         return v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index, isolate)
 
     # Simple types
@@ skipping 27 matching lines @@
         nullable = 'UnionTypeConversionMode::Nullable' if idl_type.includes_nullable_type else 'UnionTypeConversionMode::NotNullable'
         cpp_expression_format = 'V8{idl_type}::toImpl({isolate}, {v8_value}, {variable_name}, %s, exceptionState)' % nullable
     elif idl_type.use_output_parameter_for_result:
         cpp_expression_format = 'V8{idl_type}::toImpl({isolate}, {v8_value}, {variable_name}, exceptionState)'
     elif idl_type.is_callback_function:
         cpp_expression_format = (
             '{idl_type}::create(ScriptState::current({isolate}), {v8_value})')
     elif idl_type.v8_conversion_needs_exception_state:
         # Effectively, this if branch means everything with v8_conversion_needs_exception_state == True
         # except for unions, sequences and dictionary interfaces.
-        if idl_type.is_nullable:
-            idl_type = idl_type.inner_type
-        if idl_type.is_primitive_type or idl_type.name in ('ByteString', 'Date', 'Promise', 'USVString'):
-            trait_type = 'IDL%s' % idl_type.name
-        else:
-            trait_type = idl_type.name
+        base_idl_type = native_value_traits_type_name(idl_type)
         cpp_expression_format = (
-            'NativeValueTraits<%s>::nativeValue({isolate}, {arguments})' % trait_type)
+            'NativeValueTraits<{idl_type}>::nativeValue({isolate}, {arguments})')
     else:
         cpp_expression_format = (
             'V8{idl_type}::toImplWithTypeCheck({isolate}, {v8_value})')
 
     return cpp_expression_format.format(arguments=arguments, idl_type=base_idl_type, v8_value=v8_value, variable_name=variable_name, isolate=isolate)
 
 
 def v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index, isolate='info.GetIsolate()'):
     # Index is None for setters, index (starting at 0) for method arguments,
     # and is used to provide a human-readable exception message
@@ skipping 151 matching lines @@
         return 'NullableDictionary'
 
     if idl_type.is_dictionary or idl_type.is_union_type:
         return 'DictionaryOrUnion'
 
     # Array or sequence types
     native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         return 'FrozenArray' if idl_type.is_frozen_array else 'array'
 
+    # Record types.
+    if idl_type.is_record_type:
+        return 'Record'
+
     # Simple types
     base_idl_type = idl_type.base_type
     # Basic types, without additional includes
     if base_idl_type in CPP_INTEGER_CONVERSION_RULES:
         return CPP_INTEGER_CONVERSION_RULES[base_idl_type]
     if idl_type.is_string_type:
         if idl_type.is_nullable:
             return 'StringOrNull'
         return base_idl_type
     if idl_type.is_basic_type or base_idl_type == 'ScriptValue':
@@ skipping 34 matching lines @@
     'double': 'v8SetReturnValue(info, {cpp_value})',
     'unrestricted double': 'v8SetReturnValue(info, {cpp_value})',
     # No special v8SetReturnValue* function, but instead convert value to V8
     # and then use general v8SetReturnValue.
     'array': 'v8SetReturnValue(info, {cpp_value})',
     'FrozenArray': 'v8SetReturnValue(info, {cpp_value})',
     'Date': 'v8SetReturnValue(info, {cpp_value})',
     'EventHandler': 'v8SetReturnValue(info, {cpp_value})',
     'ScriptValue': 'v8SetReturnValue(info, {cpp_value})',
     'SerializedScriptValue': 'v8SetReturnValue(info, {cpp_value})',
+    # Records.
+    'Record': 'v8SetReturnValue(info, ToV8({cpp_value}, info.Holder(), info.GetIsolate()))',
     # DOMWrapper
     'DOMWrapperForMainWorld': 'v8SetReturnValueForMainWorld(info, {cpp_value})',
     'DOMWrapperFast': 'v8SetReturnValueFast(info, {cpp_value}, {script_wrappable})',
     'DOMWrapperDefault': 'v8SetReturnValue(info, {cpp_value})',
     # If [CheckSecurity=ReturnValue] is specified, the returned object must be
     # wrapped in its own realm, which can be different from the realm of the
     # receiver object.
     #
     # [CheckSecurity=ReturnValue] is used only for contentDocument and
     # getSVGDocument attributes of HTML{IFrame,Frame,Object,Embed}Element,
@@ skipping 54 matching lines @@
     format_string = V8_SET_RETURN_VALUE[this_v8_conversion_type]
     statement = format_string.format(cpp_value=cpp_value, script_wrappable=script_wrappable)
     return statement
 
 
 IdlTypeBase.v8_set_return_value = v8_set_return_value
 
 
 CPP_VALUE_TO_V8_VALUE = {
     # Built-in types
     'Date': 'v8DateOrNaN({isolate}, {cpp_value})',

[haraken, 2017/03/09 12:52:55]

Not related to this CL, do you think it's a good idea to implement ToV8 for
primitive types so that we can always use ToV8 for C++ => JS conversions?

[Yuki, 2017/03/09 13:00:56]

We already have support of ToV8 for primitive types.
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/bindings/core/...

     'DOMString': 'v8String({isolate}, {cpp_value})',
     'ByteString': 'v8String({isolate}, {cpp_value})',
     'USVString': 'v8String({isolate}, {cpp_value})',
     'boolean': 'v8Boolean({cpp_value}, {isolate})',
     # All the int types below are converted to (u)int32_t in the v8::Integer::New*() calls.
     # The 64-bit int types have already been converted to double when CPP_VALUE_TO_V8_VALUE is used, so they are not
     # listed here.
     'int8_t': 'v8::Integer::New({isolate}, {cpp_value})',
     'int16_t': 'v8::Integer::New({isolate}, {cpp_value})',
     'int32_t': 'v8::Integer::New({isolate}, {cpp_value})',
     'uint8_t': 'v8::Integer::NewFromUnsigned({isolate}, {cpp_value})',
     'uint16_t': 'v8::Integer::NewFromUnsigned({isolate}, {cpp_value})',
     'uint32_t': 'v8::Integer::NewFromUnsigned({isolate}, {cpp_value})',
     'float': 'v8::Number::New({isolate}, {cpp_value})',
     'unrestricted float': 'v8::Number::New({isolate}, {cpp_value})',
     'double': 'v8::Number::New({isolate}, {cpp_value})',
     'unrestricted double': 'v8::Number::New({isolate}, {cpp_value})',
     'void': 'v8Undefined()',
     'StringOrNull': '{cpp_value}.isNull() ? v8::Local<v8::Value>(v8::Null({isolate})) : v8String({isolate}, {cpp_value})',
     # Special cases
     'Dictionary': '{cpp_value}.v8Value()',
     'EventHandler': (
         '{cpp_value} ? ' +
         'V8AbstractEventListener::cast({cpp_value})->getListenerOrNull(' +
         '{isolate}, impl->getExecutionContext()) : ' +
         'v8::Null({isolate}).As<v8::Value>()'),
+    'Record': 'ToV8({cpp_value}, {creation_context}, {isolate})',
     'ScriptValue': '{cpp_value}.v8Value()',
     'SerializedScriptValue': 'v8Deserialize({isolate}, {cpp_value})',
     # General
     'array': 'ToV8({cpp_value}, {creation_context}, {isolate})',
     'FrozenArray': 'freezeV8Object(ToV8({cpp_value}, {creation_context}, {isolate}), {isolate})',
     'DOMWrapper': 'ToV8({cpp_value}, {creation_context}, {isolate})',
     # Passing nullable dictionaries isn't a pattern currently used
     # anywhere in the web platform, and more work would be needed in
     # the code generator to distinguish between passing null, and
     # passing an object which happened to not contain any of the
@@ skipping 113 matching lines @@
     number_of_nullable_member_types_union)
 
 
 def includes_nullable_type_union(idl_type):
     # http://heycam.github.io/webidl/#dfn-includes-a-nullable-type
     return idl_type.number_of_nullable_member_types == 1
 
 IdlTypeBase.includes_nullable_type = False
 IdlNullableType.includes_nullable_type = True
 IdlUnionType.includes_nullable_type = property(includes_nullable_type_union)