binding: Introduces ExceptionToPromiseScope.

third_party/WebKit/Source/bindings/templates/methods.cpp

 {% from 'utilities.cpp' import declare_enum_validation_variable, v8_value_to_local_cpp_value %}
 
 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
-{% if method.returns_promise and method.has_exception_state %}
-static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}Promise(const v8::FunctionCallbackInfo<v8::Value>& info, ExceptionState& exceptionState)
-{% else %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
-{% endif %}
+{% filter format_remove_duplicates([
+    'ScriptState* scriptState = ']) %}

[haraken, 2016/09/02 16:24:13]

Honestly speaking, I'm neutral about this formatter though. It looks adding
another extra mystery to the temprate files.

Is the formatter going to be widely useful in the template files? Then it might
be worth introducing it.

[Yuki, 2016/09/05 07:19:25]

I'm not sure what is the best way, but we definitely need something that solves
this problem.  There are a lot of clients of this formatter.  However, I'd like
to experiment this formatter with a few examples if it really works well or not.
 If it looks promising, then I'm going to use this more widely.

[haraken, 2016/09/05 08:24:22]

I won't object if you strongly want to do this, but I'm not really happy about
making refactoring that doesn't have a clear benefit...

 {
     {# Local variables #}
-    {% if method.has_exception_state and not method.returns_promise %}
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{method.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
+    {% if method.has_exception_state %}
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, "{{interface_name}}", "{{method.name}}");
+    {% if method.returns_promise %}
+    {% if method.is_static %}
+    ScriptState* scriptState = ScriptState::forFunctionObject(info);
+    {% else %}
+    ScriptState* scriptState = ScriptState::forReceiverObject(info);
     {% endif %}
+    ExceptionToPromiseScope exceptionToPromiseScope(info, scriptState, exceptionState);
+    {% endif %}
+    {% endif %}
+
     {# Overloaded methods have length checked during overload resolution #}
-    {% if method.number_of_required_arguments and not method.overload_index %}
+    {% if method.number_of_required_arguments and
+          not method.overload_index %}
     if (UNLIKELY(info.Length() < {{method.number_of_required_arguments}})) {
-        {{throw_minimum_arity_type_error(method, method.number_of_required_arguments) | indent(8)}}
+        {{throw_minimum_arity_error(method, method.number_of_required_arguments)}}
+        return;
     }
     {% endif %}
+
     {% if not method.is_static %}
     {{cpp_class}}* impl = {{v8_class}}::toImpl(info.Holder());
     {% endif %}
+
     {% if method.is_custom_element_callbacks %}
     V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
     {% endif %}
+
     {# Security checks #}
     {% if method.is_check_security_for_receiver %}
     {% if interface_name == 'EventTarget' %}
     // Performance hack for EventTarget.  Checking whether it's a Window or not
     // prior to the call to BindingSecurity::shouldAllowAccessTo increases 30%
     // of speed performance on Android Nexus 7 as of Dec 2015.  ALWAYS_INLINE
     // didn't work in this case.
     if (const DOMWindow* window = impl->toDOMWindow()) {
         if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()), window, exceptionState)) {
             return;
         }
     }
     {% else %}{# interface_name == 'EventTarget' #}
     if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()), impl, exceptionState)) {
         return;
     }
     {% endif %}{# interface_name == 'EventTarget' #}
     {% endif %}
     {% if method.is_check_security_for_return_value %}
     if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()), {{method.cpp_value}}, exceptionState)) {
         v8SetReturnValueNull(info);
         return;
     }
     {% endif %}
+
     {# Call method #}
+    {% if method.is_call_with_script_state or
+          method.is_call_with_this_value %}
+    {% if method.is_static %}
+    ScriptState* scriptState = ScriptState::forFunctionObject(info);
+    {% else %}
+    ScriptState* scriptState = ScriptState::forReceiverObject(info);
+    {% endif %}
+    {% endif %}
     {% if method.arguments %}
     {{generate_arguments(method, world_suffix) | indent}}
     {% endif %}
     {% if world_suffix %}
     {{cpp_method_call(method, method.v8_set_return_value_for_main_world, method.cpp_value) | indent}}
     {% else %}
     {{cpp_method_call(method, method.v8_set_return_value, method.cpp_value) | indent}}
     {% endif %}
 }
-{% if method.returns_promise and method.has_exception_state %}
-
-static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
-{
-    ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{method.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
-    {{method.name}}{{method.overload_index}}Method{{world_suffix}}Promise(info, exceptionState);
-    if (exceptionState.hadException())
-        v8SetReturnValue(info, exceptionState.reject(ScriptState::current(info.GetIsolate())).v8Value());
-}
-{% endif %}
+{% endfilter %}
 {% endmacro %}
 
 
 {######################################}
 {% macro generate_arguments(method, world_suffix) %}
 {% for argument in method.arguments %}
 {{argument.cpp_type}} {{argument.name}};
 {% endfor %}
 {
     {% if method.has_optional_argument_without_default_value %}
@@ skipping 49 matching lines @@
 {{argument.name}} = V8EventListenerList::getEventListener(ScriptState::current(info.GetIsolate()), info[{{argument.index}}], false, ListenerFindOrCreate);
 {% endif %}{# method.name #}
 {% else %}{# argument.idl_type == 'EventListener' #}
 {# Callback functions must be functions:
    http://www.w3.org/TR/WebIDL/#es-callback-function #}
 {% if argument.is_optional %}
 if (!isUndefinedOrNull(info[{{argument.index}}])) {
     if (!info[{{argument.index}}]->IsFunction()) {
         {{throw_type_error(method,
               '"The callback provided as parameter %s is not a function."' %
-                  (argument.index + 1)) | indent(8)}}
+                  (argument.index + 1))}}
+        return;
     }
     {{argument.name}} = V8{{argument.idl_type}}::create(v8::Local<v8::Function>::Cast(info[{{argument.index}}]), ScriptState::current(info.GetIsolate()));
 } else {
     {{argument.name}} = nullptr;
 }
 {% else %}{# argument.is_optional #}
 if (info.Length() <= {{argument.index}} || !{% if argument.is_nullable %}(info[{{argument.index}}]->IsFunction() || info[{{argument.index}}]->IsNull()){% else %}info[{{argument.index}}]->IsFunction(){% endif %}) {
     {{throw_type_error(method,
           '"The callback provided as parameter %s is not a function."' %
-              (argument.index + 1)) | indent}}
+              (argument.index + 1))}}
+    return;
 }
 {{argument.name}} = {% if argument.is_nullable %}info[{{argument.index}}]->IsNull() ? nullptr : {% endif %}V8{{argument.idl_type}}::create(v8::Local<v8::Function>::Cast(info[{{argument.index}}]), ScriptState::current(info.GetIsolate()));
 {% endif %}{# argument.is_optional #}
 {% endif %}{# argument.idl_type == 'EventListener' #}
 {% elif argument.is_callback_function %}
 if (!info[{{argument.index}}]->IsFunction(){% if argument.is_nullable %} && !info[{{argument.index}}]->IsNull(){% endif %}) {
     {{throw_type_error(method,
           '"The callback provided as parameter %s is not a function."' %
-              (argument.index + 1)) | indent}}
+              (argument.index + 1))}}
+    return;
 }
 {{v8_value_to_local_cpp_value(argument)}}
 {% elif argument.is_variadic_wrapper_type %}
 for (int i = {{argument.index}}; i < info.Length(); ++i) {
     if (!V8{{argument.idl_type}}::hasInstance(info[i], info.GetIsolate())) {
         {{throw_type_error(method, '"parameter %s is not of type \'%s\'."' %
-                                   (argument.index + 1, argument.idl_type)) | indent(8)}}
+                                   (argument.index + 1, argument.idl_type))}}
+        return;
     }
     {{argument.name}}.append(V8{{argument.idl_type}}::toImpl(v8::Local<v8::Object>::Cast(info[i])));
 }
 {% elif argument.is_dictionary %}
 {% if not argument.use_permissive_dictionary_conversion %}
 {# Dictionaries must have type Undefined, Null or Object:
 http://heycam.github.io/webidl/#es-dictionary #}
 if (!isUndefinedOrNull(info[{{argument.index}}]) && !info[{{argument.index}}]->IsObject()) {
     {{throw_type_error(method, '"parameter %s (\'%s\') is not an object."' %
-                               (argument.index + 1, argument.name)) | indent}}
+                               (argument.index + 1, argument.name))}}
+    return;
 }
 {% endif %}{# not argument.use_permissive_dictionary_conversion #}
 {{v8_value_to_local_cpp_value(argument)}}
 {% elif argument.is_explicit_nullable %}
 if (!isUndefinedOrNull(info[{{argument.index}}])) {
     {{v8_value_to_local_cpp_value(argument) | indent}}
 }
 {% else %}{# argument.is_nullable #}
 {{v8_value_to_local_cpp_value(argument)}}
 {% endif %}{# argument.is_nullable #}
 {# Type checking, possibly throw a TypeError, per:
    http://www.w3.org/TR/WebIDL/#es-type-mapping #}
 {% if argument.has_type_checking_interface and not argument.is_variadic_wrapper_type %}
 {# Type checking for wrapper interface types (if interface not implemented,
    throw a TypeError), per http://www.w3.org/TR/WebIDL/#es-interface
    Note: for variadic arguments, the type checking is done for each matched
    argument instead; see argument.is_variadic_wrapper_type code-path above. #}
 if (!{{argument.name}}{% if argument.is_nullable %} && !isUndefinedOrNull(info[{{argument.index}}]){% endif %}) {
     {{throw_type_error(method, '"parameter %s is not of type \'%s\'."' %
-                               (argument.index + 1, argument.idl_type)) | indent}}
+                               (argument.index + 1, argument.idl_type))}}
+    return;
 }
 {% elif argument.enum_values %}
 {# Invalid enum values: http://www.w3.org/TR/WebIDL/#idl-enums #}
 {{declare_enum_validation_variable(argument.enum_values)}}
 if (!isValidEnum({{argument.name}}, validValues, WTF_ARRAY_LENGTH(validValues), "{{argument.enum_type}}", exceptionState)) {
     return;
 }
 {% elif argument.idl_type == 'Promise' %}
 {# We require this for our implementation of promises, though not in spec:
 http://heycam.github.io/webidl/#es-promise #}
 if (!{{argument.name}}.isUndefinedOrNull() && !{{argument.name}}.isObject()) {
     {{throw_type_error(method, '"parameter %s (\'%s\') is not an object."' %
-                               (argument.index + 1, argument.name)) | indent}}
+                               (argument.index + 1, argument.name))}}
+    return;
 }
 {% endif %}
 {% endmacro %}
 
 
 {######################################}
 {% macro cpp_method_call(method, v8_set_return_value, cpp_value) %}
 {% if method.is_custom_call_prologue %}
 {{v8_class}}::{{method.name}}MethodPrologueCustom(info, impl);
 {% endif %}
 {# Local variables #}
-{% if method.is_call_with_script_state or method.is_call_with_this_value %}
-{# [ConstructorCallWith=ScriptState] #}
-{# [CallWith=ScriptState] #}
-{% if method.is_static %}
-ScriptState* scriptState = ScriptState::forFunctionObject(info);
-{% else %}
-ScriptState* scriptState = ScriptState::forReceiverObject(info);
-{% endif %}
-{% endif %}
 {% if method.is_call_with_execution_context %}
 {# [ConstructorCallWith=ExecutionContext] #}
 {# [CallWith=ExecutionContext] #}
 ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
 {% endif %}
 {% if method.is_call_with_script_arguments %}
 {# [CallWith=ScriptArguments] #}
 ScriptArguments* scriptArguments(ScriptArguments::create(scriptState, info, {{method.number_of_arguments}}));
 {% endif %}
 {% if method.is_call_with_document %}
@@ skipping 11 matching lines @@
 {{method.cpp_type}} result;
 {{cpp_value}};
 {% elif method.is_constructor %}
 {{method.cpp_type}} impl = {{cpp_value}};
 {% elif method.use_local_result %}
 {{method.cpp_type}} result = {{cpp_value}};
 {% endif %}
 {# Post-call #}
 {% if method.is_raises_exception %}
 if (exceptionState.hadException()) {
-    {{propagate_error_with_exception_state(method) | indent}}
+    return;
 }
 {% endif %}
 {# Set return value #}
 {% if method.is_new_object and not method.do_not_test_new_object %}
 // [NewObject] must always create a new wrapper.  Check that a wrapper
 // does not exist yet.
 DCHECK(!result || DOMDataStore::getWrapper(result, info.GetIsolate()).IsEmpty());
 {% endif %}
 {% if method.is_constructor %}
 {{generate_constructor_wrapper(method)}}
@@ skipping 10 matching lines @@
 {% if method.is_custom_call_epilogue %}
 {{v8_class}}::{{method.name}}MethodEpilogueCustom(info, impl);
 {% endif %}
 {% endmacro %}
 
 
 {######################################}
 {% macro throw_type_error(method, error_message) %}
 {% if method.has_exception_state %}
 exceptionState.throwTypeError({{error_message}});
-{{propagate_error_with_exception_state(method)}}
-{% elif method.idl_type == 'Promise' %}
-v8SetReturnValue(info, ScriptPromise::rejectRaw(ScriptState::current(info.GetIsolate()), V8ThrowException::createTypeError(info.GetIsolate(), {{type_error_message(method, error_message)}})));
-return;
-{% else %}
-V8ThrowException::throwTypeError(info.GetIsolate(), {{type_error_message(method, error_message)}});
-return;
-{% endif %}{# method.has_exception_state #}
+{%- elif method.is_constructor %}
+V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToConstruct("{{interface_name}}", {{error_message}}));
+{%- else %}
+V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", {{error_message}}));
+{%- endif %}
 {% endmacro %}
 
 
 {######################################}
-{% macro type_error_message(method, error_message) %}
-{% if method.is_constructor %}
-ExceptionMessages::failedToConstruct("{{interface_name}}", {{error_message}})
+{% macro throw_minimum_arity_error(method, number_of_required_arguments) %}
+{% if method.has_exception_state %}
+throwMinimumArityError(exceptionState, {{number_of_required_arguments}}, info.Length());
+{%- elif method.is_constructor %}
+throwMinimumArityErrorForConstructor(info.GetIsolate(), "{{interface_name}}", {{number_of_required_arguments}}, info.Length());
 {%- else %}
-ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", {{error_message}})
+throwMinimumArityErrorForMethod(info.GetIsolate(), "{{interface_name}}", "{{method.name}}", {{number_of_required_arguments}}, info.Length());
 {%- endif %}
-{%- endmacro %}
-
-
-{######################################}
-{% macro propagate_error_with_exception_state(method_or_overloads) %}
-{% if method_or_overloads.returns_promise_all or
-      method_or_overloads.returns_promise %}
-v8SetReturnValue(info, exceptionState.reject(ScriptState::current(info.GetIsolate())).v8Value());
-{% endif %}
-return;
-{%- endmacro %}
-
-
-{######################################}
-{% macro throw_minimum_arity_type_error(method, number_of_required_arguments) %}
-{% if method.has_exception_state %}
-setMinimumArityTypeError(exceptionState, {{number_of_required_arguments}}, info.Length());
-{{propagate_error_with_exception_state(method)}}
-{%- elif method.idl_type == 'Promise' %}
-v8SetReturnValue(info, ScriptPromise::rejectRaw(ScriptState::current(info.GetIsolate()), {{create_minimum_arity_type_error_without_exception_state(method, number_of_required_arguments)}}));
-return;
-{%- else %}
-V8ThrowException::throwException(info.GetIsolate(), {{create_minimum_arity_type_error_without_exception_state(method, number_of_required_arguments)}});
-return;
-{%- endif %}
-{%- endmacro %}
-
-
-{######################################}
-{% macro create_minimum_arity_type_error_without_exception_state(method, number_of_required_arguments) %}
-{% if method.is_constructor %}
-createMinimumArityTypeErrorForConstructor(info.GetIsolate(), "{{interface_name}}", {{number_of_required_arguments}}, info.Length())
-{%- else %}
-createMinimumArityTypeErrorForMethod(info.GetIsolate(), "{{method.name}}", "{{interface_name}}", {{number_of_required_arguments}}, info.Length())
-{%- endif %}
-{%- endmacro %}
+{% endmacro %}
 
 
 {##############################################################################}
 {% macro runtime_determined_length_method(overloads) %}
 static int {{overloads.name}}MethodLength()
 {
     {% for length, runtime_enabled_functions in overloads.runtime_determined_lengths %}
     {% for runtime_enabled_function in runtime_enabled_functions %}
     {% filter runtime_enabled(runtime_enabled_function) %}
     return {{length}};
@@ skipping 63 matching lines @@
     {% if is_partial or not overloads.has_partial_overloads %}
     default:
         {# If methods are overloaded between interface and partial interface #}
         {# definitions, need to invoke methods defined in the partial #}
         {# interface. #}
         {# FIXME: we do not need to always generate this code. #}
         {# Invalid arity, throw error #}
         {# Report full list of valid arities if gaps and above minimum #}
         {% if overloads.valid_arities %}
         if (info.Length() >= {{overloads.length}}) {
-            setArityTypeError(exceptionState, "{{overloads.valid_arities}}", info.Length());
-            {{propagate_error_with_exception_state(overloads) | indent(12)}}
+            throwInvalidArityError(exceptionState, "{{overloads.valid_arities}}", info.Length());
+            return;
         }
         {% endif %}
         break;
     {% endif %}
     }
     {% if not is_partial and overloads.has_partial_overloads %}
     ASSERT({{overloads.name}}MethodForPartialInterface);
     ({{overloads.name}}MethodForPartialInterface)(info);
     {% else %}
     {% if overloads.length != 0 %}
     if (info.Length() < {{overloads.length}}) {
         {# Otherwise just report "not enough arguments" #}
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments({{overloads.length}}, info.Length()));
-        {{propagate_error_with_exception_state(overloads) | indent(8)}}
+        return;
     }
     {% endif %}
     {# No match, throw error #}
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
-    {{propagate_error_with_exception_state(overloads) | indent}}
     {% endif %}
 }
 {% endmacro %}
 
 
 {##############################################################################}
-{% macro generate_post_message_impl() %}
+{% macro generate_post_message_impl(method) %}
 void postMessageImpl(const char* interfaceName, {{cpp_class}}* instance, const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "postMessage", interfaceName, info.Holder(), info.GetIsolate());
-    if (UNLIKELY(info.Length() < 1)) {
-        setMinimumArityTypeError(exceptionState, 1, info.Length());
+    if (UNLIKELY(info.Length() < {{method.number_of_required_arguments}})) {
+        {{throw_minimum_arity_error(method, method.number_of_required_arguments)}}
         return;
     }
     Transferables transferables;
     if (info.Length() > 1) {
         const int transferablesArgIndex = 1;
         if (!SerializedScriptValue::extractTransferables(info.GetIsolate(), info[transferablesArgIndex], transferablesArgIndex, transferables, exceptionState)) {
             return;
         }
     }
     RefPtr<SerializedScriptValue> message = SerializedScriptValue::serialize(info.GetIsolate(), info[0], &transferables, nullptr, exceptionState);
     if (exceptionState.hadException())
         return;
     // FIXME: Only pass context/exceptionState if instance really requires it.
     ExecutionContext* context = currentExecutionContext(info.GetIsolate());
     instance->postMessage(context, message.release(), transferables.messagePorts, exceptionState);
 }
 {% endmacro %}
 
+
 {##############################################################################}
 {% macro method_callback(method, world_suffix) %}
 static void {{method.name}}MethodCallback{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     {% if not method.overloads %}{# Overloaded methods are measured in overload_resolution_method() #}
     {% if method.measure_as %}
     UseCounter::countIfNotPrivateScript(info.GetIsolate(), currentExecutionContext(info.GetIsolate()), UseCounter::{{method.measure_as('Method')}});
     {% endif %}
     {% if method.deprecate_as %}
     Deprecation::countDeprecationIfNotPrivateScript(info.GetIsolate(), currentExecutionContext(info.GetIsolate()), UseCounter::{{method.deprecate_as}});
@@ skipping 119 matching lines @@
         v8SetReturnValue(info, info.Holder());
         return;
     }
     {% endif %}
     {% if constructor.has_exception_state %}
     ExceptionState exceptionState(ExceptionState::ConstructionContext, "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% endif %}
     {# Overloaded constructors have length checked during overload resolution #}
     {% if constructor.number_of_required_arguments and not constructor.overload_index %}
     if (UNLIKELY(info.Length() < {{constructor.number_of_required_arguments}})) {
-        {{throw_minimum_arity_type_error(constructor, constructor.number_of_required_arguments) | indent(8)}}
+        {{throw_minimum_arity_error(constructor, constructor.number_of_required_arguments)}}
+        return;
     }
     {% endif %}
+    {% if constructor.is_call_with_script_state or
+          constructor.is_call_with_this_value %}
+    ScriptState* scriptState = ScriptState::forReceiverObject(info);
+    {% endif %}
     {% if constructor.arguments %}
     {{generate_arguments(constructor) | indent}}
     {% endif %}
     {{cpp_method_call(constructor, constructor.v8_set_return_value, constructor.cpp_value) | indent}}
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro generate_constructor_wrapper(constructor) %}
@@ skipping 21 matching lines @@
 {"{{method.name}}", {{method_callback}}, {{method_callback_for_main_world}}, {{method.length}}, {{property_attribute}}, {{only_exposed_to_private_script}}, {{property_location(method)}}}
 {%- endmacro %}
 
 
 {######################################}
 {% macro install_custom_signature(method, instance_template, prototype_template, interface_template, signature) %}
 const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {{method_configuration(method)}};
 V8DOMConfiguration::installMethod(isolate, world, {{instance_template}}, {{prototype_template}}, {{interface_template}}, {{signature}}, {{method.name}}MethodConfiguration);
 {%- endmacro %}
 
+
 {######################################}
 {% macro install_conditionally_enabled_methods() %}
 {% if methods | conditionally_exposed(is_partial) %}
 {# Define operations with limited exposure #}
 v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interfaceTemplate);
 ExecutionContext* executionContext = toExecutionContext(prototypeObject->CreationContext());
 ASSERT(executionContext);
 {% for method in methods | conditionally_exposed(is_partial) %}
 {% filter secure_context(method.overloads.secure_context_test_all
                          if method.overloads else
                          method.secure_context_test) %}
 {% filter exposed(method.overloads.exposed_test_all
                   if method.overloads else
                   method.exposed_test) %}
 {% filter runtime_enabled(method.overloads.runtime_enabled_function_all
                           if method.overloads else
                           method.runtime_enabled_function) %}
 const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {{method_configuration(method)}};
 V8DOMConfiguration::installMethod(isolate, world, v8::Local<v8::Object>(), prototypeObject, interfaceObject, signature, {{method.name}}MethodConfiguration);
 {% endfilter %}{# runtime_enabled() #}
 {% endfilter %}{# exposed() #}
 {% endfilter %}{# secure_context() #}
 {% endfor %}
 {% endif %}
 {%- endmacro %}