IDL: Clean up argument conversion error handling

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 547 matching lines @@
         expression_format = 'toImplArray<{cpp_type}>({v8_value}, {index}, {isolate}, exceptionState)'
     expression = expression_format.format(native_array_element_type=native_array_element_type.name, cpp_type=this_cpp_type, index=index, ref_ptr_type=ref_ptr_type, v8_value=v8_value, isolate=isolate)
     return expression
 
 
 def v8_value_to_local_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index=None, declare_variable=True, isolate='info.GetIsolate()', used_in_private_script=False, return_promise=False):
     """Returns an expression that converts a V8 value to a C++ value and stores it as a local value."""
 
     # FIXME: Support union type.
     if idl_type.is_union_type:
-        return ''
+        return '/* no V8 -> C++ conversion for IDL union type: %s */' % idl_type.name

[haraken, 2014/09/26 09:49:29]

Can we raise an exception instead?

 
     this_cpp_type = idl_type.cpp_type_args(extended_attributes=extended_attributes, raw_type=True)
+    idl_type = idl_type.preprocessed_type
 
-    idl_type = idl_type.preprocessed_type
+    if idl_type.base_type in ('void', 'object', 'EventHandler', 'EventListener'):

[Jens Widell, 2014/09/26 09:45:57]

These are IDL types where we don't have meaningful conversion support, and
previously returned some bogus code, and that doesn't (currently) matter because
whatever we return from here won't be used.

All methods with |object| arguments are [Custom], |EventHandler|/|EventListener|
have special handling in the templates, and |void| obviously doesn't really make
sense to convert.

Returning this C++ comment is just meant to aid debugging if this return value
is ever actually used (which will be a compilation error too, since this is not
a valid C++ expression.)

+        return '/* no V8 -> C++ conversion for IDL type: %s */' % idl_type.name
+
     cpp_value = v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index, isolate)
-    args = [variable_name, cpp_value]
-    if idl_type.base_type == 'DOMString':
-        if return_promise:
+    if idl_type.is_string_type or idl_type.v8_conversion_needs_exception_state:
+        # Types that need error handling and use one of a group of (C++) macros
+        # to take care of this.
+
+        args = [variable_name, cpp_value]
+
+        if idl_type.v8_conversion_needs_exception_state:
+            macro = 'TONATIVE_DEFAULT_EXCEPTIONSTATE' if used_in_private_script else 'TONATIVE_VOID_EXCEPTIONSTATE'
+        elif return_promise:
             macro = 'TOSTRING_VOID_EXCEPTIONSTATE'
         else:
             macro = 'TOSTRING_DEFAULT' if used_in_private_script else 'TOSTRING_VOID'
-    elif idl_type.v8_conversion_needs_exception_state:
-        macro = 'TONATIVE_DEFAULT_EXCEPTIONSTATE' if used_in_private_script else 'TONATIVE_VOID_EXCEPTIONSTATE'
-    elif idl_type.v8_conversion_is_trivial:
-        assignment = '%s = %s' % (variable_name, cpp_value)
+
+        if macro.endswith('_EXCEPTIONSTATE'):
+            args.append('exceptionState')
+
+        if used_in_private_script:
+            args.append('false')
+
+        suffix = ''
+
+        if return_promise:
+            suffix += '_PROMISE'
+            args.append('info')
+            if macro.endswith('_EXCEPTIONSTATE'):
+                args.append('ScriptState::current(%s)' % isolate)
+
         if declare_variable:
-            return '%s %s' % (this_cpp_type, assignment)
-        return assignment
-    else:
-        macro = 'TONATIVE_DEFAULT' if used_in_private_script else 'TONATIVE_VOID'
+            args.insert(0, this_cpp_type)
+        else:
+            suffix += '_INTERNAL'
 
-    if macro.endswith('_EXCEPTIONSTATE'):
-        args.append('exceptionState')
+        return '%s(%s)' % (macro + suffix, ', '.join(args))
 
-    if used_in_private_script:
-        args.append('false')
+    # Types that don't need error handling, and simply assign a value to the
+    # local variable.
 
-    # Macros come in several variants, to minimize expensive creation of
-    # v8::TryCatch.
-    suffix = ''
+    if not idl_type.v8_conversion_is_trivial:
+        raise Exception('unclassified V8 -> C++ conversion for IDL type: %s' % idl_type.name)
 
-    if return_promise:
-        suffix += '_PROMISE'
-        args.append('info')
-        if macro.endswith('_EXCEPTIONSTATE'):
-            args.append('ScriptState::current(%s)' % isolate)
+    assignment = '%s = %s' % (variable_name, cpp_value)
+    if declare_variable:
+        return '%s %s' % (this_cpp_type, assignment)
+    return assignment
 
-    if declare_variable:
-        args.insert(0, this_cpp_type)
-    else:
-        suffix += '_INTERNAL'
-
-    return '%s(%s)' % (macro + suffix, ', '.join(args))
 
 IdlTypeBase.v8_value_to_local_cpp_value = v8_value_to_local_cpp_value
 
 
 ################################################################################
 # C++ -> V8
 ################################################################################
 
 def preprocess_idl_type(idl_type):
     if idl_type.is_enum:
@@ skipping 232 matching lines @@
 
 
 def is_explicit_nullable(idl_type):
     # Nullable type that isn't implicit nullable (see above.) For such types,
     # we use Nullable<T> or similar explicit ways to represent a null value.
     return idl_type.is_nullable and not idl_type.is_implicit_nullable
 
 IdlTypeBase.is_implicit_nullable = property(is_implicit_nullable)
 IdlUnionType.is_implicit_nullable = False
 IdlTypeBase.is_explicit_nullable = property(is_explicit_nullable)