IDL compiler: Pickle interface information

Source/bindings/scripts/unstable/interface_dependency_resolver.py

 # 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.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 20 matching lines @@
 This library computes interface dependencies (partial interfaces and
 implements), reads the dependency files, and merges them to the IdlDefinitions
 for the main IDL file, producing an IdlDefinitions object representing the
 entire interface.
 
 It also checks whether a file should have bindings generated, or whether
 instead it is just a dependency.
 """
 
 import os.path
+import cPickle as pickle
 
 
 class InterfaceNotFoundError(Exception):
     """Raised if (partial) interface not found in target IDL file."""
     pass
 
 
 class InvalidPartialInterfaceError(Exception):
     """Raised if a file listed as a partial interface is not in fact so."""
     pass
 
 
 class InterfaceDependencyResolver:
-    def __init__(self, interface_dependencies_filename, additional_idl_filenames, reader):
+    def __init__(self, interfaces_filename, additional_idl_filenames, reader):
         """Inits dependency resolver.
 
         Args:
-            interface_dependencies_filename:
-                filename of dependencies file (produced by
-                compute_dependencies.py)
+            interfaces_filename:
+                filename of interfaces file (output by compute_dependencies.py)
             additional_idl_filenames:
                 list of additional files, not listed in
                 interface_dependencies_file, for which bindings should
                 nonetheless be generated
             reader:
                 IdlReader, used for reading dependency files
         """
-        self.interface_dependencies = read_interface_dependencies_file(interface_dependencies_filename)
+        with open(interfaces_filename, 'r') as interfaces_file:
+            self.interface_dependencies = pickle.load(interfaces_file)
         self.additional_interfaces = set()
         for filename in additional_idl_filenames:
             basename = os.path.basename(filename)
             interface_name, _ = os.path.splitext(basename)
             self.additional_interfaces.add(interface_name)
         self.reader = reader
 
     def resolve_dependencies(self, definitions, interface_name):
         """Resolves dependencies, merging them into IDL definitions of main file.
 
@@ skipping 45 matching lines @@
         # additional_interfaces is a list of interfaces that should not be
         # included in DerivedSources*.cpp, and hence are not listed in the
         # interface dependencies file, but for which we should generate .cpp
         # and .h files.
         if target_interface_name in self.additional_interfaces:
             return []
 
         return None
 
 
-def read_interface_dependencies_file(interface_dependencies_filename):
-    """Reads the interface dependencies file, returns a dict for resolving dependencies.
-
-    The format of the interface dependencies file is:
-
-    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.
-
-    The head entries (first IDL file on a line) are the files that should
-    have bindings generated.
-
-    An IDL file that is a dependency of another IDL file (e.g., P.idl in the
-    above example) does not have its own line in the dependency file:
-    dependencies do not have bindings generated, and do not have their
-    own dependencies.
-
-    Args:
-        interface_dependencies_filename: filename of file in above format
-    Returns:
-        dict of interface_name -> dependency_filenames
-    """
-    interface_dependencies = {}
-    with open(interface_dependencies_filename) as interface_dependencies_file:
-        for line in interface_dependencies_file:
-            idl_filename, _, dependency_filenames_string = line.partition(' ')
-            idl_basename = os.path.basename(idl_filename)
-            interface_name, _ = os.path.splitext(idl_basename)
-            dependency_filenames = dependency_filenames_string.split()
-            interface_dependencies[interface_name] = dependency_filenames
-    return interface_dependencies
-
-
 def merge_interface_dependencies(target_interface, dependency_idl_filenames, reader):
     """Merge dependencies ('partial interface' and 'implements') in dependency_idl_filenames into target_interface.
 
     No return: modifies target_document in place.
     """
     # Sort so order consistent, so can compare output from run to run.
     for dependency_idl_filename in sorted(dependency_idl_filenames):
         dependency_interface_name, _ = os.path.splitext(os.path.basename(dependency_idl_filename))
         definitions = reader.read_idl_file(dependency_idl_filename)
 
@@ skipping 19 matching lines @@
             # FIXME: remove check for LegacyImplementedInBaseClass when this
             # attribute is removed
             if 'LegacyImplementedInBaseClass' not in dependency_interface.extended_attributes:
                 element.extended_attributes['ImplementedBy'] = dependency_interface_name
             element.extended_attributes.update(dependency_interface.extended_attributes)
             target_list.append(element)
 
     merge_lists(dependency_interface.attributes, target_interface.attributes)
     merge_lists(dependency_interface.constants, target_interface.constants)
     merge_lists(dependency_interface.operations, target_interface.operations)