Future-ify all the html methods and add named parameters

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 43 matching lines @@
   'DataView.setFloat32',
   'DataView.setFloat64',
   'DataView.setInt16',
   'DataView.setInt32',
   'DataView.setInt8',
   'DataView.setUint16',
   'DataView.setUint32',
   'DataView.setUint8',
   'DirectoryEntry.getDirectory',
   'DirectoryEntry.getFile',
+  'Entry.copyTo',
+  'Entry.moveTo',
+  'HTMLInputElement.setRangeText',
+  'XMLHttpRequest.open',
   ])
 
 #
 # Renames for attributes that have names that are not legal Dart names.
 #
 _dart_attribute_renames = monitored.Dict('generator._dart_attribute_renames', {
     'default': 'defaultValue',
 })
 
 #
@@ skipping 55 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)."""
+  callback_handlers = [operation for operation in interface.operations
+      if operation.id == 'handleEvent']
+  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:
       # Callbacks with 'Optional=XXX' are treated as optional arguments.
       return 'Optional' in argument.ext_attrs
     if constructor:
       # FIXME: Constructors with 'Optional=XXX' shouldn't be treated as
       # optional arguments.
@@ skipping 56 matching lines @@
   info.operations = operations
   info.overloads = split_operations
   info.declared_name = operations[0].id
   info.name = operations[0].ext_attrs.get('DartName', info.declared_name)
   info.constructor_name = None
   info.js_name = info.declared_name
   info.type_name = operations[0].type.id   # TODO: widen.
   info.param_infos = _BuildArguments([op.arguments for op in split_operations], interface)
   full_name = '%s.%s' % (interface.id, info.declared_name)
   info.requires_named_arguments = full_name in _methods_with_named_formals
+  # 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
+  # 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):
   """Returns an OperationInfo object for the constructor.
 
   Returns None if the interface has no Constructor.
   """
   if 'Constructor' in interface.ext_attrs:
     name = None
     overloads = interface.ext_attrs['Constructor']
     idl_args = [[] if f is None else f.arguments for f in overloads]
@@ skipping 107 matching lines @@
     argtexts = map(FormatParam, required)
     if optional:
       needs_named = self.requires_named_arguments and not force_optional
       left_bracket, right_bracket = '{}' if needs_named else '[]'
       argtexts.append(
           left_bracket +
           ', '.join(map(FormatParam, optional)) +
           right_bracket)
     return ', '.join(argtexts)
 
-  def ParametersAsArgumentList(self, parameter_count = None):
+  def ParametersAsArgumentList(self, parameter_count=None):
     """Returns a string of the parameter names suitable for passing the
     parameters as arguments.
     """
+    def param_name(param_info):
+      if self.requires_named_arguments and param_info.is_optional:
+        return '%s : %s' % (param_info.name, param_info.name)
+      else:
+        return param_info.name
+
     if parameter_count is None:
       parameter_count = len(self.param_infos)
-    return ', '.join(map(
-        lambda param_info: param_info.name,
-        self.param_infos[:parameter_count]))
+    return ', '.join(map(param_name, self.param_infos[:parameter_count]))
 
   def IsStatic(self):
     is_static = self.overloads[0].is_static
     assert any([is_static == o.is_static for o in self.overloads])
     return is_static
 
   def _ConstructorFullName(self, rename_type):
     if self.constructor_name:
       return rename_type(self.type_name) + '.' + self.constructor_name
     else:
@@ skipping 1021 matching lines @@
     'DOMMimeTypeArray': TypeData(clazz='Interface', item_type='DOMMimeType'),
     'DOMPluginArray': TypeData(clazz='Interface', item_type='DOMPlugin'),
     'DOMStringList': TypeData(clazz='Interface', item_type='DOMString',
         dart_type='List<String>', custom_to_native=True),
     'EntryArray': TypeData(clazz='Interface', item_type='Entry',
         suppress_interface=True),
     'EntryArraySync': TypeData(clazz='Interface', item_type='EntrySync',
         suppress_interface=True),
     'FileList': TypeData(clazz='Interface', item_type='File',
         dart_type='List<File>'),
+    'Future': TypeData(clazz='Interface', dart_type='Future'),
     'GamepadList': TypeData(clazz='Interface', item_type='Gamepad',
         suppress_interface=True),
     'HTMLAllCollection': TypeData(clazz='Interface', item_type='Node'),
     'HTMLCollection': TypeData(clazz='Interface', item_type='Node'),
     'MediaStreamList': TypeData(clazz='Interface',
         item_type='MediaStream', suppress_interface=True),
     'NamedNodeMap': TypeData(clazz='Interface', item_type='Node'),
     'NodeList': TypeData(clazz='Interface', item_type='Node',
                          suppress_interface=False, dart_type='List<Node>'),
     'SVGElementInstanceList': TypeData(clazz='Interface',
@@ skipping 94 matching lines @@
                                   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)
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)