Mojom runtime type info: New implementation for Dart.

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

 # Copyright 2014 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 dart source files from a mojom.Module."""
 
 import errno
 import os
 import re
 import shutil
@@ skipping 105 matching lines @@
   mojom.NULLABLE_DPPIPE:       "core.MojoDataPipeProducer",
   mojom.NULLABLE_MSGPIPE:      "core.MojoMessagePipeEndpoint",
   mojom.NULLABLE_SHAREDBUFFER: "core.MojoSharedBuffer",
   mojom.INT64:                 "int",
   mojom.UINT64:                "int",
   mojom.DOUBLE:                "double",
   mojom.STRING:                "String",
   mojom.NULLABLE_STRING:       "String"
 }
 
-_kind_to_mojom_type = {
-  mojom.BOOL:                  "bool",
-  mojom.INT8:                  "int8",
-  mojom.UINT8:                 "uint8",
-  mojom.INT16:                 "int16",
-  mojom.UINT16:                "uint16",
-  mojom.INT32:                 "int32",
-  mojom.UINT32:                "uint32",
-  mojom.FLOAT:                 "float",
-  mojom.HANDLE:                "unspecified",
-  mojom.DCPIPE:                "dataPipeConsumer",
-  mojom.DPPIPE:                "dataPipeProducer",
-  mojom.MSGPIPE:               "messagePipe",
-  mojom.SHAREDBUFFER:          "sharedBuffer",
-  mojom.NULLABLE_HANDLE:       "unspecified",
-  mojom.NULLABLE_DCPIPE:       "dataPipeConsumer",
-  mojom.NULLABLE_DPPIPE:       "dataPipeProducer",
-  mojom.NULLABLE_MSGPIPE:      "messagePipe",
-  mojom.NULLABLE_SHAREDBUFFER: "sharedBuffer",
-  mojom.INT64:                 "int64",
-  mojom.UINT64:                "uint64",
-  mojom.DOUBLE:                "double"
-}
-
 _spec_to_decode_method = {
   mojom.BOOL.spec:                  'decodeBool',
   mojom.DCPIPE.spec:                'decodeConsumerHandle',
   mojom.DOUBLE.spec:                'decodeDouble',
   mojom.DPPIPE.spec:                'decodeProducerHandle',
   mojom.FLOAT.spec:                 'decodeFloat',
   mojom.HANDLE.spec:                'decodeHandle',
   mojom.INT16.spec:                 'decodeInt16',
   mojom.INT32.spec:                 'decodeInt32',
   mojom.INT64.spec:                 'decodeInt64',
@@ skipping 92 matching lines @@
   if mojom.IsMapKind(kind):
     key_type = DartDeclType(kind.key_kind)
     value_type = DartDeclType(kind.value_kind)
     return "Map<"+ key_type + ", " + value_type + ">"
   if mojom.IsInterfaceKind(kind) or \
      mojom.IsInterfaceRequestKind(kind):
     return "Object"
   if mojom.IsEnumKind(kind):
     return GetDartType(kind)
 
-def GetSimpleMojomTypeName(kind):
-  return _kind_to_mojom_type[kind]
-
 def NameToComponent(name):
   # insert '_' between anything and a Title name (e.g, HTTPEntry2FooBar ->
   # HTTP_Entry2_FooBar). Numbers terminate a string of lower-case characters.
   name = re.sub('([^_])([A-Z][^A-Z1-9_]+)', r'\1_\2', name)
   # insert '_' between non upper and start of upper blocks (e.g.,
   # HTTP_Entry2_FooBar -> HTTP_Entry2_Foo_Bar).
   name = re.sub('([^A-Z_])([A-Z])', r'\1_\2', name)
   return [x.lower() for x in name.split('_')]
 
 def UpperCamelCase(name):
@@ skipping 203 matching lines @@
 
 def GetImportUri(module):
   package = GetPackage(module);
   elements = module.namespace.split('.')
   elements.append("%s" % module.name)
   return os.path.join(package, *elements)
 
 def RaiseHelper(msg):
     raise Exception(msg)
 
+def GetSerializedRuntimeTypeInfoLiteral(module, enabled):
+  """ Constructs a string that represents a literal definition in Dart 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 empty 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))
+
 class Generator(generator.Generator):
 
   dart_filters = {
     'array_expected_length': GetArrayExpectedLength,
     'array': GetArrayKind,
     'decode_method': DecodeMethod,
     'default_value': DartDefaultValue,
     'encode_method': EncodeMethod,
-    'fullidentifier': mojom.GetMojomTypeFullIdentifier,
-    'simple_mojom_type_name': GetSimpleMojomTypeName,
-    'mojom_type_name': mojom.GetMojomTypeName,
-    'mojom_type_identifier': mojom.GetMojomTypeIdentifier,
     'is_imported_kind': IsImportedKind,
     'is_array_kind': mojom.IsArrayKind,
     'is_map_kind': mojom.IsMapKind,
     'is_numerical_kind': mojom.IsNumericalKind,
     'is_any_handle_kind': mojom.IsAnyHandleKind,
     'is_string_kind': mojom.IsStringKind,
     'is_nullable_kind': mojom.IsNullableKind,
     'is_pointer_array_kind': IsPointerArrayKind,
     'is_enum_array_kind': IsEnumArrayKind,
     'is_struct_kind': mojom.IsStructKind,
@@ skipping 28 matching lines @@
       "namespace": self.module.namespace,
       "imports": self.GetImports(args),
       "kinds": self.module.kinds,
       "enums": self.module.enums,
       "module": resolver.ResolveConstants(self.module, ExpressionToText),
       "structs": self.GetStructs() + self.GetStructsFromMethods(),
       "unions": self.GetUnions(),
       "interfaces": self.GetInterfaces(),
       "imported_interfaces": self.GetImportedInterfaces(),
       "imported_from": self.ImportedFrom(),
+      "serialized_runtime_type_info_literal" : (
+          GetSerializedRuntimeTypeInfoLiteral(self.module,
+              self.should_gen_mojom_types)),
       "typepkg": '%s.' % _mojom_types_pkg_short,
       "descpkg": '%s.' % _service_describer_pkg_short,
       "mojom_types_import": 'import \'%s\' as %s;' % \
         (_mojom_types_pkg, _mojom_types_pkg_short),
       "service_describer_import": 'import \'%s\' as %s;' % \
         (_service_describer_pkg, _service_describer_pkg_short),
       "has_handles": has_handles,
     }
 
     # If this is the mojom types package, clear the import-related params.
@@ skipping 101 matching lines @@
         interface_to_import[name] = each_import["unique_name"] + "." + name
     return interface_to_import
 
   def ImportedFrom(self):
     interface_to_import = {}
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces:
         name = each_interface.name
         interface_to_import[name] = each_import["unique_name"] + "."
     return interface_to_import