Allow origin trials to be declared on IDL operations (methods)

third_party/WebKit/Source/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 80 matching lines @@
             constant['origin_trial_feature_name']]
 
 
 def constant_filters():
     return {'has_constant_configuration': filter_has_constant_configuration,
             'has_special_getter': filter_has_special_getter,
             'runtime_enabled_constants': filter_runtime_enabled,
             'origin_trial_enabled_constants': filter_origin_trial_enabled}
 
 
-def origin_trial_feature_names(constants, attributes):
+def origin_trial_feature_names(interface, constants, attributes, methods):
     """ Returns a list of the names of each origin trial feature used in this interface.
 
-    This list is the union of the sets of names used for constants and attributes.
+    This list is the union of the sets of names used for constants, attributes and methods.
     """
 
     feature_names = set(
         [constant['origin_trial_feature_name'] for constant in constants if constant['origin_trial_feature_name']] +
-        [attribute['origin_trial_feature_name'] for attribute in attributes if attribute['origin_trial_feature_name']]
+        [attribute['origin_trial_feature_name'] for attribute in attributes if attribute['origin_trial_feature_name']] +
+        [method['origin_trial_feature_name'] for method in methods if (
+            v8_methods.method_is_visible(method, interface.is_partial) and
+            method['origin_trial_feature_name'])]
     )
     return sorted(feature_names)
 
 
 def interface_context(interface):
     includes.clear()
     includes.update(INTERFACE_CPP_INCLUDES)
     header_includes = set(INTERFACE_H_INCLUDES)
 
     if interface.is_partial:
@@ skipping 382 matching lines @@
         elif stringifier.operation:
             implemented_as = stringifier.operation.name
         else:
             implemented_as = 'toString'
         methods.append(generated_method(
             return_type=IdlType('DOMString'),
             name='toString',
             extended_attributes=stringifier_ext_attrs,
             implemented_as=implemented_as))
 
-    conditionally_enabled_methods = []
-    custom_registration_methods = []
-    method_configuration_methods = []
-
-    for method in methods:
-        # Skip all but one method in each set of overloaded methods.
-        if 'overload_index' in method and 'overloads' not in method:
-            continue
-
-        if 'overloads' in method:
-            overloads = method['overloads']
-            if not overloads['visible']:
-                continue
-            # original interface will register instead of partial interface.
-            if overloads['has_partial_overloads'] and interface.is_partial:
-                continue
-            conditionally_exposed_function = overloads['exposed_test_all']
-            runtime_enabled_function = overloads['runtime_enabled_function_all']
-            has_custom_registration = (overloads['has_custom_registration_all'] or
-                                       overloads['runtime_determined_lengths'])
-        else:
-            if not method['visible']:
-                continue
-            conditionally_exposed_function = method['exposed_test']
-            runtime_enabled_function = method['runtime_enabled_function']
-            has_custom_registration = method['has_custom_registration']
-
-        if has_custom_registration:
-            custom_registration_methods.append(method)
-            continue
-        if conditionally_exposed_function:
-            conditionally_enabled_methods.append(method)
-            continue
-        if runtime_enabled_function:
-            custom_registration_methods.append(method)
-            continue
-        if method['should_be_exposed_to_script']:
-            method_configuration_methods.append(method)
-
     for method in methods:
         # The value of the Function object’s “length” property is a Number
         # determined as follows:
         # 1. Let S be the effective overload set for regular operations (if the
         # operation is a regular operation) or for static operations (if the
         # operation is a static operation) with identifier id on interface I and
         # with argument count 0.
         # 2. Return the length of the shortest argument list of the entries in S.
         # 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': 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)
@@ skipping 12 matching lines @@
         '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'],
     })
 
     # Origin Trials
     context.update({
-        'origin_trial_feature_names': origin_trial_feature_names(context['constants'], context['attributes']),
+        'origin_trial_feature_names': origin_trial_feature_names(interface, context['constants'], context['attributes'], context['methods']),
     })
     return context
 
 
 # [DeprecateAs], [OriginTrialEnabled], [Reflect], [RuntimeEnabled]
 def constant_context(constant, interface):
     extended_attributes = constant.extended_attributes
 
     return {
         'cpp_class': extended_attributes.get('PartialInterfaceImplementedAs'),
@@ skipping 59 matching lines @@
 def overloads_context(interface, overloads):
     """Returns |overloads| template values for a single name.
 
     Sets |method.overload_index| in place for |method| in |overloads|
     and returns dict of overall overload template values.
     """
     assert len(overloads) > 1  # only apply to overloaded names
     for index, method in enumerate(overloads, 1):
         method['overload_index'] = index
 
+    # [OriginTrialEnabled]
+    # TODO(iclelland): Allow origin trials on method overloads
+    # (crbug.com/621641)
+    if any(method.get('origin_trial_feature_name') for method in overloads):
+        raise Exception('[OriginTrialEnabled] cannot be specified on '
+                        'overloaded methods: %s.%s' % (interface.name, overloads[0]['name']))
+
     effective_overloads_by_length = effective_overload_set_by_length(overloads)
     lengths = [length for length, _ in effective_overloads_by_length]
     name = overloads[0].get('name', '<constructor>')
 
     runtime_determined_lengths = None
     function_length = lengths[0]
     runtime_determined_maxargs = None
     maxarg = lengths[-1]
 
     # The special case handling below is not needed if all overloads are
@@ skipping 702 matching lines @@
     extended_attributes = deleter.extended_attributes
     is_call_with_script_state = v8_utilities.has_extended_attribute_value(deleter, 'CallWith', 'ScriptState')
     is_ce_reactions = 'CEReactions' in extended_attributes
     return {
         'is_call_with_script_state': is_call_with_script_state,
         'is_ce_reactions': is_ce_reactions,
         'is_custom': 'Custom' in extended_attributes,
         'is_raises_exception': 'RaisesException' in extended_attributes,
         'name': cpp_name(deleter),
     }