Fixes for Blink roll.

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',
+    #'Crypto',
     'ElementTimeControl',
     'ElementTraversal',
     'EventListener',
     'MediaQueryListListener',
     'MutationCallback',
+    'ParentNode',
+    #'SubtleCrypto',

[Jacob, 2013/07/24 16:12:00]

remove commented out class names or add comments on why they are removed

     'SVGExternalResourcesRequired',
     'SVGFilterPrimitiveStandardAttributes',
     'SVGFitToViewBox',
     'SVGLangSpace',
     'SVGLocatable',
     'SVGTests',
     'SVGTransformable',
     'SVGURIReference',
     'SVGZoomAndPan',
     'TimeoutHandler',
+    'WindowTimers',
+    #'WorkerCrypto',
+    'WorkerPerformance',
     ])
 
 def IsPureInterface(interface_name):
   return interface_name in _pure_interfaces
 
 #
 # Classes which have native constructors but which we are suppressing because
 # they are not cross-platform.
 #
 _suppressed_native_constructors = monitored.Set(
@@ skipping 468 matching lines @@
                            'dynamic', 'dynamic')
 
 dart2js_conversions = monitored.Dict('generator.dart2js_conversions', {
     'Date get':
       Conversion('convertNativeToDart_DateTime', 'dynamic', 'DateTime'),
     'Date set':
       Conversion('convertDartToNative_DateTime', 'DateTime', 'dynamic'),
     # Wrap non-local Windows.  We need to check EventTarget (the base type)
     # as well.  Note, there are no functions that take a non-local Window
     # as a parameter / setter.
-    'DOMWindow get':
+    'Window get':
       Conversion('_convertNativeToDart_Window', 'dynamic', 'WindowBase'),
     'EventTarget get':
       Conversion('_convertNativeToDart_EventTarget', 'dynamic',
                  'EventTarget'),
     'EventTarget set':
       Conversion('_convertDartToNative_EventTarget', 'EventTarget',
                  'dynamic'),
 
     'ImageData get':
       Conversion('convertNativeToDart_ImageData', 'dynamic', 'ImageData'),
     'ImageData set':
       Conversion('convertDartToNative_ImageData', 'ImageData', 'dynamic'),
 
     'Dictionary get':
       Conversion('convertNativeToDart_Dictionary', 'dynamic', 'Map'),
     'Dictionary set':
       Conversion('convertDartToNative_Dictionary', 'Map', 'dynamic'),
 
     'sequence<DOMString> set':
       Conversion('convertDartToNative_StringArray', 'List<String>', 'List'),
 
     'any set IDBObjectStore.add': _serialize_SSV,
     'any set IDBObjectStore.put': _serialize_SSV,
     'any set IDBCursor.update': _serialize_SSV,
 
     # postMessage
     'any set MessagePort.postMessage': _serialize_SSV,
-    'SerializedScriptValue set DOMWindow.postMessage': _serialize_SSV,
+    'SerializedScriptValue set Window.postMessage': _serialize_SSV,
 
     '* get CustomEvent.detail':
       Conversion('convertNativeToDart_SerializedScriptValue',
                  'dynamic', 'dynamic'),
 
     # receiving message via MessageEvent
     '* get MessageEvent.data':
       Conversion('convertNativeToDart_SerializedScriptValue',
                  'dynamic', 'dynamic'),
 
@@ skipping 182 matching lines @@
     if self.merged_into():
       return '_%s' % self.idl_type()
 
     if not self.has_generated_interface():
       implementation_name = '_%s' % implementation_name
 
     return implementation_name
 
   def native_type(self):
     database = self._type_registry._database
+
     if database.HasInterface(self.idl_type()):
       interface = database.GetInterface(self.idl_type())
       if 'ImplementedAs' in interface.ext_attrs:
         return interface.ext_attrs['ImplementedAs']
     return super(InterfaceIDLTypeInfo, self).native_type()
 
   def has_generated_interface(self):
     return not self._data.suppress_interface
 
   def list_item_type(self):
@@ skipping 41 matching lines @@
 
   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()
+
   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 197 matching lines @@
     'PositionOptions': TypeData(clazz='Primitive', dart_type='Object'),
     # TODO(sra): Come up with some meaningful name so that where this appears in
     # the documentation, the user is made aware that only a limited subset of
     # serializable types are actually permitted.
     '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>'),
-    'DOMWindow': TypeData(clazz='Interface', custom_to_dart=True),
+    '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),
     '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']),
@@ skipping 91 matching lines @@
     if not type_name in self._cache:
       self._cache[type_name] = self._TypeInfo(type_name)
     return self._cache[type_name]
 
   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')
       if type_name == 'DOMString[]':
-        return DOMStringArrayTypeInfo(TypeData('Sequence'), self.TypeInfo('DOMString'))
+        return DOMStringArrayTypeInfo(type_data, self.TypeInfo('DOMString'))
       item_info = self.TypeInfo(match.group(1) or match.group(2))
-      return SequenceIDLTypeInfo(type_name, TypeData('Sequence'), item_info)
+      # TODO(vsm): Generalize this code.
+      if 'SourceInfo' in type_name:
+        type_data.native_type = '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:
         return CallbackIDLTypeInfo(type_name, TypeData('Callback',
@@ skipping 28 matching lines @@
           type_name, type_data, dart_interface_name, self)
 
     if type_data.clazz == 'BasicTypedList':
       dart_interface_name = self._renamer.RenameInterface(
           self._database.GetInterface(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)