Create fewer local v8::TryCatch objects in generated bindings code

Source/bindings/scripts/v8_types.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 101 matching lines @@
     'Promise': 'ScriptPromise',
     'ScriptValue': 'ScriptValue',
     # FIXME: Eliminate custom bindings for XPathNSResolver  http://crbug.com/345529
     'XPathNSResolver': 'RefPtrWillBeRawPtr<XPathNSResolver>',
     'boolean': 'bool',
     'unrestricted double': 'double',
     'unrestricted float': 'float',
 }
 
 
-def cpp_type(idl_type, extended_attributes=None, used_as_argument=False, used_in_cpp_sequence=False):
+def cpp_type(idl_type, extended_attributes=None, used_as_argument=False, used_as_variadic_argument=False, used_in_cpp_sequence=False):
     """Returns C++ type corresponding to IDL type.
 
     |idl_type| argument is of type IdlType, while return value is a string
 
     Args:
         idl_type:
             IdlType
         used_as_argument:
             bool, True if idl_type's raw/primitive C++ type should be returned.
         used_in_cpp_sequence:
             bool, True if the C++ type is used as an element of an array or sequence.
     """
     def string_mode():
         # FIXME: the Web IDL spec requires 'EmptyString', not 'NullString',
         # but we use NullString for performance.
         if extended_attributes.get('TreatNullAs') != 'NullString':
             return ''
         if extended_attributes.get('TreatUndefinedAs') != 'NullString':
             return 'WithNullCheck'
         return 'WithUndefinedOrNullCheck'
 
     extended_attributes = extended_attributes or {}
     idl_type = idl_type.preprocessed_type
 
     # Composite types
-    array_or_sequence_type = idl_type.array_or_sequence_type
+    if used_as_variadic_argument:
+        array_or_sequence_type = idl_type
+    else:
+        array_or_sequence_type = idl_type.array_or_sequence_type
     if array_or_sequence_type:
         vector_type = cpp_ptr_type('Vector', 'HeapVector', array_or_sequence_type.gc_type)
         return cpp_template_type(vector_type, array_or_sequence_type.cpp_type_args(used_in_cpp_sequence=True))
 
     # Simple types
     base_idl_type = idl_type.base_type
 
     if base_idl_type in CPP_TYPE_SAME_AS_IDL_TYPE:
         return base_idl_type
     if base_idl_type in CPP_INT_TYPES:
@@ skipping 266 matching lines @@
         expression_format = '(to{ref_ptr_type}NativeArray<{array_or_sequence_type}, V8{array_or_sequence_type}>({v8_value}, {index}, info.GetIsolate()))'
         add_includes_for_type(array_or_sequence_type)
     else:
         ref_ptr_type = None
         this_cpp_type = array_or_sequence_type.cpp_type
         expression_format = 'toNativeArray<{cpp_type}>({v8_value}, {index}, info.GetIsolate())'
     expression = expression_format.format(array_or_sequence_type=array_or_sequence_type.name, cpp_type=this_cpp_type, index=index, ref_ptr_type=ref_ptr_type, v8_value=v8_value)
     return expression
 
 
-def v8_value_to_local_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index=None):
+def v8_value_to_local_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index=None, declare_variable=True, method_has_try_catch=False):
     """Returns an expression that converts a V8 value to a C++ value and stores it as a local value."""
     this_cpp_type = idl_type.cpp_type_args(extended_attributes=extended_attributes, used_as_argument=True)
 
     idl_type = idl_type.preprocessed_type
     cpp_value = v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index)
-    args = [this_cpp_type, variable_name, cpp_value]
+    args = [variable_name, cpp_value]
     if idl_type.base_type == 'DOMString' and not idl_type.array_or_sequence_type:
         macro = 'TOSTRING_VOID'
     elif idl_type.is_integer_type:
         macro = 'TONATIVE_VOID_EXCEPTIONSTATE'
         args.append('exceptionState')
     else:
         macro = 'TONATIVE_VOID'
 
+    if declare_variable:
+        args.insert(0, this_cpp_type)
+    else:
+        # Use a macro that assumes a previously declared local variable.
+        macro += '_INTERNAL'
+        if method_has_try_catch and macro == 'TOSTRING_VOID_INTERNAL':

[haraken, 2014/05/21 14:56:45]

Would you add a comment about why we need the special casing for Strings?

[Jens Widell, 2014/05/21 15:07:02]

Comment added.

+            macro += '_RETHROW'
+            args.append('block')
+
     return '%s(%s)' % (macro, ', '.join(args))
 
 IdlType.v8_value_to_local_cpp_value = v8_value_to_local_cpp_value
 IdlUnionType.v8_value_to_local_cpp_value = v8_value_to_local_cpp_value
 
 
 ################################################################################
 # C++ -> V8
 ################################################################################
 
@@ skipping 182 matching lines @@
 def cpp_value_to_v8_value(idl_type, cpp_value, isolate='info.GetIsolate()', creation_context='', extended_attributes=None):
     """Returns an expression that converts a C++ value to a V8 value."""
     # the isolate parameter is needed for callback interfaces
     idl_type, cpp_value = preprocess_idl_type_and_value(idl_type, cpp_value, extended_attributes)
     this_v8_conversion_type = idl_type.v8_conversion_type(extended_attributes)
     format_string = CPP_VALUE_TO_V8_VALUE[this_v8_conversion_type]
     statement = format_string.format(cpp_value=cpp_value, isolate=isolate, creation_context=creation_context)
     return statement
 
 IdlType.cpp_value_to_v8_value = cpp_value_to_v8_value