Attempt to land Dartium roll a second time.

tools/dom/scripts/generator.py

 #!/usr/bin/python
 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module provides shared functionality for systems to generate
 Dart APIs from the IDL database."""
 
 import copy
 import json
 import monitored
 import os
 import re
 from htmlrenamer import html_interface_renames, typed_array_renames
 
 _pure_interfaces = monitored.Set('generator._pure_interfaces', [
     # TODO(sra): DOMStringMap should be a class implementing Map<String,String>.
     'DOMStringMap',
     'ChildNode',
     'EventListener',
+    'EventHandler',
     'MediaQueryListListener',
     'MutationCallback',
     'ParentNode',
     'SVGExternalResourcesRequired',
     'SVGFilterPrimitiveStandardAttributes',
     'SVGFitToViewBox',
     'SVGTests',
     'SVGURIReference',
     'SVGZoomAndPan',
     'TimeoutHandler',
@@ skipping 745 matching lines @@
 
   def merged_into(self):
     return self._data.merged_into
 
 
 class CallbackIDLTypeInfo(IDLTypeInfo):
   def __init__(self, idl_type, data):
     super(CallbackIDLTypeInfo, self).__init__(idl_type, data)
 
 
+def array_type(data_type):
+  matched = re.match(r'([\w\d_\s]+)\[\]', data_type)
+  if not matched:
+      return None
+  return matched.group(1)
+
 class SequenceIDLTypeInfo(IDLTypeInfo):
   def __init__(self, idl_type, data, item_info):
     super(SequenceIDLTypeInfo, self).__init__(idl_type, data)
     self._item_info = item_info
 
   def dart_type(self):
     return 'List<%s>' % self._item_info.dart_type()
 
   def interface_name(self):
     return self.dart_type()
 
   def implementation_name(self):
     return self.dart_type()
 
   def vector_to_dart_template_parameter(self):
     raise Exception('sequences of sequences are not supported yet')
 
   def to_native_info(self, idl_node, interface_name):
     item_native_type = self._item_info.vector_to_dart_template_parameter()
     if isinstance(self._item_info, PrimitiveIDLTypeInfo):
       return '%s', 'Vector<%s>' % item_native_type, 'DartUtilities', 'toNativeVector<%s>' % item_native_type
     return '%s', 'Vector< RefPtr<%s> >' % item_native_type, 'DartUtilities', 'toNativeVector< RefPtr<%s> >' % item_native_type
 
   def parameter_type(self):
-    return self.native_type()
+    native_type = self.native_type()
+    if array_type(native_type):
+      return 'const Vector<RefPtr<%s> > &' % array_type(native_type)
+
+    return native_type
 
   def pass_native_by_ref(self): return True
 
   def to_dart_conversion(self, value, interface_name=None, attributes=None):
     if isinstance(self._item_info, PrimitiveIDLTypeInfo):
       return 'DartDOMWrapper::vectorToDart(%s)' % value
     return 'DartDOMWrapper::vectorToDart<%s>(%s)' % (self._item_info.bindings_class(), value)
 
   def conversion_includes(self):
     return self._item_info.conversion_includes()
@@ skipping 202 matching lines @@
     'SerializedScriptValue': TypeData(clazz='Primitive', dart_type='dynamic'),
     'sequence': TypeData(clazz='Primitive', dart_type='List'),
     'void': TypeData(clazz='Primitive', dart_type='void'),
 
     'CSSRule': TypeData(clazz='Interface', conversion_includes=['CSSImportRule']),
     'DOMStringMap': TypeData(clazz='Interface', dart_type='Map<String, String>'),
     'Window': TypeData(clazz='Interface', custom_to_dart=True),
     'Element': TypeData(clazz='Interface', merged_interface='HTMLElement',
         custom_to_dart=True),
     'EventListener': TypeData(clazz='Interface', custom_to_native=True),
+    'EventHandler': TypeData(clazz='Interface', custom_to_native=True),
     'EventTarget': TypeData(clazz='Interface', custom_to_native=True),
     'HTMLElement': TypeData(clazz='Interface', merged_into='Element',
         custom_to_dart=True),
     'IDBAny': TypeData(clazz='Interface', dart_type='dynamic', custom_to_native=True),
     'MutationRecordArray': TypeData(clazz='Interface',  # C++ pass by pointer.
         native_type='MutationRecordArray', dart_type='List<MutationRecord>'),
     'StyleSheet': TypeData(clazz='Interface', conversion_includes=['CSSStyleSheet']),
     'SVGElement': TypeData(clazz='Interface', custom_to_dart=True),
 
     'ClientRectList': TypeData(clazz='Interface',
@@ skipping 92 matching lines @@
   def DartType(self, type_name):
     return self.TypeInfo(type_name).dart_type()
 
   def _TypeInfo(self, type_name):
     match = re.match(r'(?:sequence<(\w+)>|(\w+)\[\])$', type_name)
     if match:
       type_data = TypeData('Sequence')
       item_info = self.TypeInfo(match.group(1) or match.group(2))
       # TODO(vsm): Generalize this code.
       if 'SourceInfo' in type_name:
-        type_data.native_type = 'Vector<RefPtr<SourceInfo> >'
+        type_data.native_type = 'const Vector<RefPtr<SourceInfo> >& '
       return SequenceIDLTypeInfo(type_name, type_data, item_info)
 
     if not type_name in _idl_type_registry:
       if self._database.HasEnum(type_name):
         return PrimitiveIDLTypeInfo(
             type_name,
             TypeData(clazz='Primitive', dart_type='String', native_type='String'))
 
       interface = self._database.GetInterface(type_name)
       if 'Callback' in interface.ext_attrs:
@@ skipping 16 matching lines @@
       return InterfaceIDLTypeInfo(type_name, type_data, dart_interface_name,
                                   self)
 
     if type_data.clazz == 'SVGTearOff':
       dart_interface_name = self._renamer.RenameInterface(
           self._database.GetInterface(type_name))
       return SVGTearOffIDLTypeInfo(
           type_name, type_data, dart_interface_name, self)
 
     if type_data.clazz == 'TypedList':
-      dart_interface_name = self._renamer.RenameInterface(
-          self._database.GetInterface(type_name))
+      dart_interface_name = self._renamer.RenameInterfaceId(type_name)
       return TypedListIDLTypeInfo(
           type_name, type_data, dart_interface_name, self)
 
     if type_data.clazz == 'BasicTypedList':
       if type_name == 'ArrayBuffer':
         dart_interface_name = 'ByteBuffer'
       else:
-        dart_interface_name = self._renamer.RenameInterface(
-            self._database.GetInterface(type_name))
+        dart_interface_name = self._renamer.RenameInterfaceId(type_name)
       return BasicTypedListIDLTypeInfo(
           type_name, type_data, dart_interface_name, self)
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)