Bindings tests should run the same code as prod code.

third_party/WebKit/Tools/Scripts/webkitpy/bindings/bindings_tests.py

 # Copyright (C) 2011 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:
 # 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
 # 2. Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
@@ skipping 27 matching lines @@
 source_path = os.path.normpath(os.path.join(module_path, os.pardir, os.pardir,
                                             os.pardir, os.pardir, 'Source'))
 bindings_script_path = os.path.join(source_path, 'bindings', 'scripts')
 sys.path.append(bindings_script_path)  # for Source/bindings imports
 
 from code_generator_v8 import CodeGeneratorDictionaryImpl
 from code_generator_v8 import CodeGeneratorV8
 from code_generator_v8 import CodeGeneratorUnionType
 from code_generator_v8 import CodeGeneratorCallbackFunction
 from compute_interfaces_info_individual import InterfaceInfoCollector
-from compute_interfaces_info_overall import compute_interfaces_info_overall, interfaces_info
-from idl_compiler import IdlCompiler
+from compute_interfaces_info_overall import (compute_interfaces_info_overall,
+                                             interfaces_info)
+from idl_compiler import (generate_bindings,
+                          generate_union_type_containers,
+                          generate_dictionary_impl,
+                          generate_callback_function_impl)
 from utilities import ComponentInfoProviderCore
 from utilities import ComponentInfoProviderModules
 from utilities import write_file
 
 
 PASS_MESSAGE = 'All tests PASS!'
 FAIL_MESSAGE = """Some tests FAIL!
 To update the reference files, execute:
     run-bindings-tests --reset-results
 
@@ skipping 122 matching lines @@
     # component info.
     test_component_info['core']['typedefs'].update(
         non_test_component_info['typedefs'])
     component_info_providers['core'] = ComponentInfoProviderCore(
         interfaces_info, test_component_info['core'])
     component_info_providers['modules'] = ComponentInfoProviderModules(
         interfaces_info, test_component_info['core'],
         test_component_info['modules'])
 
 
+class IdlCompilerOptions(object):
+    def __init__(self, output_directory, cache_directory, impl_output_directory,
+                 target_component):
+        self.output_directory = output_directory
+        self.cache_directory = cache_directory
+        self.impl_output_directory = impl_output_directory
+        self.target_component = target_component
+
 def bindings_tests(output_directory, verbose):
     executive = Executive()
 
     def list_files(directory):
         files = []
         for component in os.listdir(directory):
             if component not in COMPONENT_DIRECTORY:
                 continue
             directory_with_component = os.path.join(directory, component)
             for filename in os.listdir(directory_with_component):
@@ skipping 62 matching lines @@
             relpath = os.path.relpath(path, reference_directory)
             if relpath not in generated_files:
                 excess_files.append(relpath)
         if excess_files:
             print ('Excess reference files! '
                    '(probably cruft from renaming or deleting):\n' +
                    '\n'.join(excess_files))
             return False
         return True
 
-    def generate_union_type_containers(output_directory, component):
-        generator = CodeGeneratorUnionType(
-            component_info_providers[component], cache_dir=None,
-            output_dir=output_directory, target_component=component)
-        outputs = generator.generate_code()
-        for output_path, output_code in outputs:
-            write_file(output_code, output_path)
-
-    def generate_callback_function_impl(output_directory, component):
-        generator = CodeGeneratorCallbackFunction(
-            component_info_providers[component], cache_dir=None,
-            output_dir=output_directory, target_component=component)
-        outputs = generator.generate_code()
-        for output_path, output_code in outputs:
-            write_file(output_code, output_path)
-
     try:
         generate_interface_dependencies()
         for component in COMPONENT_DIRECTORY:
             output_dir = os.path.join(output_directory, component)
             if not os.path.exists(output_dir):
                 os.makedirs(output_dir)
 
-            generate_union_type_containers(output_dir, component)
-            generate_callback_function_impl(output_dir, component)
+            options = IdlCompilerOptions(
+                output_directory=output_dir,
+                impl_output_directory=output_dir,
+                cache_directory=None,
+                target_component=component)
 
-            idl_compiler = IdlCompiler(
-                output_directory=output_dir,
-                code_generator_class=CodeGeneratorV8,
-                info_provider=component_info_providers[component],
-                target_component=component)
             if component == 'core':
                 partial_interface_output_dir = os.path.join(output_directory,
                                                             'modules')
                 if not os.path.exists(partial_interface_output_dir):
                     os.makedirs(partial_interface_output_dir)
-                idl_partial_interface_compiler = IdlCompiler(
+                partial_interface_options = IdlCompilerOptions(
                     output_directory=partial_interface_output_dir,
-                    code_generator_class=CodeGeneratorV8,
-                    info_provider=component_info_providers['modules'],
+                    impl_output_directory=None,
+                    cache_directory=None,
                     target_component='modules')
-            else:
-                idl_partial_interface_compiler = None
-
-            dictionary_impl_compiler = IdlCompiler(
-                output_directory=output_dir,
-                info_provider=component_info_providers[component],
-                code_generator_class=CodeGeneratorDictionaryImpl,
-                target_component=component)
 
             idl_filenames = []
+            dictionary_impl_filenames = []
+            partial_interface_filenames = []
             input_directory = os.path.join(test_input_directory, component)
             for filename in os.listdir(input_directory):
                 if (filename.endswith('.idl') and
                         # Dependencies aren't built
                         # (they are used by the dependent)
                         filename not in DEPENDENCY_IDL_FILES):
-                    idl_filenames.append(
-                        os.path.realpath(
-                            os.path.join(input_directory, filename)))
-            for idl_path in idl_filenames:
-                idl_basename = os.path.basename(idl_path)
-                idl_compiler.compile_file(idl_path)
-                definition_name, _ = os.path.splitext(idl_basename)
-                if definition_name in interfaces_info:
-                    interface_info = interfaces_info[definition_name]
-                    if interface_info['is_dictionary']:
-                        dictionary_impl_compiler.compile_file(idl_path)
-                    if component == 'core' and interface_info['dependencies_other_component_full_paths']:
-                        idl_partial_interface_compiler.compile_file(idl_path)
-                if verbose:
-                    print 'Compiled: %s' % idl_path
+                    idl_path = os.path.realpath(
+                        os.path.join(input_directory, filename))
+                    idl_filenames.append(idl_path)
+                    idl_basename = os.path.basename(idl_path)
+                    definition_name, _ = os.path.splitext(idl_basename)
+                    if definition_name in interfaces_info:
+                        interface_info = interfaces_info[definition_name]
+                        if interface_info['is_dictionary']:
+                            dictionary_impl_filenames.append(idl_path)
+                        if component == 'core' and interface_info[
+                                'dependencies_other_component_full_paths']:
+                            partial_interface_filenames.append(idl_path)
+
+            generate_union_type_containers(CodeGeneratorUnionType,
+                                           component_info_providers[component],
+                                           options)
+            generate_callback_function_impl(CodeGeneratorCallbackFunction,
+                                            component_info_providers[component],
+                                            options)
+            generate_bindings(
+                CodeGeneratorV8,
+                component_info_providers[component],
+                options,
+                idl_filenames)
+            generate_bindings(
+                CodeGeneratorV8,
+                component_info_providers['modules'],
+                partial_interface_options,
+                partial_interface_filenames)
+            generate_dictionary_impl(
+                CodeGeneratorDictionaryImpl,
+                component_info_providers[component],
+                options,
+                dictionary_impl_filenames)
+
     finally:
         delete_cache_files()
 
     # Detect all changes
     output_files = list_files(output_directory)
     passed = identical_output_files(output_files)
     passed &= no_excess_files(output_files)
 
     if passed:
         if verbose:
             print
             print PASS_MESSAGE
         return 0
     print
     print FAIL_MESSAGE
     return 1
 
 
 def run_bindings_tests(reset_results, verbose):
     # Generate output into the reference directory if resetting results, or
     # a temp directory if not.
     if reset_results:
         print 'Resetting results'
         return bindings_tests(reference_directory, verbose)
     with TemporaryDirectory() as temp_dir:
         return bindings_tests(temp_dir, verbose)