Move IDLs to 39 roll

bindings/scripts/v8_interface.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 # coding=utf-8
 #
 # 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
@@ skipping 28 matching lines @@
 import idl_definitions
 from idl_definitions import IdlOperation
 import idl_types
 from idl_types import IdlType, inherits_interface
 import v8_attributes
 from v8_globals import includes
 import v8_methods
 import v8_types
 from v8_types import cpp_ptr_type, cpp_template_type
 import v8_utilities
-from v8_utilities import capitalize, conditional_string, cpp_name, gc_type, has_extended_attribute_value, runtime_enabled_function_name
+from v8_utilities import (capitalize, conditional_string, cpp_name, gc_type,
+                          has_extended_attribute_value, runtime_enabled_function_name,
+                          extended_attribute_value_as_list)
 
 
 INTERFACE_H_INCLUDES = frozenset([
     'bindings/common/ScriptWrappable.h',
     'bindings/core/v8/V8Binding.h',
     'bindings/core/v8/V8DOMWrapper.h',
     'bindings/core/v8/WrapperTypeInfo.h',
     'platform/heap/Handle.h',
 ])
 INTERFACE_CPP_INCLUDES = frozenset([
@@ skipping 34 matching lines @@
     is_active_dom_object = 'ActiveDOMObject' in extended_attributes
 
     # [CheckSecurity]
     is_check_security = 'CheckSecurity' in extended_attributes
     if is_check_security:
         includes.add('bindings/common/BindingSecurity.h')
 
     # [DependentLifetime]
     is_dependent_lifetime = 'DependentLifetime' in extended_attributes
 
+    # [Iterable]
+    iterator_method = None
+    if 'Iterable' in extended_attributes:
+        iterator_operation = IdlOperation(interface.idl_name)
+        iterator_operation.name = 'iterator'
+        iterator_operation.idl_type = IdlType('Iterator')
+        iterator_operation.extended_attributes['RaisesException'] = None
+        iterator_operation.extended_attributes['CallWith'] = 'ScriptState'
+        iterator_method = v8_methods.method_context(interface,
+                                                    iterator_operation)
+
     # [MeasureAs]
     is_measure_as = 'MeasureAs' in extended_attributes
     if is_measure_as:
         includes.add('core/frame/UseCounter.h')
 
     # [SetWrapperReferenceFrom]
     reachable_node_function = extended_attributes.get('SetWrapperReferenceFrom')
     if reachable_node_function:
         includes.update(['bindings/core/v8/V8GCController.h',
                          'core/dom/Element.h'])
 
     # [SetWrapperReferenceTo]
     set_wrapper_reference_to_list = [{
         'name': argument.name,
         # FIXME: properly should be:
         # 'cpp_type': argument.idl_type.cpp_type_args(raw_type=True),
         # (if type is non-wrapper type like NodeFilter, normally RefPtr)
         # Raw pointers faster though, and NodeFilter hacky anyway.
         'cpp_type': argument.idl_type.implemented_as + '*',
         'idl_type': argument.idl_type,
         'v8_type': v8_types.v8_type(argument.idl_type.name),
     } for argument in extended_attributes.get('SetWrapperReferenceTo', [])]
     for set_wrapper_reference_to in set_wrapper_reference_to_list:
         set_wrapper_reference_to['idl_type'].add_includes_for_type()
 
+    # [NotScriptWrappable]
+    is_script_wrappable = 'NotScriptWrappable' not in extended_attributes
+
     # [SpecialWrapFor]
     if 'SpecialWrapFor' in extended_attributes:
-        special_wrap_for = extended_attributes['SpecialWrapFor'].split('|')
+        special_wrap_for = extended_attribute_value_as_list(interface, 'SpecialWrapFor')
     else:
         special_wrap_for = []
     for special_wrap_interface in special_wrap_for:
         v8_types.add_includes_for_interface(special_wrap_interface)
 
     # [Custom=Wrap], [SetWrapperReferenceFrom]
     has_visit_dom_wrapper = (
         has_extended_attribute_value(interface, 'Custom', 'VisitDOMWrapper') or
         reachable_node_function or
         set_wrapper_reference_to_list)
 
     this_gc_type = gc_type(interface)
 
+    wrapper_class_id = ('NodeClassId' if inherits_interface(interface.name, 'Node') else 'ObjectClassId')
+
     context = {
         'conditional_string': conditional_string(interface),  # [Conditional]
         'cpp_class': cpp_name(interface),
         'gc_type': this_gc_type,
+        # FIXME: Remove 'EventTarget' special handling, http://crbug.com/383699
+        'has_access_check_callbacks': (is_check_security and
+                                       interface.name != 'Window' and
+                                       interface.name != 'EventTarget'),
         'has_custom_legacy_call_as_function': has_extended_attribute_value(interface, 'Custom', 'LegacyCallAsFunction'),  # [Custom=LegacyCallAsFunction]
         'has_custom_to_v8': has_extended_attribute_value(interface, 'Custom', 'ToV8'),  # [Custom=ToV8]
         'has_custom_wrap': has_extended_attribute_value(interface, 'Custom', 'Wrap'),  # [Custom=Wrap]
         'has_visit_dom_wrapper': has_visit_dom_wrapper,
         'header_includes': header_includes,
         'interface_name': interface.name,
         'is_active_dom_object': is_active_dom_object,
         'is_audio_buffer': is_audio_buffer,
         'is_check_security': is_check_security,
         'is_dependent_lifetime': is_dependent_lifetime,
         'is_document': is_document,
         'is_event_target': inherits_interface(interface.name, 'EventTarget'),
         'is_exception': interface.is_exception,
         'is_node': inherits_interface(interface.name, 'Node'),
+        'is_script_wrappable': is_script_wrappable,
+        'iterator_method': iterator_method,
+        'lifetime': 'Dependent'
+            if (has_visit_dom_wrapper or
+                is_active_dom_object or
+                is_dependent_lifetime)
+            else 'Independent',
         'measure_as': v8_utilities.measure_as(interface),  # [MeasureAs]
         'parent_interface': parent_interface,
         'pass_cpp_type': cpp_template_type(
             cpp_ptr_type('PassRefPtr', 'RawPtr', this_gc_type),
             cpp_name(interface)),
         'reachable_node_function': reachable_node_function,
         'runtime_enabled_function': runtime_enabled_function_name(interface),  # [RuntimeEnabled]
         'set_wrapper_reference_to_list': set_wrapper_reference_to_list,
         'special_wrap_for': special_wrap_for,
         'v8_class': v8_utilities.v8_class_name(interface),
-        'wrapper_configuration': 'WrapperConfiguration::Dependent'
-            if (has_visit_dom_wrapper or
-                is_active_dom_object or
-                is_dependent_lifetime)
-            else 'WrapperConfiguration::Independent',
+        'wrapper_class_id': wrapper_class_id,
     }
 
     # Constructors
     constructors = [constructor_context(interface, constructor)
                     for constructor in interface.constructors
                     # FIXME: shouldn't put named constructors with constructors
                     # (currently needed for Perl compatibility)
                     # Handle named constructors separately
                     if constructor.name == 'Constructor']
     if len(constructors) > 1:
@@ skipping 26 matching lines @@
         'any_type_attributes': any_type_attributes,
         'constructors': constructors,
         'has_custom_constructor': bool(custom_constructors),
         'has_event_constructor': has_event_constructor,
         'interface_length':
             interface_length(interface, constructors + custom_constructors),
         'is_constructor_raises_exception': extended_attributes.get('RaisesException') == 'Constructor',  # [RaisesException=Constructor]
         'named_constructor': named_constructor,
     })
 
+    constants = [constant_context(constant) for constant in interface.constants]
+
+    special_getter_constants = []
+    runtime_enabled_constants = []
+    constant_configuration_constants = []
+
+    for constant in constants:
+        if constant['measure_as'] or constant['deprecate_as']:
+            special_getter_constants.append(constant)
+            continue
+        if constant['runtime_enabled_function']:
+            runtime_enabled_constants.append(constant)
+            continue
+        constant_configuration_constants.append(constant)
+
     # Constants
     context.update({
-        'constants': [constant_context(constant)
-                      for constant in interface.constants],
+        'constant_configuration_constants': constant_configuration_constants,
+        'constants': constants,
         'do_not_check_constants': 'DoNotCheckConstants' in extended_attributes,
+        'has_constant_configuration': any(
+            not constant['runtime_enabled_function']
+            for constant in constants),
+        'runtime_enabled_constants': runtime_enabled_constants,
+        'special_getter_constants': special_getter_constants,
     })
 
     # Attributes
     attributes = [v8_attributes.attribute_context(interface, attribute)
                   for attribute in interface.attributes
                   if not v8_utilities.dart_custom_method(attribute.extended_attributes)]
     context.update({
         'attributes': attributes,
         'has_accessors': any(attribute['is_expose_js_accessors'] and attribute['should_be_exposed_to_script'] for attribute in attributes),
         'has_attribute_configuration': any(
@@ skipping 93 matching lines @@
         'named_property_getter': named_property_getter(interface),
         'named_property_setter': named_property_setter(interface),
         'named_property_deleter': named_property_deleter(interface),
     })
 
     return context
 
 
 # [DeprecateAs], [Reflect], [RuntimeEnabled]
 def constant_context(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'),
+        'deprecate_as': v8_utilities.deprecate_as(constant),  # [DeprecateAs]
         'idl_type': constant.idl_type.name,
+        'measure_as': v8_utilities.measure_as(constant),  # [MeasureAs]
         'name': constant.name,
         # FIXME: use 'reflected_name' as correct 'name'
         'reflected_name': extended_attributes.get('Reflect', constant.name),
         'runtime_enabled_function': runtime_enabled_function_name(constant),
-        'value': value,
+        'value': constant.value,
     }
 
 
 ################################################################################
 # Overloads
 ################################################################################
 
 def compute_method_overloads_context(methods):
     # Regular methods
     compute_method_overloads_context_by_type([method for method in methods
@@ skipping 67 matching lines @@
     # of the extended attributes in question.
     if not overloads[0].get('is_constructor'):
         overload_extended_attributes = [
             method['custom_registration_extended_attributes']
             for method in overloads]
         for extended_attribute in v8_methods.CUSTOM_REGISTRATION_EXTENDED_ATTRIBUTES:
             if common_key(overload_extended_attributes, extended_attribute) is None:
                 raise ValueError('Overloads of %s have conflicting extended attribute %s'
                                  % (name, extended_attribute))
 
+    # Check and fail if overloads disagree about whether the return type
+    # is a Promise or not.
+    promise_overload_count = sum(1 for method in overloads if method.get('idl_type') == 'Promise')
+    if promise_overload_count not in (0, len(overloads)):
+        raise ValueError('Overloads of %s have conflicting Promise/non-Promise types'
+                         % (name))
+
     return {
         'deprecate_all_as': common_value(overloads, 'deprecate_as'),  # [DeprecateAs]
         'exposed_test_all': common_value(overloads, 'exposed_test'),  # [Exposed]
         'has_custom_registration_all': common_value(overloads, 'has_custom_registration'),
         'length_tests_methods': length_tests_methods(effective_overloads_by_length),
         # 1. Let maxarg be the length of the longest type list of the
         # entries in S.
         'maxarg': lengths[-1],
         'measure_all_as': common_value(overloads, 'measure_as'),  # [MeasureAs]
         'minarg': lengths[0],
@@ skipping 274 matching lines @@
         test = 'V8{idl_type}::hasInstance({cpp_value}, info.GetIsolate())'.format(idl_type=idl_type.base_type, cpp_value=cpp_value)
         yield test, method
 
     # 8. Otherwise: if V is any kind of object except for a native Date object,
     # a native RegExp object, and there is an entry in S that has one of the
     # following types at position i of its type list,
     # • an array type
     # • a sequence type
     # ...
     # • a dictionary
-    try:
-        # FIXME: IDL dictionary not implemented, so use Blink Dictionary
-        # http://crbug.com/321462
-        idl_type, method = next((idl_type, method)
-                                for idl_type, method in idl_types_methods
-                                if (idl_type.native_array_element_type or
-                                    idl_type.name == 'Dictionary'))
+    #
+    # FIXME:
+    # We don't strictly follow the algorithm here. The algorithm says "remove
+    # all other entries" if there is "one entry" matching, but we yield all
+    # entries to support following constructors:
+    # [constructor(sequence<DOMString> arg), constructor(Dictionary arg)]
+    # interface I { ... }
+    # (Need to check array types before objects because an array is an object)
+    for idl_type, method in idl_types_methods:
         if idl_type.native_array_element_type:
             # (We test for Array instead of generic Object to type-check.)
             # FIXME: test for Object during resolution, then have type check for
             # Array in overloaded method: http://crbug.com/262383
-            test = '%s->IsArray()' % cpp_value
-        else:
+            yield '%s->IsArray()' % cpp_value, method
+    for idl_type, method in idl_types_methods:
+        if idl_type.is_dictionary or idl_type.name == 'Dictionary':
             # FIXME: should be '{1}->IsObject() && !{1}->IsDate() && !{1}->IsRegExp()'.format(cpp_value)
             # FIXME: the IsDate and IsRegExp checks can be skipped if we've
             # already generated tests for them.
-            test = '%s->IsObject()' % cpp_value
-        yield test, method
-    except StopIteration:
-        pass
+            yield '%s->IsObject()' % cpp_value, method
 
     # (Check for exact type matches before performing automatic type conversion;
     # only needed if distinguishing between primitive types.)
     if len([idl_type.is_primitive_type for idl_type in idl_types]) > 1:
         # (Only needed if match in step 11, otherwise redundant.)
         if any(idl_type.is_string_type or idl_type.is_enum
                for idl_type in idl_types):
             # 10. Otherwise: if V is a Number value, and there is an entry in S
             # that has one of the following types at position i of its type
             # list,
@@ skipping 82 matching lines @@
     l.sort(key=key)
     return ((k, list(g)) for k, g in itertools.groupby(l, key))
 
 
 ################################################################################
 # Constructors
 ################################################################################
 
 # [Constructor]
 def constructor_context(interface, constructor):
-    arguments_need_try_catch = any(v8_methods.argument_needs_try_catch(argument, return_promise=False)
-                                   for argument in constructor.arguments)
-
     # [RaisesException=Constructor]
     is_constructor_raises_exception = \
         interface.extended_attributes.get('RaisesException') == 'Constructor'
 
     return {
         'arguments': [v8_methods.argument_context(interface, constructor, argument, index)
                       for index, argument in enumerate(constructor.arguments)],
-        'arguments_need_try_catch': arguments_need_try_catch,
         'cpp_type': cpp_template_type(
             cpp_ptr_type('RefPtr', 'RawPtr', gc_type(interface)),
             cpp_name(interface)),
         'cpp_value': v8_methods.cpp_value(
             interface, constructor, len(constructor.arguments)),
         'has_exception_state':
             is_constructor_raises_exception or
             any(argument for argument in constructor.arguments
                 if argument.idl_type.name == 'SerializedScriptValue' or
-                   argument.idl_type.may_raise_exception_on_conversion),
+                   argument.idl_type.v8_conversion_needs_exception_state),
         'is_call_with_document':
             # [ConstructorCallWith=Document]
             has_extended_attribute_value(interface,
                 'ConstructorCallWith', 'Document'),
         'is_call_with_execution_context':
             # [ConstructorCallWith=ExecutionContext]
             has_extended_attribute_value(interface,
                 'ConstructorCallWith', 'ExecutionContext'),
         'is_constructor': True,
         'is_named_constructor': False,
@@ skipping 93 matching lines @@
 def property_setter(setter):
     idl_type = setter.arguments[1].idl_type
     extended_attributes = setter.extended_attributes
     is_raises_exception = 'RaisesException' in extended_attributes
     return {
         'has_type_checking_interface':
             has_extended_attribute_value(setter, 'TypeChecking', 'Interface') and
             idl_type.is_wrapper_type,
         'idl_type': idl_type.base_type,
         'is_custom': 'Custom' in extended_attributes,
-        'has_exception_state': is_raises_exception or
-                               idl_type.is_integer_type,
+        'has_exception_state': (is_raises_exception or
+                                idl_type.v8_conversion_needs_exception_state),
         'is_raises_exception': is_raises_exception,
         'name': cpp_name(setter),
         'v8_value_to_local_cpp_value': idl_type.v8_value_to_local_cpp_value(
             extended_attributes, 'v8Value', 'propertyValue'),
     }
 
 
 def property_deleter(deleter):
     idl_type = deleter.idl_type
     if str(idl_type) != 'boolean':
@@ skipping 106 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)