Generated bindings for IDL callback functions

third_party/WebKit/Source/bindings/scripts/code_generator_v8.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 58 matching lines @@
 # jinja2 is in chromium's third_party directory.
 # Insert at 1 so at front to override system libraries, and
 # after path[0] == invoking script dir
 sys.path.insert(1, third_party_dir)
 import jinja2
 
 from idl_definitions import Visitor
 import idl_types
 from idl_types import IdlType
 from v8_attributes import attribute_filters
+import v8_callback_function
 import v8_callback_interface
 import v8_dictionary
 from v8_globals import includes, interfaces
 import v8_interface
 from v8_methods import method_filters
 import v8_types
 import v8_union
 from v8_utilities import capitalize, cpp_name, for_origin_trial_feature, unique_by
 from utilities import (
     idl_filename_to_component, is_valid_component_dependency, is_testing_target,
@@ skipping 28 matching lines @@
 
     header_text = header_template.render(template_context)
     cpp_text = cpp_template.render(template_context)
     return header_text, cpp_text
 
 
 def set_global_type_info(info_provider):
     interfaces_info = info_provider.interfaces_info
     idl_types.set_ancestors(interfaces_info['ancestors'])
     IdlType.set_callback_interfaces(interfaces_info['callback_interfaces'])
+    IdlType.set_experimental_callback_functions(
+        info_provider.callback_functions)
     IdlType.set_dictionaries(interfaces_info['dictionaries'])
     IdlType.set_enums(info_provider.enumerations)
     IdlType.set_implemented_as_interfaces(interfaces_info['implemented_as_interfaces'])
     IdlType.set_garbage_collected_types(interfaces_info['garbage_collected_interfaces'])
     v8_types.set_component_dirs(interfaces_info['component_dirs'])
 
 
 def should_generate_code(definitions):
     return definitions.interfaces or definitions.dictionaries
 
@@ skipping 272 matching lines @@
     def generate_code(self):
         union_types = self._get_union_types_for_containers()
         if not union_types:
             return ()
         outputs = set()
         for union_type in union_types:
             outputs.update(self._generate_container_code(union_type))
         return outputs
 
 
+class CodeGeneratorCallbackFunction(object):

[bashi, 2016/09/13 00:35:05]

This class is similar to CodeGeneratorUnionType. It would be better to have a
base class for both to reduce duplicated code.

That said you don't need to address this comment in this CL. You can do that in
a follow-up CL.

[lkawai, 2016/09/16 05:05:49]

Acknowledged.

+    def __init__(self, info_provider, cache_dir, output_dir, target_component):
+        self.info_provider = info_provider
+        self.jinja_env = initialize_jinja_env(cache_dir)
+        self.output_dir = output_dir
+        self.target_component = target_component
+        set_global_type_info(info_provider)
+
+    def generate_code_internal(self, callback_function):
+        header_template = self.jinja_env.get_template('callback_function.h')
+        cpp_template = self.jinja_env.get_template('callback_function.cpp')
+        template_context = v8_callback_function.callback_function_context(
+            callback_function)
+        template_context['header_includes'].add(
+            self.info_provider.include_path_for_export)
+        template_context['header_includes'] = normalize_and_sort_includes(
+            template_context['header_includes'])
+        template_context['code_generator'] = module_pyname
+        template_context['exported'] = self.info_provider.specifier_for_export
+        header_text = header_template.render(template_context)
+        cpp_text = cpp_template.render(template_context)
+        header_path = posixpath.join(self.output_dir, 'V8%s.h' % callback_function.name)
+        cpp_path = posixpath.join(self.output_dir, 'V8%s.cpp' % callback_function.name)
+        return (
+            (header_path, header_text),
+            (cpp_path, cpp_text),
+        )
+
+    def generate_code(self):
+        callback_functions = self.info_provider.callback_functions
+        if not callback_functions:
+            return ()
+        outputs = set()
+        for callback_function_dict in callback_functions.itervalues():
+            callback_function = callback_function_dict['callback_function']
+            outputs.update(self.generate_code_internal(callback_function))
+        return outputs
+
+
 def initialize_jinja_env(cache_dir):
     jinja_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(templates_dir),
         # Bytecode cache is not concurrency-safe unless pre-cached:
         # if pre-cached this is read-only, but writing creates a race condition.
         bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir),
         keep_trailing_newline=True,  # newline-terminate generated files
         lstrip_blocks=True,  # so can indent control flow tags
         trim_blocks=True)
     jinja_env.filters.update({
@@ skipping 61 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))