binding: Retires utilities in V8Binding.h for throwing arity errors.

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 %}
 {
@@ skipping 305 matching lines @@
       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());
+exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments({{method.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())
+V8ThrowException::createTypeError(info.GetIsolate(), ExceptionMessages::failedToConstruct("{{interface_name}}", ExceptionMessages::notEnoughArguments({{number_of_required_arguments}}, info.Length())))
 {%- else %}
-createMinimumArityTypeErrorForMethod(info.GetIsolate(), "{{method.name}}", "{{interface_name}}", {{number_of_required_arguments}}, info.Length())
+V8ThrowException::createTypeError(info.GetIsolate(), ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", ExceptionMessages::notEnoughArguments({{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 %}
@@ skipping 65 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());
+            exceptionState.throwTypeError(ExceptionMessages::invalidArity("{{overloads.valid_arities}}", info.Length()));
             {{propagate_error_with_exception_state(overloads) | indent(12)}}
         }
         {% 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)}}
     }
     {% 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) %}
 static 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());
+    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::ExecutionContext, interfaceName, "postMessage");
+    if (UNLIKELY(info.Length() < {{method.number_of_required_arguments}})) {
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments({{method.number_of_required_arguments}}, info.Length()));
         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);
@@ skipping 206 matching lines @@
                           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 %}