Dartium Roll 38 roll

bindings/dart/scripts/dart_methods.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 15 matching lines @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 """Generate template values for methods.
 
 Extends IdlType and IdlUnionType with property |union_arguments|.
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-compiler
 """
 
-from idl_types import IdlType, IdlUnionType, inherits_interface
+from idl_types import IdlTypeBase, IdlType, IdlUnionType, inherits_interface, IdlArrayOrSequenceType, IdlArrayType
 import dart_types
+from idl_definitions import IdlArgument
 from dart_utilities import DartUtilities
 from v8_globals import includes
 
 
 def generate_method(interface, method):
     arguments = method.arguments
     extended_attributes = method.extended_attributes
     idl_type = method.idl_type
     is_static = method.is_static
     name = method.name
 
     idl_type.add_includes_for_type()
     this_cpp_value = cpp_value(interface, method, len(arguments))
 
     def function_template():
         if is_static:
             return 'functionTemplate'
         if 'Unforgeable' in extended_attributes:
             return 'instanceTemplate'
         return 'prototypeTemplate'
 
     is_call_with_script_arguments = DartUtilities.has_extended_attribute_value(method, 'CallWith', 'ScriptArguments')
     if is_call_with_script_arguments:
-        includes.update(['bindings/v8/ScriptCallStackFactory.h',
+        includes.update(['bindings/core/v8/ScriptCallStackFactory.h',
                          'core/inspector/ScriptArguments.h'])
     is_call_with_script_state = DartUtilities.has_extended_attribute_value(method, 'CallWith', 'ScriptState')
     if is_call_with_script_state:
-        includes.add('bindings/dart/DartScriptState.h')
+        includes.add('bindings/core/dart/DartScriptState.h')
     is_check_security_for_node = 'CheckSecurity' in extended_attributes
     if is_check_security_for_node:
         includes.add('bindings/common/BindingSecurity.h')
     is_custom_element_callbacks = 'CustomElementCallbacks' in extended_attributes
     if is_custom_element_callbacks:
         includes.add('core/dom/custom/CustomElementCallbackDispatcher.h')
 
     has_event_listener_argument = any(
         argument for argument in arguments
         if argument.idl_type.name == 'EventListener')
     is_check_security_for_frame = (
         'CheckSecurity' in interface.extended_attributes and
         'DoNotCheckSecurity' not in extended_attributes)
     is_raises_exception = 'RaisesException' in extended_attributes
 
     if idl_type.union_arguments and len(idl_type.union_arguments) > 0:
         this_cpp_type = []
         for cpp_type in idl_type.member_types:
+            # FIXMEDART: we shouldn't just assume RefPtr. We should append
+            # WillBeGC as appropriate.
             this_cpp_type.append("RefPtr<%s>" % cpp_type)
     else:
         this_cpp_type = idl_type.cpp_type
 
     is_auto_scope = not 'DartNoAutoScope' in extended_attributes
 
     number_of_arguments = len(arguments)
 
     number_of_required_arguments = \
         len([
@@ skipping 81 matching lines @@
     this_has_default = 'Default' in extended_attributes
     arg_index = index + 1 if not method.is_static else index
     preprocessed_type = str(idl_type.preprocessed_type)
     # FIXMEDART: handle the drift between preprocessed type names in 1847 and
     # 1985 dartium builds in a more generic way.
     if preprocessed_type == 'unrestricted float':
         preprocessed_type = 'float'
     if preprocessed_type == 'unrestricted double':
         preprocessed_type = 'double'
     argument_data = {
-        'cpp_type': idl_type.cpp_type_args(used_in_cpp_sequence=use_heap_vector_type),
+        'cpp_type': idl_type.cpp_type_args(extended_attributes=extended_attributes,
+                                           raw_type=True,
+                                           used_in_cpp_sequence=use_heap_vector_type),
         'cpp_value': this_cpp_value,
-        'local_cpp_type': idl_type.cpp_type_args(argument.extended_attributes, used_as_argument=True),
+        'local_cpp_type': idl_type.cpp_type_args(argument.extended_attributes, raw_type=True),
         # FIXME: check that the default value's type is compatible with the argument's
         'default_value': str(argument.default_value) if argument.default_value else None,
         'enum_validation_expression': idl_type.enum_validation_expression,
         # Ignore 'Default' in extended_attributes not exposed in dart:html.
         'has_default': False,
         'has_event_listener_argument': any(
             argument_so_far for argument_so_far in method.arguments[:index]
             if argument_so_far.idl_type.name == 'EventListener'),
         'idl_type_object': idl_type,
         'preprocessed_type': preprocessed_type,
         # Dictionary is special-cased, but arrays and sequences shouldn't be
-        'idl_type': not idl_type.array_or_sequence_type and idl_type.base_type,
+        'idl_type': idl_type.base_type,
         'index': index,
-        'is_array_or_sequence_type': not not idl_type.array_or_sequence_type,
+        'is_array_or_sequence_type': not not idl_type.native_array_element_type,
         'is_clamp': 'Clamp' in extended_attributes,
         'is_callback_interface': idl_type.is_callback_interface,
         'is_nullable': idl_type.is_nullable,
         # Only expose as optional if no default value.
         'is_optional': argument.is_optional and not (this_has_default or argument.default_value),
         'is_strict_type_checking': 'DartStrictTypeChecking' in extended_attributes,
         'is_variadic_wrapper_type': is_variadic_wrapper_type,
         'vector_type': 'WillBeHeapVector' if use_heap_vector_type else 'Vector',
         'is_wrapper_type': idl_type.is_wrapper_type,
         'name': argument.name,
@@ skipping 119 matching lines @@
     property_attributes_list = []
     if 'NotEnumerable' in extended_attributes:
         property_attributes_list.append('v8::DontEnum')
     if 'ReadOnly' in extended_attributes:
         property_attributes_list.append('v8::ReadOnly')
     if property_attributes_list:
         property_attributes_list.insert(0, 'v8::DontDelete')
     return property_attributes_list
 
 
+# FIXMEDART: better align this method with the v8 version.
+def union_member_argument_context(idl_type, index):
+    """Returns a context of union member for argument."""
+    return 'result%d' % index
+
 def union_arguments(idl_type):
-    """Return list of ['result0Enabled', 'result0', 'result1Enabled', ...] for union types, for use in setting return value"""
-    return [arg
-            for i in range(len(idl_type.member_types))
-            for arg in ['result%sEnabled' % i, 'result%s' % i]]
+    return [union_member_argument_context(member_idl_type, index)
+            for index, member_idl_type
+            in enumerate(idl_type.member_types)]
 
-IdlType.union_arguments = property(lambda self: None)
+
+def argument_default_cpp_value(argument):
+    if not argument.default_value:
+        return None
+    return argument.idl_type.literal_cpp_value(argument.default_value)
+
+
+IdlTypeBase.union_arguments = None
 IdlUnionType.union_arguments = property(union_arguments)
+IdlArgument.default_cpp_value = property(argument_default_cpp_value)
+#IdlType.union_arguments = property(lambda self: None)
+#IdlUnionType.union_arguments = property(union_arguments)