Stop using v8_interface.interface_context in Web modules bindings.

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.
 
 The Web Modules are the high-level services like Autofill,
 Autocomplete, Translate, Distiller, Phishing Detector, and others. Web Modules
 typically want to introspec the document and rendering infromation to implement
 browser features.
 
 The bindings are meant to be as simple and as ephemeral as possible, mostly just
 wrapping existing DOM classes. Their primary goal is to avoid leaking the actual
 DOM classes to the Web Modules layer.
 """
 
 import os
 import posixpath
 
 from code_generator import CodeGeneratorBase
 # TODO(dglazkov): Move TypedefResolver to code_generator.py
 from code_generator_v8 import TypedefResolver
-from v8_interface import interface_context
 
 MODULE_PYNAME = os.path.splitext(os.path.basename(__file__))[0] + '.py'
 
 WEB_MODULE_IDL_ATTRIBUTE = 'WebModuleAPI'
 
 
+def includes_for_type(idl_type):

[haraken, 2016/11/12 08:01:37]

Would you help me understand why you need to implement a customized
includes_for_type for web modules? Doesn't includes_for_type in v8_types.py
work?

[dglazkov, 2016/11/13 00:11:45]

Sure! `v8_types.includes_for_type` returns very specific paths and names that
don't apply in webmodules. For example, if I need to depend on NodeList, I
probably don't need `bindings/core/v8/V8NodeList.h` in my includes (see
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/bindings/scrip...).

+    # TODO(dglazkov): Make this actually work.
+    name = idl_type.preprocessed_type.base_type
+    return set([name])
+
+
+def interface_context(idl_interface):
+    attributes = []
+    methods = []
+    includes = set()
+    for idl_attribute in idl_interface.attributes:
+        attributes.append(Attribute.create(idl_attribute))
+        includes.update(includes_for_type(idl_attribute.idl_type))
+    for idl_operation in idl_interface.operations:
+        if idl_operation.name:
+            methods.append(Method.create(idl_operation))

[haraken, 2016/11/12 08:01:37]

bashi@, yukishiino@: Is this an expected way to build up meta information of
attributes and methods? I'm asking this just because we're not using the
Attribute/Method.create pattern in other generators in the IDL compiler.

[dglazkov, 2016/11/13 00:11:45]

Factories seem like a good thing. We use them elsewhere in blink :)

[bashi, 2016/11/13 23:33:58]

We haven't used factories but I'm fine with using them. I like classes over
dicts.

yukishiino@: what do you think?

[haraken, 2016/11/14 01:41:41]

Yeah, other places are using attribute_context, method_context etc, which return
a dictionary. Also this CL is using interface_context.

I don't care as long as they will get consistent in the future :)

+    return {
+        'code_generator': MODULE_PYNAME,
+        'class_name': idl_interface.name,
+        'cpp_includes': includes,
+        'attributes': attributes,
+        'methods': methods,
+    }
+
+
+class Attribute(object):

[haraken, 2016/11/12 08:01:37]

object is unused

[dglazkov, 2016/11/13 00:11:45]

What do you mean? The Attribute.create returns an instance.

+    def __init__(self, name, return_type):
+        self.name = name
+        self.return_type = return_type
+
+    @staticmethod
+    def create(idl_attribute):
+        name = idl_attribute.name
+        return_type = idl_attribute.idl_type.preprocessed_type.base_type
+        return Attribute(name, return_type)
+
+
+# TODO(dglazkov): Attribute and Method are both created off
+# idl_definitions.TypedObject sub-types, so maybe use inheritance?
+class Method(object):

[haraken, 2016/11/12 08:01:37]

Ditto.

[dglazkov, 2016/11/13 00:11:45]

Same here.

+    def __init__(self, name, return_type):
+        self.name = name
+        self.return_type = return_type
+
+    @staticmethod
+    def create(idl_operation):
+        name = idl_operation.name
+        return_type = idl_operation.idl_type.preprocessed_type.base_type
+        return Method(name, return_type)
+
+
 class CodeGeneratorWebModule(CodeGeneratorBase):
     def __init__(self, info_provider, cache_dir, output_dir):
         CodeGeneratorBase.__init__(self, MODULE_PYNAME, info_provider,
                                    cache_dir, output_dir)
         self.typedef_resolver = TypedefResolver(info_provider)
 
-    def get_template(self):
-        template_filename = 'web_module_interface.cpp.tmpl'
+    def get_template(self, file_extension):
+        template_filename = 'web_module_interface.%s.tmpl' % file_extension
         return self.jinja_env.get_template(template_filename)
 
     # TODO(dglazkov): Move to CodeGeneratorBase.
     def output_paths(self, definition_name):
         header_path = posixpath.join(self.output_dir,
                                      'Web%s.h' % definition_name)
         cpp_path = posixpath.join(self.output_dir,
                                   'Web%s.cpp' % definition_name)
         return header_path, cpp_path
 
+    def generate_interface_code(self, interface):
+        # TODO(dglazkov): Implement callback interfaces.
+        # TODO(dglazkov): Make sure partial interfaces are handled.
+        if interface.is_callback and interface.is_partial:

[haraken, 2016/11/12 08:01:37]

and => or ?

[dglazkov, 2016/11/13 00:11:45]

Oops. Thanks! Fixed.

+            return None

[haraken, 2016/11/12 08:01:37]

Or you can raise an exception when you hit something you don't expect.

[dglazkov, 2016/11/13 00:11:45]

That's a great idea! Fixed.

+
+        template_context = interface_context(interface)
+
+        cpp_template = self.get_template('cpp')
+        h_template = self.get_template('h')

[haraken, 2016/11/12 08:01:37]

header_template

[dglazkov, 2016/11/13 00:11:45]

Fixed.

+        cpp_text = cpp_template.render(template_context)
+        h_text = h_template.render(template_context)

[haraken, 2016/11/12 08:01:37]

header_text

[dglazkov, 2016/11/13 00:11:45]

Fixed.

+        header_path, cpp_path = self.output_paths(interface.name)
+
+        return (
+            (header_path, h_text),
+            (cpp_path, cpp_text)
+        )
+
     def generate_code(self, definitions, definition_name):
         self.typedef_resolver.resolve(definitions, definition_name)
         header_path, cpp_path = self.output_paths(definition_name)
 
         template_context = {}
         # 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
 
-        # TODO(dglazkov): Implement callback interfaces.
-        # TODO(dglazkov): Implement partial interfaces.
-        if interface.is_callback and interface.is_partial:
-            return None
-
-        template_context = interface_context(interface,
-                                             definitions.interfaces)
-        template_context['code_generator'] = MODULE_PYNAME
-        template_context['class_name'] = definition_name
-
-        cpp_template = self.get_template()
-        cpp_text = cpp_template.render(template_context)
-
-        header_text = 'header'
-        return (
-            (header_path, header_text),
-            (cpp_path, cpp_text)
-        )
+        return self.generate_interface_code(interface)