IDL compiler: Basic setters

Source/bindings/scripts/unstable/v8_attributes.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 19 matching lines @@
 
 FIXME: Not currently used in build.
 This is a rewrite of the Perl IDL compiler in Python, but is not complete.
 Once it is complete, we will switch all IDL files over to Python at once.
 Until then, please work on the Perl IDL compiler.
 For details, see bug http://crbug.com/239771
 """
 
 import v8_types
 import v8_utilities
-from v8_utilities import cpp_name, has_extended_attribute, uncapitalize
+from v8_utilities import capitalize, cpp_name, has_extended_attribute, uncapitalize
 
 
 def generate_attributes(interface):
     def generate_attribute(attribute):
         attribute_contents, attribute_includes = generate_attribute_and_includes(interface, attribute)
         includes.update(attribute_includes)
         return attribute_contents
 
     includes = set()
     contents = generate_attributes_common(interface)
@@ skipping 10 matching lines @@
         # Size 0 constant array is not allowed in VC++
         'number_of_attributes': 'WTF_ARRAY_LENGTH(%sAttributes)' % v8_class_name if attributes else '0',
         'attribute_templates': '%sAttributes' % v8_class_name if attributes else '0',
     }
 
 
 def generate_attribute_and_includes(interface, attribute):
     idl_type = attribute.data_type
     extended_attributes = attribute.extended_attributes
     this_is_keep_alive_for_gc = is_keep_alive_for_gc(attribute)
+    has_setter = not attribute.is_read_only  # FIXME: need to check [Reflect] and [PutForwards]
     contents = {
         'access_control_list': access_control_list(attribute),
         'cached_attribute_validation_method': extended_attributes.get('CachedAttribute'),
         'conditional_string': v8_utilities.generate_conditional_string(attribute),
         'cpp_type': v8_types.cpp_type(idl_type),
+        'getter_callback_name': getter_callback_name(interface, attribute),
+        'getter_callback_name_for_main_world': getter_callback_name_for_main_world(interface, attribute),
         'idl_type': idl_type,
+        'has_setter': has_setter,
         'is_keep_alive_for_gc': this_is_keep_alive_for_gc,
         'is_nullable': attribute.is_nullable,
         'is_static': attribute.is_static,
         'name': attribute.name,
+        'per_context_enabled_function_name': v8_utilities.per_context_enabled_function_name(attribute),  # [PerContextEnabled]
         'property_attributes': property_attributes(attribute),
+        'setter_callback_name': setter_callback_name(interface, attribute),
+        'setter_callback_name_for_main_world': setter_callback_name_for_main_world(interface, attribute),
         'v8_type': v8_types.v8_type(idl_type),
-        'per_context_enabled_function_name': v8_utilities.per_context_enabled_function_name(attribute),  # [PerContextEnabled]
         'runtime_enabled_function_name': v8_utilities.runtime_enabled_function_name(attribute),  # [RuntimeEnabled]
-        # [PerWorldBindings]
-        'world_suffixes': ['', 'ForMainWorld'] if 'PerWorldBindings' in attribute.extended_attributes else [''],
-        'getter_for_main_world': getter_for_main_world(interface, attribute),
-        'setter_for_main_world': setter_for_main_world(interface, attribute),
+        'world_suffixes': ['', 'ForMainWorld'] if 'PerWorldBindings' in attribute.extended_attributes else [''],  # [PerWorldBindings]
     }
     if has_extended_attribute(attribute, ('Custom', 'CustomGetter')):
-        contents['is_custom_getter'] = True
+        contents['has_custom_getter'] = True
         return contents, set()
 
     includes = set()
     cpp_value = getter_expression(interface, attribute, contents, includes)
     # [GetterRaisesException], [RaisesException]
     is_getter_raises_exception = has_extended_attribute(attribute, ('GetterRaisesException', 'RaisesException'))
     # Normally we can inline the function call into the return statement to
     # avoid the overhead of using a Ref<> temporary, but for some cases
     # (nullable types, EventHandler, [CachedAttribute], or if there are
     # exceptions), we need to use a local variable.
     # FIXME: check if compilers are smart enough to inline this, and if so,
     # always use a local variable (for readability and CG simplicity).
     if (attribute.is_nullable or
         idl_type == 'EventHandler' or
         'CachedAttribute' in extended_attributes or
         is_getter_raises_exception):
         contents['cpp_value_original'] = cpp_value
         cpp_value = 'value'
     contents['cpp_value'] = cpp_value
 
     if this_is_keep_alive_for_gc:
-        return_v8_value_statement = 'v8SetReturnValue(info, wrapper);'
+        v8_set_return_value_statement = 'v8SetReturnValue(info, wrapper)'
         includes.update(v8_types.includes_for_type(idl_type))
         includes.add('bindings/v8/V8HiddenPropertyName.h')
     else:
-        return_v8_value_statement = v8_types.v8_set_return_value(idl_type, cpp_value, includes, callback_info='info', isolate='info.GetIsolate()', extended_attributes=extended_attributes, script_wrappable='imp')
-    contents['return_v8_value_statement'] = return_v8_value_statement
+        v8_set_return_value_statement = v8_types.v8_set_return_value(idl_type, cpp_value, includes, callback_info='info', isolate='info.GetIsolate()', extended_attributes=extended_attributes, script_wrappable='imp')
+    contents['v8_set_return_value'] = v8_set_return_value_statement
 
     if (idl_type == 'EventHandler' and
         interface.name in ['Window', 'WorkerGlobalScope'] and
         attribute.name == 'onerror'):
             includes.add('bindings/v8/V8ErrorHandler.h')
 
     # [CheckSecurityForNode]
     is_check_security_for_node = 'CheckSecurityForNode' in extended_attributes
     if is_check_security_for_node:
         includes.add('bindings/v8/BindingSecurity.h')
     v8_utilities.generate_measure_as(attribute, contents, includes)  # [MeasureAs]
 
     # [DeprecateAs]
     v8_utilities.generate_deprecate_as(attribute, contents, includes)
     if is_check_security_for_node or is_getter_raises_exception:
         includes.update(set(['bindings/v8/ExceptionMessages.h',
                              'bindings/v8/ExceptionState.h']))
 
     contents.update({
         'activity_logging_getter': v8_utilities.has_activity_logging(attribute, includes, 'Getter'),  # [ActivityLogging]
         'is_check_security_for_node': is_check_security_for_node,
         'is_getter_raises_exception': is_getter_raises_exception,
         'is_unforgeable': 'Unforgeable' in extended_attributes,
     })
 
+    # Setter
+    if not has_setter:
+        return contents, includes
+
+    contents.update({
+        'v8_value_to_local_cpp_value': v8_types.v8_value_to_local_cpp_value(idl_type, attribute.extended_attributes, 'value', 'v', includes, 'info.GetIsolate()'),
+        'cpp_setter': 'imp->set%s(v)' % capitalize(cpp_name(attribute)),
+    })
+
     return contents, includes
 
 
 def getter_expression(interface, attribute, contents, includes):
     arguments = []
     if 'Reflect' in attribute.extended_attributes:
         getter_base_name = content_attribute_getter_base_name(attribute, includes, arguments)
     else:
         getter_base_name = uncapitalize(cpp_name(attribute))
 
@@ skipping 53 matching lines @@
          not(
              # Node lifetime is managed by object grouping.
              v8_types.dom_node_type(idl_type) or
              # A self-reference is unnecessary.
              attribute.name == 'self' or
              # FIXME: Remove these hard-coded hacks.
              idl_type in ['EventHandler', 'Promise', 'Window'] or
              idl_type.startswith('HTML'))))
 
 
+def getter_callback_name(interface, attribute):
+    return '%sV8Internal::%sAttributeGetterCallback' % (cpp_name(interface), attribute.name)
+
+
+def setter_callback_name(interface, attribute):
+    if attribute.is_read_only:
+        return '0'
+    return '%sV8Internal::%sAttributeSetterCallback' % (cpp_name(interface), attribute.name)
+
+
 # [DoNotCheckSecurity], [DoNotCheckSecurityOnGetter], [DoNotCheckSecurityOnSetter], [Unforgeable]
 def access_control_list(attribute):
     extended_attributes = attribute.extended_attributes
     access_control = []
     if 'DoNotCheckSecurity' in extended_attributes:
         access_control.append('v8::ALL_CAN_READ')
         if not attribute.is_read_only:
             access_control.append('v8::ALL_CAN_WRITE')
     if 'DoNotCheckSecurityOnSetter' in extended_attributes:
         access_control.append('v8::ALL_CAN_WRITE')
     if 'DoNotCheckSecurityOnGetter' in extended_attributes:
         access_control.append('v8::ALL_CAN_READ')
     if 'Unforgeable' in extended_attributes:
         access_control.append('v8::PROHIBITS_OVERWRITING')
     return access_control or ['v8::DEFAULT']
 
 
 # [NotEnumerable], [Unforgeable]
 def property_attributes(attribute):
     extended_attributes = attribute.extended_attributes
     property_attributes_list = []
     if 'NotEnumerable' in extended_attributes:
         property_attributes_list.append('v8::DontEnum')
     if 'Unforgeable' in extended_attributes:
         property_attributes_list.append('v8::DontDelete')
     return property_attributes_list or ['v8::None']
 
 
 # [PerWorldBindings]
-def getter_for_main_world(interface, attribute):
+def getter_callback_name_for_main_world(interface, attribute):
     if 'PerWorldBindings' not in attribute.extended_attributes:
         return '0'
     return '%sV8Internal::%sAttributeGetterCallbackForMainWorld' % (cpp_name(interface), attribute.name)
 
 
-def setter_for_main_world(interface, attribute):
+def setter_callback_name_for_main_world(interface, attribute):
     if ('PerWorldBindings' not in attribute.extended_attributes or
         attribute.is_read_only):
         return '0'
     return '%sV8Internal::%sAttributeSetterCallbackForMainWorld' % (cpp_name(interface), attribute.name)