Implement Blink-in-JS for DOM attributes

Source/bindings/scripts/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 53 matching lines @@
     if is_custom_element_callbacks or is_reflect:
         includes.add('core/dom/custom/CustomElementCallbackDispatcher.h')
     # [PerWorldBindings]
     if 'PerWorldBindings' in extended_attributes:
         assert idl_type.is_wrapper_type or 'LogActivity' in extended_attributes, '[PerWorldBindings] should only be used with wrapper types: %s.%s' % (interface.name, attribute.name)
     # [TypeChecking]
     has_type_checking_unrestricted = (
         (has_extended_attribute_value(interface, 'TypeChecking', 'Unrestricted') or
          has_extended_attribute_value(attribute, 'TypeChecking', 'Unrestricted')) and
          idl_type.name in ('Float', 'Double'))
+    # [ImplementedInPrivateScript]
+    is_implemented_in_private_script = 'ImplementedInPrivateScript' in extended_attributes
+    if is_implemented_in_private_script:
+        includes.add('bindings/core/v8/PrivateScriptRunner.h')
+        includes.add('core/frame/LocalFrame.h')
 
     if (base_idl_type == 'EventHandler' and
         interface.name in ['Window', 'WorkerGlobalScope'] and
         attribute.name == 'onerror'):
         includes.add('bindings/core/v8/V8ErrorHandler.h')
 
     # Nullable type where the corresponding C++ type supports a null value.
     is_nullable_simple = idl_type.is_nullable and (
         (idl_type.is_string_type or idl_type.is_wrapper_type) and
         not idl_type.array_or_sequence_type)
@@ skipping 17 matching lines @@
         'has_type_checking_unrestricted': has_type_checking_unrestricted,
         'idl_type': str(idl_type),  # need trailing [] on array for Dictionary::ConversionContext::setConversionType
         'is_call_with_execution_context': v8_utilities.has_extended_attribute_value(attribute, 'CallWith', 'ExecutionContext'),
         'is_call_with_script_state': v8_utilities.has_extended_attribute_value(attribute, 'CallWith', 'ScriptState'),
         'is_check_security_for_node': is_check_security_for_node,
         'is_custom_element_callbacks': is_custom_element_callbacks,
         'is_expose_js_accessors': 'ExposeJSAccessors' in extended_attributes,
         'is_getter_raises_exception':  # [RaisesException]
             'RaisesException' in extended_attributes and
             extended_attributes['RaisesException'] in (None, 'Getter'),
+        'is_implemented_in_private_script': is_implemented_in_private_script,
         'is_initialized_by_event_constructor':
             'InitializedByEventConstructor' in extended_attributes,
         'is_keep_alive_for_gc': is_keep_alive_for_gc(interface, attribute),
         'is_nullable': idl_type.is_nullable,
         'is_nullable_simple': is_nullable_simple,
         'is_partial_interface_member':
             'PartialInterfaceImplementedAs' in extended_attributes,
         'is_per_world_bindings': 'PerWorldBindings' in extended_attributes,
         'is_read_only': attribute.is_read_only,
         'is_reflect': is_reflect,
         'is_replaceable': 'Replaceable' in attribute.extended_attributes,
         'is_static': attribute.is_static,
         'is_url': 'URL' in extended_attributes,
         'is_unforgeable': 'Unforgeable' in extended_attributes,
         'measure_as': v8_utilities.measure_as(attribute),  # [MeasureAs]
         'name': attribute.name,
         'per_context_enabled_function': v8_utilities.per_context_enabled_function_name(attribute),  # [PerContextEnabled]
+        'private_script_v8_value_to_local_cpp_value': idl_type.v8_value_to_local_cpp_value(
+            extended_attributes, 'v8Value', 'cppValue', isolate='scriptState->isolate()', used_in_private_script=True),
         'property_attributes': property_attributes(attribute),
         'put_forwards': 'PutForwards' in extended_attributes,
+        'argument_cpp_type': idl_type.cpp_type_args(used_as_argument=True),

[Jens Widell, 2014/07/03 11:33:14]

Alphabetical order. :-)

[haraken, 2014/07/03 11:56:09]

Done.

         'reflect_empty': extended_attributes.get('ReflectEmpty'),
         'reflect_invalid': extended_attributes.get('ReflectInvalid', ''),
         'reflect_missing': extended_attributes.get('ReflectMissing'),
         'reflect_only': extended_attributes['ReflectOnly'].split('|')
             if 'ReflectOnly' in extended_attributes else None,
+        'runtime_enabled_function': v8_utilities.runtime_enabled_function_name(attribute),  # [RuntimeEnabled]
         'setter_callback': setter_callback_name(interface, attribute),
         'v8_type': v8_types.v8_type(base_idl_type),
-        'runtime_enabled_function': v8_utilities.runtime_enabled_function_name(attribute),  # [RuntimeEnabled]
         'world_suffixes': ['', 'ForMainWorld']
                           if 'PerWorldBindings' in extended_attributes
                           else [''],  # [PerWorldBindings]
     }
 
     if is_constructor_attribute(attribute):
         constructor_getter_context(interface, attribute, context)
         return context
     if not has_custom_getter:
         getter_context(interface, attribute, context)
@@ skipping 24 matching lines @@
     if ((idl_type.is_nullable and not context['is_nullable_simple']) or
         base_idl_type == 'EventHandler' or
         'CachedAttribute' in extended_attributes or
         'LogPreviousValue' in extended_attributes or
         'ReflectOnly' in extended_attributes or
         context['is_keep_alive_for_gc'] or
         context['is_getter_raises_exception']):
         context['cpp_value_original'] = cpp_value
         cpp_value = 'cppValue'
         # EventHandler has special handling
-        if base_idl_type != 'EventHandler' and idl_type.is_interface_type:
-            release = True
+        if base_idl_type != 'EventHandler':
+            release = idl_type.release
+
+    if 'ImplementedInPrivateScript' in extended_attributes:

[Jens Widell, 2014/07/03 11:33:14]

Both this branch and the one before it pushes cpp_value into
'cpp_value_original' and changes cpp_value to something else. Would it work for
both branches to do that for one attribute, or are they in fact mutually
exclusive? If the latter, maybe make this "elif" instead?

[haraken, 2014/07/03 11:56:09]

Yes, changed it to elif.

+        if (not idl_type.is_wrapper_type and
+            not idl_type.is_basic_type):
+            raise Exception('Private scripts supports only primitive types and DOM wrappers.')
+
+        context['cpp_value_original'] = cpp_value
+        cpp_value = 'result'
+        # EventHandler has special handling
+        if base_idl_type != 'EventHandler':
+            release = idl_type.release
 
     def v8_set_return_value_statement(for_main_world=False):
         if context['is_keep_alive_for_gc']:
             return 'v8SetReturnValue(info, wrapper)'
         return idl_type.v8_set_return_value(cpp_value, extended_attributes=extended_attributes, script_wrappable='impl', release=release, for_main_world=for_main_world)
 
     context.update({
         'cpp_value': cpp_value,
         'cpp_value_to_v8_value': idl_type.cpp_value_to_v8_value(
             cpp_value=cpp_value, creation_context='info.Holder()',
             extended_attributes=extended_attributes),
         'v8_set_return_value_for_main_world': v8_set_return_value_statement(for_main_world=True),
         'v8_set_return_value': v8_set_return_value_statement(),
     })
 
 
 def getter_expression(interface, attribute, context):
     arguments = []
     this_getter_base_name = getter_base_name(interface, attribute, arguments)
     getter_name = scoped_name(interface, attribute, this_getter_base_name)
 
+    if 'ImplementedInPrivateScript' in attribute.extended_attributes:
+        arguments.append('toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext())')
+        arguments.append('impl')
+        arguments.append('&result')
     arguments.extend(v8_utilities.call_with_arguments(
         attribute.extended_attributes.get('CallWith')))
     # Members of IDL partial interface definitions are implemented in C++ as
     # static member functions, which for instance members (non-static members)
     # take *impl as their first argument
     if ('PartialInterfaceImplementedAs' in attribute.extended_attributes and
         not attribute.is_static):
         arguments.append('*impl')
     if attribute.idl_type.is_nullable and not context['is_nullable_simple']:
         arguments.append('isNull')
     if context['is_getter_raises_exception']:
         arguments.append('exceptionState')
     return '%s(%s)' % (getter_name, ', '.join(arguments))
 
 
 CONTENT_ATTRIBUTE_GETTER_NAMES = {
     'boolean': 'fastHasAttribute',
     'long': 'getIntegralAttribute',
     'unsigned long': 'getUnsignedIntegralAttribute',
 }
 
 
 def getter_base_name(interface, attribute, arguments):
     extended_attributes = attribute.extended_attributes
+
+    if 'ImplementedInPrivateScript' in extended_attributes:
+        return '%sAttributeGetterImplementedInPrivateScript' % uncapitalize(cpp_name(attribute))
+
     if 'Reflect' not in extended_attributes:
         return uncapitalize(cpp_name(attribute))
 
     content_attribute_name = extended_attributes['Reflect'] or attribute.name.lower()
     if content_attribute_name in ['class', 'id', 'name']:
         # Special-case for performance optimization.
         return 'get%sAttribute' % content_attribute_name.capitalize()
 
     arguments.append(scoped_content_attribute_name(interface, attribute))
 
@@ skipping 64 matching lines @@
         'has_setter_exception_state':
             is_setter_raises_exception or has_type_checking_interface or
             context['has_type_checking_unrestricted'] or
             idl_type.may_raise_exception_on_conversion,
         'has_type_checking_interface': has_type_checking_interface,
         'is_setter_call_with_execution_context': v8_utilities.has_extended_attribute_value(
             attribute, 'SetterCallWith', 'ExecutionContext'),
         'is_setter_raises_exception': is_setter_raises_exception,
         'v8_value_to_local_cpp_value': idl_type.v8_value_to_local_cpp_value(
             extended_attributes, 'v8Value', 'cppValue'),
+        'cpp_value_to_v8_value': idl_type.cpp_value_to_v8_value(

[Jens Widell, 2014/07/03 11:33:14]

This is set to a different value in getter_context(). Won't these conflict?

[haraken, 2014/07/03 11:56:09]

Nice catch, renamed it to private_script_cpp_value_to_v8_value.

+            'cppValue', isolate='scriptState->isolate()',
+            creation_context='scriptState->context()->Global()'),
     })
 
     # setter_expression() depends on context values we set above.
     context['cpp_setter'] = setter_expression(interface, attribute, context)
 
 
 def setter_expression(interface, attribute, context):
     extended_attributes = attribute.extended_attributes
     arguments = v8_utilities.call_with_arguments(
         extended_attributes.get('SetterCallWith') or
         extended_attributes.get('CallWith'))
 
     this_setter_base_name = setter_base_name(interface, attribute, arguments)
     setter_name = scoped_name(interface, attribute, this_setter_base_name)
 
     # Members of IDL partial interface definitions are implemented in C++ as
     # static member functions, which for instance members (non-static members)
     # take *impl as their first argument
     if ('PartialInterfaceImplementedAs' in extended_attributes and
         not attribute.is_static):
         arguments.append('*impl')
     idl_type = attribute.idl_type
-    if idl_type.base_type == 'EventHandler':
+    if 'ImplementedInPrivateScript' in extended_attributes:
+        arguments.append('toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext())')
+        arguments.append('impl')
+        arguments.append('cppValue')
+    elif idl_type.base_type == 'EventHandler':
         getter_name = scoped_name(interface, attribute, cpp_name(attribute))
         context['event_handler_getter_expression'] = '%s(%s)' % (
             getter_name, ', '.join(arguments))
         if (interface.name in ['Window', 'WorkerGlobalScope'] and
             attribute.name == 'onerror'):
             includes.add('bindings/core/v8/V8ErrorHandler.h')
             arguments.append('V8EventListenerList::findOrCreateWrapper<V8ErrorHandler>(v8Value, true, ScriptState::current(info.GetIsolate()))')
         else:
             arguments.append('V8EventListenerList::getEventListener(ScriptState::current(info.GetIsolate()), v8Value, true, ListenerFindOrCreate)')
     elif idl_type.is_interface_type and not idl_type.array_type:
         # FIXME: should be able to eliminate WTF::getPtr in most or all cases
         arguments.append('WTF::getPtr(cppValue)')
     else:
         arguments.append('cppValue')
     if context['is_setter_raises_exception']:
         arguments.append('exceptionState')
 
     return '%s(%s)' % (setter_name, ', '.join(arguments))
 
 
 CONTENT_ATTRIBUTE_SETTER_NAMES = {
     'boolean': 'setBooleanAttribute',
     'long': 'setIntegralAttribute',
     'unsigned long': 'setUnsignedIntegralAttribute',
 }
 
 
 def setter_base_name(interface, attribute, arguments):
+    if 'ImplementedInPrivateScript' in attribute.extended_attributes:
+        return '%sAttributeSetterImplementedInPrivateScript' % uncapitalize(cpp_name(attribute))
+
     if 'Reflect' not in attribute.extended_attributes:
         return 'set%s' % capitalize(cpp_name(attribute))
     arguments.append(scoped_content_attribute_name(interface, attribute))
 
     base_idl_type = attribute.idl_type.base_type
     if base_idl_type in CONTENT_ATTRIBUTE_SETTER_NAMES:
         return CONTENT_ATTRIBUTE_SETTER_NAMES[base_idl_type]
     return 'setAttribute'
 
 
@@ skipping 60 matching lines @@
     lambda self: strip_suffix(self.base_type, 'Constructor'))
 
 
 def is_constructor_attribute(attribute):
     # FIXME: replace this with [ConstructorAttribute] extended attribute
     return attribute.idl_type.base_type.endswith('Constructor')
 
 
 def constructor_getter_context(interface, attribute, context):
     context['needs_constructor_getter_callback'] = context['measure_as'] or context['deprecate_as']