IDL: Use IdlArrayOrSequenceType for array/sequence IDL types

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 21 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
+from idl_types import IdlTypeBase, IdlType, IdlUnionType, IdlArrayOrSequenceType
 import v8_attributes  # for IdlType.constructor_type_name
 from v8_globals import includes
 
 
 ################################################################################
 # V8-specific handling of IDL types
 ################################################################################
 
 NON_WRAPPER_TYPES = frozenset([
     'CompareHow',
@@ skipping 92 matching lines @@
             return 'TreatNullAsEmptyString'
         if idl_type.is_nullable or extended_attributes.get('TreatNullAs') == 'NullString':
             if extended_attributes.get('TreatUndefinedAs') == 'NullString':
                 return 'TreatNullAndUndefinedAsNullString'
             return 'TreatNullAsNullString'
         return ''
 
     extended_attributes = extended_attributes or {}
     idl_type = idl_type.preprocessed_type
 
-    # Composite types
+    # 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.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
@@ skipping 54 matching lines @@
 
 # Allow access as idl_type.cpp_type if no arguments
 IdlTypeBase.cpp_type = property(cpp_type)
 IdlTypeBase.cpp_type_initializer = property(cpp_type_initializer)
 IdlTypeBase.cpp_type_args = cpp_type
 IdlUnionType.cpp_type = property(cpp_type_union)
 IdlUnionType.cpp_type_initializer = property(cpp_type_initializer_union)
 IdlUnionType.cpp_type_args = cpp_type_union
 
 
+IdlTypeBase.native_array_element_type = None
+IdlArrayOrSequenceType.native_array_element_type = property(
+    lambda self: self.element_type)
+
+
 def cpp_template_type(template, inner_type):
     """Returns C++ template specialized to type, with space added if needed."""
     if inner_type.endswith('>'):
         format_string = '{template}<{inner_type} >'
     else:
         format_string = '{template}<{inner_type}>'
     return format_string.format(template=template, inner_type=inner_type)
 
 
 def cpp_ptr_type(old_type, new_type, gc_type):
@@ skipping 100 matching lines @@
                      'core/html/LabelsNodeList.h']),
     'Promise': set(['bindings/core/v8/ScriptPromise.h']),
     'SerializedScriptValue': set(['bindings/core/v8/SerializedScriptValue.h']),
     'ScriptValue': set(['bindings/core/v8/ScriptValue.h']),
 }
 
 
 def includes_for_type(idl_type):
     idl_type = idl_type.preprocessed_type
 
-    # Composite types
-    native_array_element_type = idl_type.native_array_element_type
-    if native_array_element_type:
-        return includes_for_type(native_array_element_type)
-
     # Simple types
     base_idl_type = idl_type.base_type
     if base_idl_type in INCLUDES_FOR_TYPE:
         return INCLUDES_FOR_TYPE[base_idl_type]
     if idl_type.is_basic_type:
         return set()
     if idl_type.is_typed_array_element_type:
         return set(['bindings/core/v8/custom/V8%sCustom.h' % base_idl_type])
     if base_idl_type.endswith('ConstructorConstructor'):
         # FIXME: rename to NamedConstructor
         # FIXME: replace with a [NamedConstructorAttribute] extended attribute
         # Ending with 'ConstructorConstructor' indicates a named constructor,
         # and these do not have header files, as they are part of the generated
         # bindings for the interface
         return set()
     if base_idl_type.endswith('Constructor'):
         # FIXME: replace with a [ConstructorAttribute] extended attribute
         base_idl_type = idl_type.constructor_type_name
     if base_idl_type not in component_dir:
         return set()
     return set(['bindings/%s/v8/V8%s.h' % (component_dir[base_idl_type],
                                            base_idl_type)])
 
 IdlType.includes_for_type = property(includes_for_type)
 IdlUnionType.includes_for_type = property(
     lambda self: set.union(*[includes_for_type(member_type)
                              for member_type in self.member_types]))
+IdlArrayOrSequenceType.includes_for_type = property(
+    lambda self: self.element_type.includes_for_type)
 
 
 def add_includes_for_type(idl_type):
     includes.update(idl_type.includes_for_type)
 
 IdlTypeBase.add_includes_for_type = add_includes_for_type
 
 
 def includes_for_interface(interface_name):
     return IdlType(interface_name).includes_for_type
@@ skipping 73 matching lines @@
     'ScriptValue': 'ScriptValue(ScriptState::current({isolate}), {v8_value})',
     'Window': 'toDOMWindow({v8_value}, {isolate})',
     'XPathNSResolver': 'toXPathNSResolver({v8_value}, {isolate})',
 }
 
 
 def v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index, isolate):
     if idl_type.name == 'void':
         return ''
 
-    # Composite types
+    # 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)
 
     # Simple types
     idl_type = idl_type.preprocessed_type
     add_includes_for_type(idl_type)
     base_idl_type = idl_type.base_type
 
     if 'EnforceRange' in extended_attributes:
@@ skipping 44 matching lines @@
 
     # FIXME: Support union type.
     if idl_type.is_union_type:
         return ''
 
     this_cpp_type = idl_type.cpp_type_args(extended_attributes=extended_attributes, raw_type=True)
 
     idl_type = idl_type.preprocessed_type
     cpp_value = v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index, isolate)
     args = [variable_name, cpp_value]
-    if idl_type.base_type == 'DOMString' and not idl_type.native_array_element_type:
+    if idl_type.base_type == 'DOMString':
         macro = 'TOSTRING_DEFAULT' if used_in_private_script else 'TOSTRING_VOID'
     elif idl_type.may_raise_exception_on_conversion:
         macro = 'TONATIVE_DEFAULT_EXCEPTIONSTATE' if used_in_private_script else 'TONATIVE_VOID_EXCEPTIONSTATE'
         args.append('exceptionState')
     else:
         macro = 'TONATIVE_DEFAULT' if used_in_private_script else 'TONATIVE_VOID'
 
     if used_in_private_script:
         args.append('false')
 
@@ skipping 56 matching lines @@
 
 def v8_conversion_type(idl_type, extended_attributes):
     """Returns V8 conversion type, adding any additional includes.
 
     The V8 conversion type is used to select the C++ -> V8 conversion function
     or v8SetReturnValue* function; it can be an idl_type, a cpp_type, or a
     separate name for the type of conversion (e.g., 'DOMWrapper').
     """
     extended_attributes = extended_attributes or {}
 
-    # Composite types
+    # FIXME: Support union type.
+    if idl_type.is_union_type:
+        return ''
+
+    # Array or sequence types
     native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         if native_array_element_type.is_interface_type:
             add_includes_for_type(native_array_element_type)
         return 'array'
 
     # Simple types
     base_idl_type = idl_type.base_type
     # Basic types, without additional includes
     if base_idl_type in CPP_INT_TYPES:
@@ skipping 98 matching lines @@
             for i, member_type in
             enumerate(idl_type.member_types)]
 
 IdlTypeBase.v8_set_return_value = v8_set_return_value
 IdlUnionType.v8_set_return_value = v8_set_return_value_union
 
 IdlType.release = property(lambda self: self.is_interface_type)
 IdlUnionType.release = property(
     lambda self: [member_type.is_interface_type
                   for member_type in self.member_types])
+IdlArrayOrSequenceType.release = False
 
 
 CPP_VALUE_TO_V8_VALUE = {
     # Built-in types
     'Date': 'v8DateOrNaN({cpp_value}, {isolate})',
     'DOMString': 'v8String({isolate}, {cpp_value})',
     'ByteString': 'v8String({isolate}, {cpp_value})',
     'ScalarValueString': 'v8String({isolate}, {cpp_value})',
     'boolean': 'v8Boolean({cpp_value}, {isolate})',
     'int': 'v8::Integer::New({isolate}, {cpp_value})',
@@ skipping 42 matching lines @@
 ################################################################################
 # Utility properties for nullable types
 ################################################################################
 
 
 def cpp_type_has_null_value(idl_type):
     # - String types (String/AtomicString) represent null as a null string,
     #   i.e. one for which String::isNull() returns true.
     # - Wrapper types (raw pointer or RefPtr/PassRefPtr) represent null as
     #   a null pointer.
-    return ((idl_type.is_string_type or idl_type.is_wrapper_type) and
-            not idl_type.native_array_element_type)
+    return idl_type.is_string_type or idl_type.is_wrapper_type
 
 IdlTypeBase.cpp_type_has_null_value = property(cpp_type_has_null_value)
 
 
 def is_implicit_nullable(idl_type):
     # Nullable type where the corresponding C++ type supports a null value.
     return idl_type.is_nullable and idl_type.cpp_type_has_null_value
 
 
 def is_explicit_nullable(idl_type):
     # Nullable type that isn't implicit nullable (see above.) For such types,
     # we use Nullable<T> or similar explicit ways to represent a null value.
     return idl_type.is_nullable and not idl_type.is_implicit_nullable
 
 IdlTypeBase.is_implicit_nullable = property(is_implicit_nullable)
 IdlUnionType.is_implicit_nullable = False
 IdlTypeBase.is_explicit_nullable = property(is_explicit_nullable)