IDL: Generate union type containers

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 46 matching lines @@
 class IdlBadFilenameError(Exception):
     """Raised if an IDL filename disagrees with the interface name in the file."""
     pass
 
 
 def parse_options():
     usage = 'Usage: %prog [options] [generated1.idl]...'
     parser = optparse.OptionParser(usage=usage)
     parser.add_option('--cache-directory', help='cache directory')
     parser.add_option('--idl-files-list', help='file listing IDL files')
-    parser.add_option('--interfaces-info-file', help='output pickle file')
+    parser.add_option('--interfaces-info-file', help='interface info pickle file')
+    parser.add_option('--component-info-file', help='component wide info pickle file')
     parser.add_option('--write-file-only-if-changed', type='int', help='if true, do not write an output file if it would be identical to the existing one, which avoids unnecessary rebuilds in ninja')
 
     options, args = parser.parse_args()
     if options.interfaces_info_file is None:
         parser.error('Must specify an output file using --interfaces-info-file.')
     if options.idl_files_list is None:
         parser.error('Must specify a file listing IDL files using --idl-files-list.')
     if options.write_file_only_if_changed is None:
         parser.error('Must specify whether file is only written if changed using --write-file-only-if-changed.')
     options.write_file_only_if_changed = bool(options.write_file_only_if_changed)
@@ skipping 112 matching lines @@
         elif definitions.dictionaries:
             definition = next(definitions.dictionaries.itervalues())
             interface_info = {
                 'is_callback_interface': False,
                 'is_dictionary': True,
                 'referenced_interfaces': None,
             }
         else:
             raise Exception('IDL file must contain one interface or dictionary')
 
-        self.union_types.update(
-            collect_union_types_from_definitions(definitions))
+        this_union_types = collect_union_types_from_definitions(definitions)
+        self.union_types.update(this_union_types)
 
         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.
             self.add_paths_to_partials_dict(definition.name, full_path, 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),
             '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),
         })
         self.interfaces_info[definition.name] = interface_info
 
     def get_info_as_dict(self):
         """Returns info packaged as a dict."""
         return {
             'interfaces_info': self.interfaces_info,
             # Can't pickle defaultdict, convert to dict
+            # FIXME: this should be included in get_component_info.
             'partial_interface_files': dict(self.partial_interface_files),
+        }
+
+    def get_component_info_as_dict(self):
+        """Returns component wide information as a dict."""
+        return {
             'union_types': self.union_types,
         }
 
 
 ################################################################################
 
 def main():
     options, args = parse_options()
 
     # Static IDL files are passed in a file (generated at GYP time), due to OS
     # command line length limits
     idl_files = read_file_to_list(options.idl_files_list)
     # Generated IDL files are passed at the command line, since these are in the
     # build directory, which is determined at build time, not GYP time, so these
     # cannot be included in the file listing static files
     idl_files.extend(args)
 
     # Compute information for individual files
     # Information is stored in global variables interfaces_info and
     # partial_interface_files.
     info_collector = InterfaceInfoCollector(options.cache_directory)
     for idl_filename in idl_files:
         info_collector.collect_info(idl_filename)
 
     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())