IDL: Support runtime enabled overloads affecting Function.length

Source/bindings/templates/methods.cpp

 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
 {% filter conditional(method.conditional_string) %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     {# Local variables #}
     {% if method.has_exception_state %}
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{method.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% endif %}
     {# Overloaded methods have length checked during overload resolution #}
@@ skipping 314 matching lines @@
 {% 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 %}
 
 
 {##############################################################################}
+{% 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}};
+    {% endfilter %}
+    {% endfor %}
+    {% endfor %}
+}
+{% endmacro %}
+
+
+{##############################################################################}
 {# FIXME: We should return a rejected Promise if an error occurs in this
 function when ALL methods in this overload return Promise. In order to do so,
 we must ensure either ALL or NO methods in this overload return Promise #}
 {% macro overload_resolution_method(overloads, world_suffix) %}
 static void {{overloads.name}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{overloads.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% if overloads.measure_all_as %}
     UseCounter::countIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::{{overloads.measure_all_as}});
     {% endif %}
@@ skipping 35 matching lines @@
         {# 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.minarg}}) {
             setArityTypeError(exceptionState, "{{overloads.valid_arities}}", info.Length());
             {{throw_from_exception_state(overloads)}};
             return;
         }
         {% endif %}
-        {# Otherwise just report "not enough arguments" #}
-        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments({{overloads.minarg}}, info.Length()));
-        {{throw_from_exception_state(overloads)}};
-        return;
+        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()));
+        {{throw_from_exception_state(overloads)}};
+        return;
+    }
+    {% endif %}
     {# No match, throw error #}
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     {{throw_from_exception_state(overloads)}};
     {% endif %}
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro method_callback(method, world_suffix) %}
@@ skipping 178 matching lines @@
 {% set only_exposed_to_private_script = 'V8DOMConfiguration::OnlyExposedToPrivateScript' if method.only_exposed_to_private_script else 'V8DOMConfiguration::ExposedToAllScripts' %}
 {"{{method.name}}", {{method_callback}}, {{method_callback_for_main_world}}, {{method.length}}, {{only_exposed_to_private_script}}}
 {%- endmacro %}
 
 
 {######################################}
 {% macro install_custom_signature(method) %}
 {% set method_callback = '%sV8Internal::%sMethodCallback' % (cpp_class_or_partial, method.name) %}
 {% set method_callback_for_main_world = '%sForMainWorld' % method_callback
   if method.is_per_world_bindings else '0' %}
+{% set method_length = method.overloads.length if method.overloads else method.length %}
 {% set property_attribute =
   'static_cast<v8::PropertyAttribute>(%s)' % ' | '.join(method.property_attributes)
   if method.property_attributes else 'v8::None' %}
 {% set only_exposed_to_private_script = 'V8DOMConfiguration::OnlyExposedToPrivateScript' if method.only_exposed_to_private_script else 'V8DOMConfiguration::ExposedToAllScripts' %}
-static const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {
-    "{{method.name}}", {{method_callback}}, {{method_callback_for_main_world}}, {{method.length}}, {{only_exposed_to_private_script}},
+const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {
+    "{{method.name}}", {{method_callback}}, {{method_callback_for_main_world}}, {{method_length}}, {{only_exposed_to_private_script}},
 };
 V8DOMConfiguration::installMethod({{method.function_template}}, {{method.signature}}, {{property_attribute}}, {{method.name}}MethodConfiguration, isolate);
 {%- endmacro %}
 
 {######################################}
 {% macro install_conditionally_enabled_methods() %}
 void {{v8_class_or_partial}}::installConditionallyEnabledMethods(v8::Handle<v8::Object> prototypeObject, v8::Isolate* isolate)
 {
     {% if is_partial %}
     {{v8_class}}::installConditionallyEnabledMethods(prototypeObject, isolate);
     {% endif %}
     {% if conditionally_enabled_methods %}
     {# Define per-context enabled operations #}
     v8::Local<v8::Signature> defaultSignature = v8::Signature::New(isolate, domTemplate(isolate));
     ExecutionContext* context = toExecutionContext(prototypeObject->CreationContext());
     ASSERT(context);
 
     {% for method in conditionally_enabled_methods %}
     {% filter per_context_enabled(method.per_context_enabled_function) %}
     {% filter exposed(method.exposed_test) %}
     {% filter runtime_enabled(method.overloads.runtime_enabled_function_all if method.overloads else method.runtime_enabled_function) %}
     prototypeObject->Set(v8AtomicString(isolate, "{{method.name}}"), v8::FunctionTemplate::New(isolate, {{cpp_class_or_partial}}V8Internal::{{method.name}}MethodCallback, v8Undefined(), defaultSignature, {{method.number_of_required_arguments}})->GetFunction());
     {% endfilter %}
     {% endfilter %}
     {% endfilter %}
     {% endfor %}
     {% endif %}
 }
 {%- endmacro %}