Mojom compiler backend: Stop re-computing interface version numbers and consume method declaration o

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 436 matching lines @@
       mojom_type: {UserDefinedType} referring to the MojomInterface to be
         translated.
     """
     assert (mojom_type.tag
         == mojom_types_mojom.UserDefinedType.Tags.interface_type)
     mojom_interface = mojom_type.interface_type
     interface.attributes = self.AttributesFromMojom(mojom_interface)
     self.PopulateModuleOrImportedFrom(interface, mojom_interface)
     interface.name = mojom_interface.decl_data.short_name
     interface.spec = interface.name
+    interface.version = mojom_interface.current_version
     interface.service_name = mojom_interface.service_name
     if interface.attributes:
       assert interface.service_name == interface.attributes.get(
           'ServiceName', None), interface.service_name
     else:
       assert interface.service_name is None, interface.service_name
 
 
     # Translate the dictionary of methods into a list of module.Methods.
-    # In order to have a deterministic ordering we sort by method ordinal.
-    # TODO(rudominer) Consider ordering by declaration order instead once
-    # this field is populated by the front-end.
     interface.methods = [self.MethodFromMojom(mojom_method, interface)
-        for ordinal, mojom_method in sorted(mojom_interface.methods.iteritems(),
-          key=operator.itemgetter(0))]
+        for ordinal, mojom_method in mojom_interface.methods.iteritems()]
+    # We want the methods in an interface to be in some deterministic order
+    # and we choose declaration order (i.e. lexical order within the
+    # .mojom file.)
+    interface.methods.sort(key=lambda method: method.declaration_order)
     self.PopulateContainedDeclarationsFromMojom(
         interface, mojom_interface.decl_data.contained_declarations)
 
   def MethodFromMojom(self, mojom_method, interface):
     """Translates a mojom_types_mojom.MojomMethod to a module.Method.
 
     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.declaration_order = mojom_method.decl_data.declaration_order
     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')
+    method.min_version=mojom_method.min_version
 
     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.
 
@@ skipping 363 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}