IDL compiler: [Clamp] for arguments

Source/bindings/templates/methods.cpp

 {##############################################################################}
 {% macro generate_method(method) %}
 static void {{method.name}}Method(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     {% if method.number_of_required_arguments %}
     if (UNLIKELY(args.Length() < {{method.number_of_required_arguments}})) {
         throwTypeError(ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", ExceptionMessages::notEnoughArguments({{method.number_of_required_arguments}}, args.Length())), args.GetIsolate());
         return;
     }
     {% endif %}
     {{cpp_class_name}}* imp = {{v8_class_name}}::toNative(args.Holder());
     {% for argument in method.arguments %}
     {% if argument.is_optional %}
     if (UNLIKELY(args.Length() <= {{argument.index}})) {
         {{argument.cpp_method}};
         return;
     }
     {% endif %}
-    {% if argument.idl_type == 'SerializedScriptValue' %}
+    {% if argument.is_clamp %}
+    {# For clamping, IDL type (not C++ type) is used for a C++ variable #}
+    {{argument.idl_type}} {{argument.name}} = 0;

[Nils Barth (inactive), 2013/10/31 03:22:44]

We might want to use |cpp_type| here, so it's the type we assume later.

[Nils Barth (inactive), 2013/10/31 04:18:25]

I've put a FIXME here.

+    V8TRYCATCH_VOID(double, {{argument.name}}NativeValue, args[{{argument.index}}]->NumberValue());
+    if (!std::isnan({{argument.name}}NativeValue))
+        {{argument.name}} = clampTo<{{argument.idl_type}}>({{argument.name}}NativeValue);

[Nils Barth (inactive), 2013/10/31 03:22:44]

OTOH, we need |idl_type| here for the actual clamping.

[Nils Barth (inactive), 2013/10/31 04:18:25]

I've put a comment here.

+    {% elif argument.idl_type == 'SerializedScriptValue' %}
     bool {{argument.name}}DidThrow = false;
     {{argument.cpp_type}} {{argument.name}} = SerializedScriptValue::create(args[{{argument.index}}], 0, 0, {{argument.name}}DidThrow, args.GetIsolate());
     if ({{argument.name}}DidThrow)
         return;
     {% elif argument.is_variadic_wrapper_type %}
     Vector<{{argument.cpp_type}} > {{argument.name}};
     for (int i = {{argument.index}}; i < args.Length(); ++i) {
         if (!V8{{argument.idl_type}}::HasInstance(args[i], args.GetIsolate(), worldType(args.GetIsolate()))) {
             throwTypeError(ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", "parameter {{argument.index + 1}} is not of type '{{argument.idl_type}}'."), args.GetIsolate());
             return;
@@ skipping 25 matching lines @@
 
 {##############################################################################}
 {% macro method_callback(method) %}
 static void {{method.name}}MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
     {{cpp_class_name}}V8Internal::{{method.name}}Method(args);
     TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
 }
 {% endmacro %}