API functions returning Promises should not throw exceptions.

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 %}
     {% if method.number_of_required_arguments %}
     if (UNLIKELY(info.Length() < {{method.number_of_required_arguments}})) {
         {{throw_arity_type_error(method, method.number_of_required_arguments)}};
         return;
     }
     {% endif %}
     {% if not method.is_static %}
     {{cpp_class}}* impl = {{v8_class}}::toNative(info.Holder());
     {% endif %}
     {% if method.is_custom_element_callbacks %}
     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
     {% endif %}
     {# Security checks #}
     {# FIXME: change to method.is_check_security_for_window #}
     {% if interface_name == 'EventTarget' %}
     if (DOMWindow* window = impl->toDOMWindow()) {
         if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), window->frame(), exceptionState)) {
-            exceptionState.throwIfNeeded();
+            {{throw_from_exception_state(method)}};
             return;
         }
         if (!window->document())
             return;
     }
     {% elif method.is_check_security_for_frame %}
     if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), impl->frame(), exceptionState)) {
-        exceptionState.throwIfNeeded();
+        {{throw_from_exception_state(method)}};
         return;
     }
     {% endif %}
     {% if method.is_check_security_for_node %}
     if (!BindingSecurity::shouldAllowAccessToNode(info.GetIsolate(), impl->{{method.name}}(exceptionState), exceptionState)) {
         v8SetReturnValueNull(info);
-        exceptionState.throwIfNeeded();
+        {{throw_from_exception_state(method)}};
         return;
     }
     {% endif %}
     {# Call method #}
     {% for argument in method.arguments %}
     {{generate_argument(method, argument, world_suffix) | indent}}
     {% endfor %}
     {% if world_suffix %}
     {{cpp_method_call(method, method.v8_set_return_value_for_main_world, method.cpp_value) | indent}}
     {% else %}
@@ skipping 74 matching lines @@
           '"The callback provided as parameter %s is not a function."' %
               (argument.index + 1)) | indent }}
     return;
 }
 OwnPtr<{{argument.idl_type}}> {{argument.name}} = {% if argument.is_nullable %}info[{{argument.index}}]->IsNull() ? nullptr : {% endif %}V8{{argument.idl_type}}::create(v8::Handle<v8::Function>::Cast(info[{{argument.index}}]), currentExecutionContext(info.GetIsolate()));
 {% endif %}{# argument.is_optional #}
 {% endif %}{# argument.idl_type == 'EventListener' #}
 {% elif argument.is_clamp %}{# argument.is_callback_interface #}
 {# NaN is treated as 0: http://www.w3.org/TR/WebIDL/#es-type-mapping #}
 {{argument.cpp_type}} {{argument.name}} = 0;
+{% if method.idl_type == 'Promise' %}
+TONATIVE_VOID_ASYNC(double, {{argument.name}}NativeValue, info[{{argument.index}}]->NumberValue(), info);
+{% else %}
 TONATIVE_VOID(double, {{argument.name}}NativeValue, info[{{argument.index}}]->NumberValue());
+{% endif %}
 if (!std::isnan({{argument.name}}NativeValue))
     {# IDL type is used for clamping, for the right bounds, since different
        IDL integer types have same internal C++ type (int or unsigned) #}
     {{argument.name}} = clampTo<{{argument.idl_type}}>({{argument.name}}NativeValue);
 {% elif argument.idl_type == 'SerializedScriptValue' %}
 {{argument.cpp_type}} {{argument.name}} = SerializedScriptValue::create(info[{{argument.index}}], 0, 0, exceptionState, info.GetIsolate());
-if (exceptionState.throwIfNeeded())
+if (exceptionState.hadException()) {
+    {{throw_from_exception_state(method)}};
     return;
+}
 {% elif argument.is_variadic_wrapper_type %}
 {{argument.vector_type}}<{{argument.cpp_type}} > {{argument.name}};
 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)}}
         return;
     }
     {{argument.name}}.append(V8{{argument.idl_type}}::toNative(v8::Handle<v8::Object>::Cast(info[i])));
 }
 {% else %}
+{% if method.idl_type == 'Promise' %}
+{{argument.v8_value_to_local_cpp_value_async}};
+{% else %}
 {{argument.v8_value_to_local_cpp_value}};
 {% endif %}
+{% endif %}
 {% if argument.enum_validation_expression %}
 {# Methods throw on invalid enum values: http://www.w3.org/TR/WebIDL/#idl-enums #}
 String string = {{argument.name}};
 if (!({{argument.enum_validation_expression}})) {
     {{throw_type_error(method,
           '"parameter %s (\'" + string + "\') is not a valid enum value."' %
               (argument.index + 1)) | indent}}
     return;
 }
 {% endif %}
@@ skipping 32 matching lines @@
 {% if method.idl_type == 'void' %}
 {{cpp_value}};
 {% elif method.is_constructor %}
 {{method.cpp_type}} impl = {{cpp_value}};
 {% elif method.is_call_with_script_state or method.is_call_with_new_script_state or method.is_raises_exception %}
 {# FIXME: consider always using a local variable #}
 {{method.cpp_type}} result = {{cpp_value}};
 {% endif %}
 {# Post-call #}
 {% if method.is_raises_exception %}
-if (exceptionState.throwIfNeeded())
+if (exceptionState.hadException()) {
+    {{throw_from_exception_state(method)}};
     return;
+}
 {% endif %}
 {# Set return value #}
 {% if method.is_constructor %}
 {{generate_constructor_wrapper(method)}}{% elif method.union_arguments %}
 {{union_type_method_call_and_set_return_value(method)}}
 {% elif v8_set_return_value %}{{v8_set_return_value}};{% endif %}{# None for void #}
 {% endmacro %}
 
 
 {######################################}
@@ skipping 15 matching lines @@
 {% endfor %}
 {# Fall back to null if none of the union members results are returned #}
 v8SetReturnValueNull(info);
 {%- endmacro %}
 
 
 {######################################}
 {% macro throw_type_error(method, error_message) %}
 {% if method.has_exception_state %}
 exceptionState.throwTypeError({{error_message}});
-exceptionState.throwIfNeeded();
+{{throw_from_exception_state(method)}};
 {%- elif method.is_constructor %}
+{% if method.idl_type == 'Promise' %}
+v8SetReturnValue(info, ScriptPromise::rejectWithTypeError(ExceptionMessages::failedToConstruct("{{interface_name}}", {{error_message}}), info.GetIsolate()).v8Value());
+{%- else %}
 throwTypeError(ExceptionMessages::failedToConstruct("{{interface_name}}", {{error_message}}), info.GetIsolate());
+{%- endif %}{# if method.idl_type == 'Promise' #}
+{%- else %}

[Nils Barth (inactive), 2014/04/14 01:18:55]

Could you comment the outer statements instead, or in addition?
{%- else %}{# method.is_constructor #}

(It's easy to keep track of the immediate inner block,
but the outer block is what's confusing.)

Also no need to repeat the 'if':
{%- endif %}{# method.idl_type == 'Promise' #}

[yhirano, 2014/04/14 06:12:43]

Done.

+{% if method.idl_type == 'Promise' %}
+v8SetReturnValue(info, ScriptPromise::rejectWithTypeError(ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", {{error_message}}), info.GetIsolate()).v8Value());
 {%- else %}
 throwTypeError(ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", {{error_message}}), info.GetIsolate());
+{%- endif %}{# if method.idl_type == 'Promise' #}
+{%- endif %}
+{% endmacro %}
+
+
+{######################################}
+{% macro throw_from_exception_state(method) %}
+{% if method.idl_type == 'Promise' %}
+v8SetReturnValue(info, exceptionState.reject().v8Value())
+{%- else %}
+exceptionState.throwIfNeeded()
 {%- endif %}
 {% endmacro %}
 
 
 {######################################}
 {% macro throw_arity_type_error(method, number_of_required_arguments) %}
+{% if method.idl_type == 'Promise' %}
+{% if method.has_exception_state %}
+v8SetReturnValue(info, ScriptPromise::rejectWithArityTypeError(exceptionState, {{number_of_required_arguments}}, info.Length()).v8Value())
+{%- elif method.is_constructor %}
+v8SetReturnValue(info, ScriptPromise::rejectWithArityTypeErrorForConstructor("{{interface_name}}", {{number_of_required_arguments}}, info.Length(), info.GetIsolate().v8Value())
+{%- else %}
+v8SetReturnValue(info, ScriptPromise::rejectWithArityTypeErrorForMethod("{{method.name}}", "{{interface_name}}", {{number_of_required_arguments}}, info.Length(), info.GetIsolate()).v8Value())
+{%- endif %}
+{%- else %}

[Nils Barth (inactive), 2014/04/14 01:18:55]

Could you put {# method.idl_type != 'Promise' #} here,
due to the nested ifs?

[yhirano, 2014/04/14 06:12:43]

Done. I think using 'method.idl_type == 'Promise' for both else and endif
statements is better.

[Nils Barth (inactive), 2014/04/14 06:17:43]

That's fine, thanks!

 {% if method.has_exception_state %}
 throwArityTypeError(exceptionState, {{number_of_required_arguments}}, info.Length())
 {%- elif method.is_constructor %}
 throwArityTypeErrorForConstructor("{{interface_name}}", {{number_of_required_arguments}}, info.Length(), info.GetIsolate())
 {%- else %}
 throwArityTypeErrorForMethod("{{method.name}}", "{{interface_name}}", {{number_of_required_arguments}}, info.Length(), info.GetIsolate())
 {%- endif %}
+{%- endif %}
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro overload_resolution_method(overloads, world_suffix) %}
 static void {{overloads.name}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     {% for method in overloads.methods %}
     if ({{method.overload_resolution_expression}}) {
         {{method.name}}{{method.overload_index}}Method{{world_suffix}}(info);
@@ skipping 176 matching lines @@
     {% endfor %}
     {{constructor.cpp_type}} impl = {{cpp_class}}::createForJSConstructor({{constructor.argument_list | join(', ')}});
     {% if is_constructor_raises_exception %}
     if (exceptionState.throwIfNeeded())
         return;
     {% endif %}
 
     {{generate_constructor_wrapper(constructor) | indent}}
 }
 {% endmacro %}