Add code generation for ConditionalFeatures bindings code

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

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # pylint: disable=import-error,print-statement,relative-import
 
 """Plumbing for a Jinja-based code generator, including CodeGeneratorBase, a base class for all generators."""
 
 import os
 import posixpath
@@ skipping 103 matching lines @@
 
 
 class CodeGeneratorBase(object):
     """Base class for jinja-powered jinja template generation.
     """
     def __init__(self, generator_name, info_provider, cache_dir, output_dir):
         self.generator_name = generator_name
         self.info_provider = info_provider
         self.jinja_env = initialize_jinja_env(cache_dir)
         self.output_dir = output_dir
-        self.set_global_type_info()
-
-    def should_generate_code(self, definitions):
-        return definitions.interfaces or definitions.dictionaries
-
-    def set_global_type_info(self):
-        interfaces_info = self.info_provider.interfaces_info
-        set_ancestors(interfaces_info['ancestors'])
-        IdlType.set_callback_interfaces(interfaces_info['callback_interfaces'])
-        IdlType.set_dictionaries(interfaces_info['dictionaries'])
-        IdlType.set_enums(self.info_provider.enumerations)
-        IdlType.set_callback_functions(self.info_provider.callback_functions)
-        IdlType.set_implemented_as_interfaces(interfaces_info['implemented_as_interfaces'])
-        IdlType.set_garbage_collected_types(interfaces_info['garbage_collected_interfaces'])
-        set_component_dirs(interfaces_info['component_dirs'])
 
     def render_template(self, include_paths, header_template, cpp_template,
                         template_context, component=None):
         template_context['code_generator'] = self.generator_name
 
         # Add includes for any dependencies
         template_context['header_includes'] = normalize_and_sort_includes(
             template_context['header_includes'])
 
         for include_path in include_paths:
             if component:
                 dependency = idl_filename_to_component(include_path)
                 assert is_valid_component_dependency(component, dependency)
             includes.add(include_path)
 
         template_context['cpp_includes'] = normalize_and_sort_includes(includes)
 
         header_text = render_template(header_template, template_context)
         cpp_text = render_template(cpp_template, template_context)
         return header_text, cpp_text
 
+
+class IDLCodeGeneratorBase(CodeGeneratorBase):

[Yuki, 2017/07/14 03:30:07]

Is this just a refactoring?
Does this make sense?

Is |info_provider| independent from IDLs?

|render_template| seems using only self.generator_name as a member. 
CodeGeneratorBase won't use any of info_provider, jinja_env, nor output_dir. 
Does it make sense to have CodeGeneratorBase class at all?

[iclelland, 2017/07/14 18:25:04]

I wanted to reuse some of the functionality from CodeGeneratorBase, although it
was too specifically targetted towards just generating code for a single
interface. Specifically, I wanted:
  -- Access to info_provider for a global view of the interfaces
  -- The jinja templating environment
and I didn't want the parts that assumed a single IDL type. So I split it into
two, and based the conditional features generator on the root base class.
That's a legitimate question :) It did when I started, but I had a slightly
different approach at the time (I was annotating the
interfaces_info_overall.pickle file with the origin_trials information). I will
revisit that and see what it looks like if I avoid using the CodeGenerator
classes at all.
I'm not sure what you mean by that. Are you asking whether the same information
appears in both? I suppose so, since |info_provider| provides the information
that ultimately comes from the IDL files. It's already been processed though --
partial interfaces have had their dependencies resolved, etc.

Again, maybe that's a dependency that I don't need anymore, so I'll see if I can
live without it.

+    """Base class for code generators which create bindings implementations from
+    IDL files.
+    """
+    def __init__(self, generator_name, info_provider, cache_dir, output_dir):
+        super(IDLCodeGeneratorBase, self).__init__(generator_name, info_provider, cache_dir, output_dir)
+        self.set_global_type_info()
+
+    def should_generate_code(self, definitions):
+        return definitions.interfaces or definitions.dictionaries
+
+    def set_global_type_info(self):
+        interfaces_info = self.info_provider.interfaces_info
+        set_ancestors(interfaces_info['ancestors'])
+        IdlType.set_callback_interfaces(interfaces_info['callback_interfaces'])
+        IdlType.set_dictionaries(interfaces_info['dictionaries'])
+        IdlType.set_enums(self.info_provider.enumerations)
+        IdlType.set_callback_functions(self.info_provider.callback_functions)
+        IdlType.set_implemented_as_interfaces(interfaces_info['implemented_as_interfaces'])
+        IdlType.set_garbage_collected_types(interfaces_info['garbage_collected_interfaces'])
+        set_component_dirs(interfaces_info['component_dirs'])
+
     def generate_code(self, definitions, definition_name):
         """Invokes code generation. The [definitions] argument is a list of definitions,
         and the [definition_name] is the name of the definition
         """
         # This should be implemented in subclasses.
         raise NotImplementedError()
 
 
 def main(argv):
     # If file itself executed, cache templates
@@ skipping 14 matching lines @@
 
     # Create a dummy file as output for the build system,
     # since filenames of individual cache files are unpredictable and opaque
     # (they are hashes of the template path, which varies based on environment)
     with open(dummy_filename, 'w') as dummy_file:
         pass  # |open| creates or touches the file
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))