IDL: DOM impl class code generation for IDL dictionaries

Source/bindings/scripts/v8_dictionary.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Generate template contexts of dictionaries for both v8 bindings and
 implementation classes that are used by blink's core/modules.
 """
 
 import copy
 import operator
@@ skipping 61 matching lines @@
 
     cpp_default_value, v8_default_value = default_values()
 
     return {
         'cpp_default_value': cpp_default_value,
         'cpp_type': idl_type.cpp_type,
         'cpp_value_to_v8_value': idl_type.cpp_value_to_v8_value(
             cpp_value='impl->%s()' % member.name, isolate='isolate',
             creation_context='creationContext',
             extended_attributes=member.extended_attributes),
         'has_name': has_name_for_dictionary_member(member),

[haraken, 2014/07/27 07:46:35]

has_name => has_method_name
has_name_for_dictionary_member => has_method_name_for_dictionary_member

[bashi, 2014/07/29 03:52:50]

Done.

         'name': member.name,
         'setter_name': setter_name_for_dictionary_member(member),
         'v8_default_value': v8_default_value,
         'v8_type': v8_types.v8_type(idl_type.base_type),
     }
 
-# FIXME: Implement context for impl class.
+
+# Context for implementation classes
+
+def dictionary_impl_context(dictionary, interfaces_info):
+    includes.clear()
+    header_includes = set(['platform/heap/Handle.h'])
+    return {
+        'header_includes': header_includes,
+        'cpp_class': v8_utilities.cpp_name(dictionary),
+        'members': [member_impl_context(member, interfaces_info,
+                                        header_includes)
+                    for member in dictionary.members],
+    }
+
+
+def member_impl_context(member, interfaces_info, header_includes):
+    idl_type = member.idl_type
+
+    def should_use_nullable_container():

[haraken, 2014/07/27 07:46:35]

Can we use is_implicit_nullable/is_explicit_nullable in v8_types.py?

[bashi, 2014/07/29 03:52:50]

It seems that we can't use is_implicit_nullable/is_explicit_nullable unless we
change the definitions of those method. They check |idl_type.is_nullable| first,
but we don't want to check it here. For example, for both DOMString and
DOMString? types, we want to use String. Same for interface types.

+        return idl_type.native_array_element_type or idl_type.is_primitive_type
+
+    def collect_includes(idl_type):

[haraken, 2014/07/27 07:46:35]

Can we move this method to v8_types.py?

Similarly to v8_types.includes_for_type, let's name this method
v8_types.impl_includes_for_type. You can also define IMPL_INCLUDES_FOR_TYPE if
necessary (just like INCLUDES_FOR_TYPE).

[bashi, 2014/07/29 03:52:50]

Done.

+        includes_for_type = set()
+        if should_use_nullable_container():
+            includes_for_type.add('bindings/core/v8/Nullable.h')
+
+        idl_type = idl_type.preprocessed_type
+        native_array_element_type = idl_type.native_array_element_type
+        if native_array_element_type:
+            includes_for_type.update(collect_includes(
+                    native_array_element_type))
+            includes_for_type.add('wtf/Vector.h')
+
+        if idl_type.is_string_type:
+            includes_for_type.add('wtf/text/WTFString.h')
+        if idl_type.name in interfaces_info:
+            interface_info = interfaces_info[idl_type.name]
+            includes_for_type.add(interface_info['include_path'])
+        return includes_for_type
+
+    def argument_cpp_type():
+        argument_cpp_type = idl_type.cpp_type_args(used_as_argument=True)
+        if idl_type.native_array_element_type:
+            return 'const %s&' % argument_cpp_type
+        return argument_cpp_type
+
+    def getter_cpp_type():
+        getter_cpp_type = idl_type.cpp_type_args(used_as_return_type=True)
+        if (idl_type.native_array_element_type or idl_type.is_string_type):
+            return 'const %s&' % getter_cpp_type
+        return getter_cpp_type
+
+    def getter_method_expression():
+        if should_use_nullable_container():
+            return 'm_%s.get()' % member.name
+        return 'm_%s' % member.name
+
+    def has_method_expression():
+        if should_use_nullable_container() or idl_type.is_string_type:
+            return '!m_%s.isNull()' % member.name

[haraken, 2014/07/27 07:46:35]

I think we should share this code with property_getter in v8_interface.py.

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[bashi, 2014/07/29 03:52:51]

Hmm, the semantics of Nullable usage are different between here (dictionary
impl) and others. For dictionaries, we use Nullable to implement the 'present'
notion. Others use Nullable to represent IDL's nullable. This means that we will
have different rules for code generation.

For example, suppose we are going to share the implementation of
|is_null_expression|. In dictionary case, 'int' type should be
"m_intMember.isNull()". In other cases, 'int' type should be ''. To make this
workable, we need an extra flag for dictionaries. I think this is just adding
complexity.

[haraken, 2014/07/29 11:09:19]

Thanks for the clarification, makes sense!

+        else:
+            return 'm_%s' % member.name
+
+    def member_cpp_type():
+        member_cpp_type = idl_type.cpp_type_args(used_as_member=True)
+        if should_use_nullable_container():
+            return v8_types.cpp_template_type('Nullable', member_cpp_type)

[haraken, 2014/07/27 07:46:35]

Ditto. We can share this code with v8_method.py.

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

Other than this, we have several code in bindings/scripts/ to do special
conversion for nullable types. Probably we want to introduce good helper methods
to v8_types.py and get rid of the duplicated code for the nullable types.
Specifically, we want to get rid of getter_cpp_type, getter_method_expression,
has_method_expression and method_cpp_type from this file.

[bashi, 2014/07/29 03:52:51]

I put these functions in this file because these are dictionary specific(as
described above). We can put them into v8_types, but they're unlikely to be able
to share with other (IDL's) nullable logic.

+        return member_cpp_type
+
+    header_includes.update(collect_includes(idl_type))
+    return {
+        'argument_cpp_type': argument_cpp_type(),
+        'getter_cpp_type': getter_cpp_type(),
+        'getter_method_expression': getter_method_expression(),
+        'has_method_expression': has_method_expression(),
+        'has_name': has_name_for_dictionary_member(member),
+        'is_traceable': (idl_type.is_garbage_collected or
+                         idl_type.is_will_be_garbage_collected),
+        'member_cpp_type': member_cpp_type(),
+        'name': member.name,
+        'setter_name': setter_name_for_dictionary_member(member),
+    }