Use auto-rethrowing v8::TryCatch variant

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 #}
     {% 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)}};
         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)) {
-            {{throw_from_exception_state(method) | indent(12)}}
+            {{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)) {
-        {{throw_from_exception_state(method) | indent(8)}}
+        {{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);
-        {{throw_from_exception_state(method) | indent(8)}}
+        {{throw_from_exception_state(method)}};
         return;
     }
     {% endif %}
     {# Call method #}
     {% 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 %}
@@ skipping 20 matching lines @@
 
 
 {######################################}
 {% macro generate_arguments(method, world_suffix) %}
 {% for argument in method.arguments %}
 {{generate_argument_var_declaration(argument)}};
 {% endfor %}
 {
     {% if method.arguments_need_try_catch %}
     v8::TryCatch block;
+    V8RethrowTryCatchScope rethrow(block);
     {% endif %}
     {% for argument in method.arguments %}
     {{generate_argument(method, argument, world_suffix) | indent}}
     {% endfor %}
 }
 {% endmacro %}
 
 
 {######################################}
 {% macro generate_argument_var_declaration(argument) %}
@@ skipping 16 matching lines @@
 {######################################}
 {% macro generate_argument(method, argument, world_suffix) %}
 {% if argument.is_optional and not argument.has_default and
       argument.idl_type != 'Dictionary' and
       not argument.is_callback_interface %}
 {# Optional arguments without a default value generate an early call with
    fewer arguments if they are omitted.
    Optional Dictionary arguments default to empty dictionary. #}
 if (UNLIKELY(info.Length() <= {{argument.index}})) {
     {% if world_suffix %}
-    {{cpp_method_call(method, argument.v8_set_return_value_for_main_world, argument.cpp_value, method.arguments_need_try_catch) | indent}}
+    {{cpp_method_call(method, argument.v8_set_return_value_for_main_world, argument.cpp_value) | indent}}
     {% else %}
-    {{cpp_method_call(method, argument.v8_set_return_value, argument.cpp_value, method.arguments_need_try_catch) | indent}}
+    {{cpp_method_call(method, argument.v8_set_return_value, argument.cpp_value) | indent}}
     {% endif %}
     {% if argument.has_event_listener_argument %}
     {{hidden_dependency_action(method.name) | indent}}
     {% endif %}
     return;
 }
 {% endif %}
 {% if argument.has_type_checking_interface %}
 {# Type checking for wrapper interface types (if interface not implemented,
    throw a TypeError), per http://www.w3.org/TR/WebIDL/#es-interface #}
@@ skipping 38 matching lines @@
 {# NaN is treated as 0: http://www.w3.org/TR/WebIDL/#es-type-mapping #}
 double {{argument.name}}NativeValue;
 TONATIVE_VOID_INTERNAL({{argument.name}}NativeValue, info[{{argument.index}}]->NumberValue());
 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.name}} = SerializedScriptValue::create(info[{{argument.index}}], 0, 0, exceptionState, info.GetIsolate());
 if (exceptionState.hadException()) {
-    {{throw_from_exception_state(method) | indent}}
+    {{throw_from_exception_state(method)}};
     return;
 }
 {% 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)}}
         return;
     }
     {{argument.name}}.append(V8{{argument.idl_type}}::toNative(v8::Handle<v8::Object>::Cast(info[i])));
@@ skipping 29 matching lines @@
 if (!{{argument.name}}.isUndefinedOrNull() && !{{argument.name}}.isObject()) {
     {{throw_type_error(method, '"parameter %s (\'%s\') is not an object."' %
                                (argument.index + 1, argument.name)) | indent}}
     return;
 }
 {% endif %}
 {% endmacro %}
 
 
 {######################################}
-{% macro cpp_method_call(method, v8_set_return_value, cpp_value, has_try_catch) %}
+{% macro cpp_method_call(method, v8_set_return_value, cpp_value) %}
 {# Local variables #}
 {% if method.is_call_with_script_state %}
 ScriptState* scriptState = ScriptState::current(info.GetIsolate());
 {% endif %}
 {% if method.is_call_with_execution_context %}
 ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
 {% endif %}
 {% if method.is_call_with_script_arguments %}
 RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, {{method.number_of_arguments}}));
 {% endif %}
 {# Call #}
 {% 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_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.hadException()) {
-    {{throw_from_exception_state(method, has_try_catch) | indent}}
+    {{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 17 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}});
-{{throw_from_exception_state(method, method.arguments_need_try_catch)}}
-{%- else %}{# method.has_exception_state #}
-{% if method.is_constructor %}
+{{throw_from_exception_state(method)}};
+{% elif method.is_constructor %}
 throwTypeError(ExceptionMessages::failedToConstruct("{{interface_name}}", {{error_message}}), info.GetIsolate());
 {% else %}{# method.has_exception_state #}
 throwTypeError(ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", {{error_message}}), info.GetIsolate());
-{% endif %}
-{% if method.arguments_need_try_catch %}
-block.ReThrow();
-{% endif %}
 {% endif %}{# method.has_exception_state #}
 {% endmacro %}
 
 
 {######################################}
 {# FIXME: return a rejected Promise if method.idl_type == 'Promise' #}
-{% macro throw_from_exception_state(method, has_try_catch) %}
-exceptionState.throwIfNeeded();
-{% if has_try_catch %}
-block.ReThrow();
-{%- endif %}
+{% macro throw_from_exception_state(method) %}
+exceptionState.throwIfNeeded()
 {%- endmacro %}
 
 
 {######################################}
 {% macro throw_arity_type_error(method, valid_arities) %}
 {% if method.has_exception_state %}
 throwArityTypeError(exceptionState, {{valid_arities}}, info.Length())
 {%- elif method.is_constructor %}
 throwArityTypeErrorForConstructor("{{interface_name}}", {{valid_arities}}, info.Length(), info.GetIsolate())
 {%- else %}
@@ skipping 237 matching lines @@
     {% endif %}
     {{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 %}