Mojo code generator: change where to add computed data to mojom definitions

mojo/public/tools/bindings/generators/mojom_js_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 JavaScript source files from a mojom.Module."""
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 import os
@@ skipping 77 matching lines @@
   return expected_dimension_sizes
 
 
 def GetRelativePath(module, base_module):
   return os.path.relpath(module.path, os.path.dirname(base_module.path))
 
 
 class Generator(generator.Generator):
   def _GetParameters(self):
     return {
-      "namespace": self.module.namespace,
-      "imports": self._GetImports(),
+      "enums": self.module.enums,
+      "imports": self.module.imports,
+      "interfaces": self.module.interfaces,
       "kinds": self.module.kinds,
-      "enums": self.module.enums,
       "module": self.module,
-      "structs": self.GetStructs() + self.GetStructsFromMethods(),
-      "unions": self.GetUnions(),
+      "structs": self.module.structs + self._GetStructsFromMethods(),
+      "unions": self.module.unions,
       "use_new_js_bindings": self.use_new_js_bindings,
-      "interfaces": self.GetInterfaces(),
-      "imported_interfaces": self._GetImportedInterfaces(),
     }
 
   @staticmethod
   def GetTemplatePrefix():
     return "js_templates"
 
   def GetFilters(self):
     js_filters = {
       "decode_snippet": self._JavaScriptDecodeSnippet,
       "default_value": self._JavaScriptDefaultValue,
       "encode_snippet": self._JavaScriptEncodeSnippet,
       "expression_to_text": self._ExpressionToText,
       "field_offset": JavaScriptFieldOffset,
+      "get_relative_path": GetRelativePath,
       "has_callbacks": mojom.HasCallbacks,
       "is_any_handle_or_interface_kind": mojom.IsAnyHandleOrInterfaceKind,
       "is_array_kind": mojom.IsArrayKind,
       "is_associated_interface_kind": mojom.IsAssociatedInterfaceKind,
       "is_associated_interface_request_kind":
           mojom.IsAssociatedInterfaceRequestKind,
       "is_bool_kind": mojom.IsBoolKind,
       "is_enum_kind": mojom.IsEnumKind,
       "is_any_handle_kind": mojom.IsAnyHandleKind,
       "is_interface_kind": mojom.IsInterfaceKind,
       "is_interface_request_kind": mojom.IsInterfaceRequestKind,
       "is_map_kind": mojom.IsMapKind,
       "is_object_kind": mojom.IsObjectKind,
       "is_string_kind": mojom.IsStringKind,
       "is_struct_kind": mojom.IsStructKind,
       "is_union_kind": mojom.IsUnionKind,
       "js_type": self._JavaScriptType,
       "method_passes_associated_kinds": mojom.MethodPassesAssociatedKinds,
       "payload_size": JavaScriptPayloadSize,
-      "get_relative_path": GetRelativePath,
-      "stylize_method": generator.StudlyCapsToCamel,
+      "stylize_method": lambda x: generator.ToCamel(x, lower_initial=True),
+      "to_camel": generator.ToCamel,
       "union_decode_snippet": self._JavaScriptUnionDecodeSnippet,
       "union_encode_snippet": self._JavaScriptUnionEncodeSnippet,
       "validate_array_params": self._JavaScriptValidateArrayParams,
       "validate_enum_params": self._JavaScriptValidateEnumParams,
       "validate_map_params": self._JavaScriptValidateMapParams,
       "validate_nullable_params": self._JavaScriptNullableParam,
       "validate_struct_params": self._JavaScriptValidateStructParams,
       "validate_union_params": self._JavaScriptValidateUnionParams,
     }
     return js_filters
 
   @UseJinja("module.amd.tmpl")
   def _GenerateAMDModule(self):
     return self._GetParameters()
 
   def GenerateFiles(self, args):
     if self.variant:
       raise Exception("Variants not supported in JavaScript bindings.")
 
+    # TODO(yzshen): Remove this method once the old JS bindings go away.
+    self._SetUniqueNameForImports()
+
     self.Write(self._GenerateAMDModule(),
         self.MatchMojomFilePath("%s.js" % self.module.name))
 
-  def _GetImports(self):
-    # TODO(yzshen): Remove this method once the old JS bindings go away.
+  def _SetUniqueNameForImports(self):
     used_names = set()
     for each_import in self.module.imports:
       simple_name = each_import.name.split(".")[0]
 
       # Since each import is assigned a variable in JS, they need to have unique
       # names.
       unique_name = simple_name
       counter = 0
       while unique_name in used_names:
         counter += 1
         unique_name = simple_name + str(counter)
 
       used_names.add(unique_name)
       each_import.unique_name = unique_name + "$"
       counter += 1
-    return self.module.imports
-
-  def _GetImportedInterfaces(self):
-    interface_to_import = {};
-    for each_import in self.module.imports:
-      for each_interface in each_import.interfaces:
-        name = each_interface.name
-        interface_to_import[name] = each_import.unique_name + "." + name
-    return interface_to_import;
 
   def _JavaScriptType(self, kind):
     name = []
     if kind.module and kind.module.path != self.module.path:
       name.append(kind.module.unique_name)
     if kind.parent_kind:
       name.append(kind.parent_kind.name)
     name.append(kind.name)
     return ".".join(name)
 
@@ skipping 174 matching lines @@
          token.value == "float.NEGATIVE_INFINITY":
         return "-Infinity";
       if token.value == "double.NAN" or token.value == "float.NAN":
         return "NaN";
 
     return token
 
   def _ExpressionToText(self, value):
     return self._TranslateConstants(value)
 
+  def _GetStructsFromMethods(self):
+    result = []
+    for interface in self.module.interfaces:
+      for method in interface.methods:
+        result.append(method.param_struct)
+        if method.response_param_struct is not None:
+          result.append(method.response_param_struct)
+    return result