[WebAgent API]: Implement name style handling.

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, 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'
 
 WEB_MODULE_IDL_ATTRIBUTE = 'WebModuleAPI'
 STRING_INCLUDE_PATH = 'wtf/text/WTFString.h'
 
 def interface_context(idl_interface):
     builder = InterfaceContextBuilder(MODULE_PYNAME, TypeResolver())
     builder.set_class_name(idl_interface.name)
     builder.set_inheritance(idl_interface.parent)
@@ skipping 36 matching lines @@
         # type that can be used directly in the jinja2 template.
         return idl_definition.idl_type.base_type
 
 
 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):
-        self.result['class_name'] = class_name
+        converter = NameStyleConverter(class_name)
+        self.result['class_name'] = converter.to_all_cases()
 
     def set_inheritance(self, base_interface):
         if base_interface is None:
             return
         self.result['inherits_expression'] = ' : public %s' % base_interface
         self._ensure_set('cpp_includes').update(
             self.type_resolver.includes_from_interface(base_interface))
 
     def _ensure_set(self, name):
         return self.result.setdefault(name, set())
@@ skipping 38 matching lines @@
 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_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)
 
-        cpp_template = self.get_template('cpp')
-        header_template = self.get_template('h')
-        cpp_text = render_template(cpp_template, template_context)
-        header_text = render_template(header_template, template_context)
-        header_path, cpp_path = self.output_paths(interface.name)
-
         return (
-            (header_path, header_text),
-            (cpp_path, cpp_text)
+            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)
-        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)