Rename es => exceptionState in bindings/

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)
 {
     {% if method.name in ['addEventListener', 'removeEventListener'] %}
     {{add_remove_event_listener_method(method.name) | indent}}
     {% else %}
     {% if method.number_of_required_arguments %}
     if (UNLIKELY(info.Length() < {{method.number_of_required_arguments}})) {
         throwTypeError(ExceptionMessages::failedToExecute("{{method.name}}", "{{interface_name}}", ExceptionMessages::notEnoughArguments({{method.number_of_required_arguments}}, info.Length())), info.GetIsolate());
         return;
     }
     {% endif %}
     {% if not method.is_static %}
     {{cpp_class_name}}* imp = {{v8_class_name}}::toNative(info.Holder());
     {% endif %}
     {% if method.is_custom_element_callbacks %}
     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
     {% endif %}
     {% if method.is_raises_exception %}
-    ExceptionState es(info.GetIsolate());
+    ExceptionState exceptionState(info.GetIsolate());
     {% endif %}
     {% if method.is_check_security_for_node %}
-    if (!BindingSecurity::shouldAllowAccessToNode(imp->{{method.name}}(es), es)) {
+    if (!BindingSecurity::shouldAllowAccessToNode(imp->{{method.name}}(exceptionState), exceptionState)) {
         v8SetReturnValueNull(info);
-        es.throwIfNeeded();
+        exceptionState.throwIfNeeded();
         return;
     }
     {% endif %}
     {% for argument in method.arguments %}
     {% if argument.is_optional and not argument.has_default and
           argument.idl_type != 'Dictionary' %}
     {# 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}})) {
@@ skipping 59 matching lines @@
 {######################################}
 {% macro add_remove_event_listener_method(method_name) %}
 {# Set template values for addEventListener vs. removeEventListener #}
 {% set listener_lookup_type, listener, hidden_dependency_action =
     ('ListenerFindOrCreate', 'listener', 'createHiddenDependency')
     if method_name == 'addEventListener' else
     ('ListenerFindOnly', 'listener.get()', 'removeHiddenDependency')
 %}
 EventTarget* impl = {{v8_class_name}}::toNative(info.Holder());
 if (DOMWindow* window = impl->toDOMWindow()) {
-    ExceptionState es(info.GetIsolate());
-    if (!BindingSecurity::shouldAllowAccessToFrame(window->frame(), es)) {
-        es.throwIfNeeded();
+    ExceptionState exceptionState(info.GetIsolate());
+    if (!BindingSecurity::shouldAllowAccessToFrame(window->frame(), exceptionState)) {
+        exceptionState.throwIfNeeded();
         return;
     }
     if (!window->document())
         return;
 }
 RefPtr<EventListener> listener = V8EventListenerList::getEventListener(info[1], false, {{listener_lookup_type}});
 if (listener) {
     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, eventName, info[0]);
     impl->{{method_name}}(eventName, {{listener}}, info[2]->BooleanValue());
     if (!impl->toNode())
@@ skipping 16 matching lines @@
 {% if method.is_call_with_script_arguments %}
 RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, {{method.number_of_arguments}}));
 {% endif %}
 {% if method.idl_type == 'void' %}
 {{cpp_value}};
 {% elif method.is_call_with_script_state %}
 {# FIXME: consider always using a local variable #}
 {{method.cpp_type}} result = {{cpp_value}};
 {% endif %}
 {% if method.is_raises_exception %}
-if (es.throwIfNeeded())
+if (exceptionState.throwIfNeeded())
     return;
 {% endif %}
 {% if method.is_call_with_script_state %}
 if (state.hadException()) {
     v8::Local<v8::Value> exception = state.exception();
     state.clearException();
     throwError(exception, info.GetIsolate());
     return;
 }
 {% endif %}
@@ skipping 45 matching lines @@
     {% endif %}
     {% if method.is_custom %}
     {{v8_class_name}}::{{method.name}}MethodCustom(info);
     {% else %}
     {{cpp_class_name}}V8Internal::{{method.name}}Method{{world_suffix}}(info);
     {% endif %}
     TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
 }
 {% endfilter %}
 {% endmacro %}