Dart: Encode/Decode handle and interface types.

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 re
 
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
@@ skipping 33 matching lines @@
 _kind_to_dart_decl_type = {
   mojom.BOOL:                  "bool",
   mojom.INT8:                  "int",
   mojom.UINT8:                 "int",
   mojom.INT16:                 "int",
   mojom.UINT16:                "int",
   mojom.INT32:                 "int",
   mojom.UINT32:                "int",
   mojom.FLOAT:                 "double",
   mojom.HANDLE:                "core.MojoHandle",
-  mojom.DCPIPE:                "core.MojoHandle",
-  mojom.DPPIPE:                "core.MojoHandle",
-  mojom.MSGPIPE:               "core.MojoHandle",
-  mojom.SHAREDBUFFER:          "core.MojoHandle",
+  mojom.DCPIPE:                "core.MojoDataPipeConsumer",
+  mojom.DPPIPE:                "core.MojoDataPipeProducer",
+  mojom.MSGPIPE:               "core.MojoMessagePipeEndpoint",
+  mojom.SHAREDBUFFER:          "core.MojoSharedBuffer",
   mojom.NULLABLE_HANDLE:       "core.MojoHandle",
-  mojom.NULLABLE_DCPIPE:       "core.MojoHandle",
-  mojom.NULLABLE_DPPIPE:       "core.MojoHandle",
-  mojom.NULLABLE_MSGPIPE:      "core.MojoHandle",
-  mojom.NULLABLE_SHAREDBUFFER: "core.MojoHandle",
+  mojom.NULLABLE_DCPIPE:       "core.MojoDataPipeConsumer",
+  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"
 }
 
 _spec_to_decode_method = {
   mojom.BOOL.spec:                  'decodeBool',
   mojom.DCPIPE.spec:                'decodeHandle',
   mojom.DOUBLE.spec:                'decodeDouble',
   mojom.DPPIPE.spec:                'decodeHandle',
   mojom.FLOAT.spec:                 'decodeFloat',
   mojom.HANDLE.spec:                'decodeHandle',
   mojom.INT16.spec:                 'decodeInt16',
   mojom.INT32.spec:                 'decodeInt32',
   mojom.INT64.spec:                 'decodeInt64',
   mojom.INT8.spec:                  'decodeInt8',
-  mojom.MSGPIPE.spec:               'decodeHandle',
-  mojom.NULLABLE_DCPIPE.spec:       'decodeHandle',
-  mojom.NULLABLE_DPPIPE.spec:       'decodeHandle',
+  mojom.MSGPIPE.spec:               'decodeMessagePipeHandle',
+  mojom.NULLABLE_DCPIPE.spec:       'decodeConsumerHandle',
+  mojom.NULLABLE_DPPIPE.spec:       'decodeProducerHandle',
   mojom.NULLABLE_HANDLE.spec:       'decodeHandle',
-  mojom.NULLABLE_MSGPIPE.spec:      'decodeHandle',
-  mojom.NULLABLE_SHAREDBUFFER.spec: 'decodeHandle',
+  mojom.NULLABLE_MSGPIPE.spec:      'decodeMessagePipeHandle',
+  mojom.NULLABLE_SHAREDBUFFER.spec: 'decodeSharedBufferHandle',
   mojom.NULLABLE_STRING.spec:       'decodeString',
-  mojom.SHAREDBUFFER.spec:          'decodeHandle',
+  mojom.SHAREDBUFFER.spec:          'decodeSharedBufferHandle',
   mojom.STRING.spec:                'decodeString',
   mojom.UINT16.spec:                'decodeUint16',
   mojom.UINT32.spec:                'decodeUint32',
   mojom.UINT64.spec:                'decodeUint64',
   mojom.UINT8.spec:                 'decodeUint8',
 }
 
 _spec_to_encode_method = {
   mojom.BOOL.spec:                  'encodeBool',
   mojom.DCPIPE.spec:                'encodeHandle',
   mojom.DOUBLE.spec:                'encodeDouble',
   mojom.DPPIPE.spec:                'encodeHandle',
   mojom.FLOAT.spec:                 'encodeFloat',
   mojom.HANDLE.spec:                'encodeHandle',
   mojom.INT16.spec:                 'encodeInt16',
   mojom.INT32.spec:                 'encodeInt32',
   mojom.INT64.spec:                 'encodeInt64',
   mojom.INT8.spec:                  'encodeInt8',
-  mojom.MSGPIPE.spec:               'encodeHandle',
-  mojom.NULLABLE_DCPIPE.spec:       'encodeHandle',
-  mojom.NULLABLE_DPPIPE.spec:       'encodeHandle',
+  mojom.MSGPIPE.spec:               'encodeMessagePipeHandle',
+  mojom.NULLABLE_DCPIPE.spec:       'encodeConsumerHandle',
+  mojom.NULLABLE_DPPIPE.spec:       'encodeProducerHandle',
   mojom.NULLABLE_HANDLE.spec:       'encodeHandle',
-  mojom.NULLABLE_MSGPIPE.spec:      'encodeHandle',
-  mojom.NULLABLE_SHAREDBUFFER.spec: 'encodeHandle',
+  mojom.NULLABLE_MSGPIPE.spec:      'encodeMessagePipeHandle',
+  mojom.NULLABLE_SHAREDBUFFER.spec: 'encodeSharedBufferHandle',
   mojom.NULLABLE_STRING.spec:       'encodeString',
-  mojom.SHAREDBUFFER.spec:          'encodeHandle',
+  mojom.SHAREDBUFFER.spec:          'encodeSharedBufferHandle',
   mojom.STRING.spec:                'encodeString',
   mojom.UINT16.spec:                'encodeUint16',
   mojom.UINT32.spec:                'encodeUint32',
   mojom.UINT64.spec:                'encodeUint64',
   mojom.UINT8.spec:                 'encodeUint8',
 }
 
 def GetDartType(kind):
   if kind.imported_from:
     return kind.imported_from["unique_name"] + "." + kind.name
   return kind.name
 
 def DartDefaultValue(field):
   if field.default:
     if mojom.IsStructKind(field.kind):
       assert field.default == "default"
       return "new %s()" % GetDartType(field.kind)
     return ExpressionToText(field.default)
   if field.kind in mojom.PRIMITIVES:
     return _kind_to_dart_default_value[field.kind]
   if mojom.IsStructKind(field.kind):
     return "null"
   if mojom.IsArrayKind(field.kind):
     return "null"
   if mojom.IsMapKind(field.kind):
     return "null"
   if mojom.IsInterfaceKind(field.kind) or \
      mojom.IsInterfaceRequestKind(field.kind):
-    return _kind_to_dart_default_value[mojom.MSGPIPE]
+    return "null"
   if mojom.IsEnumKind(field.kind):
     return "0"
 
 def DartDeclType(kind):
   if kind in mojom.PRIMITIVES:
     return _kind_to_dart_decl_type[kind]
   if mojom.IsStructKind(kind):
     return GetDartType(kind)
   if mojom.IsArrayKind(kind):
     array_type = DartDeclType(kind.kind)
     return "List<" + array_type + ">"
   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 _kind_to_dart_decl_type[mojom.MSGPIPE]
+    return "Object"
   if mojom.IsEnumKind(kind):
     return "int"
 
 def NameToComponent(name):
   # insert '_' between anything and a Title name (e.g, HTTPEntry2FooBar ->
   # HTTP_Entry2_FooBar)
   name = re.sub('([^_])([A-Z][^A-Z_]+)', 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)
@@ skipping 63 matching lines @@
     flags_to_set = []
     if mojom.IsNullableKind(kind):
         flags_to_set.append(ARRAY_NULLABLE)
     if mojom.IsNullableKind(kind.kind):
         flags_to_set.append(ELEMENT_NULLABLE)
 
     if not flags_to_set:
         flags_to_set = [NOTHING_NULLABLE]
     return ' | '.join(flags_to_set)
 
-def AppendEncodeDecodeParams(initial_params, kind, bit):
+def AppendDecodeParams(initial_params, kind, bit):
+  """ Appends standard parameters for decode calls. """
+  params = list(initial_params)
+  if (kind == mojom.BOOL):
+    params.append(str(bit))
+  if mojom.IsReferenceKind(kind):
+    if mojom.IsArrayKind(kind):
+      params.append(GetArrayNullabilityFlags(kind))
+    else:
+      params.append(GetDartTrueFalse(mojom.IsNullableKind(kind)))
+  if mojom.IsInterfaceKind(kind):
+    params.append('%sClient.newFromEndpoint' % GetDartType(kind))
+  if mojom.IsArrayKind(kind) and mojom.IsInterfaceKind(kind.kind):
+    params.append('%sClient.newFromEndpoint' % GetDartType(kind.kind))
+  if mojom.IsInterfaceRequestKind(kind):
+    params.append('%sInterface.newFromEndpoint' % GetDartType(kind.kind))
+  if mojom.IsArrayKind(kind) and mojom.IsInterfaceRequestKind(kind.kind):
+    params.append('%sInterface.newFromEndpoint' % GetDartType(kind.kind.kind))
+  if mojom.IsArrayKind(kind):
+    params.append(GetArrayExpectedLength(kind))
+  return params
+
+def AppendEncodeParams(initial_params, kind, bit):
   """ Appends standard parameters shared between encode and decode calls. """
   params = list(initial_params)
   if (kind == mojom.BOOL):
     params.append(str(bit))
   if mojom.IsReferenceKind(kind):
     if mojom.IsArrayKind(kind):
       params.append(GetArrayNullabilityFlags(kind))
     else:
       params.append(GetDartTrueFalse(mojom.IsNullableKind(kind)))
   if mojom.IsArrayKind(kind):
     params.append(GetArrayExpectedLength(kind))
   return params
 
 def DecodeMethod(kind, offset, bit):
   def _DecodeMethodName(kind):
     if mojom.IsArrayKind(kind):
       return _DecodeMethodName(kind.kind) + 'Array'
     if mojom.IsEnumKind(kind):
       return _DecodeMethodName(mojom.INT32)
     if mojom.IsInterfaceRequestKind(kind):
-      return 'decodeHandle'
+      return 'decodeInterfaceRequest'
     if mojom.IsInterfaceKind(kind):
-      return 'decodeHandle'
+      return 'decodeServiceInterface'
     return _spec_to_decode_method[kind.spec]
   methodName = _DecodeMethodName(kind)
-  params = AppendEncodeDecodeParams([ str(offset) ], kind, bit)
+  params = AppendDecodeParams([ str(offset) ], kind, bit)
   return '%s(%s)' % (methodName, ', '.join(params))
 
 def EncodeMethod(kind, variable, offset, bit):
   def _EncodeMethodName(kind):
     if mojom.IsStructKind(kind):
       return 'encodeStruct'
     if mojom.IsArrayKind(kind):
       return _EncodeMethodName(kind.kind) + 'Array'
     if mojom.IsEnumKind(kind):
       return _EncodeMethodName(mojom.INT32)
     if mojom.IsInterfaceRequestKind(kind):
-      return 'encodeHandle'
+      return 'encodeInterfaceRequest'
     if mojom.IsInterfaceKind(kind):
-      return 'encodeHandle'
+      return 'encodeInterface'
     return _spec_to_encode_method[kind.spec]
   methodName = _EncodeMethodName(kind)
-  params = AppendEncodeDecodeParams([ variable, str(offset) ], kind, bit)
+  params = AppendEncodeParams([ variable, str(offset) ], kind, bit)
   return '%s(%s)' % (methodName, ', '.join(params))
 
 def TranslateConstants(token):
   if isinstance(token, (mojom.EnumValue, mojom.NamedValue)):
     # Both variable and enum constants are constructed like:
     # NamespaceUid.Struct.Enum_CONSTANT_NAME
     name = ""
     if token.imported_from:
       name = token.imported_from["unique_name"] + "."
     if token.parent_kind:
@@ skipping 111 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