IDL: DOM impl class code generation for IDL dictionaries

After this CL, CodeGeneratorV8 generates not only V8 bindings, but also
DOM implementation classes for IDL dictionaries.

- For an IDL file which defines a dictionary, the code generator
  generates bindings code (V8Foo.{cpp,h}) and DOM impl code
  (Foo.{cpp,h}).

- Added Jinja templates for DOM impl generation. The context for these
  templates is created by v8_dictionary.dictionary_impl_context().

- v8_types.cpp_types() takes a new argument called
  |used_as_return_type|. This flags is used by member_impl_context().
  Also, |used_in_cpp_sequence| argument is renamed to |used_as_member|.

IDL dictionaries are still not be able to use in core/modules. We need
to generate impl classes in the right place.
(e.g. core/dom/Foo.idl -> gen/blink/core/dom/Foo.{cpp,h})

Also, following types are not supported yet as dictionary members:
- union types.
- enumeration types.
- composite types (arrays, sequences and dictionaries) of which element
  type is an interface.

BUG=321462

Review URL: https://codereview.chromium.org/420763002

git-svn-id: svn://svn.chromium.org/blink/trunk@179190 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/bindings/scripts/code_generator_v8.py

@@ -96,10 +96,11 @@ def render_template(interface_info, header_template, cpp_template,
 
 
 class CodeGeneratorV8(object):
-    def __init__(self, interfaces_info, cache_dir):
+    def __init__(self, interfaces_info, cache_dir, output_dir):
         interfaces_info = interfaces_info or {}
         self.interfaces_info = interfaces_info
         self.jinja_env = initialize_jinja_env(cache_dir)
+        self.output_dir = output_dir
 
         # Set global type info
         idl_types.set_ancestors(dict(
@@ -130,6 +131,17 @@ class CodeGeneratorV8(object):
             (interface_name, interface_info['component_dir'])
             for interface_name, interface_info in interfaces_info.iteritems()))
 
+    def output_paths_for_bindings(self, definition_name):
+        header_path = posixpath.join(self.output_dir,
+                                     'V8%s.h' % definition_name)
+        cpp_path = posixpath.join(self.output_dir, 'V8%s.cpp' % definition_name)
+        return header_path, cpp_path
+
+    def output_paths_for_impl(self, definition_name):
+        header_path = posixpath.join(self.output_dir, '%s.h' % definition_name)
+        cpp_path = posixpath.join(self.output_dir, '%s.cpp' % definition_name)
+        return header_path, cpp_path
+
     def generate_code(self, definitions, definition_name):
         """Returns .h/.cpp code as (header_text, cpp_text)."""
         # Set local type info
@@ -170,14 +182,20 @@ class CodeGeneratorV8(object):
         template_context['header_includes'].add(interface_info['include_path'])
         header_text, cpp_text = render_template(
             interface_info, header_template, cpp_template, template_context)
-        return header_text, cpp_text
+        header_path, cpp_path = self.output_paths_for_bindings(interface_name)
+        return (
+            (header_path, header_text),
+            (cpp_path, cpp_text),
+        )
 
     def generate_dictionary_code(self, definitions, dictionary_name,
                                  dictionary):
         interface_info = self.interfaces_info[dictionary_name]
-        # FIXME: Generate impl class
-        return self.generate_dictionary_bindings(
+        bindings_results = self.generate_dictionary_bindings(
+            dictionary_name, interface_info, dictionary)
+        impl_results = self.generate_dictionary_impl(
             dictionary_name, interface_info, dictionary)
+        return bindings_results + impl_results
 
     def generate_dictionary_bindings(self, dictionary_name,
                                      interface_info, dictionary):
@@ -188,7 +206,25 @@ class CodeGeneratorV8(object):
         template_context['header_includes'].add(interface_info['include_path'])
         header_text, cpp_text = render_template(
             interface_info, header_template, cpp_template, template_context)
-        return header_text, cpp_text
+        header_path, cpp_path = self.output_paths_for_bindings(dictionary_name)
+        return (
+            (header_path, header_text),
+            (cpp_path, cpp_text),
+        )
+
+    def generate_dictionary_impl(self, dictionary_name,
+                                 interface_info, dictionary):
+        header_template = self.jinja_env.get_template('dictionary_impl.h')
+        cpp_template = self.jinja_env.get_template('dictionary_impl.cpp')
+        template_context = v8_dictionary.dictionary_impl_context(
+            dictionary, self.interfaces_info)
+        header_text, cpp_text = render_template(
+            interface_info, header_template, cpp_template, template_context)
+        header_path, cpp_path = self.output_paths_for_impl(dictionary_name)
+        return (
+            (header_path, header_text),
+            (cpp_path, cpp_text),
+        )
 
 
 def initialize_jinja_env(cache_dir):

third_party/WebKit/Source/bindings/scripts/idl_compiler.py

@@ -100,14 +100,13 @@ class IdlCompiler(object):
         self.output_directory = output_directory
         self.reader = IdlReader(interfaces_info, cache_directory)
 
-    def compile_and_write(self, idl_filename, output_filenames):
+    def compile_and_write(self, idl_filename):
         interface_name = idl_filename_to_interface_name(idl_filename)
         definitions = self.reader.read_idl_definitions(idl_filename)
         output_code_list = self.code_generator.generate_code(
             definitions, interface_name)
-        for output_code, output_filename in zip(output_code_list,
-                                                output_filenames):
-            write_file(output_code, output_filename, self.only_if_changed)
+        for output_path, output_code in output_code_list:
+            write_file(output_code, output_path, self.only_if_changed)
 
     @abc.abstractmethod
     def compile_file(self, idl_filename):
@@ -118,15 +117,11 @@ class IdlCompilerV8(IdlCompiler):
     def __init__(self, *args, **kwargs):
         IdlCompiler.__init__(self, *args, **kwargs)
         self.code_generator = CodeGeneratorV8(self.interfaces_info,
-                                              self.cache_directory)
+                                              self.cache_directory,
+                                              self.output_directory)
 
     def compile_file(self, idl_filename):
-        interface_name = idl_filename_to_interface_name(idl_filename)
-        header_filename = os.path.join(self.output_directory,
-                                       'V8%s.h' % interface_name)
-        cpp_filename = os.path.join(self.output_directory,
-                                    'V8%s.cpp' % interface_name)
-        self.compile_and_write(idl_filename, (header_filename, cpp_filename))
+        self.compile_and_write(idl_filename)
 
 
 def main():

third_party/WebKit/Source/bindings/scripts/v8_attributes.py

@@ -92,7 +92,7 @@ def attribute_context(interface, attribute):
         'activity_logging_world_list_for_setter': v8_utilities.activity_logging_world_list(attribute, 'Setter'),  # [ActivityLogging]
         'activity_logging_include_old_value_for_setter': 'LogPreviousValue' in extended_attributes,  # [ActivityLogging]
         'activity_logging_world_check': v8_utilities.activity_logging_world_check(attribute),  # [ActivityLogging]
-        'argument_cpp_type': idl_type.cpp_type_args(used_as_argument=True),
+        'argument_cpp_type': idl_type.cpp_type_args(used_as_rvalue_type=True),
         'cached_attribute_validation_method': extended_attributes.get('CachedAttribute'),
         'conditional_string': v8_utilities.conditional_string(attribute),
         'constructor_type': idl_type.constructor_type_name

third_party/WebKit/Source/bindings/scripts/v8_dictionary.py

@@ -28,7 +28,7 @@ def setter_name_for_dictionary_member(member):
     return 'set%s' % v8_utilities.capitalize(member.name)
 
 
-def has_name_for_dictionary_member(member):
+def has_method_name_for_dictionary_member(member):
     return 'has%s' % v8_utilities.capitalize(member.name)
 
 
@@ -79,11 +79,58 @@ def member_context(member):
             cpp_value='impl->%s()' % member.name, isolate='isolate',
             creation_context='creationContext',
             extended_attributes=member.extended_attributes),
-        'has_name': has_name_for_dictionary_member(member),
+        'has_method_name': has_method_name_for_dictionary_member(member),
         '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 getter_expression():
+        if idl_type.impl_should_use_nullable_container:
+            return 'm_%s.get()' % member.name
+        return 'm_%s' % member.name
+
+    def has_method_expression():
+        if (idl_type.impl_should_use_nullable_container or
+            idl_type.is_string_type):
+            return '!m_%s.isNull()' % member.name
+        else:
+            return 'm_%s' % member.name
+
+    def member_cpp_type():
+        member_cpp_type = idl_type.cpp_type_args(used_in_cpp_sequence=True)
+        if idl_type.impl_should_use_nullable_container:
+            return v8_types.cpp_template_type('Nullable', member_cpp_type)
+        return member_cpp_type
+
+    header_includes.update(idl_type.impl_includes_for_type(interfaces_info))
+    return {
+        'getter_expression': getter_expression(),
+        'has_method_expression': has_method_expression(),
+        'has_method_name': has_method_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,
+        'rvalue_cpp_type': idl_type.cpp_type_args(used_as_rvalue_type=True),
+        'setter_name': setter_name_for_dictionary_member(member),
+    }

third_party/WebKit/Source/bindings/scripts/v8_methods.py

@@ -251,7 +251,7 @@ def argument_declarations_for_private_script(interface, method):
     argument_declarations = ['LocalFrame* frame']
     argument_declarations.append('%s* holderImpl' % interface.name)
     argument_declarations.extend(['%s %s' % (argument.idl_type.cpp_type_args(
-        used_as_argument=True), argument.name) for argument in method.arguments])
+        used_as_rvalue_type=True), argument.name) for argument in method.arguments])
     if method.idl_type.name != 'void':
         argument_declarations.append('%s* %s' % (method.idl_type.cpp_type, 'result'))
     return argument_declarations

third_party/WebKit/Source/bindings/scripts/v8_types.py

@@ -120,7 +120,7 @@ CPP_SPECIAL_CONVERSION_RULES = {
 }
 
 
-def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_argument=False, used_as_variadic_argument=False, used_in_cpp_sequence=False):
+def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_rvalue_type=False, used_as_variadic_argument=False, used_in_cpp_sequence=False):
     """Returns C++ type corresponding to IDL type.
 
     |idl_type| argument is of type IdlType, while return value is a string
@@ -130,12 +130,14 @@ def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_argumen
             IdlType
         raw_type:
             bool, True if idl_type's raw/primitive C++ type should be returned.
-        used_as_argument:
-            bool, True if the C++ type is used as an argument of a method.
+        used_as_rvalue_type:
+            bool, True if the C++ type is used as an argument or the return
+            type of a method.
         used_as_variadic_argument:
             bool, True if the C++ type is used as a variadic argument of a method.
         used_in_cpp_sequence:
-            bool, True if the C++ type is used as an element of an array or sequence.
+            bool, True if the C++ type is used as an element of a container.
+            Containers can be an array, a sequence or a dictionary.
     """
     def string_mode():
         if extended_attributes.get('TreatNullAs') == 'EmptyString':
@@ -156,7 +158,10 @@ def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_argumen
         native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         vector_type = cpp_ptr_type('Vector', 'HeapVector', native_array_element_type.gc_type)
-        return cpp_template_type(vector_type, native_array_element_type.cpp_type_args(used_in_cpp_sequence=True))
+        vector_template_type = cpp_template_type(vector_type, native_array_element_type.cpp_type_args(used_in_cpp_sequence=True))
+        if used_as_rvalue_type:
+            return 'const %s&' % vector_template_type
+        return vector_template_type
 
     # Simple types
     base_idl_type = idl_type.base_type
@@ -171,7 +176,7 @@ def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_argumen
         return CPP_SPECIAL_CONVERSION_RULES[base_idl_type]
 
     if base_idl_type in NON_WRAPPER_TYPES:
-        return ('PassRefPtr<%s>' if used_as_argument else 'RefPtr<%s>') % base_idl_type
+        return ('PassRefPtr<%s>' if used_as_rvalue_type else 'RefPtr<%s>') % base_idl_type
     if idl_type.is_string_type:
         if not raw_type:
             return 'String'
@@ -184,7 +189,7 @@ def cpp_type(idl_type, extended_attributes=None, raw_type=False, used_as_argumen
         if raw_type:
             return implemented_as_class + '*'
         new_type = 'Member' if used_in_cpp_sequence else 'RawPtr'
-        ptr_type = cpp_ptr_type(('PassRefPtr' if used_as_argument else 'RefPtr'), new_type, idl_type.gc_type)
+        ptr_type = cpp_ptr_type(('PassRefPtr' if used_as_rvalue_type else 'RefPtr'), new_type, idl_type.gc_type)
         return cpp_template_type(ptr_type, implemented_as_class)
     # Default, assume native type is a pointer with same type name as idl type
     return base_idl_type + '*'
@@ -387,11 +392,41 @@ def includes_for_interface(interface_name):
 def add_includes_for_interface(interface_name):
     includes.update(includes_for_interface(interface_name))
 
+
+def impl_should_use_nullable_container(idl_type):
+    return idl_type.native_array_element_type or idl_type.is_primitive_type
+
+IdlType.impl_should_use_nullable_container = property(
+    impl_should_use_nullable_container)
+
+
+def impl_includes_for_type(idl_type, interfaces_info):
+    includes_for_type = set()
+    if idl_type.impl_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(impl_includes_for_type(
+                native_array_element_type, interfaces_info))
+        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
+
+IdlType.impl_includes_for_type = impl_includes_for_type
+
+
 component_dir = {}
 
 
 def set_component_dirs(new_component_dirs):
-        component_dir.update(new_component_dirs)
+    component_dir.update(new_component_dirs)
 
 
 ################################################################################

third_party/WebKit/Source/bindings/templates/dictionary_impl.cpp

+// 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.
+
+// This file has been auto-generated by {{code_generator}}. DO NOT MODIFY!
+
+#include "config.h"
+#include "{{cpp_class}}.h"
+
+{% for filename in cpp_includes %}
+#include "{{filename}}"
+{% endfor %}
+
+namespace blink {
+
+{# Constructor #}
+{{cpp_class}}::{{cpp_class}}()
+{
+}
+
+void {{cpp_class}}::trace(Visitor* visitor)
+{
+    {% for member in members if member.is_traceable %}
+    visitor->trace(m_{{member.name}});
+    {% endfor %}
+}
+
+} // namespace blink

third_party/WebKit/Source/bindings/templates/dictionary_impl.h

+// 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.
+
+// This file has been auto-generated by {{code_generator}}. DO NOT MODIFY!
+
+#ifndef {{cpp_class}}_h
+#define {{cpp_class}}_h
+
+{% for filename in header_includes %}
+#include "{{filename}}"
+{% endfor %}
+
+namespace blink {
+
+class {{cpp_class}} FINAL : public GarbageCollectedFinalized<{{cpp_class}}> {
+public:
+    static {{cpp_class}}* create()
+    {
+        return new {{cpp_class}};
+    }
+
+    {% for member in members %}
+    bool {{member.has_method_name}}() const { return {{member.has_method_expression}}; }
+    {{member.rvalue_cpp_type}} {{member.name}}() const { return {{member.getter_expression}}; }
+    void {{member.setter_name}}({{member.rvalue_cpp_type}} value) { m_{{member.name}} = value;}
+    {% endfor %}
+
+    void trace(Visitor*);
+
+private:
+    {{cpp_class}}();
+
+    {% for member in members %}
+    {{member.member_cpp_type}} m_{{member.name}};
+    {% endfor %}
+
+    friend class V8{{cpp_class}};
+};
+
+} // namespace blink
+
+#endif // {{cpp_class}}_h

third_party/WebKit/Source/bindings/templates/dictionary_v8.cpp

@@ -35,7 +35,7 @@ v8::Handle<v8::Value> toV8({{cpp_class}}* impl, v8::Handle<v8::Object> creationC
 {
     v8::Handle<v8::Object> v8Object = v8::Object::New(isolate);
     {% for member in members %}
-    if (impl->{{member.has_name}}())
+    if (impl->{{member.has_method_name}}())
         v8Object->Set(v8String(isolate, "{{member.name}}"), {{member.cpp_value_to_v8_value}});
     {% if member.v8_default_value %}
     else

third_party/WebKit/Source/bindings/templates/templates.gypi

@@ -8,6 +8,8 @@
       'attributes.cpp',
       'callback_interface.cpp',
       'callback_interface.h',
+      'dictionary_impl.cpp',
+      'dictionary_impl.h',
       'dictionary_v8.cpp',
       'dictionary_v8.h',
       'interface_base.cpp',

third_party/WebKit/Source/bindings/tests/idls/TestDictionary.idl

@@ -11,4 +11,10 @@
     double? doubleOrNullMember = null;
     DOMString? stringOrNullMember = "default string value";
     TestInterface? testInterfaceOrNullMember;
+    TestInterfaceGarbageCollected testInterfaceGarbageCollectedMember;
+    TestInterfaceGarbageCollected? testInterfaceGarbageCollectedOrNullMember;
+    TestInterfaceWillBeGarbageCollected testInterfaceWillBeGarbageCollectedMember;
+    TestInterfaceWillBeGarbageCollected? testInterfaceWillBeGarbageCollectedOrNullMember;
+    DOMString[] stringArrayMember;
+    sequence<DOMString> stringSequenceMember;
 };

third_party/WebKit/Source/bindings/tests/results/TestDictionary.cpp

+// 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.
+
+// This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
+
+#include "config.h"
+#include "TestDictionary.h"
+
+
+namespace blink {
+
+TestDictionary::TestDictionary()
+{
+}
+
+void TestDictionary::trace(Visitor* visitor)
+{
+    visitor->trace(m_testInterfaceGarbageCollectedMember);
+    visitor->trace(m_testInterfaceGarbageCollectedOrNullMember);
+    visitor->trace(m_testInterfaceWillBeGarbageCollectedMember);
+    visitor->trace(m_testInterfaceWillBeGarbageCollectedOrNullMember);
+}
+
+} // namespace blink

third_party/WebKit/Source/bindings/tests/results/TestDictionary.h

+// 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.
+
+// This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
+
+#ifndef TestDictionary_h
+#define TestDictionary_h
+
+#include "bindings/core/v8/Nullable.h"
+#include "bindings/tests/idls/TestInterfaceGarbageCollected.h"
+#include "bindings/tests/idls/TestInterfaceImplementation.h"
+#include "bindings/tests/idls/TestInterfaceWillBeGarbageCollected.h"
+#include "platform/heap/Handle.h"
+#include "wtf/Vector.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class TestDictionary FINAL : public GarbageCollectedFinalized<TestDictionary> {
+public:
+    static TestDictionary* create()
+    {
+        return new TestDictionary;
+    }
+
+    bool hasBooleanMember() const { return !m_booleanMember.isNull(); }
+    bool booleanMember() const { return m_booleanMember.get(); }
+    void setBooleanMember(bool value) { m_booleanMember = value;}
+    bool hasLongMember() const { return !m_longMember.isNull(); }
+    int longMember() const { return m_longMember.get(); }
+    void setLongMember(int value) { m_longMember = value;}
+    bool hasStringMember() const { return !m_stringMember.isNull(); }
+    String stringMember() const { return m_stringMember; }
+    void setStringMember(String value) { m_stringMember = value;}
+    bool hasTestInterfaceMember() const { return m_testInterfaceMember; }
+    PassRefPtr<TestInterfaceImplementation> testInterfaceMember() const { return m_testInterfaceMember; }
+    void setTestInterfaceMember(PassRefPtr<TestInterfaceImplementation> value) { m_testInterfaceMember = value;}
+    bool hasDoubleOrNullMember() const { return !m_doubleOrNullMember.isNull(); }
+    double doubleOrNullMember() const { return m_doubleOrNullMember.get(); }
+    void setDoubleOrNullMember(double value) { m_doubleOrNullMember = value;}
+    bool hasStringOrNullMember() const { return !m_stringOrNullMember.isNull(); }
+    String stringOrNullMember() const { return m_stringOrNullMember; }
+    void setStringOrNullMember(String value) { m_stringOrNullMember = value;}
+    bool hasTestInterfaceOrNullMember() const { return m_testInterfaceOrNullMember; }
+    PassRefPtr<TestInterfaceImplementation> testInterfaceOrNullMember() const { return m_testInterfaceOrNullMember; }
+    void setTestInterfaceOrNullMember(PassRefPtr<TestInterfaceImplementation> value) { m_testInterfaceOrNullMember = value;}
+    bool hasTestInterfaceGarbageCollectedMember() const { return m_testInterfaceGarbageCollectedMember; }
+    RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedMember() const { return m_testInterfaceGarbageCollectedMember; }
+    void setTestInterfaceGarbageCollectedMember(RawPtr<TestInterfaceGarbageCollected> value) { m_testInterfaceGarbageCollectedMember = value;}
+    bool hasTestInterfaceGarbageCollectedOrNullMember() const { return m_testInterfaceGarbageCollectedOrNullMember; }
+    RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedOrNullMember() const { return m_testInterfaceGarbageCollectedOrNullMember; }
+    void setTestInterfaceGarbageCollectedOrNullMember(RawPtr<TestInterfaceGarbageCollected> value) { m_testInterfaceGarbageCollectedOrNullMember = value;}
+    bool hasTestInterfaceWillBeGarbageCollectedMember() const { return m_testInterfaceWillBeGarbageCollectedMember; }
+    PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedMember() const { return m_testInterfaceWillBeGarbageCollectedMember; }
+    void setTestInterfaceWillBeGarbageCollectedMember(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> value) { m_testInterfaceWillBeGarbageCollectedMember = value;}
+    bool hasTestInterfaceWillBeGarbageCollectedOrNullMember() const { return m_testInterfaceWillBeGarbageCollectedOrNullMember; }
+    PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedOrNullMember() const { return m_testInterfaceWillBeGarbageCollectedOrNullMember; }
+    void setTestInterfaceWillBeGarbageCollectedOrNullMember(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> value) { m_testInterfaceWillBeGarbageCollectedOrNullMember = value;}
+    bool hasStringArrayMember() const { return !m_stringArrayMember.isNull(); }
+    const Vector<String>& stringArrayMember() const { return m_stringArrayMember.get(); }
+    void setStringArrayMember(const Vector<String>& value) { m_stringArrayMember = value;}
+    bool hasStringSequenceMember() const { return !m_stringSequenceMember.isNull(); }
+    const Vector<String>& stringSequenceMember() const { return m_stringSequenceMember.get(); }
+    void setStringSequenceMember(const Vector<String>& value) { m_stringSequenceMember = value;}
+
+    void trace(Visitor*);
+
+private:
+    TestDictionary();
+
+    Nullable<bool> m_booleanMember;
+    Nullable<int> m_longMember;
+    String m_stringMember;
+    RefPtr<TestInterfaceImplementation> m_testInterfaceMember;
+    Nullable<double> m_doubleOrNullMember;
+    String m_stringOrNullMember;
+    RefPtr<TestInterfaceImplementation> m_testInterfaceOrNullMember;
+    Member<TestInterfaceGarbageCollected> m_testInterfaceGarbageCollectedMember;
+    Member<TestInterfaceGarbageCollected> m_testInterfaceGarbageCollectedOrNullMember;
+    RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> m_testInterfaceWillBeGarbageCollectedMember;
+    RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> m_testInterfaceWillBeGarbageCollectedOrNullMember;
+    Nullable<Vector<String> > m_stringArrayMember;
+    Nullable<Vector<String> > m_stringSequenceMember;
+
+    friend class V8TestDictionary;
+};
+
+} // namespace blink
+
+#endif // TestDictionary_h

third_party/WebKit/Source/bindings/tests/results/V8TestDictionary.cpp

@@ -9,6 +9,8 @@
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/tests/v8/V8TestInterface.h"
+#include "bindings/tests/v8/V8TestInterfaceGarbageCollected.h"
+#include "bindings/tests/v8/V8TestInterfaceWillBeGarbageCollected.h"
 
 namespace blink {
 
@@ -29,6 +31,9 @@ TestDictionary* V8TestDictionary::toNative(v8::Isolate* isolate, v8::Handle<v8::
         impl->setLongMember(longMember);
     else
         impl->setLongMember(1);
+    Vector<String> stringArrayMember;
+    if (DictionaryHelper::get(dictionary, "stringArrayMember", stringArrayMember))
+        impl->setStringArrayMember(stringArrayMember);
     String stringMember;
     if (DictionaryHelper::get(dictionary, "stringMember", stringMember))
         impl->setStringMember(stringMember);
@@ -37,12 +42,27 @@ TestDictionary* V8TestDictionary::toNative(v8::Isolate* isolate, v8::Handle<v8::
         impl->setStringOrNullMember(stringOrNullMember);
     else
         impl->setStringOrNullMember(String("default string value"));
+    Vector<String> stringSequenceMember;
+    if (DictionaryHelper::get(dictionary, "stringSequenceMember", stringSequenceMember))
+        impl->setStringSequenceMember(stringSequenceMember);
+    RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedMember;
+    if (DictionaryHelper::get(dictionary, "testInterfaceGarbageCollectedMember", testInterfaceGarbageCollectedMember))
+        impl->setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
+    RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedOrNullMember;
+    if (DictionaryHelper::get(dictionary, "testInterfaceGarbageCollectedOrNullMember", testInterfaceGarbageCollectedOrNullMember))
+        impl->setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
     RefPtr<TestInterfaceImplementation> testInterfaceMember;
     if (DictionaryHelper::get(dictionary, "testInterfaceMember", testInterfaceMember))
         impl->setTestInterfaceMember(testInterfaceMember);
     RefPtr<TestInterfaceImplementation> testInterfaceOrNullMember;
     if (DictionaryHelper::get(dictionary, "testInterfaceOrNullMember", testInterfaceOrNullMember))
         impl->setTestInterfaceOrNullMember(testInterfaceOrNullMember);
+    RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedMember;
+    if (DictionaryHelper::get(dictionary, "testInterfaceWillBeGarbageCollectedMember", testInterfaceWillBeGarbageCollectedMember))
+        impl->setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
+    RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedOrNullMember;
+    if (DictionaryHelper::get(dictionary, "testInterfaceWillBeGarbageCollectedOrNullMember", testInterfaceWillBeGarbageCollectedOrNullMember))
+        impl->setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
     return impl;
 }
 
@@ -59,16 +79,28 @@ v8::Handle<v8::Value> toV8(TestDictionary* impl, v8::Handle<v8::Object> creation
         v8Object->Set(v8String(isolate, "longMember"), v8::Integer::New(isolate, impl->longMember()));
     else
         v8Object->Set(v8String(isolate, "longMember"), v8::Integer::New(isolate, 1));
+    if (impl->hasStringArrayMember())
+        v8Object->Set(v8String(isolate, "stringArrayMember"), v8Array(impl->stringArrayMember(), creationContext, isolate));
     if (impl->hasStringMember())
         v8Object->Set(v8String(isolate, "stringMember"), v8String(isolate, impl->stringMember()));
     if (impl->hasStringOrNullMember())
         v8Object->Set(v8String(isolate, "stringOrNullMember"), impl->stringOrNullMember().isNull() ? v8::Handle<v8::Value>(v8::Null(isolate)) : v8String(isolate, impl->stringOrNullMember()));
     else
         v8Object->Set(v8String(isolate, "stringOrNullMember"), v8String(isolate, String("default string value")));
+    if (impl->hasStringSequenceMember())
+        v8Object->Set(v8String(isolate, "stringSequenceMember"), v8Array(impl->stringSequenceMember(), creationContext, isolate));
+    if (impl->hasTestInterfaceGarbageCollectedMember())
+        v8Object->Set(v8String(isolate, "testInterfaceGarbageCollectedMember"), toV8(impl->testInterfaceGarbageCollectedMember(), creationContext, isolate));
+    if (impl->hasTestInterfaceGarbageCollectedOrNullMember())
+        v8Object->Set(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"), toV8(impl->testInterfaceGarbageCollectedOrNullMember(), creationContext, isolate));
     if (impl->hasTestInterfaceMember())
         v8Object->Set(v8String(isolate, "testInterfaceMember"), toV8(impl->testInterfaceMember(), creationContext, isolate));
     if (impl->hasTestInterfaceOrNullMember())
         v8Object->Set(v8String(isolate, "testInterfaceOrNullMember"), toV8(impl->testInterfaceOrNullMember(), creationContext, isolate));
+    if (impl->hasTestInterfaceWillBeGarbageCollectedMember())
+        v8Object->Set(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"), toV8(impl->testInterfaceWillBeGarbageCollectedMember(), creationContext, isolate));
+    if (impl->hasTestInterfaceWillBeGarbageCollectedOrNullMember())
+        v8Object->Set(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"), toV8(impl->testInterfaceWillBeGarbageCollectedOrNullMember(), creationContext, isolate));
     return v8Object;
 }