Mojom backend: Stop re-computing version info and field packing data.

mojo/public/tools/bindings/pylib/mojom/generate/mojom_translator.py

 #!/usr/bin/env python
 # Copyright 2015 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.
 #
 # This module is responsible for translating a MojomFileGraph (see
 # mojom_files.mojom) to one or more module.Module.
 #
 # This module takes the output of the mojom parser, a MojomFileGraph  and
 # translates it to the input of the code generators, a module.Module object.
@@ skipping 11 matching lines @@
 # NOTE: This module assumes that the python path contains the generated modules
 # for mojom_files.mojom and mojom_types.mojom as well as their dependencies.
 # It is the responsibility of the module's loader to handle this.
 
 import os
 
 from generated import mojom_files_mojom
 from generated import mojom_types_mojom
 import module
 import operator
+import pack
 
 
 class FileTranslator(object):
   """FileTranslator translates a MojomFile to a module.Module."""
   def __init__(self, graph, file_name):
     """Initializes a FileTranslator.
 
     Args:
       graph: {mojom_files_mojom.MojomFileGraph} containing the file to be
           translated.
@@ skipping 143 matching lines @@
   def StructFromMojom(self, struct, mojom_type):
     """Populates a module.Struct based on a MojomStruct.
 
     Args:
       struct: {module.Struct} to be populated.
       mojom_type: {UserDefinedType} referring to the MojomStruct to be
         translated.
     """
     assert mojom_type.tag == mojom_types_mojom.UserDefinedType.Tags.struct_type
     mojom_struct = mojom_type.struct_type
+    self.StructFromMojomStruct(struct, mojom_struct)
+
+  def StructFromMojomStruct(self, struct, mojom_struct):
+    """Populates a module.Struct based on a MojomStruct.
+
+    Args:
+      struct: {module.Struct} to be populated.
+      mojom_struct: {mojom_types.MojomStruct} to be translated.
+    """
     self.PopulateUserDefinedType(struct, mojom_struct)
-    # mojom_struct.fields is indexed by the field ordinals. We want
-    # to capture these ordinals but sort struct.fields by declaration_order.
-    struct.fields = [self.StructFieldFromMojom(ordinal, f) for (ordinal, f) in
-        enumerate(mojom_struct.fields)]
+    # mojom_struct.fields is indexed by the field ordinals.
+    struct.fields_in_ordinal_order = [self.StructFieldFromMojom(ordinal, f)
+        for (ordinal, f) in  enumerate(mojom_struct.fields)]
+    # We also want a list of fields sorted in declaration_order.
+    struct.fields = [f for f in struct.fields_in_ordinal_order]
     struct.fields.sort(key=lambda field: field.declaration_order)
+
+    assert mojom_struct.version_info
+    struct.versions = [self.VersionInfoFromMojom(version) for version in
+        mojom_struct.version_info]
     self.PopulateContainedDeclarationsFromMojom(
         struct, mojom_struct.decl_data.contained_declarations)
 
   def UnionFieldFromMojom(self, mojom_field):
     """Translates a mojom_types_mojom.UnionField to a module.UnionField.
 
     Args:
       mojom_field: {mojom_types_mojom.UnionField} to be translated.
 
     Returns:
@@ skipping 21 matching lines @@
       ordinal: {int} The 0-based ordinal position of the field within the
                struct. Note that this is not necessarily the same as the lexical
                order or the packing order.
       mojom_field: {mojom_types_mojom.StructField} to be translated.
 
     Returns:
       {module.StructField} translated from mojom_field.
     """
     struct_field = module.StructField()
     self.PopulateCommonFieldValues(struct_field, mojom_field)
+    struct_field.computed_offset = mojom_field.offset
+    struct_field.computed_bit = mojom_field.bit
+    struct_field.computed_min_version = mojom_field.min_version
     # Note that the |ordinal| attribute of |struct_field| records only the
     # *declared* ordinal and as such is not defined for every field whereas
     # the |computed_ordinal| attribute is defined for every field. If
     # |ordinal| is defined then it is equal to |computed_ordinal|.
     struct_field.ordinal = self.OrdinalFromMojom(mojom_field)
     struct_field.computed_ordinal = ordinal
     struct_field.declaration_order = mojom_field.decl_data.declaration_order
     if mojom_field.default_value:
       if (mojom_field.default_value.tag ==
           mojom_types_mojom.DefaultFieldValue.Tags.default_keyword):
         struct_field.default = 'default'
       else:
         struct_field.default = self.ValueFromMojom(
             mojom_field.default_value.value)
 
     return struct_field
 
+  def VersionInfoFromMojom(self, mojom_version):
+    """Translates a mojom_types_mojom.StructVersion to a pack.VersionInfo
+    Args:
+       mojom_version: {mojom_types_mojom.StructVersion} to be translated.
+
+    Returns:
+      {pack.VersionInfo} translated from |mojom_version|.
+    """
+    return pack.VersionInfo(mojom_version.version_number,
+        mojom_version.num_fields, mojom_version.num_bytes)
+
+
   def ParamFromMojom(self, mojom):
     """Translates a mojom_types_mojom.StructField to a module.Parameter.
 
     The parameters passed to and returned from a method are expressed as a
     struct. The struct fields in the struct are the parameters.
 
     Args:
       mojom: {mojom_types_mojom.StructField} representing a method parameter.
 
     Returns:
@@ skipping 178 matching lines @@
 
     Args:
       mojom_method: {mojom_types_mojom.MojomMethod} to be translated.
       interface: {module.Interface} the method is a member of.
 
     Returns:
       {module.Method} translated from mojom_method.
     """
     method = module.Method(interface, mojom_method.decl_data.short_name)
     method.ordinal = mojom_method.ordinal
+    method.param_struct = module.Struct()
+    self.StructFromMojomStruct(method.param_struct, mojom_method.parameters)
+    # The name of a synthetic request parameter struct is not guaranteed by
+    # the frontend to be anything in particular so we set the name of the
+    # translated struct to a value that the code generators are expecting.
+    method.param_struct.name = "%s_%s_Params" % (
+        method.interface.name, method.name)
     method.parameters = [self.ParamFromMojom(param)
         for param in mojom_method.parameters.fields]
     if mojom_method.response_params is not None:
+      method.response_param_struct = module.Struct()
+      self.StructFromMojomStruct(method.response_param_struct,
+          mojom_method.response_params)
+      # The name of a synthetic response parameter struct is not guaranteed by
+      # the frontend to be anything in particular so we set the name of the
+      # translated struct to a value that the code generators are expecting.
+      method.response_param_struct.name = "%s_%s_ResponseParams" % (
+          method.interface.name, method.name)
       method.response_parameters = [self.ParamFromMojom(param)
           for param in mojom_method.response_params.fields]
+
+    # Set the min_version attribute on the method.
+    method.min_version=None
+    # TODO(rudominer) For now we parse the "MinVersion" attribute here but
+    # after we add a min_version field to mojom_types_mojom.MojomMethod then
+    # we should take the value from there instead.
+    if method.attributes:
+      method.min_version=method.get('MinVersion')
+
     return method
 
   def ConstantFromValueKey(self, value_key):
     """Takes a value key into a graph.resolved_values referring to a constant
     and returns the module equivalent.
 
     Args:
       value_key: {str} the value key referring to the value to be returned.
 
     Returns:
@@ skipping 362 matching lines @@
 
   Args:
     graph: {mojom_types_mojom.MojomFileGraph} to be translated.
 
   Return:
     {dict<str, module.Module>} mapping the file's name to its module.Module
     translation for all files in graph.files.
   """
   return {file_name: FileTranslator(graph, file_name).Translate()
       for file_name in graph.files}