Replace EntryArray type by an Entry[]

Source/bindings/scripts/code_generator_v8.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 108 matching lines @@
         return 'v8Boolean(%s, %s)' % (cpp_value, isolate)
     if data_type in ['long long', 'unsigned long long', 'DOMTimeStamp']:
         # long long and unsigned long long are not representable in ECMAScript.
         return 'v8::Number::New(static_cast<double>(%s))' % cpp_value
     if primitive_type(data_type):
         if data_type not in ['float', 'double']:
             raise Exception('unexpected data_type %s' % data_type)
         return 'v8::Number::New(%s)' % cpp_value
     if data_type == 'DOMString':
         return 'v8String(%s, %s)' % (cpp_value, isolate)
-    if sequence_type(data_type):
+    if array_or_sequence_type(data_type):
         return 'v8Array(%s, %s)' % (cpp_value, isolate)
     return 'toV8(%s, %s, %s)' % (cpp_value, creation_context, isolate)
 
 
 def generate_conditional_string(interface_or_attribute_or_operation):
     if 'Conditional' not in interface_or_attribute_or_operation.extended_attributes:
         return ''
     conditional = interface_or_attribute_or_operation.extended_attributes['Conditional']
     for operator in ['&', '|']:
         if operator in conditional:
             conditions = set(conditional.split(operator))
             operator_separator = ' %s%s ' % (operator, operator)
             return operator_separator.join(['ENABLE(%s)' % expression for expression in sorted(conditions)])
     return 'ENABLE(%s)' % conditional
 
 
 def includes_for_type(data_type):
     if primitive_type(data_type) or data_type == 'DOMString':
         return set()
-    if sequence_type(data_type):
-        return includes_for_type(sequence_type(data_type))
+    if array_or_sequence_type(data_type):
+        return includes_for_type(array_or_sequence_type(data_type))
     return set(['V8%s.h' % data_type])
 
 
 def includes_for_cpp_class(class_name, relative_dir_posix):
     return set([posixpath.join('bindings', relative_dir_posix, class_name + '.h')])
 
 
 def includes_for_operation(operation):
     includes = includes_for_type(operation.data_type)
     for parameter in operation.arguments:
         includes |= includes_for_type(parameter.data_type)
     return includes
 
 
 def primitive_type(data_type):
     return data_type in PRIMITIVE_TYPES
 
 
 def sequence_type(data_type):
     matched = re.match(r'sequence<([\w\d_\s]+)>', data_type)
     if not matched:
         return None
     return matched.group(1)
 
 
+def array_type(data_type):
+    matched = re.match(r'([\w\d_\s]+)\[\]', data_type)
+    if not matched:
+        return None
+    return matched.group(1)
+
+
+def array_or_sequence_type(data_type):
+    return array_type(data_type) or sequence_type(data_type)
+
 def cpp_type(data_type, pointer_type):
     """Returns the C++ type corresponding to the IDL type.
 
     Args:
         pointer_type:
             'raw': return raw pointer form (e.g. Foo*)
             'RefPtr': return RefPtr form (e.g. RefPtr<Foo>)
             'PassRefPtr': return PassRefPtr form (e.g. RefPtr<Foo>)
     """
     if data_type in CPP_TYPE_SPECIAL_CONVERSION_RULES:
         return CPP_TYPE_SPECIAL_CONVERSION_RULES[data_type]
-    if sequence_type(data_type):
-        return 'Vector<%s >' % cpp_type(sequence_type(data_type), 'RefPtr')
+    if array_or_sequence_type(data_type):
+        return 'const Vector<%s >&' % cpp_type(array_or_sequence_type(data_type), 'RefPtr')
     if pointer_type == 'raw':
         return data_type + '*'
     if pointer_type in ['RefPtr', 'PassRefPtr']:
         return '%s<%s>' % (pointer_type, data_type)
     raise Exception('Unrecognized pointer type: "%s"' % pointer_type)
 
 
 def v8_type(data_type):
     return 'V8' + data_type
 
@@ skipping 143 matching lines @@
 
         methods = [generate_method(operation) for operation in self.interface.operations]
         template_contents = {
             'cpp_class_name': self.interface.name,
             'v8_class_name': v8_class_name(self.interface),
             'cpp_includes': sorted(list(self.cpp_includes)),
             'header_includes': sorted(list(self.header_includes)),
             'methods': methods,
         }
         return template_contents