Roll 50: Updated for push to origin/master.

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
@@ skipping 383 matching lines @@
     self.is_optional = is_optional
 
   def Copy(self):
     return ParamInfo(self.name, self.type_id, self.is_optional)
 
   def __repr__(self):
     content = 'name = %s, type_id = %s, is_optional = %s' % (
         self.name, self.type_id, self.is_optional)
     return '<ParamInfo(%s)>' % content
 
-def GetCallbackInfo(interface):
-  """For the given interface, find operations that take callbacks (for use in
-  auto-transforming callbacks into futures)."""
+def GetCallbackHandlers(interface):
+  callback_handlers = []
   callback_handlers = [operation for operation in interface.operations
       if operation.id == 'handleEvent']
   if callback_handlers == []:
     callback_handlers = [operation for operation in interface.operations
                          if operation.id == 'handleItem']
+  return callback_handlers
+
+def GetCallbackInfo(interface):
+  """For the given interface, find operations that take callbacks (for use in
+  auto-transforming callbacks into futures)."""
+  callback_handlers = GetCallbackHandlers(interface)
   return AnalyzeOperation(interface, callback_handlers)
 
 # Given a list of overloaded arguments, render dart arguments.
 def _BuildArguments(args, interface, constructor=False):
   def IsOptional(argument):
     if 'Callback' in argument.ext_attrs:
       # Optional callbacks arguments are treated as optional arguments.
       return argument.optional
     if constructor:
       # FIXME: Optional constructors arguments should not be treated as
@@ skipping 75 matching lines @@
   # The arguments in that the original operation took as callbacks (for
   # conversion to futures).
   info.callback_args = []
   return info
 
 def ConvertToFuture(info):
   """Given an OperationInfo object, convert the operation's signature so that it
   instead uses futures instead of callbacks."""
   new_info = copy.deepcopy(info)
   def IsNotCallbackType(param):
-    return 'Callback' not in param.type_id
+    type_id = param.type_id
+    if type_id is None:
+      return False
+    else:
+      return 'Callback' not in type_id
+
   # Success callback is the first argument (change if this no longer holds).
   new_info.callback_args = filter(
       lambda x: not IsNotCallbackType(x), new_info.param_infos)
   new_info.param_infos = filter(IsNotCallbackType, new_info.param_infos)
   new_info.type_name = 'Future'
 
   return new_info
 
 
 def AnalyzeConstructor(interface):
@@ skipping 116 matching lines @@
     """
     def FormatParam(param):
       # Is the type a typedef if so it's a union so it's dynamic.
       # TODO(terry): This may have to change for dart2js for code shaking the
       #              return types (unions) needs to be emitted with @create
       #              annotations and/or with JS('type1|type2',...)
       if hasattr(rename_type, 'im_self') and rename_type.im_self._database.HasTypeDef(param.type_id):
         dart_type = 'dynamic'
       else:
         dart_type = rename_type(param.type_id) if param.type_id else 'dynamic'
+      # Special handling for setlike IDL forEach operation.
+      if dart_type is None and param.type_id.endswith('ForEachCallback'):
+        dart_type = param.type_id
       return (TypeOrNothing(dart_type, param.type_id), param.name)
     required = []
     optional = []
     for param_info in self.param_infos:
       if param_info.is_optional:
         optional.append(FormatParam(param_info))
       else:
         if optional:
           raise Exception('Optional parameters cannot precede required ones: '
                           + str(param_info))
@@ skipping 519 matching lines @@
   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()
+    darttype = self._item_info.dart_type()
+    return 'List' if darttype is None else 'List<%s>' % darttype
 
   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')
 
@@ skipping 316 matching lines @@
     'GLushort': TypeData(clazz='Primitive', dart_type='int', native_type='int'),
     'GLuint': TypeData(clazz='Primitive', dart_type='int',
         native_type='unsigned'),
     'GLfloat': TypeData(clazz='Primitive', dart_type='num', native_type='float'),
     'GLclampf': TypeData(clazz='Primitive', dart_type='num', native_type='float'),
     'HTMLCollection': TypeData(clazz='Interface', item_type='Node',
         dart_type='List<Node>'),
     'NamedNodeMap': TypeData(clazz='Interface', item_type='Node'),
     'NodeList': TypeData(clazz='Interface', item_type='Node',
                          suppress_interface=False, dart_type='List<Node>'),
+    'NotificationAction': TypedListTypeData(''),
     'SVGElementInstanceList': TypeData(clazz='Interface',
         item_type='SVGElementInstance', suppress_interface=True),
     'SourceBufferList': TypeData(clazz='Interface', item_type='SourceBuffer'),
     'SpeechGrammarList': TypeData(clazz='Interface', item_type='SpeechGrammar'),
     'SpeechInputResultList': TypeData(clazz='Interface',
         item_type='SpeechInputResult', suppress_interface=True),
     'SpeechRecognitionResultList': TypeData(clazz='Interface',
         item_type='SpeechRecognitionResult', suppress_interface=True),
     'SQLResultSetRowList': TypeData(clazz='Interface', item_type='Dictionary'),
     'StyleSheetList': TypeData(clazz='Interface',
@@ skipping 25 matching lines @@
         native_type='SVGPathSegListPropertyTearOff'),
     'SVGPoint': TypeData(clazz='SVGTearOff', native_type='SVGPointTearOff'),
     'SVGPointList': TypeData(clazz='SVGTearOff', native_type='SVGPointListTearOff'),
     'SVGPreserveAspectRatio': TypeData(clazz='SVGTearOff', native_type='SVGPreserveAspectRatioTearOff'),
     'SVGRect': TypeData(clazz='SVGTearOff', native_type='SVGRectTearOff'),
     'SVGStringList': TypeData(clazz='SVGTearOff', item_type='DOMString',
         native_type='SVGStringListTearOff'),
     'SVGTransform': TypeData(clazz='SVGTearOff', native_type="SVGPropertyTearOff<SVGTransform>"),
     'SVGTransformList': TypeData(clazz='SVGTearOff', item_type='SVGTransform',
         native_type='SVGTransformListPropertyTearOff'),
+
+     # Add any setlike forEach Callback types here.
+    'FontFaceSetForEachCallback': TypeData(clazz='Interface', item_type='FontFaceSetForEachCallback'),
 })
 
 _svg_supplemental_includes = [
     '"core/svg/properties/SVGPropertyTraits.h"',
 ]
 
 class TypeRegistry(object):
   def __init__(self, database, renamer=None):
     self._database = database
     self._renamer = renamer
@@ skipping 127 matching lines @@
             return_type == 'Rectangle')
 
 def wrap_return_type_blink(return_type, type_name, type_registry):
     """Returns True if we should wrap the returned value. This checks
     a number of different variations, calling the more basic functions
     above."""
     return (wrap_unwrap_type_blink(return_type, type_registry) or
             wrap_unwrap_type_blink(type_name, type_registry) or
             wrap_type_blink(return_type, type_registry) or
             wrap_unwrap_list_blink(return_type, type_registry))