Roll IDL Dartium37 (r181477)

bindings/dart/scripts/dart_interface.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 377 matching lines @@
     for extended_attribute_name in extended_attributes:
         ignore_extended_values = IGNORE_EXTENDED_ATTRIBUTES.get(extended_attribute_name)
         if ignore_extended_values != None:
             extended_attribute_value = extended_attributes.get(extended_attribute_name)
             if ((not ignore_extended_values and extended_attribute_value == None) or
                 extended_attribute_value in ignore_extended_values):
                 return True
     return False
 
 
+def add_native_entries(interface, constructors, is_custom):
+    for constructor in constructors:
+        types = None
+        if not is_custom:
+            types = [arg['preprocessed_type']
+                     for arg in constructor['arguments']]
+        argument_names = [arg['name'] for arg in constructor['arguments']]
+        native_entry = \
+            DartUtilities.generate_native_entry(interface.name, constructor,
+                                                None, 'Constructor', None,
+                                                argument_names, types)
+        constructor.update({'native_entry': native_entry})
+
+
 def generate_interface(interface):
     includes.clear()
     includes.update(INTERFACE_CPP_INCLUDES)
     header_includes = set(INTERFACE_H_INCLUDES)
 
     parent_interface = interface.parent
     if parent_interface:
         header_includes.update(dart_types.includes_for_interface(parent_interface))
     extended_attributes = interface.extended_attributes
 
@@ skipping 125 matching lines @@
     any_type_attributes = [attribute for attribute in interface.attributes
                            if attribute.idl_type.name == 'Any']
     if has_event_constructor:
         includes.add('bindings/common/Dictionary.h')
         if any_type_attributes:
             includes.add('bindings/v8/SerializedScriptValue.h')
 
     # [NamedConstructor]
     named_constructor = generate_named_constructor(interface)
 
+    add_native_entries(interface, constructors, bool(custom_constructors))
+    add_native_entries(interface, custom_constructors, bool(custom_constructors))
+    if named_constructor:
+        add_native_entries(interface, [named_constructor], bool(custom_constructors))
+
     if (constructors or custom_constructors or has_event_constructor or
         named_constructor):
         includes.add('core/frame/LocalDOMWindow.h')
 
     template_contents.update({
         'any_type_attributes': any_type_attributes,
         'constructors': constructors,
         'custom_constructors': custom_constructors,
         'has_custom_constructor': bool(custom_constructors),
         'has_event_constructor': has_event_constructor,
@@ skipping 49 matching lines @@
                    not _suppress_extended_attributes(method.extended_attributes) and
                    not 'DartSuppress' in method.extended_attributes)]
     generate_overloads(methods)
     for method in methods:
         method['do_generate_method_configuration'] = (
             method['do_not_check_signature'] and
             not method['per_context_enabled_function'] and
             # For overloaded methods, only generate one accessor
             ('overload_index' not in method or method['overload_index'] == 1))
 
+    generate_method_native_entries(interface, methods)
+
     template_contents.update({
         'has_origin_safe_method_setter': any(
             method['is_check_security_for_frame'] and not method['is_read_only']
             for method in methods),
         'has_method_configuration': any(method['do_generate_method_configuration'] for method in methods),
         'has_per_context_enabled_methods': any(method['per_context_enabled_function'] for method in methods),
         'methods': methods,
     })
 
+    native_entries = generate_native_entries(interface, constructors,
+                                             custom_constructors, attributes,
+                                             methods, named_constructor)
+
     template_contents.update({
         'indexed_property_getter': indexed_property_getter(interface),
         'indexed_property_setter': indexed_property_setter(interface),
         'indexed_property_deleter': indexed_property_deleter(interface),
         'is_override_builtins': 'OverrideBuiltins' in extended_attributes,
         'named_property_getter': named_property_getter(interface),
         'named_property_setter': named_property_setter(interface),
         'named_property_deleter': named_property_deleter(interface),
+        'native_entries': native_entries,
     })
 
     return template_contents
 
 
+def generate_native_entries(interface, constructors, custom_constructors,
+                            attributes, methods, named_constructor):
+    entries = []
+    for constructor in constructors:
+        entries.append(constructor['native_entry'])
+    for constructor in custom_constructors:
+        entries.append(constructor['native_entry'])
+    if named_constructor:
+        entries.append(named_constructor['native_entry'])
+    for method in methods:
+        entries.extend(method['native_entries'])
+    for attribute in attributes:
+        entries.append(attribute['native_entry_getter'])
+        entries.append(attribute['native_entry_setter'])
+    return entries
+
+
 # [DeprecateAs], [Reflect], [RuntimeEnabled]
 def generate_constant(constant):
     # (Blink-only) string literals are unquoted in tokenizer, must be re-quoted
     # in C++.
     if constant.idl_type.name == 'String':
         value = '"%s"' % constant.value
     else:
         value = constant.value
 
     extended_attributes = constant.extended_attributes
     return {
         'cpp_class': extended_attributes.get('PartialInterfaceImplementedAs'),
         'name': constant.name,
         # FIXME: use 'reflected_name' as correct 'name'
         'reflected_name': extended_attributes.get('Reflect', constant.name),
         'runtime_enabled_function': DartUtilities.runtime_enabled_function_name(constant),
         'value': value,
     }
 
 
 ################################################################################
 # Overloads
 ################################################################################
 
+def generate_method_native_entry(interface, method, count, optional_index):
+    types = None
+    if not method['is_custom']:
+        types = [arg['preprocessed_type'] for arg in method['arguments'][0:count]]
+    if method['is_call_with_script_arguments']:
+        types.append("object")
+    argument_names = [arg['name'] for arg in method['arguments'][0:count]]
+    name = method['name']
+    native_entry = \
+        DartUtilities.generate_native_entry(interface.name, method,
+                                            name, 'Method',
+                                            optional_index,
+                                            argument_names, types)
+    return native_entry
+
+
+def generate_method_native_entries(interface, methods):
+    for method in methods:
+        native_entries = []
+        required_arg_count = method['number_of_required_arguments']
+        arg_count = method['number_of_arguments']
+        if required_arg_count != arg_count:
+            for x in range(required_arg_count, arg_count + 1):
+                # This is really silly, but is here for now just to match up
+                # the existing name generation in the old dart:html scripts
+                index = arg_count - x + 1
+                native_entry = \
+                    generate_method_native_entry(interface, method, x, index)
+                native_entries.append(native_entry)
+        else:
+            # Eventually, we should probably always generate an unindexed
+            # native entry, to handle cases like
+            # addEventListener in which we suppress the optionality,
+            # and in general to make us more robust against optional changes
+            native_entry = \
+                generate_method_native_entry(interface, method, arg_count, None)
+            native_entries.append(native_entry)
+
+        method.update({'native_entries': native_entries})
+
 def generate_overloads(methods):
     generate_overloads_by_type(methods, is_static=False)  # Regular methods
     generate_overloads_by_type(methods, is_static=True)
 
 
 def generate_overloads_by_type(methods, is_static):
     # Generates |overloads| template values and modifies |methods| in place;
     # |is_static| flag used (instead of partitioning list in 2) because need to
     # iterate over original list of methods to modify in place
     method_counts = defaultdict(lambda: 0)
@@ skipping 155 matching lines @@
         'number_of_required_arguments':
             number_of_required_arguments(constructor),
         }
 
 
 # We don't need much from this - just the idl_type_objects and preproceed_type
 # to use in generating the resolver strings.
 def custom_constructor_argument(argument, index):
     return {
         'idl_type_object': argument.idl_type,
-        'preprocessed_type': argument.idl_type.preprocessed_type,
+        'name': argument.name,
+        'preprocessed_type': str(argument.idl_type.preprocessed_type),
     }
 
 
 # [Constructor]
 def generate_constructor(interface, constructor):
     return {
         'argument_list': constructor_argument_list(interface, constructor),
         # TODO(terry): Use dart_methods.generate_argument instead constructor_argument.
         'arguments': [constructor_argument(interface, argument, index)
                       for index, argument in enumerate(constructor.arguments)],
@@ skipping 48 matching lines @@
     default_value = str(argument.default_value) if argument.default_value else None
 
     argument_content = {
         'cpp_type': idl_type.cpp_type_args(),
         'local_cpp_type': idl_type.cpp_type_args(argument.extended_attributes, used_as_argument=True),
         # FIXME: check that the default value's type is compatible with the argument's
         'default_value': default_value,
         # FIXME: remove once [Default] removed and just use argument.default_value
         'has_default': 'Default' in argument.extended_attributes or default_value,
         'idl_type_object': idl_type,
-        'preprocessed_type': idl_type.preprocessed_type,
+        'preprocessed_type': str(idl_type.preprocessed_type),
         # Dictionary is special-cased, but arrays and sequences shouldn't be
         'idl_type': not idl_type.array_or_sequence_type and idl_type.base_type,
         'index': index,
         'is_array_or_sequence_type': not not idl_type.array_or_sequence_type,
         'is_optional': argument.is_optional,
         'is_strict_type_checking': False,  # Required for overload resolution
         'name': argument.name,
         'dart_value_to_local_cpp_value': dart_methods.dart_value_to_local_cpp_value(interface, argument, index),
     }
     return argument_content
@@ skipping 229 matching lines @@
         deleter = next(
             method
             for method in interface.operations
             if ('deleter' in method.specials and
                 len(method.arguments) == 1 and
                 str(method.arguments[0].idl_type) == 'DOMString'))
     except StopIteration:
         return None
 
     return property_deleter(deleter)