Add first bindings unit test and enable testing.

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 20 matching lines @@
 WEB_MODULE_IDL_ATTRIBUTE = 'WebModuleAPI'
 
 
 def includes_for_type(idl_type):
     # 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()
+    builder = InterfaceContextBuilder(MODULE_PYNAME)
+    builder.set_class_name(idl_interface.name)
+
     for idl_attribute in idl_interface.attributes:
-        attributes.append(Attribute.create(idl_attribute))
-        includes.update(includes_for_type(idl_attribute.idl_type))
+        builder.add_attribute(idl_attribute)
+
     for idl_operation in idl_interface.operations:
-        if idl_operation.name:
-            methods.append(Method.create(idl_operation))
-    return {
-        'code_generator': MODULE_PYNAME,
-        'class_name': idl_interface.name,
-        'cpp_includes': includes,
-        'attributes': attributes,
-        'methods': methods,
-    }
+        builder.add_operation(idl_operation)
+
+    return builder.build()
 
 
-class Attribute(object):
-    def __init__(self, name, return_type):
-        self.name = name
-        self.return_type = return_type
+class InterfaceContextBuilder(object):
+    def __init__(self, code_generator):
+        self.result = {'code_generator': code_generator}
 
-    @staticmethod
-    def create(idl_attribute):
+    def set_class_name(self, class_name):
+        self.result['class_name'] = class_name
+
+    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(
+            self.create_attribute(idl_attribute))
+        self._ensure_set('cpp_includes').update(
+            includes_for_type(idl_attribute.idl_type))
+
+    def add_operation(self, idl_operation):
+        if idl_operation.name:
+            self._ensure_list('methods').append(
+                self.create_method(idl_operation))
+            self._ensure_set('cpp_includes').update(
+                includes_for_type(idl_operation.idl_type))
+
+    def create_method(self, idl_operation):
+        name = idl_operation.name
+        return_type = idl_operation.idl_type.preprocessed_type.base_type

[bashi, 2016/12/12 05:04:38]

Not directly related to this CL but do we need preprocessed_type? Maybe we need
a function like "return_type_for_type(idl_type)" instead? (As you did for
includes_for_type())

|preprocessed_type| is installed in v8_types.py, which means that it includes V8
specific logic. I'm not sure what's a right value of 'return_type' for web
modules.

+        return {
+            'name': name,
+            'return_type': return_type
+        }
+
+    def create_attribute(self, idl_attribute):
         name = idl_attribute.name
         return_type = idl_attribute.idl_type.preprocessed_type.base_type
-        return Attribute(name, return_type)
+        return {
+            'name': name,
+            'return_type': return_type
+        }
 
-
-class Method(object):
-    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)
+    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.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)
 
     # 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 or interface.is_partial:
-            raise ValueError("Partial or callback interfaces are not supported")
+            raise ValueError('Partial or callback interfaces are not supported')
 
         template_context = interface_context(interface)
 
         cpp_template = self.get_template('cpp')
         header_template = self.get_template('h')
         cpp_text = cpp_template.render(template_context)
         header_text = header_template.render(template_context)
         header_path, cpp_path = self.output_paths(interface.name)
 
         return (
             (header_path, header_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
 
         return self.generate_interface_code(interface)