[bindings] Implement an ExperimentEnabled IDL extended attribute.

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 47 matching lines @@
     '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',
+    'core/experiments/Experiments.h',
     'platform/RuntimeEnabledFeatures.h',
     'platform/TraceEvent.h',
     'wtf/GetPtr.h',
     'wtf/RefPtr.h',
 ])
 
 
 def interface_context(interface):
     includes.clear()
     includes.update(INTERFACE_CPP_INCLUDES)
@@ skipping 78 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)
 
     context = {
+        'api_experiment_name': v8_utilities.api_experiment_name(interface),
         '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]
@@ skipping 56 matching lines @@
         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)))
+            unscopeables.append((attribute.name, v8_utilities.runtime_enabled_function_name(attribute), v8_utilities.api_experiment_name(attribute)))
     for method in interface.operations:
         if 'Unscopeable' in method.extended_attributes:
-            unscopeables.append((method.name, v8_utilities.runtime_enabled_function_name(method)))
+            unscopeables.append((method.name, v8_utilities.runtime_enabled_function_name(method), v8_utilities.api_experiment_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 = dict()
+    experimental_enabled_constants = dict()
+    experimental_only_enabled_constants = []
     constant_configuration_constants = []
 
     for constant in constants:
+        api_experiment_name = constant['api_experiment_name']
         if constant['measure_as'] or constant['deprecate_as']:
             special_getter_constants.append(constant)
             continue
         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)
+            if api_experiment_name:
+                experimental_enabled_constants[constant['name']] = api_experiment_name
+            continue
+        if api_experiment_name:
+            experimental_only_enabled_constants.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,
+        'experimental_enabled_constants': experimental_enabled_constants,
+        'experimental_only_constants': experimental_only_enabled_constants,
         'has_constant_configuration': any(
-            not constant['runtime_enabled_function']
+            (constant['runtime_enabled_function'] is None and constant['api_experiment_name'] is None)
             for constant in 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)
@@ skipping 224 matching lines @@
 
         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']
+            api_experiment_name = overloads['api_experiment_name_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']
+            api_experiment_name = method['api_experiment_name']
             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 api_experiment_name:
+            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.
@@ skipping 54 matching lines @@
     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, interface),  # [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),
+        'api_experiment_name': extended_attributes.get('APIExperimentEnabled'),
         'value': constant.value,
     }
 
 
 ################################################################################
 # Overloads
 ################################################################################
 
 def compute_method_overloads_context(interface, methods):
     # Regular methods
@@ skipping 134 matching lines @@
             has_overload_not_visible = True
 
     # If some overloads are not visible and others are visible,
     # the method is overloaded between core and modules.
     has_partial_overloads = has_overload_visible and has_overload_not_visible
 
     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'),
+        'api_experiment_name_all': common_value(overloads, 'api_experiment_name'),  # [APIExperimentEnabled]
         'length': function_length,
         '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': maxarg,
         'measure_all_as': common_value(overloads, 'measure_as'),  # [MeasureAs]
         'returns_promise_all': promise_overload_count > 0,
         'runtime_determined_lengths': runtime_determined_lengths,
         'runtime_determined_maxargs': runtime_determined_maxargs,
         'runtime_enabled_function_all': common_value(overloads, 'runtime_enabled_function'),  # [RuntimeEnabled]
@@ skipping 603 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),
     }