Roll 50: Copied IDLs, PYTHON scripts from WebKit removed deleted files in WebCore

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, IdlArgument
 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 (cpp_name_or_partial, capitalize, conditional_string, cpp_name, gc_type,
+from v8_utilities import (origin_trial_enabled_function, cpp_name_or_partial, capitalize, cpp_name, gc_type,
                           has_extended_attribute_value, runtime_enabled_function_name,
                           extended_attribute_value_as_list, is_legacy_interface_type_checking)
 
 
 INTERFACE_H_INCLUDES = frozenset([
     'bindings/core/v8/ScriptWrappable.h',
     'bindings/core/v8/ToV8.h',
     'bindings/core/v8/V8Binding.h',
     'bindings/core/v8/V8DOMWrapper.h',
     'bindings/core/v8/WrapperTypeInfo.h',
     'platform/heap/Handle.h',
 ])
 INTERFACE_CPP_INCLUDES = frozenset([
     'bindings/core/v8/ExceptionState.h',
     'bindings/core/v8/V8DOMConfiguration.h',
     'bindings/core/v8/V8ObjectConstructor.h',
-    'core/dom/ContextFeatures.h',
     'core/dom/Document.h',
-    'platform/RuntimeEnabledFeatures.h',
-    'platform/TraceEvent.h',
     'wtf/GetPtr.h',
     'wtf/RefPtr.h',
 ])
 
 
 def interface_context(interface):
     includes.clear()
     includes.update(INTERFACE_CPP_INCLUDES)
     header_includes = set(INTERFACE_H_INCLUDES)
 
     if interface.is_partial:
         # A partial interface definition cannot specify that the interface
         # inherits from another interface. Inheritance must be specified on
         # the original interface definition.
         parent_interface = None
         is_event_target = False
         # partial interface needs the definition of its original interface.
         includes.add('bindings/core/v8/V8%s.h' % interface.name)
     else:
         parent_interface = interface.parent
         if parent_interface:
             header_includes.update(v8_types.includes_for_interface(parent_interface))
         is_event_target = inherits_interface(interface.name, 'EventTarget')
 
     extended_attributes = interface.extended_attributes
 
     is_array_buffer_or_view = interface.idl_type.is_array_buffer_or_view
     is_typed_array_type = interface.idl_type.is_typed_array
     if is_array_buffer_or_view:
-        includes.add('bindings/core/v8/V8ArrayBuffer.h')
+        includes.update(('bindings/core/v8/V8ArrayBuffer.h',
+                         'bindings/core/v8/V8SharedArrayBuffer.h'))
     if interface.name == 'ArrayBufferView':
         includes.update((
             'bindings/core/v8/V8Int8Array.h',
             'bindings/core/v8/V8Int16Array.h',
             'bindings/core/v8/V8Int32Array.h',
             'bindings/core/v8/V8Uint8Array.h',
             'bindings/core/v8/V8Uint8ClampedArray.h',
             'bindings/core/v8/V8Uint16Array.h',
             'bindings/core/v8/V8Uint32Array.h',
             'bindings/core/v8/V8Float32Array.h',
             'bindings/core/v8/V8Float64Array.h',
             'bindings/core/v8/V8DataView.h'))
 
-    # [ActiveDOMObject]
-    is_active_dom_object = 'ActiveDOMObject' in extended_attributes
-
     # [CheckSecurity]
     is_check_security = 'CheckSecurity' in extended_attributes
     if is_check_security:
         includes.add('bindings/core/v8/BindingSecurity.h')
 
     # [DependentLifetime]
     is_dependent_lifetime = 'DependentLifetime' in extended_attributes
 
-    # [MeasureAs]
-    is_measure_as = 'MeasureAs' in extended_attributes
-    if is_measure_as:
-        includes.add('core/frame/UseCounter.h')
+    # [PrimaryGlobal] and [Global]
+    is_global = ('PrimaryGlobal' in extended_attributes or
+                 'Global' in extended_attributes)
 
     # [SetWrapperReferenceFrom]
     set_wrapper_reference_from = extended_attributes.get('SetWrapperReferenceFrom')
     if set_wrapper_reference_from:
         includes.update(['bindings/core/v8/V8GCController.h',
                          'core/dom/Element.h'])
 
     # [SetWrapperReferenceTo]
     set_wrapper_reference_to_argument = extended_attributes.get('SetWrapperReferenceTo')
     set_wrapper_reference_to = None
@@ skipping 17 matching lines @@
 
     this_gc_type = gc_type(interface)
 
     wrapper_class_id = ('NodeClassId' if inherits_interface(interface.name, 'Node') else 'ObjectClassId')
 
     v8_class_name = v8_utilities.v8_class_name(interface)
     cpp_class_name = cpp_name(interface)
     cpp_class_name_or_partial = cpp_name_or_partial(interface)
     v8_class_name_or_partial = v8_utilities.v8_class_name_or_partial(interface)
 
+    if 'RuntimeEnabled' in extended_attributes:
+        includes.add('platform/RuntimeEnabledFeatures.h')
+
+    if 'OriginTrialEnabled' in extended_attributes:
+        includes.add('core/inspector/ConsoleMessage.h')
+        includes.add('core/origin_trials/OriginTrials.h')
+
     context = {
-        'conditional_string': conditional_string(interface),  # [Conditional]
         'cpp_class': cpp_class_name,
         'cpp_class_or_partial': cpp_class_name_or_partial,
         'event_target_inheritance': 'InheritFromEventTarget' if is_event_target else 'NotInheritFromEventTarget',
         '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_partial_interface': len(interface.partial_interfaces) > 0,
         '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_array_buffer_or_view': is_array_buffer_or_view,
         'is_check_security': is_check_security,
         'is_event_target': is_event_target,
         'is_exception': interface.is_exception,
+        'is_global': is_global,
         'is_node': inherits_interface(interface.name, 'Node'),
         'is_partial': interface.is_partial,
         'is_typed_array_type': is_typed_array_type,
-        'lifetime': 'Dependent'
-            if (has_visit_dom_wrapper or
-                is_active_dom_object or
-                is_dependent_lifetime)
-            else 'Independent',
+        'lifetime': 'Dependent' if (has_visit_dom_wrapper or is_dependent_lifetime) else 'Independent',
         'measure_as': v8_utilities.measure_as(interface, None),  # [MeasureAs]
+        'origin_trial_name': v8_utilities.origin_trial_name(interface),
         'parent_interface': parent_interface,
         'pass_cpp_type': cpp_template_type(
             cpp_ptr_type('PassRefPtr', 'RawPtr', this_gc_type),
             cpp_name(interface)),
         'runtime_enabled_function': runtime_enabled_function_name(interface),  # [RuntimeEnabled]
         'set_wrapper_reference_from': set_wrapper_reference_from,
         'set_wrapper_reference_to': set_wrapper_reference_to,
         'v8_class': v8_class_name,
         'v8_class_or_partial': v8_class_name_or_partial,
         'wrapper_class_id': wrapper_class_id,
@@ skipping 14 matching lines @@
         'number_of_required_arguments':
             number_of_required_arguments(constructor),
     } for constructor in interface.custom_constructors]
 
     # [NamedConstructor]
     named_constructor = named_constructor_context(interface)
 
     if constructors or custom_constructors or named_constructor:
         if interface.is_partial:
             raise Exception('[Constructor] and [NamedConstructor] MUST NOT be'
-                            ' specified on partial interface definitions:'
+                            ' specified on partial interface definitions: '
                             '%s' % interface.name)
 
         includes.add('bindings/core/v8/V8ObjectConstructor.h')
         includes.add('core/frame/LocalDOMWindow.h')
+    elif 'Measure' in extended_attributes or 'MeasureAs' in extended_attributes:
+        raise Exception('[Measure] or [MeasureAs] specified for interface without a constructor: '
+                        '%s' % interface.name)
 
     # [Unscopeable] attributes and methods
     unscopeables = []
     for attribute in interface.attributes:
         if 'Unscopeable' in attribute.extended_attributes:
             unscopeables.append((attribute.name, v8_utilities.runtime_enabled_function_name(attribute)))
     for method in interface.operations:
         if 'Unscopeable' in method.extended_attributes:
             unscopeables.append((method.name, v8_utilities.runtime_enabled_function_name(method)))
 
     context.update({
         'constructors': constructors,
         'has_custom_constructor': bool(custom_constructors),
         'interface_length':
             interface_length(interface, constructors + custom_constructors),
         'is_constructor_raises_exception': extended_attributes.get('RaisesException') == 'Constructor',  # [RaisesException=Constructor]
         'named_constructor': named_constructor,
         'unscopeables': sorted(unscopeables),
     })
 
     constants = [constant_context(constant, interface) for constant in interface.constants]
 
     special_getter_constants = []
-    runtime_enabled_constants = []
+    runtime_enabled_constants = dict()
     constant_configuration_constants = []
 
     for constant in constants:
-        if constant['measure_as'] or constant['deprecate_as']:
+        if constant['measure_as'] or constant['deprecate_as'] or constant['origin_trial_name']:
             special_getter_constants.append(constant)
             continue
-        if constant['runtime_enabled_function']:
-            runtime_enabled_constants.append(constant)
+        runtime_enabled_function = constant['runtime_enabled_function']
+        if runtime_enabled_function:
+            if runtime_enabled_function not in runtime_enabled_constants:
+                runtime_enabled_constants[runtime_enabled_function] = []
+            runtime_enabled_constants[runtime_enabled_function].append(constant)
             continue
         constant_configuration_constants.append(constant)
 
     # Constants
     context.update({
         '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,
+        'runtime_enabled_constants': sorted(runtime_enabled_constants.iteritems()),
         'special_getter_constants': special_getter_constants,
     })
 
     # Attributes
     attributes = [v8_attributes.attribute_context(interface, attribute)
                   for attribute in interface.attributes]
 
     has_conditional_attributes = any(attribute['exposed_test'] for attribute in attributes)
     if has_conditional_attributes and interface.is_partial:
         raise Exception('Conditional attributes between partial interfaces in modules and the original interfaces(%s) in core are not allowed.' % interface.name)
 
     context.update({
         'attributes': attributes,
         'has_accessor_configuration': any(
-            attribute['is_expose_js_accessors'] and
-            not (attribute['is_static'] or
+            not (attribute['exposed_test'] or
                  attribute['runtime_enabled_function']) and
+            not attribute['is_data_type_property'] and
             attribute['should_be_exposed_to_script']
             for attribute in attributes),
         'has_attribute_configuration': any(
-             not (attribute['is_expose_js_accessors'] or
-                  attribute['is_static'] or
-                  attribute['runtime_enabled_function'])
-             and attribute['should_be_exposed_to_script']
-             for attribute in attributes),
+            not (attribute['exposed_test'] or
+                 attribute['runtime_enabled_function']) and
+            attribute['is_data_type_property'] and
+            attribute['should_be_exposed_to_script']
+            for attribute in attributes),
         'has_constructor_attributes': any(attribute['constructor_type'] for attribute in attributes),
+        'needs_constructor_setter_callback': any(attribute['constructor_type'] == attribute['name'] for attribute in attributes),
         'has_replaceable_attributes': any(attribute['is_replaceable'] for attribute in attributes),
     })
 
     # Methods
     methods = []
     if interface.original_interface:
         methods.extend([v8_methods.method_context(interface, operation, is_visible=False)
                         for operation in interface.original_interface.operations
                         if operation.name])
     methods.extend([v8_methods.method_context(interface, method)
@@ skipping 24 matching lines @@
         argument = IdlArgument(interface.idl_name)
         argument.idl_type = idl_type
         argument.name = name
         argument.is_optional = is_optional
         if extended_attributes:
             argument.extended_attributes.update(extended_attributes)
         return argument
 
     # [Iterable], iterable<>, maplike<> and setlike<>
     iterator_method = None
+    has_array_iterator = False
+
     # FIXME: support Iterable in partial interfaces. However, we don't
     # need to support iterator overloads between interface and
     # partial interface definitions.
     # http://heycam.github.io/webidl/#idl-overloading
     if (not interface.is_partial
         and (interface.iterable or interface.maplike or interface.setlike
-             or 'Iterable' in extended_attributes)):
+             or interface.has_indexed_elements or 'Iterable' in extended_attributes)):
 
         used_extended_attributes = {}
 
         if interface.iterable:
             used_extended_attributes.update(interface.iterable.extended_attributes)
         elif interface.maplike:
             used_extended_attributes.update(interface.maplike.extended_attributes)
         elif interface.setlike:
             used_extended_attributes.update(interface.setlike.extended_attributes)
 
@@ skipping 12 matching lines @@
             'CallWith': ['ScriptState', 'ThisValue'],
         })
 
         def generated_iterator_method(name, implemented_as=None):
             return generated_method(
                 return_type=IdlType('Iterator'),
                 name=name,
                 extended_attributes=used_extended_attributes,
                 implemented_as=implemented_as)
 
-        iterator_method = generated_iterator_method('iterator', implemented_as='iterator')
+        if interface.iterable or interface.maplike or interface.setlike or 'Iterable' in extended_attributes:
+            iterator_method = generated_iterator_method('iterator', implemented_as='iterator')
+        elif interface.has_indexed_elements:
+            has_array_iterator = True
 
         if interface.iterable or interface.maplike or interface.setlike:
             implicit_methods = [
                 generated_iterator_method('keys'),
                 generated_iterator_method('values'),
                 generated_iterator_method('entries'),
 
                 # void forEach(Function callback, [Default=Undefined] optional any thisArg)
                 generated_method(IdlType('void'), 'forEach',
                                  arguments=[generated_argument(IdlType('Function'), 'callback'),
@@ skipping 146 matching lines @@
         # FIXME: This calculation doesn't take into account whether runtime
         # enabled overloads are actually enabled, so length may be incorrect.
         # E.g., [RuntimeEnabled=Foo] void f(); void f(long x);
         # should have length 1 if Foo is not enabled, but length 0 if it is.
         method['length'] = (method['overloads']['length'] if 'overloads' in method else
                             method['number_of_required_arguments'])
 
     context.update({
         'conditionally_enabled_methods': conditionally_enabled_methods,
         'custom_registration_methods': custom_registration_methods,
-        'has_origin_safe_method_setter': any(
-            method['is_check_security_for_frame'] and not method['is_read_only']
+        'has_origin_safe_method_setter': is_global and any(
+            method['is_check_security_for_receiver'] and not method['is_unforgeable']
             for method in methods),
         'has_private_script': any(attribute['is_implemented_in_private_script'] for attribute in attributes) or
             any(method['is_implemented_in_private_script'] for method in methods),
         'iterator_method': iterator_method,
+        'has_array_iterator': has_array_iterator,
         'method_configuration_methods': method_configuration_methods,
         'methods': methods,
     })
 
     # Conditionally enabled members
     has_conditional_attributes_on_instance = any(
         attribute['exposed_test'] and attribute['on_instance']
         for attribute in attributes)
     has_conditional_attributes_on_prototype = any(
         attribute['exposed_test'] and attribute['on_prototype']
         for attribute in attributes)
     context.update({
         'has_conditional_attributes_on_instance':
             has_conditional_attributes_on_instance,
         'has_conditional_attributes_on_prototype':
             has_conditional_attributes_on_prototype,
     })
 
     context.update({
         'indexed_property_getter': property_getter(interface.indexed_property_getter, ['index']),
         'indexed_property_setter': property_setter(interface.indexed_property_setter, interface),
         'indexed_property_deleter': property_deleter(interface.indexed_property_deleter),
         'is_override_builtins': 'OverrideBuiltins' in extended_attributes,
         'named_property_getter': property_getter(interface.named_property_getter, ['propertyName']),
         'named_property_setter': property_setter(interface.named_property_setter, interface),
         'named_property_deleter': property_deleter(interface.named_property_deleter),
     })
+    context.update({
+        'has_named_properties_object': is_global and context['named_property_getter'],
+    })
 
     return context
 
 
-# [DeprecateAs], [Reflect], [RuntimeEnabled]
+# [DeprecateAs], [OriginTrialEnabled], [Reflect], [RuntimeEnabled]
 def constant_context(constant, interface):
     extended_attributes = constant.extended_attributes
+
+    if 'OriginTrialEnabled' in extended_attributes:
+        includes.add('core/inspector/ConsoleMessage.h')
+        includes.add('core/origin_trials/OriginTrials.h')
+
     return {
         'cpp_class': extended_attributes.get('PartialInterfaceImplementedAs'),
         'deprecate_as': v8_utilities.deprecate_as(constant),  # [DeprecateAs]
         'idl_type': constant.idl_type.name,
+        'is_origin_trial_enabled': v8_utilities.origin_trial_enabled_function(constant) or v8_utilities.origin_trial_enabled_function(interface),  # [OriginTrialEnabled]
         'measure_as': v8_utilities.measure_as(constant, interface),  # [MeasureAs]
         'name': constant.name,
+        'origin_trial_enabled': v8_utilities.origin_trial_enabled_function(constant),  # [OriginTrialEnabled]
+        'origin_trial_enabled_per_interface': v8_utilities.origin_trial_enabled_function(interface),  # [OriginTrialEnabled]
+        'origin_trial_name': extended_attributes.get('OriginTrialEnabled'),  # [OriginTrialEnabled]
         # FIXME: use 'reflected_name' as correct 'name'
         'reflected_name': extended_attributes.get('Reflect', constant.name),
-        'runtime_enabled_function': runtime_enabled_function_name(constant),
+        'runtime_enabled_function': runtime_enabled_function_name(constant),  # [RuntimeEnabled]
         'value': constant.value,
     }
 
 
 ################################################################################
 # Overloads
 ################################################################################
 
 def compute_method_overloads_context(interface, methods):
     # Regular methods
@@ skipping 271 matching lines @@
 
     If there is more than one entry in an effective overload set that has a
     given type list length, then for those entries there must be an index i
     such that for each pair of entries the types at index i are
     distinguishable.
     The lowest such index is termed the distinguishing argument index for the
     entries of the effective overload set with the given type list length.
     """
     # Only applicable “If there is more than one entry”
     assert len(entries) > 1
-    type_lists = [tuple(idl_type.name for idl_type in entry[1])
+
+    def typename_without_nullable(idl_type):
+        if idl_type.is_nullable:
+            return idl_type.inner_type.name
+        return idl_type.name
+
+    type_lists = [tuple(typename_without_nullable(idl_type)
+                        for idl_type in entry[1])
                   for entry in entries]
     type_list_length = len(type_lists[0])
     # Only applicable for entries that “[have] a given type list length”
     assert all(len(type_list) == type_list_length for type_list in type_lists)
     name = entries[0][0].get('name', 'Constructor')  # for error reporting
 
     # The spec defines the distinguishing argument index by conditions it must
     # satisfy, but does not give an algorithm.
     #
     # We compute the distinguishing argument index by first computing the
@@ skipping 284 matching lines @@
 ################################################################################
 # Constructors
 ################################################################################
 
 # [Constructor]
 def constructor_context(interface, constructor):
     # [RaisesException=Constructor]
     is_constructor_raises_exception = \
         interface.extended_attributes.get('RaisesException') == 'Constructor'
 
+    argument_contexts = [
+        v8_methods.argument_context(interface, constructor, argument, index)
+        for index, argument in enumerate(constructor.arguments)]
+
     return {
-        'arguments': [v8_methods.argument_context(interface, constructor, argument, index)
-                      for index, argument in enumerate(constructor.arguments)],
+        'arguments': argument_contexts,
         '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.v8_conversion_needs_exception_state),
+        'has_optional_argument_without_default_value':
+            any(True for argument_context in argument_contexts
+                if argument_context['is_optional_without_default_value']),
         '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_call_with_script_state':
             # [ConstructorCallWith=ScriptState]
@@ skipping 102 matching lines @@
 def property_setter(setter, interface):
     if not setter:
         return None
 
     extended_attributes = setter.extended_attributes
     idl_type = setter.arguments[1].idl_type
     idl_type.add_includes_for_type(extended_attributes)
     is_call_with_script_state = v8_utilities.has_extended_attribute_value(setter, 'CallWith', 'ScriptState')
     is_raises_exception = 'RaisesException' in extended_attributes
 
-    # [TypeChecking=Interface] / [LegacyInterfaceTypeChecking]
+    # [LegacyInterfaceTypeChecking]
     has_type_checking_interface = (
         not is_legacy_interface_type_checking(interface, setter) and
         idl_type.is_wrapper_type)
 
     return {
         'has_exception_state': (is_raises_exception or
                                 idl_type.v8_conversion_needs_exception_state),
         'has_type_checking_interface': has_type_checking_interface,
         'idl_type': idl_type.base_type,
         'is_call_with_script_state': is_call_with_script_state,
@@ skipping 12 matching lines @@
 
     extended_attributes = deleter.extended_attributes
     idl_type = deleter.idl_type
     is_call_with_script_state = v8_utilities.has_extended_attribute_value(deleter, 'CallWith', 'ScriptState')
     return {
         'is_call_with_script_state': is_call_with_script_state,
         'is_custom': 'Custom' in extended_attributes,
         'is_raises_exception': 'RaisesException' in extended_attributes,
         'name': cpp_name(deleter),
     }