Enable the WebIDL [Exposed] annotation on an interface's members.

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 222 matching lines @@
     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(
              not (attribute['is_expose_js_accessors'] or
                   attribute['is_static'] or
                   attribute['runtime_enabled_function'] or
                   attribute['per_context_enabled_function'])
              and attribute['should_be_exposed_to_script']
              for attribute in attributes),
+        'has_conditional_attributes': any(attribute['per_context_enabled_function'] or attribute['exposed_test'] for attribute in attributes),
         'has_constructor_attributes': any(attribute['constructor_type'] for attribute in attributes),
-        'has_per_context_enabled_attributes': any(attribute['per_context_enabled_function'] for attribute in attributes),
         'has_replaceable_attributes': any(attribute['is_replaceable'] for attribute in attributes),
     })
 
     # Methods
     methods = [v8_methods.method_context(interface, method)
                for method in interface.operations
                if method.name]  # Skip anonymous special operations (methods)
     compute_method_overloads_context(methods)
 
     # Stringifier
     if interface.stringifier:
         stringifier = interface.stringifier
         method = IdlOperation()
         method.name = 'toString'
         method.idl_type = IdlType('DOMString')
         method.extended_attributes.update(stringifier.extended_attributes)
         if stringifier.attribute:
             method.extended_attributes['ImplementedAs'] = stringifier.attribute.name
         elif stringifier.operation:
             method.extended_attributes['ImplementedAs'] = stringifier.operation.name
         methods.append(v8_methods.method_context(interface, method))
 
     per_context_enabled_methods = []
+    conditionally_exposed_methods = []

[Jens Widell, 2014/08/01 14:21:27]

I think merging the lists here would make things simpler (unless there's some
reason to keep them separate that I'm missing.) I.e. replace
per_context_enabled_methods and conditionally_exposed_methods with a
conditionally_enabled_methods. This matches the renamed function that registers
them too, which is nice.

[Peter Beverloo, 2014/08/01 14:30:44]

Done. Fredrik tells me that you're on holiday -- cheers for the reviews!

     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']
             per_context_enabled_function = overloads['per_context_enabled_function_all']
+            conditionally_exposed_function = overloads['exposed_test_all']
             runtime_enabled_function = overloads['runtime_enabled_function_all']
             has_custom_registration = overloads['has_custom_registration_all']
         else:
             per_context_enabled_function = method['per_context_enabled_function']
+            conditionally_exposed_function = method['exposed_test']
             runtime_enabled_function = method['runtime_enabled_function']
             has_custom_registration = method['has_custom_registration']
 
         if per_context_enabled_function:
             per_context_enabled_methods.append(method)
             continue
+        if conditionally_exposed_function:
+            conditionally_exposed_methods.append(method)
+            continue
         if runtime_enabled_function or has_custom_registration:
             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']['minarg'] if 'overloads' in method else
                             method['number_of_required_arguments'])
 
     context.update({
+        'conditionally_exposed_methods': conditionally_exposed_methods,
         'custom_registration_methods': custom_registration_methods,
+        'has_conditional_methods': per_context_enabled_methods or conditionally_exposed_methods,

[Jens Widell, 2014/08/01 14:21:27]

You could skip this then also, and just use the new list as the condition.

[Peter Beverloo, 2014/08/01 14:30:44]

Done.

         'has_origin_safe_method_setter': any(
             method['is_check_security_for_frame'] and not method['is_read_only']
             for method in methods),
         'method_configuration_methods': method_configuration_methods,
+        'methods': methods,
         'per_context_enabled_methods': per_context_enabled_methods,
-        'methods': methods,
     })
 
     context.update({
         'indexed_property_getter': indexed_property_getter(interface),
         'indexed_property_setter': indexed_property_setter(interface),
         'indexed_property_deleter': indexed_property_deleter(interface),
         'is_override_builtins': 'OverrideBuiltins' in extended_attributes,
         'named_property_getter': named_property_getter(interface),
         'named_property_setter': named_property_setter(interface),
         'named_property_deleter': named_property_deleter(interface),
@@ skipping 102 matching lines @@
         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))
 
     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),
-        'minarg': lengths[0],
         # 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]
-        'has_custom_registration_all': common_value(overloads, 'has_custom_registration'),
+        'minarg': lengths[0],
         'per_context_enabled_function_all': common_value(overloads, 'per_context_enabled_function'),  # [PerContextEnabled]
         'runtime_enabled_function_all': common_value(overloads, 'runtime_enabled_function'),  # [RuntimeEnabled]
         'valid_arities': lengths
             # Only need to report valid arities if there is a gap in the
             # sequence of possible lengths, otherwise invalid length means
             # "not enough arguments".
             if lengths[-1] - lengths[0] != len(lengths) - 1 else None,
     }
 
 
@@ skipping 645 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)