[Web Agents API]: Start fleshing out generated code.

third_party/WebKit/Source/bindings/scripts/code_generator_web_module.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
 
 """Generates Blink Web Module bindings.
 
 The Blink Web Module bindings provide a stable, IDL-generated interface for the
 Web Modules.
@@ skipping 11 matching lines @@
 import os
 import posixpath
 
 from code_generator import CodeGeneratorBase, render_template
 # TODO(dglazkov): Move TypedefResolver to code_generator.py
 from code_generator_v8 import TypedefResolver
 from name_style_converter import NameStyleConverter
 
 MODULE_PYNAME = os.path.splitext(os.path.basename(__file__))[0] + '.py'
 
+OILPAN_INCLUDE_PATH = 'platform/heap/Handle.h'

[haraken, 2017/02/11 09:56:46]

BLINK_GC_INCLUDE_PATH

Oilpan is a project name and we normally avoid writing it in the code base
(except comments).

However, I'm not sure how helpful the macro is. We could just write
''platform/heap/Handle.h' on the call sites.

[dglazkov, 2017/02/11 21:56:20]

Good point. Incorporated inline.

+STRING_INCLUDE_PATH = 'wtf/text/WTFString.h'
 WEB_MODULE_IDL_ATTRIBUTE = 'WebModuleAPI'
-STRING_INCLUDE_PATH = 'wtf/text/WTFString.h'
 
-def interface_context(idl_interface):
-    builder = InterfaceContextBuilder(MODULE_PYNAME, TypeResolver())
+
+def interface_context(idl_interface, type_resolver):
+    builder = InterfaceContextBuilder(MODULE_PYNAME, type_resolver)
     builder.set_class_name(idl_interface.name)
     builder.set_inheritance(idl_interface.parent)
 
     for idl_attribute in idl_interface.attributes:
         builder.add_attribute(idl_attribute)
 
     for idl_operation in idl_interface.operations:
         builder.add_operation(idl_operation)
 
     return builder.build()
 
 
 class TypeResolver(object):
     """Resolves Web IDL types into corresponding C++ types and include paths
        to the generated and existing files."""
 
-    def includes_from_interface(self, base_type):
-        # TODO(dglazkov): Are there any exceptional conditions here?
-        return set([base_type])
+    def __init__(self, interfaces_info):
+        self.interfaces_info = interfaces_info
+
+    def includes_from_interface(self, interface_name):
+        interface_info = self.interfaces_info.get(interface_name)
+        if interface_info is None:
+            raise KeyError('Unkown interface "%s".' % interface_name)
+        return set([interface_info['include_path']])
 
     def _includes_from_type(self, idl_type):
         if idl_type.is_void:
             return set()
         if idl_type.is_primitive_type:
             return set()
         if idl_type.is_string_type:
             return set([STRING_INCLUDE_PATH])
 
         # TODO(dglazkov): Handle complex/weird types.
-        # TODO(dglazkov): Make these proper paths to generated and non-generated
-        # files.
-        return set([idl_type.base_type])
+        return self.includes_from_interface(idl_type.base_type)
 
     def includes_from_definition(self, idl_definition):
         return self._includes_from_type(idl_definition.idl_type)
 
     def type_from_definition(self, idl_definition):
         # TODO(dglazkov): The output of this method must be a reasonable C++
         # type that can be used directly in the jinja2 template.
         return idl_definition.idl_type.base_type
 
+    def base_class_includes(self):
+        return set([OILPAN_INCLUDE_PATH])
+
 
 class InterfaceContextBuilder(object):
     def __init__(self, code_generator, type_resolver):
         self.result = {'code_generator': code_generator}
         self.type_resolver = type_resolver
 
     def set_class_name(self, class_name):
         converter = NameStyleConverter(class_name)
         self.result['class_name'] = converter.to_all_cases()
+        self._ensure_set('cpp_includes').update(
+            self.type_resolver.includes_from_interface(class_name))
 
     def set_inheritance(self, base_interface):
         if base_interface is None:
+            self._ensure_set('header_includes').update(
+                self.type_resolver.base_class_includes())
             return
-        self.result['inherits_expression'] = ' : public %s' % base_interface
-        self._ensure_set('cpp_includes').update(
+        self.result['base_class'] = base_interface
+        self._ensure_set('header_includes').update(
             self.type_resolver.includes_from_interface(base_interface))
 
     def _ensure_set(self, name):
         return self.result.setdefault(name, set())
 
     def _ensure_list(self, name):
         return self.result.setdefault(name, [])
 
     def add_attribute(self, idl_attribute):
         self._ensure_list('attributes').append(
@@ skipping 26 matching lines @@
         }
 
     def build(self):
         return self.result
 
 
 class CodeGeneratorWebModule(CodeGeneratorBase):
     def __init__(self, info_provider, cache_dir, output_dir):
         CodeGeneratorBase.__init__(self, MODULE_PYNAME, info_provider,
                                    cache_dir, output_dir)
+        self.type_resolver = TypeResolver(info_provider.interfaces_info)
         self.typedef_resolver = TypedefResolver(info_provider)
 
     def get_template(self, file_extension):
         template_filename = 'web_module_interface.%s.tmpl' % file_extension
         return self.jinja_env.get_template(template_filename)
 
     def generate_file(self, template_context, file_extension):
         template = self.get_template(file_extension)
         path = posixpath.join(
             self.output_dir,
             '%s.%s' % (template_context['class_name']['snake_case'],
                        file_extension))
         text = render_template(template, template_context)
         return (path, text)
 
     def generate_interface_code(self, interface):
         # TODO(dglazkov): Implement callback interfaces.
         # TODO(dglazkov): Make sure partial interfaces are handled.
         if interface.is_callback or interface.is_partial:
             raise ValueError('Partial or callback interfaces are not supported')
 
-        template_context = interface_context(interface)
+        template_context = interface_context(interface, self.type_resolver)
 
         return (
             self.generate_file(template_context, 'h'),
             self.generate_file(template_context, 'cc')
         )
 
     def generate_code(self, definitions, definition_name):
         self.typedef_resolver.resolve(definitions, definition_name)
 
         # TODO(dglazkov): Implement dictionaries
         if definition_name not in definitions.interfaces:
             return None
 
         interface = definitions.interfaces[definition_name]
         if WEB_MODULE_IDL_ATTRIBUTE not in interface.extended_attributes:
             return None
 
         return self.generate_interface_code(interface)