[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 30 matching lines @@
 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,
                           has_extended_attribute_value, runtime_enabled_function_name,
-                          extended_attribute_value_as_list, is_legacy_interface_type_checking)
+                          extended_attribute_value_as_list, is_legacy_interface_type_checking,
+                          experimental_api_name)
 
 
 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',
+    'core/experiments/Experiments.h',

[haraken, 2015/12/16 02:16:41]

I feel that "Experiments" sounds a bit too general. "APIExperiments"?

[Daniel Nishi, 2015/12/16 21:42:02]

core/experiments/* is already landed by a different author, but I can look into
if the owners are open to changing the name.

     'platform/RuntimeEnabledFeatures.h',
     'platform/TraceEvent.h',
     'wtf/GetPtr.h',
     'wtf/RefPtr.h',
 ])
 
 
 def interface_context(interface):
     includes.clear()
     includes.update(INTERFACE_CPP_INCLUDES)
@@ skipping 82 matching lines @@
     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 = {
         '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',
+        'experimental_api_name': v8_utilities.experimental_api_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_partial_interface': len(interface.partial_interfaces) > 0,
         'has_visit_dom_wrapper': has_visit_dom_wrapper,
         'header_includes': header_includes,
         'interface_name': interface.name,
@@ skipping 52 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.experimental_api_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.experimental_api_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:
+        experimental_api_name = constant['experimental_api_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 experimental_api_name:
+                experimental_enabled_constants[constant['name']] = experimental_api_name
+            continue
+        if experimental_api_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['experimental_api_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']
+            experimental_api_name = overloads['experimental_api_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']
+            experimental_api_name = method['experimental_api_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 experimental_api_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),
+        'experimental_api_name': extended_attributes.get('ExperimentEnabled'),
         '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'),
+        'experimental_api_name_all': common_value(overloads, 'experimental_api_name'),  # [ExperimentEnabled]
         '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),
     }