path: root/chromium/third_party/blink/renderer/bindings/templates/attributes.cc.tmpl

{% from 'utilities.cc.tmpl' import declare_enum_validation_variable, v8_value_to_local_cpp_value %}
{% from 'methods.cc.tmpl' import runtime_timer_scope, runtime_timer_scope_disabled_by_default %}

{##############################################################################}
{% macro attribute_getter(attribute, world_suffix) %}
static void {{attribute.camel_case_name}}AttributeGetter{{world_suffix}}(
{%- if attribute.is_data_type_property %}
const v8::PropertyCallbackInfo<v8::Value>& info
{%- else %}
const v8::FunctionCallbackInfo<v8::Value>& info
{%- endif %}) {
  {% filter format_remove_duplicates(['ExceptionState exception_state']) %}
  {% set define_exception_state -%}
  ExceptionState exception_state(info.GetIsolate(), ExceptionState::kGetterContext, "{{interface_name}}", "{{attribute.name}}");
  {%- endset %}

  {% if attribute.is_lenient_this %}
  // [LenientThis]
  // Make sure that info.Holder() really points to an instance if [LenientThis].
  if (!{{v8_class}}::HasInstance(info.Holder(), info.GetIsolate()))
    return; // Return silently because of [LenientThis].
  {% elif attribute.has_promise_type %}
  // This attribute returns a Promise.
  // Per https://heycam.github.io/webidl/#dfn-attribute-getter, all exceptions
  // must be turned into a Promise rejection.
  {{define_exception_state}}
  ExceptionToRejectPromiseScope reject_promise_scope(info, exception_state);

  // Returning a Promise type requires us to disable some of V8's type checks,
  // so we have to manually check that info.Holder() really points to an
  // instance of the type.
  if (!{{v8_class}}::HasInstance(info.Holder(), info.GetIsolate())) {
    exception_state.ThrowTypeError("Illegal invocation");
    return;
  }
  {% endif %}

  {% if not attribute.is_static or attribute.is_save_same_object %}
  v8::Local<v8::Object> holder = info.Holder();
  {% endif %}

  {% if attribute.is_save_same_object %}
  // [SaveSameObject]
  static const V8PrivateProperty::SymbolKey kSaveSameObjectKey;
  auto private_same_object =
      V8PrivateProperty::GetSymbol(info.GetIsolate(), kSaveSameObjectKey);
  {
    v8::Local<v8::Value> v8_value;
    if (private_same_object.GetOrUndefined(holder).ToLocal(&v8_value) && !v8_value->IsUndefined()) {
      V8SetReturnValue(info, v8_value);
      return;
    }
  }
  {% endif %}

  {% if not attribute.is_static %}
  {% set local_dom_window_only = interface_name == 'Window' and not attribute.has_cross_origin_getter %}
  {% if local_dom_window_only %}
  {% if attribute.is_check_security_for_receiver %}
  {{cpp_class}}* unchecked_impl = {{v8_class}}::ToImpl(holder);
  {% else %}
  // Same-origin attribute getters are never exposed via the cross-origin
  // interceptors. Since same-origin access requires a LocalDOMWindow, it is
  // safe to downcast here.
  LocalDOMWindow* impl = To<LocalDOMWindow>({{v8_class}}::ToImpl(holder));
  {% endif %}{# attribute.is_check_security_for_receiver #}
  {% else %}
  {{cpp_class}}* impl = {{v8_class}}::ToImpl(holder);
  {% endif %}{# local_dom_window_only #}
  {% endif %}{# not attribute.is_static #}

  {% if attribute.cached_attribute_validation_method %}
  // [CachedAttribute]
  {% if cpp_class == 'History' and attribute.camel_case_name == 'State' %}
  V8PrivateProperty::Symbol property_symbol =
      V8PrivateProperty::GetHistoryStateSymbol(info.GetIsolate());
  {% else %}
  {% if not attribute.private_property_is_shared_between_getter_and_setter %}
  static const V8PrivateProperty::SymbolKey kPrivateProperty{{attribute.camel_case_name}};

  {% endif %}
  V8PrivateProperty::Symbol property_symbol =
      V8PrivateProperty::GetSymbol(info.GetIsolate(),
          kPrivateProperty{{attribute.camel_case_name}});
  {% endif %}
  if (!static_cast<const {{cpp_class}}*>(impl)->{{attribute.cached_attribute_validation_method}}()) {
    v8::Local<v8::Value> v8_value;
    if (property_symbol.GetOrUndefined(holder).ToLocal(&v8_value) && !v8_value->IsUndefined()) {
      V8SetReturnValue(info, v8_value);
      return;
    }
  }
  {% endif %}

  {% if attribute.is_check_security_for_receiver and not attribute.is_data_type_property %}
  // Perform a security check for the receiver object.
  {{define_exception_state}}
  {% if local_dom_window_only %}
  if (!BindingSecurity::ShouldAllowAccessTo(CurrentDOMWindow(info.GetIsolate()), unchecked_impl, exception_state)) {
  {% else %}
  if (!BindingSecurity::ShouldAllowAccessTo(CurrentDOMWindow(info.GetIsolate()), impl, exception_state)) {
  {% endif %}{# local_dom_window_only #}
    V8SetReturnValueNull(info);
    return;
  }
  {% if local_dom_window_only %}
  LocalDOMWindow* impl = To<LocalDOMWindow>(unchecked_impl);
  {% endif %}{# local_dom_window_only #}
  {% endif %}

  {% if attribute.is_check_security_for_return_value %}
  // Perform a security check for the returned object.
  {{define_exception_state}}
  if (!BindingSecurity::ShouldAllowAccessTo(CurrentDOMWindow(info.GetIsolate()), {{attribute.cpp_value}}, BindingSecurity::ErrorReportOption::kDoNotReport)) {
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()),
                      WebFeature::kCrossOrigin{{interface_name}}{{attribute.camel_case_name}});
    V8SetReturnValueNull(info);
    return;
  }
  {% endif %}

  {% if attribute.is_call_with_execution_context %}
  {% if attribute.is_static %}
  ExecutionContext* execution_context = ExecutionContext::ForCurrentRealm(info);
  {% else %}
  ExecutionContext* execution_context = ExecutionContext::ForRelevantRealm(info);
  {% endif %}
  {% endif %}

  {% if attribute.is_call_with_script_state %}
  {% if attribute.is_static %}
  ScriptState* script_state = ScriptState::ForCurrentRealm(info);
  {% else %}
  ScriptState* script_state = ScriptState::ForRelevantRealm(info);
  {% endif %}
  {% endif %}

  {% if attribute.is_getter_raises_exception %}
  {{define_exception_state}}
  {% endif %}
  {% if attribute.is_explicit_nullable %}
  bool is_null = false;
  {% endif %}

  {% if attribute.cpp_value_original %}
  {{attribute.cpp_type}} {{attribute.cpp_value}}({{attribute.cpp_value_original}});
  {% endif %}

  {% if attribute.use_output_parameter_for_result %}
  {{attribute.cpp_type}} result;
  {{attribute.cpp_value}};
  {% endif %}

  {% if attribute.is_getter_raises_exception %}
  if (UNLIKELY(exception_state.HadException()))
    return;
  {% endif %}

  {% if attribute.reflect_only %}
  {{release_only_check(attribute.reflect_only, attribute.reflect_missing,
                       attribute.reflect_invalid, attribute.reflect_empty,
                       attribute.cpp_value)
      | trim | indent(2)}}
  {% endif %}

  {% if attribute.cached_attribute_validation_method %}
  // [CachedAttribute]
  v8::Local<v8::Value> v8_value({{attribute.cpp_value_to_v8_value}});
  property_symbol.Set(holder, v8_value);
  {% endif %}

  {% if attribute.is_explicit_nullable %}
  if (is_null) {
    V8SetReturnValueNull(info);
    return;
  }
  {% endif %}

  {% if attribute.is_keep_alive_for_gc %}
  // Keep the wrapper object for the return value alive as long as |this|
  // object is alive in order to save creation time of the wrapper object.
  if ({{attribute.cpp_value}} && DOMDataStore::SetReturnValue{{world_suffix}}(info.GetReturnValue(), {{attribute.cpp_value_to_script_wrappable}}))
    return;
  v8::Local<v8::Value> v8_value(ToV8({{attribute.cpp_value_to_script_wrappable}}, holder, info.GetIsolate()));
  static const V8PrivateProperty::SymbolKey kKeepAliveKey;
  V8PrivateProperty::GetSymbol(info.GetIsolate(), kKeepAliveKey)
      .Set(holder, v8_value);
  {% endif %}

  {% if world_suffix %}
  {{attribute.v8_set_return_value_for_main_world}};
  {% else %}
  {{attribute.v8_set_return_value}};
  {% endif %}

  {% if attribute.is_save_same_object %}
  // [SaveSameObject]
  private_same_object.Set(holder, info.GetReturnValue().Get());
  {% endif %}
  {% endfilter %}{# format_remove_duplicates #}
}
{% endmacro %}


{######################################}
{% macro release_only_check(reflect_only_values, reflect_missing,
                            reflect_invalid, reflect_empty, cpp_value) %}
{# Attribute is limited to only known values: check that the attribute value is
   one of those. If not, set it to the empty string.
   http://www.whatwg.org/specs/web-apps/current-work/#limited-to-only-known-values #}
{% if reflect_only_values %}
AtomicString atomic_{{cpp_value}}({{cpp_value}}.LowerASCII());
{% endif %}
{% if reflect_empty %}
if ({{cpp_value}}.IsNull()) {
{% if reflect_missing %}
  {{cpp_value}} = {{reflect_missing}};
{% else %}
  ;
{% endif %}
} else if ({{cpp_value}}.IsEmpty()) {
  {{cpp_value}} = {{reflect_empty}};
{% else %}
if ({{cpp_value}}.IsEmpty()) {
{# FIXME: should use [ReflectEmpty] instead; need to change IDL files #}
{% if reflect_missing %}
  {{cpp_value}} = {{reflect_missing}};
{% else %}
  ;
{% endif %}
{% endif %}
{% for value in reflect_only_values %}
} else if (atomic_{{cpp_value}} == {{value}}) {
  {{cpp_value}} = {{value}};
{% endfor %}
} else {
  {{cpp_value}} = {{reflect_invalid}};
}
{% endmacro %}


{##############################################################################}
{% macro attribute_getter_callback(attribute, world_suffix) %}
void {{v8_class_or_partial}}::{{attribute.camel_case_name}}AttributeGetterCallback{{world_suffix}}(
{%- if attribute.is_data_type_property %}
v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info
{%- else %}
const v8::FunctionCallbackInfo<v8::Value>& info
{%- endif %}) {
  {% if attribute.runtime_call_stats.extended_attribute_defined %}
  {{ runtime_timer_scope(attribute.runtime_call_stats.getter_counter) | trim | indent(2) }}
  {% else %}
  {{ runtime_timer_scope_disabled_by_default(attribute.runtime_call_stats.getter_counter) }}
  {% endif %}

  {% if attribute.deprecate_as %}
  Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::k{{attribute.deprecate_as}});
  {% endif %}

  {% if attribute.measure_as %}
  ExecutionContext* execution_context_for_measurement = CurrentExecutionContext(info.GetIsolate());
  UseCounter::Count(execution_context_for_measurement, WebFeature::k{{attribute.measure_as('AttributeGetter')}});
  {% if attribute.high_entropy %}
  Dactyloscoper::Record(execution_context_for_measurement, WebFeature::k{{attribute.measure_as('AttributeGetter')}});
  {% endif %}
  {% endif %}

  {% if world_suffix in attribute.activity_logging_world_list_for_getter %}
  {% if attribute.is_static %}
  ScriptState* script_state = ScriptState::ForCurrentRealm(info);
  {% else %}
  ScriptState* script_state = ScriptState::ForRelevantRealm(info);
  {% endif %}
  V8PerContextData* context_data = script_state->PerContextData();
  if (
  {%- if attribute.activity_logging_world_check -%}
      script_state->World().IsIsolatedWorld() && {# one space at the end #}
  {%- endif -%}
      context_data && context_data->ActivityLogger()) {
    context_data->ActivityLogger()->LogGetter("{{interface_name}}.{{attribute.name}}");
  }
  {% endif %}

  {% if attribute.has_custom_getter %}
  {{v8_class}}::{{attribute.camel_case_name}}AttributeGetterCustom(info);
  {% else %}
  {{internal_namespace}}::{{attribute.camel_case_name}}AttributeGetter{{world_suffix}}(info);
  {% endif %}
}
{% endmacro %}


{##############################################################################}
{% macro constructor_getter_callback(attribute, world_suffix) %}
void {{v8_class_or_partial}}::{{attribute.camel_case_name}}ConstructorGetterCallback{{world_suffix}}(
    v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) {
  {{ runtime_timer_scope_disabled_by_default(attribute.runtime_call_stats.constructor_getter_callback_counter) }}
  {% if attribute.deprecate_as %}
  Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::k{{attribute.deprecate_as}});
  {% endif %}

  {% if attribute.measure_as %}
  ExecutionContext* execution_context_for_measurement = CurrentExecutionContext(info.GetIsolate());
  UseCounter::Count(execution_context_for_measurement, WebFeature::k{{attribute.measure_as('ConstructorGetter')}});
  {% if attribute.high_entropy %}
  Dactyloscoper::Record(execution_context_for_measurement, WebFeature::k{{attribute.measure_as('ConstructorGetter')}});
  {% endif %}
  {% endif %}

  {% if attribute.is_named_constructor %}
  V8{{attribute.constructor_type}}::NamedConstructorAttributeGetter(property, info);
  {% else %}
  V8ConstructorAttributeGetter(property, info, V8{{attribute.constructor_type}}::GetWrapperTypeInfo());
  {% endif %}
}
{% endmacro %}


{##############################################################################}
{% macro attribute_setter(attribute, world_suffix) %}
{% if not attribute.use_common_reflection_setter %}
static void {{attribute.camel_case_name}}AttributeSetter{{world_suffix}}(
    {% if attribute.has_cross_origin_setter %}
    v8::Local<v8::Value> v8_value, const V8CrossOriginCallbackInfo& info
    {% elif attribute.is_data_type_property %}
    v8::Local<v8::Value> v8_value, const v8::PropertyCallbackInfo<void>& info
    {% else %}
    v8::Local<v8::Value> v8_value, const v8::FunctionCallbackInfo<v8::Value>& info
    {%- endif %}) {
  {% filter format_remove_duplicates(['ExceptionState exception_state']) %}
  v8::Isolate* isolate = info.GetIsolate();
  ALLOW_UNUSED_LOCAL(isolate);

  v8::Local<v8::Object> holder = info.Holder();
  ALLOW_UNUSED_LOCAL(holder);

  {% set define_exception_state -%}
  ExceptionState exception_state(isolate, ExceptionState::kSetterContext, "{{interface_name}}", "{{attribute.name}}");
  {%- endset %}

  {% if attribute.is_lenient_this %}
  // [LenientThis]
  // Make sure that info.Holder() really points to an instance if [LenientThis].
  if (!{{v8_class}}::HasInstance(holder, isolate))
    return; // Return silently because of [LenientThis].
  {% endif %}

  {% if not attribute.is_static and not attribute.is_replaceable and not attribute.is_put_forwards %}
  {% set local_dom_window_only = interface_name == 'Window' and not attribute.has_cross_origin_setter %}
  {% if local_dom_window_only %}
  {% if attribute.is_check_security_for_receiver %}
  {{cpp_class}}* unchecked_impl = {{v8_class}}::ToImpl(holder);
  {% else %}
  // Same-origin attributes setters are never exposed via the cross-origin
  // interceptors. Since same-origin access requires a LocalDOMWindow, it is
  // safe to downcast here.
  LocalDOMWindow* impl = To<LocalDOMWindow>({{v8_class}}::ToImpl(holder));
  {% endif %}{# attribute.is_check_security_for_receiver #}
  {% else %}
  {{cpp_class}}* impl = {{v8_class}}::ToImpl(holder);
  {% endif %}{# local_dom_window_only #}
  {% endif %}

  {% if attribute.is_check_security_for_receiver and not attribute.is_data_type_property %}
  // Perform a security check for the receiver object.
  {{define_exception_state}}
  {% if local_dom_window_only %}
  if (!BindingSecurity::ShouldAllowAccessTo(CurrentDOMWindow(isolate), unchecked_impl, exception_state)) {
  {% else %}
  if (!BindingSecurity::ShouldAllowAccessTo(CurrentDOMWindow(isolate), impl, exception_state)) {
  {% endif %}{# local_dom_window_only #}
    V8SetReturnValue(info, v8_value);
    return;
  }
  {% if local_dom_window_only %}
  LocalDOMWindow* impl = To<LocalDOMWindow>(unchecked_impl);
  {% endif %}{# local_dom_window_only #}
  {% endif %}

  {% if attribute.is_check_security_for_return_value %}
#error Attribute setter with the security check for the return value is not supported.  Since the return value is the given value to be set, it\'s meaningless to perform the security check for the return value.
  {% endif %}

  {% if attribute.is_put_forwards %}
  // [PutForwards] => {{attribute.name}}.{{attribute.target_attribute_name}}
  {{define_exception_state}}
  v8::Local<v8::Value> target;
  if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "{{attribute.name}}"))
      .ToLocal(&target)) {
    return;
  }
  if (!target->IsObject()) {
    exception_state.ThrowTypeError("The attribute value is not an object");
    return;
  }
  bool result;
  if (!target.As<v8::Object>()->Set(
          isolate->GetCurrentContext(),
          V8AtomicString(isolate, "{{attribute.target_attribute_name}}"),
          v8_value).To(&result)) {
    return;
  }
  if (!result)
    return;
  {% else %}{# attribute.is_put_forwards #}
  {% if attribute.is_custom_element_callbacks or attribute.is_reflect %}
  V0CustomElementProcessingStack::CallbackDeliveryScope delivery_scope;
  {% endif %}

  {% if attribute.has_setter_exception_state %}
  {{define_exception_state}}
  {% endif %}
  {% if attribute.is_ce_reactions %}
  CEReactionsScope ce_reactions_scope;
  {% endif %}

  {% if attribute.is_explicit_nullable %}
  bool is_null = IsUndefinedOrNull(v8_value);
  {% endif %}

  // Prepare the value to be set.
  {% if attribute.idl_type != 'EventHandler' %}
  {{v8_value_to_local_cpp_value(attribute) | trim | indent(2)}}
  {% endif %}

  {% if attribute.has_type_checking_interface %}
  // Type check per: http://heycam.github.io/webidl/#es-interface
  if (!cpp_value{% if attribute.is_nullable %} && !IsUndefinedOrNull(v8_value){% endif %}) {
    exception_state.ThrowTypeError("The provided value is not of type '{{attribute.idl_type}}'.");
    return;
  }
  {% endif %}

  {% if attribute.enum_values %}
  // Type check per: http://heycam.github.io/webidl/#dfn-attribute-setter
  // Returns undefined without setting the value if the value is invalid.
  DummyExceptionStateForTesting dummy_exception_state;
  {
    {{declare_enum_validation_variable(attribute.enum_values) | trim | indent(2)}}
    if (!IsValidEnum(cpp_value, kValidValues, base::size(kValidValues),
                     "{{attribute.enum_type}}", dummy_exception_state)) {
      ExecutionContext::ForCurrentRealm(info)->AddConsoleMessage(
          ConsoleMessage::Create(mojom::ConsoleMessageSource::kJavaScript,
                                 mojom::ConsoleMessageLevel::kWarning,
                                 dummy_exception_state.Message()));
      return;
    }
  }
  {% endif %}

  {% if attribute.is_call_with_execution_context or
        attribute.is_setter_call_with_execution_context %}
  {% if attribute.is_static %}
  ExecutionContext* execution_context = ExecutionContext::ForCurrentRealm(info);
  {% else %}
  ExecutionContext* execution_context = ExecutionContext::ForRelevantRealm(info);
  {% endif %}
  {% endif %}

  {% if attribute.is_call_with_script_state or
  	attribute.is_setter_call_with_script_state %}
  {% if attribute.is_static %}
  ScriptState* script_state = ScriptState::ForCurrentRealm(info);
  {% else %}
  ScriptState* script_state = ScriptState::ForRelevantRealm(info);
  {% endif %}
  {% endif %}

  {% if attribute.is_replaceable %}
  v8::Local<v8::String> property_name = V8AtomicString(isolate, "{{attribute.name}}");
  {% endif %}
  {{attribute.cpp_setter | indent(2)}};

  {% if attribute.cached_attribute_validation_method %}
  // [CachedAttribute]
  // Invalidate the cached value.
  V8PrivateProperty::GetSymbol(
      isolate,
      kPrivateProperty{{attribute.camel_case_name}})
      .DeleteProperty(holder);
  {% endif %}
  {% endif %}{# attribute.is_put_forwards #}
  {% endfilter %}{# format_remove_duplicates #}
}
{% endif %}
{% endmacro %}


{##############################################################################}
{% macro attribute_setter_callback(attribute, world_suffix) %}
void {{v8_class_or_partial}}::{{attribute.camel_case_name}}AttributeSetterCallback{{world_suffix}}(
    {% if attribute.is_data_type_property %}
    v8::Local<v8::Name>, v8::Local<v8::Value> v8_value, const v8::PropertyCallbackInfo<void>& info
    {% else %}
    const v8::FunctionCallbackInfo<v8::Value>& info
    {%- endif %}) {
  {% if attribute.is_lenient_setter %}
  // Setter for {{attribute.name}} is no-op because [LenientSetter] is specified.
  {% else %}
  {% if attribute.runtime_call_stats.extended_attribute_defined %}
  {{ runtime_timer_scope(attribute.runtime_call_stats.setter_counter) | trim | indent(2) }}
  {% else %}
  {{ runtime_timer_scope_disabled_by_default(attribute.runtime_call_stats.setter_counter) }}
  {% endif %}

  {% if not attribute.is_data_type_property and not attribute.use_common_reflection_setter %}
  v8::Local<v8::Value> v8_value = info[0];
  {% endif %}

  {% if attribute.deprecate_as %}
  Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::k{{attribute.deprecate_as}});
  {% endif %}

  {% if attribute.measure_as %}
  UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::k{{attribute.measure_as('AttributeSetter')}});
  {% endif %}

  {% if world_suffix in attribute.activity_logging_world_list_for_setter %}
  {% if attribute.is_static %}
  ScriptState* script_state = ScriptState::ForCurrentRealm(info);
  {% else %}
  ScriptState* script_state = ScriptState::ForRelevantRealm(info);
  {% endif %}
  V8PerContextData* context_data = script_state->PerContextData();
  if (
  {%- if attribute.activity_logging_world_check -%}
      script_state->World().IsIsolatedWorld() && {# one space at the end #}
  {%- endif -%}
      context_data && context_data->ActivityLogger()) {
    context_data->ActivityLogger()->LogSetter("{{interface_name}}.{{attribute.name}}", v8_value);
  }
  {% endif %}

  {% if attribute.has_custom_setter %}
  {{v8_class}}::{{attribute.camel_case_name}}AttributeSetterCustom(v8_value, info);
  {% elif attribute.has_cross_origin_setter %}
  {{internal_namespace}}::{{attribute.camel_case_name}}AttributeSetter(
      v8_value, V8CrossOriginCallbackInfo(info));
  {% elif attribute.use_common_reflection_setter %}
  {{attribute.cpp_setter}};
  {% else %}
  {{internal_namespace}}::{{attribute.camel_case_name}}AttributeSetter{{world_suffix}}(v8_value, info);
  {% endif %}
  {% endif %}{# attribute.is_lenient_setter #}
}
{% endmacro %}


{##############################################################################}
{% macro build_attribute_or_accessor_configuration(attribute, config_type) %}
{% from 'utilities.cc.tmpl' import property_location %}
{% if attribute.constructor_type %}
  {% set getter_callback = '%s::%sConstructorGetterCallback' % (v8_class_or_partial, attribute.camel_case_name) %}
  {% set setter_callback = 'nullptr' %}
{% else %}{# regular attributes #}
  {% set getter_callback = '%s::%sAttributeGetterCallback' % (v8_class_or_partial, attribute.camel_case_name) %}
  {% set setter_callback = '%s::%sAttributeSetterCallback' % (v8_class_or_partial, attribute.camel_case_name)
      if attribute.has_setter else 'nullptr' %}
{% endif %}

{% set property_attribute = 'static_cast<v8::PropertyAttribute>(%s)' %
                            ' | '.join(attribute.property_attributes) %}
{% set cached_property_key = 'V8PrivateProperty::k' +
    (attribute.cached_accessor_name if attribute.is_cached_accessor
     else 'NoCachedAccessor') %}
{% set holder_check = 'V8DOMConfiguration::kDoNotCheckHolder'
    if attribute.is_lenient_this or attribute.has_promise_type
    else 'V8DOMConfiguration::kCheckHolder' %}
{% set getter_side_effect_type = 'V8DOMConfiguration::kHasNoSideEffect'
    if attribute.getter_has_no_side_effect else 'V8DOMConfiguration::kHasSideEffect' %}
{% set getter_behavior = 'V8DOMConfiguration::kAlwaysCallGetter'
    if not attribute.is_lazy_data_attribute else 'V8DOMConfiguration::kReplaceWithDataProperty' %}
{% if attribute.is_per_world_bindings %}
  {% set getter_callback_for_main_world = '%sForMainWorld' % getter_callback %}
  {% set setter_callback_for_main_world =
      '%sForMainWorld' % setter_callback if attribute.has_setter else 'nullptr' %}
{% endif %}
{% set config_pre = {
    'main' : [
        '"%s"' % attribute.name,
        getter_callback_for_main_world,
        setter_callback_for_main_world,
    ],
    'non_main' : [
        '"%s"' % attribute.name,
        getter_callback,
        setter_callback,
    ],
} %}
{% set accessor_only_fields = [] if config_type == 'attribute' else [cached_property_key] %}
{% set config_post = [
    property_attribute,
    property_location(attribute),
    holder_check,
    getter_side_effect_type,
    getter_behavior,
] %}

{% if attribute.is_per_world_bindings %}
  {% set main_config_list = config_pre["main"] + accessor_only_fields +
      config_post + ['V8DOMConfiguration::kMainWorld'] %}
  {% set non_main_config_list = config_pre["non_main"] + accessor_only_fields +
      config_post + ['V8DOMConfiguration::kNonMainWorlds'] %}
  {# Emit for main world then non-main.#}
{ {{main_config_list | join(', ')}} },
{ {{non_main_config_list | join(', ')}} }
{%- else -%}
  {% set all_worlds_config_list = config_pre["non_main"] + accessor_only_fields +
      config_post + ['V8DOMConfiguration::kAllWorlds'] %}
  {# Emit only for all worlds #}
{ {{all_worlds_config_list | join(', ')}} }
{%- endif -%}
{% endmacro %}


{##############################################################################}
{% macro attribute_configuration(attribute) %}
{{build_attribute_or_accessor_configuration(attribute, 'attribute')}}
{% endmacro %}


{##############################################################################}
{% macro accessor_configuration(attribute) %}
{{build_attribute_or_accessor_configuration(attribute, 'accessor')}}
{% endmacro %}


{##############################################################################}
{# This macro installs |attributes_to_install| conditionally based on Exposed, SecureContext, and RuntimeEnabled checks. #}
{% macro install_conditional_attributes(attributes_to_install) %}
{% for exposed_test, exposed_attribute_list in attributes_to_install | groupby('exposed_test') %}
{% filter exposed(exposed_test) %}
{% for secure_context_test, secure_context_attribute_list in exposed_attribute_list | groupby('secure_context_test') %}
{% filter secure_context(secure_context_test) %}
{% for feature_name, attribute_list in secure_context_attribute_list | groupby('runtime_enabled_feature_name') %}
{% filter runtime_enabled(feature_name) %}
{{install_attributes(attribute_list | sort, 'instance_object', 'prototype_object', 'interface_object')}}
{% endfilter %}{# runtime_enabled #}
{% endfor %}{# secure_context_attribute_list grouped by runtime_enabled #}
{% endfilter %}{# secure_context #}
{% endfor %}{# exposed_attribute_list grouped by secure_context_text #}
{% endfilter %}{# exposed #}
{% endfor %}{# attributes grouped by exposed_test #}
{% endmacro %}


{##############################################################################}
{# This macro installs |attributes_to_install| unconditionally. #}
{% macro install_attributes(attributes_to_install, instance_variable, prototype_variable, interface_variable) %}
static constexpr V8DOMConfiguration::AccessorConfiguration
kAccessorConfigurations[] = {
    {% for attribute in attributes_to_install %}
    {{accessor_configuration(attribute) | trim | indent(4)}},
    {% endfor %}
};
V8DOMConfiguration::InstallAccessors(
    isolate, world, {{instance_variable}}, {{prototype_variable}}, {{interface_variable}},
    signature, kAccessorConfigurations,
    base::size(kAccessorConfigurations));
{% endmacro %}


{##############################################################################}
{# This macro installs |attributes_to_install| conditionally based on Exposed, SecureContext, and RuntimeEnabled checks. #}
{% macro install_conditional_interface_objects(attributes_to_install) %}
{% for exposed_test, exposed_attribute_list in attributes_to_install | groupby('exposed_test') %}
{% filter exposed(exposed_test) %}
{% for secure_context_test, secure_context_attribute_list in exposed_attribute_list | groupby('secure_context_test') %}
{% filter secure_context(secure_context_test) %}
{% for feature_name, attribute_list in secure_context_attribute_list | groupby('runtime_enabled_feature_name') %}
{% filter runtime_enabled(feature_name) %}
{{install_interface_objects(attribute_list | sort, 'instance_object', 'prototype_object')}}
{% endfilter %}{# runtime_enabled #}
{% endfor %}{# secure_context_attribute_list grouped by runtime_enabled #}
{% endfilter %}{# secure_context #}
{% endfor %}{# exposed_attribute_list grouped by secure_context_text #}
{% endfilter %}{# exposed #}
{% endfor %}{# attributes grouped by exposed_test #}
{% endmacro %}


{##############################################################################}
{# This macro installs |attributes_to_install| unconditionally. #}
{% macro install_interface_objects(attributes_to_install, instance_variable, prototype_variable) %}
static constexpr V8DOMConfiguration::AttributeConfiguration
kAttributeConfigurations[] = {
    {% for attribute in attributes_to_install %}
    {{attribute_configuration(attribute) | trim | indent(4)}},
    {% endfor %}
};
V8DOMConfiguration::InstallAttributes(
    isolate, world, {{instance_variable}}, {{prototype_variable}},
    kAttributeConfigurations, base::size(kAttributeConfigurations));
{% endmacro %}