Support partial interface for test support idls

Source/bindings/scripts/compute_dependencies.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 32 matching lines @@
 class IdlInterfaceFileNotFoundError(Exception):
     """Raised if the IDL file implementing an interface cannot be found."""
     pass
 
 
 def parse_options():
     parser = optparse.OptionParser()
     parser.add_option('--event-names-file', help='output file')
     parser.add_option('--idl-files-list', help='file listing all IDLs')
     parser.add_option('--interface-dependencies-file', help='output file')
+    parser.add_option('--test-support-idl-files-list', help='file listing all test support IDLs')
+    parser.add_option('--test-support-interface-dependencies-file', help='output file')
     parser.add_option('--window-constructors-file', help='output file')
     parser.add_option('--workerglobalscope-constructors-file', help='output file')
     parser.add_option('--sharedworkerglobalscope-constructors-file', help='output file')
     parser.add_option('--dedicatedworkerglobalscope-constructors-file', help='output 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.event_names_file is None:
         parser.error('Must specify an output file using --event-names-file.')
     if options.interface_dependencies_file is None:
         parser.error('Must specify an output file using --interface-dependencies-file.')
+    if options.test_support_interface_dependencies_file is None:
+        parser.error('Must specify an output file using --test-support-interface-dependencies-file')
     if options.window_constructors_file is None:
         parser.error('Must specify an output file using --window-constructors-file.')
     if options.workerglobalscope_constructors_file is None:
         parser.error('Must specify an output file using --workerglobalscope-constructors-file.')
     if options.workerglobalscope_constructors_file is None:
         parser.error('Must specify an output file using --sharedworkerglobalscope-constructors-file.')
     if options.workerglobalscope_constructors_file is None:
         parser.error('Must specify an output file using --dedicatedworkerglobalscope-constructors-file.')
     if options.idl_files_list is None:
         parser.error('Must specify the file listing all IDLs using --idl-files-list.')
+    if options.test_support_idl_files_list is None:
+        parser.error('Must specify the file listing all IDLs using --test-support-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)
     if args:
         parser.error('No arguments taken, but "%s" given.' % ' '.join(args))
     return options
 
 
 def get_file_contents(idl_filename):
     with open(idl_filename) as idl_file:
@@ skipping 110 matching lines @@
 
 
 def generate_global_constructors_partial_interface(interface_name, destination_filename, constructor_attributes_list, only_if_changed):
     lines = (['partial interface %s {\n' % interface_name] +
              ['    %s;\n' % constructor_attribute
               for constructor_attribute in sorted(constructor_attributes_list)] +
              ['};\n'])
     write_file(lines, destination_filename, only_if_changed)
 
 
-def parse_idl_files(idl_files, global_constructors_filenames):
-    """Return dependencies between IDL files, constructors on global objects, and events.
-
-    Returns:
-        interfaces:
-            set of all interfaces
-        dependencies:
-            dict of main IDL filename (for a given interface) -> list of partial IDL filenames (for that interface)
-            The keys (main IDL files) are the files for which bindings are
-            generated. This does not include IDL files for interfaces
-            implemented by another interface.
-        global_constructors:
-            dict of global objects -> list of constructors on that object
-        event_names:
-            dict of interfaces that inherit from Event -> list of extended attributes for the interface
-    """
-    interfaces = set()
-    dependencies = {}
-    partial_interface_files = {}
-    implements_interfaces = {}
-    implemented_somewhere = set()
-
-    global_constructors = {}
-    for global_object in global_constructors_filenames.keys():
-        global_constructors[global_object] = []
-
-    # Parents and extended attributes (of interfaces with parents) are
-    # used in generating event names
-    parent_interface = {}
-    interface_extended_attribute = {}
-
-    interface_name_to_idl_file = {}
+def generate_interface_name_to_idl_file(idl_files,
+                                        interface_name_to_idl_file,
+                                        partial_interface_files,
+                                        interfaces,
+                                        dependencies,
+                                        implements_interfaces,
+                                        implemented_somewhere,
+                                        global_constructors,
+                                        parent_interface,
+                                        interface_extended_attribute):
     for idl_file_name in idl_files:
         full_path = os.path.realpath(idl_file_name)
         interface_name, _ = os.path.splitext(os.path.basename(idl_file_name))
         interface_name_to_idl_file[interface_name] = full_path
         partial_interface_files[interface_name] = []
 
     for idl_file_name in idl_files:
         interface_name, _ = os.path.splitext(os.path.basename(idl_file_name))
         full_path = interface_name_to_idl_file[interface_name]
         idl_file_contents = get_file_contents(full_path)
 
         # Handle partial interfaces
         partial_interface_name = get_partial_interface_name_from_idl(idl_file_contents)
         if partial_interface_name:
             partial_interface_files[partial_interface_name].append(full_path)
             continue
 
         interfaces.add(interface_name)
         # Non-partial interfaces default to having bindings generated
         dependencies[full_path] = []
         extended_attributes = get_interface_extended_attributes_from_idl(idl_file_contents)
 
         # Parse 'identifier-A implements identifier-B;' statements
         implemented_interfaces = get_implemented_interfaces_from_idl(idl_file_contents, interface_name)
         implements_interfaces[interface_name] = implemented_interfaces
         implemented_somewhere |= set(implemented_interfaces)
 
         # Record global constructors
-        if not is_callback_interface_from_idl(idl_file_contents) and 'NoInterfaceObject' not in extended_attributes:
-            global_contexts = extended_attributes.get('GlobalContext', 'Window').split('&')
-            new_constructor_list = generate_constructor_attribute_list(interface_name, extended_attributes)
-            for global_object in global_contexts:
-                global_constructors[global_object].extend(new_constructor_list)
+        if global_constructors:
+            if not is_callback_interface_from_idl(idl_file_contents) and 'NoInterfaceObject' not in extended_attributes:
+                global_contexts = extended_attributes.get('GlobalContext', 'Window').split('&')
+                new_constructor_list = generate_constructor_attribute_list(interface_name, extended_attributes)
+                for global_object in global_contexts:
+                    global_constructors[global_object].extend(new_constructor_list)
 
         # Record parents and extended attributes for generating event names
         if interface_name == 'Event':
             interface_extended_attribute[interface_name] = extended_attributes
         parent = get_parent_interface(idl_file_contents)
         if parent:
             parent_interface[interface_name] = parent
             interface_extended_attribute[interface_name] = extended_attributes
 
+
+def parse_idl_files(idl_files, test_support_idl_files, global_constructors_filenames):
+    """Return dependencies between IDL files, constructors on global objects, and events.
+
+    Returns:
+        interfaces:
+            set of all interfaces
+        dependencies:
+            dict of main IDL filename (for a given interface) -> list of partial IDL filenames (for that interface)
+            The keys (main IDL files) are the files for which bindings are
+            generated. This does not include IDL files for interfaces
+            implemented by another interface.
+        test_support_dependencies:
+            dict of test support IDL filename (for a given interface) -> list of partial IDL filenames (for that interface)
+            The keys (main IDL files) are the files for which bindings are
+            generated. This does not include IDL files for interfaces
+            implemented by another interface.
+        global_constructors:
+            dict of global objects -> list of constructors on that object
+        event_names:
+            dict of interfaces that inherit from Event -> list of extended attributes for the interface
+    """
+    interfaces = set()
+    dependencies = {}
+    partial_interface_files = {}
+    implements_interfaces = {}
+    implemented_somewhere = set()
+
+    test_support_interfaces = set()
+    test_support_dependencies = {}
+    test_support_partial_interface_files = {}
+    test_support_implements_interfaces = {}
+    test_support_implemented_somewhere = set()
+
+    global_constructors = {}
+    for global_object in global_constructors_filenames.keys():
+        global_constructors[global_object] = []
+
+    # Parents and extended attributes (of interfaces with parents) are
+    # used in generating event names
+    parent_interface = {}
+    interface_extended_attribute = {}
+
+    interface_name_to_idl_file = {}
+    generate_interface_name_to_idl_file(idl_files,
+                                        interface_name_to_idl_file,
+                                        partial_interface_files,
+                                        interfaces,
+                                        dependencies,
+                                        implements_interfaces,
+                                        implemented_somewhere,
+                                        global_constructors,
+                                        parent_interface,
+                                        interface_extended_attribute)
+
+    test_support_interface_name_to_idl_file = {}
+    generate_interface_name_to_idl_file(test_support_idl_files,
+                                        test_support_interface_name_to_idl_file,
+                                        test_support_partial_interface_files,
+                                        test_support_interfaces,
+                                        test_support_dependencies,
+                                        test_support_implements_interfaces,
+                                        test_support_implemented_somewhere,
+                                        None,
+                                        parent_interface,
+                                        interface_extended_attribute)
+
     # Add constructors on global objects to partial interfaces
+
     for global_object, filename in global_constructors_filenames.iteritems():
         if global_object in interfaces:
             partial_interface_files[global_object].append(filename)
+        if global_object in test_support_interfaces:

[do-not-use, 2013/09/09 07:27:10]

elif?

[Nils Barth (inactive), 2013/09/10 09:52:10]

I'm actually confused about whether we want to be generated the global
constructor IDLs for test support interfaces...
From the POV of building Blink, we don't want any test interface IDLs in there,
right?
Do we need the global constructor IDLs for testing?
If not, we could omit it here.

+            test_support_partial_interface_files[global_object].append(filename)
 
     # Interfaces that are implemented by another interface do not have
     # their own bindings generated, as this would be redundant with the
     # actual implementation.
     for implemented_interface in implemented_somewhere:
         full_path = interface_name_to_idl_file[implemented_interface]
         del dependencies[full_path]
 
+    for test_support_implemented_interface in test_support_implemented_somewhere:
+        full_path = test_support_interface_name_to_idl_file[test_support_implemented_interface]
+        del test_support_dependencies[full_path]
+
     # An IDL file's dependencies are partial interface files that extend it,
     # and files for other interfaces that this interfaces implements.
     for idl_file_path in dependencies.iterkeys():
         interface_name, _ = os.path.splitext(os.path.basename(idl_file_path))
         implemented_interfaces = implements_interfaces[interface_name]
         try:
             interface_paths = map(lambda x: interface_name_to_idl_file[x], implemented_interfaces)
         except KeyError as key_name:
             raise IdlInterfaceFileNotFoundError('Could not find the IDL file where the following implemented interface is defined: %s' % key_name)
         dependencies[idl_file_path] = sorted(partial_interface_files[interface_name] + interface_paths)
 
+    for test_support_idl_file_path in test_support_dependencies.iterkeys():
+        interface_name, _ = os.path.splitext(os.path.basename(test_support_idl_file_path))
+        test_support_implemented_interfaces = test_support_implements_interfaces[interface_name]
+        try:
+            interface_paths = map(lambda x: test_support_interface_name_to_idl_file[x], test_support_implemented_interfaces)
+        except KeyError, key_name:
+            raise IdlInterfaceFileNotFoundError('Could not find the IDL file where the following implemented interface is defined: %s' % key_name)
+        test_support_dependencies[test_support_idl_file_path] = sorted(test_support_partial_interface_files[interface_name] + interface_paths)
+
     # Generate event names for all interfaces that inherit from Event,
     # including Event itself.
     event_names = {}
     if 'Event' in interfaces:
         event_names[interface_name_to_idl_file['Event']] = interface_extended_attribute['Event']
     for interface, parent in parent_interface.iteritems():
         while parent in parent_interface:
             parent = parent_interface[parent]
         if parent == 'Event':
             event_names[interface_name_to_idl_file[interface]] = interface_extended_attribute[interface]
 
-    return interfaces, dependencies, global_constructors, event_names
+    return interfaces, dependencies, test_support_dependencies, global_constructors, event_names
 
 
 def write_dependency_file(filename, dependencies, only_if_changed):
     """Write the interface dependencies file.
 
     The format is as follows:
 
     Document.idl P.idl
     Event.idl
     Window.idl Q.idl R.idl S.idl
     ...
 
     The above indicates that:
     Document.idl depends on P.idl,
     Event.idl depends on no other IDL files, and
     Window.idl depends on Q.idl, R.idl, and S.idl.
 
     An IDL that is a dependency of another IDL (e.g. P.idl) does not have its
     own line in the dependency file.
     """
     lines = ['%s %s\n' % (idl_file, ' '.join(sorted(dependency_files)))
              for idl_file, dependency_files in sorted(dependencies.iteritems())]
     write_file(lines, filename, only_if_changed)
 
 
+
 def main():
     options = parse_options()
     idl_files = []
     with open(options.idl_files_list) as idl_files_list_file:
         for line in idl_files_list_file:
             idl_files.append(string.rstrip(line, '\n'))
+    test_support_idl_files = []
+    with open(options.test_support_idl_files_list) as test_support_idl_files_list_file:
+        for line in test_support_idl_files_list_file:
+            test_support_idl_files.append(string.rstrip(line, '\n'))
     only_if_changed = options.write_file_only_if_changed
     global_constructors_filenames = {
         'Window': options.window_constructors_file,
         'WorkerGlobalScope': options.workerglobalscope_constructors_file,
         'SharedWorkerGlobalScope': options.sharedworkerglobalscope_constructors_file,
         'DedicatedWorkerGlobalScope': options.dedicatedworkerglobalscope_constructors_file,
         }
 
-    interfaces, dependencies, global_constructors, event_names = parse_idl_files(idl_files, global_constructors_filenames)
+    interfaces, dependencies, test_support_dependencies, global_constructors, event_names = parse_idl_files(idl_files, test_support_idl_files, global_constructors_filenames)
 
     write_dependency_file(options.interface_dependencies_file, dependencies, only_if_changed)
+    write_dependency_file(options.test_support_interface_dependencies_file, test_support_dependencies, only_if_changed)
     for interface_name, filename in global_constructors_filenames.iteritems():
         if interface_name in interfaces:
             generate_global_constructors_partial_interface(interface_name, filename, global_constructors[interface_name], only_if_changed)
     generate_event_names_file(options.event_names_file, event_names, only_if_changed)
 
 
 if __name__ == '__main__':
     main()