Mojom runtime type info: Use compression and base64 encoding.

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

 # 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.
 
 '''Generates Go source files from a mojom.Module.'''
 
 from itertools import chain
 import os
 import re
 
@@ skipping 207 matching lines @@
 def GetAllConstants(module):
   data = [module] + module.structs + module.interfaces
   constants = [x.constants for x in data]
   return [i for i in chain.from_iterable(constants)]
 
 def GetAllEnums(module):
   data = [module] + module.structs + module.interfaces
   enums = [x.enums for x in data]
   return [i for i in chain.from_iterable(enums)]
 
-def GetSerializedRuntimeTypeInfoLiteral(module, enabled):
-  """ Constructs a string that represents a literal definition in Go of
-  an array of bytes corresponding to |module.serialized_runtime_type_info|.
-
-  Args:
-    module: {mojom.Module} the module being processed.
-    enabled: {bool} Is this feature enabled.
-
-  Returns: A string of the form '{b0, b1, b2,...}' where the 'bi' are
-  the decimal representation of the bytes of
-  |module.serialized_runtime_type_info| or the string '{}' if either
-  |enabled| is false or |module.serialized_runtime_type_info| is None.
-  Furthermore the returned string will have embedded newline characters inserted
-  every 1000 characters to make the generated source code more tractable.
-  """
-  if not enabled or not module.serialized_runtime_type_info:
-    return '{}'
-  return '{%s}' % ','.join('%s%d' %
-      ('\n' if index > 0 and index%1000 == 0 else '', b)
-          for index, b in enumerate(module.serialized_runtime_type_info))
-
 def AddImport(imports, mojom_imports, module, element):
   """Adds an import required to use the provided element.
 
   The required import is stored in the imports parameter.
   The corresponding mojom import is stored in the mojom_imports parameter.
   Each import is also updated to include a 'go_name' entry. The 'go_name' entry
   is the name by which the imported module will be referred to in the generated
   code. Because the import dictionary is accessible from the element's
   imported_from field this allows us to generate the qualified name for the
   element.
@@ skipping 75 matching lines @@
       'imports': imports,
       'interfaces': self.GetInterfaces(),
       'mojom_imports': mojom_imports,
       'package': package,
       'structs': self.GetStructs(),
       'descpkg': '%s.' % _service_describer_pkg_short \
         if package != _service_describer_pkg_short else '',
       'typepkg': '%s.' % _mojom_types_pkg_short \
         if package != _mojom_types_pkg_short else '',
       'unions': self.GetUnions(),
-      'serialized_runtime_type_info_literal' : (
-          GetSerializedRuntimeTypeInfoLiteral(self.module,
-              self.should_gen_mojom_types))
     }
 
   @UseJinja('go_templates/source.tmpl', filters=go_filters)
   def GenerateSource(self):
     return self.GetParameters()
 
   def GenerateFiles(self, args):
     self.should_gen_mojom_types = "--generate_type_info" in args
 
     self.Write(self.GenerateSource(), os.path.join("go", "src",
@@ skipping 57 matching lines @@
     for enum in GetAllEnums(self.module):
       for field in enum.fields:
         if field.value:
           AddImport(imports, mojom_imports, self.module, field.value)
 
     # Mojom Type generation requires additional imports.
     defInterface = len(self.module.interfaces) > 0
     defOtherType = len(self.module.unions) + len(all_structs) + \
       len(GetAllEnums(self.module)) > 0
 
+    if self.should_gen_mojom_types:
+      imports['bytes'] = 'bytes'
+      imports['compress/gzip'] = 'gzip'
+      imports['encoding/base64'] = 'base64'
+      imports['io/ioutil'] = 'ioutil'
+
     if GetPackageName(self.module) != _mojom_types_pkg_short:
       if defInterface:
         # Each Interface has a service description that uses this.
         imports[_mojom_types_pkg] = _mojom_types_pkg_short
       if defOtherType and self.should_gen_mojom_types:
         # This import is needed only if generating mojom type definitions.
         imports[_mojom_types_pkg] = _mojom_types_pkg_short
 
     if GetPackageName(self.module) != _service_describer_pkg_short and \
       defInterface:
@@ skipping 20 matching lines @@
   # Overrides the implementation from the base class in order to customize the
   # struct and field names.
   def _GetResponseStructFromMethod(self, method):
     params_class = "%s_%s_ResponseParams" % (
         GetNameForElement(method.interface), GetNameForElement(method))
     struct = mojom.Struct(params_class, module=method.interface.module)
     for param in method.response_parameters:
       struct.AddField("out%s" % GetNameForElement(param),
           param.kind, param.ordinal, attributes=param.attributes)
     return self._AddStructComputedData(False, struct)