Implement cross-origin attributes using access check interceptors.

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 352 matching lines @@
     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,
     })
 
     # Methods
     methods, iterator_method = methods_context(interface)
     context.update({
-        '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,
         'methods': methods,
     })
 
     # Window.idl in Blink has indexed properties, but the spec says Window
     # interface doesn't have indexed properties, instead the WindowProxy exotic
     # object has indexed properties.  Thus, Window interface must not support
     # iterators.
@@ skipping 23 matching lines @@
         '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_features': origin_trial_features(interface, context['constants'], context['attributes'], context['methods']),
     })
+
+    # Cross-origin interceptors
+    has_cross_origin_named_getter = False
+    has_cross_origin_named_setter = False
+    has_cross_origin_indexed_getter = False

[haraken, 2016/11/02 04:30:32]

What about an indexed setter?

[dcheng, 2016/11/02 07:45:32]

There are no cross-origin indexed setters. We can add them if it becomes
necessary later.

This actually goes along with my question in interface_base.cpp.tmpl. There are
a lot of things we don't really support with CrossOrigin attributes, for
example, per-world bindings. There is no real code that actually uses them.

For these things, is it better to try to make the bindings generator raise an
exception? Is it OK if we don't raise exceptions for anything? For example, it's
likely we'll never support cross-origin deleter, but do we need to raise an
exception for that?

[Yuki, 2016/11/02 08:26:39]

I'm happy with raising an exception in the binding generator for unsupported
things (cross-origin deleter, etc).  People should claim to the binding team.

[dcheng, 2016/11/03 07:44:45]

I updated the bindings generator to raise exceptions for explicitly unsupported
use cases (which can be implemented later if we needed them).

+
+    for attribute in attributes:
+        if attribute['has_cross_origin_getter']:
+            has_cross_origin_named_getter = True
+        elif attribute['has_cross_origin_setter']:
+            has_cross_origin_named_setter = True
+
+    for method in methods:
+        if method['is_cross_origin']:
+            has_cross_origin_named_getter = True

[haraken, 2016/11/02 04:30:32]

Why do we treat cross-origin methods as named getters?

[dcheng, 2016/11/02 07:45:32]

Added a comment.

+
+    if context['named_property_getter'] and context['named_property_getter']['is_cross_origin']:
+        has_cross_origin_named_getter = True
+
+    if context['indexed_property_getter'] and context['indexed_property_getter']['is_cross_origin']:
+        has_cross_origin_indexed_getter = True
+
+    context.update({
+        'has_cross_origin_named_getter': has_cross_origin_named_getter,
+        'has_cross_origin_named_setter': has_cross_origin_named_setter,
+        'has_cross_origin_indexed_getter': has_cross_origin_indexed_getter,
+    })
+
     return context
 
 
 def methods_context(interface):
     """Creates a list of Jinja template contexts for methods of an interface.
 
     Args:
         interface: An interface to create contexts for
 
     Returns:
@@ skipping 355 matching lines @@
                     if method.get('runtime_enabled_function'))
                 if not runtime_enabled_functions:
                     # This "length" is unconditionally enabled, so stop here.
                     runtime_determined_maxargs.append((length, [None]))
                     break
                 runtime_determined_maxargs.append(
                     (length, sorted(runtime_enabled_functions)))
             maxarg = ('%sV8Internal::%sMethodMaxArg()'
                       % (cpp_name_or_partial(interface), name))
 
-    # Check and fail if overloads disagree on any of the extended attributes
-    # that affect how the method should be registered.
-    # Skip the check for overloaded constructors, since they don't support any
-    # of the extended attributes in question.
-    if not overloads[0].get('is_constructor'):
-        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))
-
     # Check and fail if overloads disagree about whether the return type
     # is a Promise or not.
     promise_overload_count = sum(1 for method in overloads if method.get('returns_promise'))
     if promise_overload_count not in (0, len(overloads)):
         raise ValueError('Overloads of %s have conflicting Promise/non-Promise types'
                          % (name))
 
     has_overload_visible = False
     has_overload_not_visible = False
     for overload in overloads:
         if overload.get('visible', True):
             # If there exists an overload which is visible, need to generate
             # overload_resolution, i.e. overlods_visible should be True.
             has_overload_visible = True
         else:
             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'),
         '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 543 matching lines @@
     if is_raises_exception:
         cpp_arguments.append('exceptionState')
     if use_output_parameter_for_result:
         cpp_arguments.append('result')
 
     cpp_value = '%s(%s)' % (cpp_method_name, ', '.join(cpp_arguments))
 
     return {
         'cpp_type': idl_type.cpp_type,
         'cpp_value': cpp_value,
-        'do_not_check_security': 'DoNotCheckSecurity' in extended_attributes,
         'is_call_with_script_state': is_call_with_script_state,
+        'is_cross_origin': 'CrossOrigin' in extended_attributes,
         'is_custom':
             'Custom' in extended_attributes and
             (not extended_attributes['Custom'] or
              has_extended_attribute_value(getter, 'Custom', 'PropertyGetter')),
         'is_custom_property_enumerator': has_extended_attribute_value(
             getter, 'Custom', 'PropertyEnumerator'),
         'is_custom_property_query': has_extended_attribute_value(
             getter, 'Custom', 'PropertyQuery'),
         'is_enumerable': 'NotEnumerable' not in extended_attributes,
         'is_null_expression': is_null_expression(idl_type),
@@ skipping 43 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),
     }