Implement Blink-in-JS for DOM attributes

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 393 matching lines @@
     'MediaQueryListListener': 'MediaQueryListListener::create(ScriptState::current({isolate}), ScriptValue(ScriptState::current({isolate}), {v8_value}))',
     'NodeFilter': 'toNodeFilter({v8_value}, info.Holder(), ScriptState::current({isolate}))',
     'Promise': 'ScriptPromise::cast(ScriptState::current({isolate}), {v8_value})',
     'SerializedScriptValue': 'SerializedScriptValue::create({v8_value}, {isolate})',
     'ScriptValue': 'ScriptValue(ScriptState::current({isolate}), {v8_value})',
     'Window': 'toDOMWindow({v8_value}, {isolate})',
     'XPathNSResolver': 'toXPathNSResolver({v8_value}, {isolate})',
 }
 
 
-def v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index, isolate='info.GetIsolate()'):
+def v8_value_to_cpp_value(idl_type, extended_attributes, v8_value, index, isolate):
     if idl_type.name == 'void':
         return ''
 
     # Composite types
     array_or_sequence_type = idl_type.array_or_sequence_type
     if array_or_sequence_type:
         return v8_value_to_cpp_value_array_or_sequence(array_or_sequence_type, v8_value, index)
 
     # Simple types
     idl_type = idl_type.preprocessed_type
@@ skipping 34 matching lines @@
         expression_format = '(to{ref_ptr_type}NativeArray<{array_or_sequence_type}, V8{array_or_sequence_type}>({v8_value}, {index}, {isolate}))'
         add_includes_for_type(array_or_sequence_type)
     else:
         ref_ptr_type = None
         this_cpp_type = array_or_sequence_type.cpp_type
         expression_format = 'toNativeArray<{cpp_type}>({v8_value}, {index}, {isolate})'
     expression = expression_format.format(array_or_sequence_type=array_or_sequence_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):
+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):
     """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 ''
+
     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, index)
+    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' and not idl_type.array_or_sequence_type:
-        macro = 'TOSTRING_VOID'
+        macro = 'TOSTRING_DEFAULT' if used_in_private_script else 'TOSTRING_VOID'
     elif idl_type.may_raise_exception_on_conversion:
-        macro = 'TONATIVE_VOID_EXCEPTIONSTATE'
+        macro = 'TONATIVE_DEFAULT_EXCEPTIONSTATE' if used_in_private_script else 'TONATIVE_VOID_EXCEPTIONSTATE'

[Jens Widell, 2014/07/03 13:23:26]

This might be somewhat nicer if we had
"TONATIVE_(|EXCEPTIONSTATE)_(VOID|DEFAULT)" instead, in which case we would have

  macro = 'TONATIVE' / 'TONATIVE_EXCEPTIONSTATE' / 'TOSTRING'

first, then

  if used_in_private_script:
      macro += '_DEFAULT'
      args.append('false')
  else:
      macro += '_VOID'

And also, at least in this context, "DEFAULT" is a bit strange. "WITH_RETVAL"
maybe? Not overwhelmingly perfect either, but a bit less confusing. (Also
unrelated to this CL, of course.)

[haraken, 2014/07/11 04:29:56]

I took a look at this. I agree that "TONATIVE_(|EXCEPTIONSTATE)_(VOID|DEFAULT)"
makes the code generator nicer, but in terms of the macro name,
TO*_RETURNTYPE[_ARGTYPE] would make more sense, as commented in
V8BindingMacros.h. So I'm leaning toward keeping the current name as is.

         args.append('exceptionState')
     else:
-        macro = 'TONATIVE_VOID'
+        macro = 'TONATIVE_DEFAULT' if used_in_private_script else 'TONATIVE_VOID'
+
+    if used_in_private_script:
+        args.append('false')
 
     # Macros come in several variants, to minimize expensive creation of
     # v8::TryCatch.
     suffix = ''
 
     if declare_variable:
         args.insert(0, this_cpp_type)
     else:
         suffix += '_INTERNAL'
 
@@ skipping 68 matching lines @@
     if idl_type.is_string_type:
         if idl_type.is_nullable:
             return 'StringOrNull'
         if 'TreatReturnedNullStringAs' not in extended_attributes:
             return base_idl_type
         treat_returned_null_string_as = extended_attributes['TreatReturnedNullStringAs']
         if treat_returned_null_string_as == 'Null':
             return 'StringOrNull'
         if treat_returned_null_string_as == 'Undefined':
             return 'StringOrUndefined'
-        raise 'Unrecognized TreatReturnNullStringAs value: "%s"' % treat_returned_null_string_as
+        raise 'Unrecognized TreatReturnedNullStringAs value: "%s"' % treat_returned_null_string_as
     if idl_type.is_basic_type or base_idl_type == 'ScriptValue':
         return base_idl_type
 
     # Data type with potential additional includes
     add_includes_for_type(idl_type)
     if base_idl_type in V8_SET_RETURN_VALUE:  # Special v8SetReturnValue treatment
         return base_idl_type
 
     # Pointer type
     return 'DOMWrapper'
 
 IdlType.v8_conversion_type = v8_conversion_type
 
 
 V8_SET_RETURN_VALUE = {
     'boolean': 'v8SetReturnValueBool(info, {cpp_value})',
     'int': 'v8SetReturnValueInt(info, {cpp_value})',
     'unsigned': 'v8SetReturnValueUnsigned(info, {cpp_value})',
     'DOMString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())',
     'ByteString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())',
     'ScalarValueString': 'v8SetReturnValueString(info, {cpp_value}, info.GetIsolate())',
-    # [TreatNullReturnValueAs]
+    # [TreatReturnedNullStringAs]
     'StringOrNull': 'v8SetReturnValueStringOrNull(info, {cpp_value}, info.GetIsolate())',
     'StringOrUndefined': 'v8SetReturnValueStringOrUndefined(info, {cpp_value}, info.GetIsolate())',
     'void': '',
     # No special v8SetReturnValue* function (set value directly)
     'float': 'v8SetReturnValue(info, {cpp_value})',
     'unrestricted float': 'v8SetReturnValue(info, {cpp_value})',
     'double': 'v8SetReturnValue(info, {cpp_value})',
     'unrestricted double': 'v8SetReturnValue(info, {cpp_value})',
     # No special v8SetReturnValue* function, but instead convert value to V8
     # and then use general v8SetReturnValue.
@@ skipping 68 matching lines @@
     'ByteString': 'v8String({isolate}, {cpp_value})',
     'ScalarValueString': 'v8String({isolate}, {cpp_value})',
     'boolean': 'v8Boolean({cpp_value}, {isolate})',
     'int': 'v8::Integer::New({isolate}, {cpp_value})',
     'unsigned': 'v8::Integer::NewFromUnsigned({isolate}, {cpp_value})',
     'float': 'v8::Number::New({isolate}, {cpp_value})',
     'unrestricted float': 'v8::Number::New({isolate}, {cpp_value})',
     'double': 'v8::Number::New({isolate}, {cpp_value})',
     'unrestricted double': 'v8::Number::New({isolate}, {cpp_value})',
     'void': 'v8Undefined()',
-    # [TreatNullReturnValueAs]
+    # [TreatReturnedNullStringAs]
     'StringOrNull': '{cpp_value}.isNull() ? v8::Handle<v8::Value>(v8::Null({isolate})) : v8String({isolate}, {cpp_value})',
     'StringOrUndefined': '{cpp_value}.isNull() ? v8Undefined() : v8String({isolate}, {cpp_value})',
     # Special cases
     'EventHandler': '{cpp_value} ? v8::Handle<v8::Value>(V8AbstractEventListener::cast({cpp_value})->getListenerObject(impl->executionContext())) : v8::Handle<v8::Value>(v8::Null({isolate}))',
     'ScriptValue': '{cpp_value}.v8Value()',
     'SerializedScriptValue': '{cpp_value} ? {cpp_value}->deserialize() : v8::Handle<v8::Value>(v8::Null({isolate}))',
     # General
     'array': 'v8Array({cpp_value}, {creation_context}, {isolate})',
     'DOMWrapper': 'toV8({cpp_value}, {creation_context}, {isolate})',
 }
@@ skipping 13 matching lines @@
 
 def literal_cpp_value(idl_type, idl_literal):
     """Converts an expression that is a valid C++ literal for this type."""
     # FIXME: add validation that idl_type and idl_literal are compatible
     literal_value = str(idl_literal)
     if idl_type.base_type in CPP_UNSIGNED_TYPES:
         return literal_value + 'u'
     return literal_value
 
 IdlType.literal_cpp_value = literal_cpp_value