Generate separate files for union type containers

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

 #!/usr/bin/python
 #
 # 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.
@@ skipping 248 matching lines @@
         extended_attributes = definition.extended_attributes
         implemented_as = extended_attributes.get('ImplementedAs')
         full_path = os.path.realpath(idl_filename)
         this_include_path = None if 'NoImplHeader' in extended_attributes else include_path(idl_filename, implemented_as)
         if definition.is_partial:
             # We don't create interface_info for partial interfaces, but
             # adds paths to another dict.
             partial_include_paths = []
             if this_include_path:
                 partial_include_paths.append(this_include_path)
-            if this_union_types:
+            for union_type in this_union_types:
+                if union_type.is_nullable:
+                    union_type = union_type.inner_type
                 partial_include_paths.append(
-                    'bindings/%s/v8/UnionTypes%s.h' % (component, component.capitalize()))
+                    'bindings/%s/v8/%s.h' % (component, union_type.name))
             self.add_paths_to_partials_dict(definition.name, full_path, partial_include_paths)
             # Collects C++ header paths which should be included from generated
             # .cpp files.  The resulting structure is as follows.
             #   interfaces_info[interface_name] = {
             #       'cpp_includes': {
             #           'core': set(['core/foo/Foo.h', ...]),
             #           'modules': set(['modules/bar/Bar.h', ...]),
             #       },
             #       ...
             #   }
             if this_include_path:
                 merge_dict_recursively(
                     self.interfaces_info[definition.name],
                     {'cpp_includes': {component: set([this_include_path])}})
             return
 
         # 'implements' statements can be included in either the file for the
         # implement*ing* interface (lhs of 'implements') or implement*ed* interface
         # (rhs of 'implements'). Store both for now, then merge to implement*ing*
         # interface later.
         left_interfaces, right_interfaces = get_implements_from_definitions(
             definitions, definition.name)
 
         interface_info.update({
             'extended_attributes': extended_attributes,
             'full_path': full_path,
-            'has_union_types': bool(this_union_types),
+            'union_types': this_union_types,
             'implemented_as': implemented_as,
             'implemented_by_interfaces': left_interfaces,
             'implements_interfaces': right_interfaces,
             'include_path': this_include_path,
             # FIXME: temporary private field, while removing old treatement of
             # 'implements': http://crbug.com/360435
             'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes,
             'parent': definition.parent,
             'relative_dir': relative_dir_posix(idl_filename, source_path),
         })
@@ skipping 40 matching lines @@
 
     write_pickle_file(options.interfaces_info_file,
                       info_collector.get_info_as_dict(),
                       options.write_file_only_if_changed)
     write_pickle_file(options.component_info_file,
                       info_collector.get_component_info_as_dict(),
                       options.write_file_only_if_changed)
 
 if __name__ == '__main__':
     sys.exit(main())