Mojo bindings: support generating identifers using different style rules for different target langu…

mojo/public/tools/bindings/generators/mojom_cpp_generator.py

 # Copyright 2013 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.
 
 """Generates C++ source files from a mojom.Module."""
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 from mojom.generate.template_expander import UseJinja
@@ skipping 631 matching lines @@
     "is_map_kind": mojom.IsMapKind,
     "is_nullable_kind": mojom.IsNullableKind,
     "is_object_kind": mojom.IsObjectKind,
     "is_reference_kind": mojom.IsReferenceKind,
     "is_string_kind": mojom.IsStringKind,
     "is_struct_kind": mojom.IsStructKind,
     "is_typemapped_kind": IsTypemappedKind,
     "is_union_kind": mojom.IsUnionKind,
     "passes_associated_kinds": mojom.PassesAssociatedKinds,
     "struct_constructors": GetStructConstructors,
-    "stylize_method": generator.StudlyCapsToCamel,
-    "under_to_camel": generator.UnderToCamel,
+    "under_to_camel": generator.ToCamel,
     "unmapped_type_for_serializer": GetUnmappedTypeForSerializer,
     "wtf_hash_fn_name_for_enum": GetWtfHashFnNameForEnum,
   }
 
   def GetExtraTraitsHeaders(self):
     extra_headers = set()
     for typemap in self._GetAllUsedTypemaps():
       extra_headers.update(typemap.get("traits_headers", []))
     return sorted(extra_headers)
 
@@ skipping 63 matching lines @@
     for struct in self.module.structs + self.module.unions:
       for field in struct.fields:
         yield field.kind
 
     for interface in self.module.interfaces:
       for method in interface.methods:
         for param in method.parameters + (method.response_parameters or []):
           yield param.kind
 
   def GetJinjaExports(self):
-    structs = self.GetStructs()
-    interfaces = self.GetInterfaces()
     all_enums = list(self.module.enums)
-    for struct in structs:
+    for struct in self.module.structs:
       all_enums.extend(struct.enums)
-    for interface in interfaces:
+    for interface in self.module.interfaces:
       all_enums.extend(interface.enums)
 
     return {
       "module": self.module,
       "namespace": self.module.namespace,
       "namespaces_as_array": NamespaceToArray(self.module.namespace),
       "imports": self.module.imports,
       "kinds": self.module.kinds,
       "enums": self.module.enums,
       "all_enums": all_enums,
-      "structs": structs,
-      "unions": self.GetUnions(),
-      "interfaces": interfaces,
+      "structs": self.module.structs,
+      "unions": self.module.unions,
+      "interfaces": self.module.interfaces,
       "variant": self.variant,
       "extra_traits_headers": self.GetExtraTraitsHeaders(),
       "extra_public_headers": self.GetExtraPublicHeaders(),
       "for_blink": self.for_blink,
       "use_once_callback": self.use_once_callback,
       "export_attribute": self.export_attribute,
       "export_header": self.export_header,
     }
 
   @staticmethod
@@ skipping 18 matching lines @@
 
   @UseJinja("module-shared-internal.h.tmpl")
   def GenerateModuleSharedInternalHeader(self):
     return self.GetJinjaExports()
 
   @UseJinja("module-shared.cc.tmpl")
   def GenerateModuleSharedSource(self):
     return self.GetJinjaExports()
 
   def GenerateFiles(self, args):
+    self.FinalizeModule()
+
     if self.generate_non_variant_code:
       self.Write(self.GenerateModuleSharedHeader(),
                  self.MatchMojomFilePath("%s-shared.h" % self.module.name))
       self.Write(
           self.GenerateModuleSharedInternalHeader(),
           self.MatchMojomFilePath("%s-shared-internal.h" % self.module.name))
       self.Write(self.GenerateModuleSharedSource(),
                  self.MatchMojomFilePath("%s-shared.cc" % self.module.name))
     else:
       global _current_typemap
       _current_typemap = self.typemap
       global _for_blink
       _for_blink = self.for_blink
       global _use_once_callback
       _use_once_callback = self.use_once_callback
       global _variant
       _variant = self.variant
       global _export_attribute
       _export_attribute = self.export_attribute
       suffix = "-%s" % self.variant if self.variant else ""
       self.Write(self.GenerateModuleHeader(),
                  self.MatchMojomFilePath("%s%s.h" % (self.module.name, suffix)))
       self.Write(
           self.GenerateModuleSource(),
           self.MatchMojomFilePath("%s%s.cc" % (self.module.name, suffix)))