WIP bindings: Expand usage of NativeValueTraits.

third_party/WebKit/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 127 matching lines @@
             bool, True if idl_type's raw/primitive C++ type should be returned.
         used_as_rvalue_type:
             bool, True if the C++ type is used as an argument or the return
             type of a method.
         used_as_variadic_argument:
             bool, True if the C++ type is used as a variadic argument of a method.
         used_in_cpp_sequence:
             bool, True if the C++ type is used as an element of a container.
             Containers can be an array, a sequence or a dictionary.
     """
-    def string_mode():
-        if idl_type.is_nullable:
-            return 'TreatNullAndUndefinedAsNullString'
-        if extended_attributes.get('TreatNullAs') == 'EmptyString':
-            return 'TreatNullAsEmptyString'
-        if extended_attributes.get('TreatNullAs') == 'NullString':
-            return 'TreatNullAsNullString'
-        return ''
-
     extended_attributes = extended_attributes or {}
     idl_type = idl_type.preprocessed_type
 
     # Array or sequence types
     if used_as_variadic_argument:
         native_array_element_type = idl_type
     else:
         native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         vector_type = cpp_ptr_type('Vector', 'HeapVector', native_array_element_type.is_gc_type)
@@ skipping 12 matching lines @@
     if base_idl_type in CPP_UNSIGNED_TYPES:
         return 'unsigned'
     if base_idl_type in CPP_SPECIAL_CONVERSION_RULES:
         return CPP_SPECIAL_CONVERSION_RULES[base_idl_type]
 
     if base_idl_type == 'SerializedScriptValue':
         return ('PassRefPtr<%s>' if used_as_rvalue_type else 'RefPtr<%s>') % base_idl_type
     if idl_type.is_string_type:
         if not raw_type:
             return 'String'
-        return 'V8StringResource<%s>' % string_mode()
+        return 'V8StringResource<>'
 
     if base_idl_type == 'ArrayBufferView' and 'FlexibleArrayBufferView' in extended_attributes:
         return 'FlexibleArrayBufferView'
     if base_idl_type in TYPED_ARRAY_TYPES and 'FlexibleArrayBufferView' in extended_attributes:
         return 'Flexible' + base_idl_type + 'View'
     if idl_type.is_interface_type:
         implemented_as_class = idl_type.implemented_as
         if raw_type or (used_as_rvalue_type and idl_type.is_garbage_collected) or not used_in_cpp_sequence:
             return implemented_as_class + '*'
         if not used_in_cpp_sequence:
@@ skipping 167 matching lines @@
 
     # Simple types
     base_idl_type = idl_type.base_type
     if base_idl_type in INCLUDES_FOR_TYPE:
         return INCLUDES_FOR_TYPE[base_idl_type]
     if base_idl_type in TYPED_ARRAY_TYPES:
         return INCLUDES_FOR_TYPE['ArrayBufferView'].union(
             set(['bindings/%s/v8/V8%s.h' % (component_dir[base_idl_type], base_idl_type)])
         )
     if idl_type.is_basic_type:
-        return set()
+        return set(['bindings/core/v8/IDLTypes.h'])
     if base_idl_type.endswith('ConstructorConstructor'):
         # FIXME: rename to NamedConstructor
         # FIXME: replace with a [NamedConstructorAttribute] extended attribute
         # Ending with 'ConstructorConstructor' indicates a named constructor,
         # and these do not have header files, as they are part of the generated
         # bindings for the interface
         return set()
     if base_idl_type.endswith('Constructor'):
         # FIXME: replace with a [ConstructorAttribute] extended attribute
         base_idl_type = idl_type.constructor_type_name
     if idl_type.is_custom_callback_function:
         return set()
     if idl_type.is_callback_function:
         component = IdlType.callback_functions[base_idl_type]['component_dir']
         return set(['bindings/%s/v8/%s.h' % (component, base_idl_type)])
     if base_idl_type not in component_dir:
         return set()
     return set(['bindings/%s/v8/V8%s.h' % (component_dir[base_idl_type],
-                                           base_idl_type)])
+                                           base_idl_type),
+                'bindings/core/v8/IDLTypes.h'])
 
 IdlType.includes_for_type = includes_for_type
 
 
 def includes_for_union_type(idl_type, extended_attributes=None):
     return set.union(*[member_type.includes_for_type(extended_attributes)
                        for member_type in idl_type.member_types])
 
 IdlUnionType.includes_for_type = includes_for_union_type
 
@@ skipping 70 matching lines @@
 
 def set_component_dirs(new_component_dirs):
     component_dir.update(new_component_dirs)
 
 
 ################################################################################
 # V8 -> C++
 ################################################################################
 
 V8_VALUE_TO_CPP_VALUE = {
-    # Basic
-    'Date': 'toCoreDate({isolate}, {v8_value}, exceptionState)',
-    'DOMString': '{v8_value}',
-    'ByteString': 'toByteString({isolate}, {arguments})',
-    'USVString': 'toUSVString({isolate}, {arguments})',
-    'boolean': 'toBoolean({isolate}, {arguments})',
-    'float': 'toRestrictedFloat({isolate}, {arguments})',
-    'unrestricted float': 'toFloat({isolate}, {arguments})',
-    'double': 'toRestrictedDouble({isolate}, {arguments})',
-    'unrestricted double': 'toDouble({isolate}, {arguments})',
-    'byte': 'toInt8({isolate}, {arguments})',
-    'octet': 'toUInt8({isolate}, {arguments})',
-    'short': 'toInt16({isolate}, {arguments})',
-    'unsigned short': 'toUInt16({isolate}, {arguments})',
-    'long': 'toInt32({isolate}, {arguments})',
-    'unsigned long': 'toUInt32({isolate}, {arguments})',
-    'long long': 'toInt64({isolate}, {arguments})',
-    'unsigned long long': 'toUInt64({isolate}, {arguments})',
     # Interface types
-    'Dictionary': 'Dictionary({isolate}, {v8_value}, exceptionState)',
     'FlexibleArrayBufferView': 'toFlexibleArrayBufferView({isolate}, {v8_value}, {variable_name}, allocateFlexibleArrayBufferViewStorage({v8_value}))',
     'NodeFilter': 'toNodeFilter({v8_value}, info.Holder(), ScriptState::current({isolate}))',
-    'Promise': 'ScriptPromise::cast(ScriptState::current({isolate}), {v8_value})',
-    'SerializedScriptValue': 'SerializedScriptValue::serialize({isolate}, {v8_value}, nullptr, nullptr, exceptionState)',
-    'ScriptValue': 'ScriptValue(ScriptState::current({isolate}), {v8_value})',
-    'Window': 'toDOMWindow({isolate}, {v8_value})',
     'XPathNSResolver': 'toXPathNSResolver(ScriptState::current({isolate}), {v8_value})',
 }
 
 
 def v8_conversion_needs_exception_state(idl_type):
     return (idl_type.is_numeric_type or
             idl_type.is_enum or
             idl_type.is_dictionary or
+            idl_type.is_string_type or
             idl_type.name in ('Boolean', 'ByteString', 'Date', 'Dictionary', 'USVString', 'SerializedScriptValue'))
 
 IdlType.v8_conversion_needs_exception_state = property(v8_conversion_needs_exception_state)
 IdlArrayOrSequenceType.v8_conversion_needs_exception_state = True
 IdlUnionType.v8_conversion_needs_exception_state = True
 
 
 TRIVIAL_CONVERSIONS = frozenset([
     'any',
     'boolean',
     'Date',
     'Dictionary',
     'NodeFilter',
     'XPathNSResolver',
     'Promise'
 ])
 
 
 def v8_conversion_is_trivial(idl_type):
     # The conversion is a simple expression that returns the converted value and
     # cannot raise an exception.
     return (idl_type.base_type in TRIVIAL_CONVERSIONS or
             idl_type.is_wrapper_type)
 
 IdlType.v8_conversion_is_trivial = property(v8_conversion_is_trivial)
 
 
+def idl_type_name(idl_type):
+    idl_type = idl_type.preprocessed_type
+    if idl_type.native_array_element_type:
+        return 'idl::Sequence<%s>' % idl_type_name(idl_type.native_array_element_type)
+    elif idl_type.is_union_type:
+        return idl_type.as_union_type.name
+    elif idl_type.is_basic_type:
+        return 'idl::%s' % idl_type.name
+    elif idl_type.implemented_as is not None:
+        return idl_type.implemented_as
+    return idl_type.name
+
+
 def v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index, isolate):
     if idl_type.name == 'void':
         return ''
 
-    # Array or sequence types
-    native_array_element_type = idl_type.native_array_element_type
-    if native_array_element_type:
-        return v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index, isolate)
+    def string_mode(idl_type):
+        if idl_type.is_nullable:
+            return 'TreatNullAndUndefinedAsNullString'
+        if extended_attributes.get('TreatNullAs') == 'EmptyString':
+            return 'TreatNullAsEmptyString'
+        if extended_attributes.get('TreatNullAs') == 'NullString':
+            return 'TreatNullAsNullString'
+        return 'DefaultMode'
 
     # Simple types
     idl_type = idl_type.preprocessed_type
-    base_idl_type = idl_type.as_union_type.name if idl_type.is_union_type else idl_type.base_type
+    if idl_type.is_union_type:
+        base_idl_type = idl_type.as_union_type.name
+    else:
+        base_idl_type = idl_type.base_type
 
     if 'FlexibleArrayBufferView' in extended_attributes:
         if base_idl_type not in TYPED_ARRAY_TYPES.union(set(['ArrayBufferView'])):
             raise "Unrecognized base type for extended attribute 'FlexibleArrayBufferView': %s" % (idl_type.base_type)
         base_idl_type = 'FlexibleArrayBufferView'
 
     if idl_type.is_integer_type:
         configuration = 'NormalConversion'
         if 'EnforceRange' in extended_attributes:
             configuration = 'EnforceRange'
         elif 'Clamp' in extended_attributes:
             configuration = 'Clamp'
-        arguments = ', '.join([v8_value, configuration, 'exceptionState'])
-    elif idl_type.v8_conversion_needs_exception_state:
+        arguments = ', '.join([v8_value, 'exceptionState', configuration])
+    elif idl_type.native_array_element_type:
+        # Index is None for setters, index (starting at 0) for method arguments,
+        # and is used to provide a human-readable exception message
+        if index is None:
+            index = 0  # special case, meaning "setter"
+        else:
+            index += 1  # human-readable index
+        arguments = ', '.join([v8_value, 'exceptionState', str(index)])
+    else:
         arguments = ', '.join([v8_value, 'exceptionState'])
-    else:
-        arguments = v8_value
+
     if base_idl_type in V8_VALUE_TO_CPP_VALUE:
         cpp_expression_format = V8_VALUE_TO_CPP_VALUE[base_idl_type]
-    elif idl_type.is_array_buffer_or_view:
+    else:
+        str_mode = string_mode(idl_type)
+
+        if idl_type.is_nullable:
+            idl_type = idl_type.inner_type
+        base_idl_type = idl_type_name(idl_type)
+
+        if base_idl_type == 'idl::String':
+            nvt_args = '<%s>' % str_mode
+        else:
+            nvt_args = ''
+
         cpp_expression_format = (
-            '{v8_value}->Is{idl_type}() ? '
-            'V8{idl_type}::toImpl(v8::Local<v8::{idl_type}>::Cast({v8_value})) : 0')
-    elif idl_type.is_union_type:
-        nullable = 'UnionTypeConversionMode::Nullable' if idl_type.includes_nullable_type else 'UnionTypeConversionMode::NotNullable'
-        cpp_expression_format = 'V8{idl_type}::toImpl({isolate}, {v8_value}, {variable_name}, %s, exceptionState)' % nullable
-    elif idl_type.use_output_parameter_for_result:
-        cpp_expression_format = 'V8{idl_type}::toImpl({isolate}, {v8_value}, {variable_name}, exceptionState)'
-    elif idl_type.is_callback_function:
-        cpp_expression_format = (
-            '{idl_type}::create(ScriptState::current({isolate}), {v8_value})')
-    else:
-        cpp_expression_format = (
-            'V8{idl_type}::toImplWithTypeCheck({isolate}, {v8_value})')
+            'NativeValueTraits<{idl_type}>::nativeValue%s({isolate}, {arguments})' % nvt_args)
 
     return cpp_expression_format.format(arguments=arguments, idl_type=base_idl_type, v8_value=v8_value, variable_name=variable_name, isolate=isolate)
 
 
-def v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index, isolate='info.GetIsolate()'):
-    # Index is None for setters, index (starting at 0) for method arguments,
-    # and is used to provide a human-readable exception message
-    if index is None:
-        index = 0  # special case, meaning "setter"
-    else:
-        index += 1  # human-readable index
-    if (native_array_element_type.is_interface_type and
-        native_array_element_type.name != 'Dictionary'):
-        this_cpp_type = None
-        expression_format = 'toMemberNativeArray<{native_array_element_type}>({v8_value}, {index}, {isolate}, exceptionState)'
-    else:
-        this_cpp_type = native_array_element_type.cpp_type
-        if native_array_element_type.is_dictionary or native_array_element_type.is_union_type:
-            vector_type = 'HeapVector'
-        else:
-            vector_type = 'Vector'
-        expression_format = 'toImplArray<%s<{cpp_type}>>({v8_value}, {index}, {isolate}, exceptionState)' % vector_type
-    expression = expression_format.format(native_array_element_type=native_array_element_type.name, cpp_type=this_cpp_type,
-                                          index=index, v8_value=v8_value, isolate=isolate)
-    return expression
-
-
 # FIXME: this function should be refactored, as this takes too many flags.
 def v8_value_to_local_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index=None, declare_variable=True,
                                 isolate='info.GetIsolate()', bailout_return_value=None, use_exception_state=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, raw_type=True)
     idl_type = idl_type.preprocessed_type
 
     cpp_value = v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, variable_name, index, isolate)
 
     # Optional expression that returns a value to be assigned to the local variable.
     assign_expression = None
     # Optional void expression executed unconditionally.
     set_expression = None
     # Optional expression that returns true if the conversion fails.
     check_expression = None
     # Optional expression used as the return value when returning. Only
     # meaningful if 'check_expression' is not None.
     return_expression = bailout_return_value
 
-    if idl_type.is_string_type or idl_type.v8_conversion_needs_exception_state:
+    if idl_type.v8_conversion_needs_exception_state:
         # Types for which conversion can fail and that need error handling.
-
         check_expression = 'exceptionState.hadException()'
-
-        if idl_type.is_dictionary or idl_type.is_union_type:
-            set_expression = cpp_value
-        else:
-            assign_expression = cpp_value
-            # Note: 'not idl_type.v8_conversion_needs_exception_state' implies
-            # 'idl_type.is_string_type', but there are types for which both are
-            # true (ByteString and USVString), so using idl_type.is_string_type
-            # as the condition here would be wrong.
-            if not idl_type.v8_conversion_needs_exception_state:
-                if use_exception_state:
-                    check_expression = '!%s.prepare(exceptionState)' % variable_name
-                else:
-                    check_expression = '!%s.prepare()' % variable_name
+        assign_expression = cpp_value
     elif not idl_type.v8_conversion_is_trivial and not idl_type.is_callback_function:
         return {
             'error_message': 'no V8 -> C++ conversion for IDL type: %s' % idl_type.name
         }
     elif 'FlexibleArrayBufferView' in extended_attributes:
         if idl_type.base_type not in TYPED_ARRAY_TYPES.union(set(['ArrayBufferView'])):
             raise "Unrecognized base type for extended attribute 'FlexibleArrayBufferView': %s" % (idl_type.base_type)
         set_expression = cpp_value
     else:
         assign_expression = cpp_value
@@ skipping 359 matching lines @@
     number_of_nullable_member_types_union)
 
 
 def includes_nullable_type_union(idl_type):
     # http://heycam.github.io/webidl/#dfn-includes-a-nullable-type
     return idl_type.number_of_nullable_member_types == 1
 
 IdlTypeBase.includes_nullable_type = False
 IdlNullableType.includes_nullable_type = True
 IdlUnionType.includes_nullable_type = property(includes_nullable_type_union)