Implement python mojo bindings unions.

mojo/public/tools/bindings/generators/mojom_python_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 Python source files from a mojom.Module."""
 
 import re
 
 import mojom.generate.constant_resolver as resolver
 import mojom.generate.generator as generator
@@ skipping 128 matching lines @@
 
   if mojom.IsMapKind(kind):
     arguments = [
       GetFieldType(kind.key_kind),
       GetFieldType(kind.value_kind),
     ]
     if mojom.IsNullableKind(kind):
       arguments.append('nullable=True')
     return '_descriptor.MapType(%s)' % ', '.join(arguments)
 
-  if mojom.IsStructKind(kind) or mojom.IsUnionKind(kind):
+  if mojom.IsUnionKind(kind):
     arguments = [ 'lambda: %s' % GetFullyQualifiedName(kind) ]
     if mojom.IsNullableKind(kind):
       arguments.append('nullable=True')
+    return '_descriptor.UnionType(%s)' % ', '.join(arguments)
+
+  if mojom.IsStructKind(kind):
+    arguments = [ 'lambda: %s' % GetFullyQualifiedName(kind) ]
+    if mojom.IsNullableKind(kind):
+      arguments.append('nullable=True')
     return '_descriptor.StructType(%s)' % ', '.join(arguments)
 
   if mojom.IsEnumKind(kind):
     return GetFieldType(mojom.INT32)
 
   if mojom.IsInterfaceKind(kind):
     arguments = [ 'lambda: %s' % GetFullyQualifiedName(kind) ]
     if mojom.IsNullableKind(kind):
       arguments.append('nullable=True')
     return '_descriptor.InterfaceType(%s)' % ', '.join(arguments)
 
   if mojom.IsInterfaceRequestKind(kind):
     arguments = []
     if mojom.IsNullableKind(kind):
       arguments.append('nullable=True')
     return '_descriptor.InterfaceRequestType(%s)' % ', '.join(arguments)
 
   return _kind_to_type[kind]
 
-def GetFieldDescriptor(packed_field):
-  field = packed_field.field
+def GetFieldDescriptor(field, index, min_version):
   class_name = 'SingleFieldGroup'
   if field.kind == mojom.BOOL:
     class_name = 'FieldDescriptor'
   arguments = [ '%r' % GetNameForElement(field) ]
   arguments.append(GetFieldType(field.kind, field))
-  arguments.append(str(packed_field.index))
-  arguments.append(str(packed_field.min_version))
+  arguments.append(str(index))
+  arguments.append(str(min_version))
   if field.default:
     if mojom.IsStructKind(field.kind):
       arguments.append('default_value=True')
     else:
       arguments.append('default_value=%s' % ExpressionToText(field.default))
   return '_descriptor.%s(%s)' % (class_name, ', '.join(arguments))
 
+def GetStructFieldDescriptor(packed_field):
+  return GetFieldDescriptor(
+      packed_field.field, packed_field.index, packed_field.min_version)
+
+def GetUnionFieldDescriptor(field):
+  return GetFieldDescriptor(field, field.ordinal, 0)
+
 def GetFieldGroup(byte):
   if byte.packed_fields[0].field.kind == mojom.BOOL:
-    descriptors = map(GetFieldDescriptor, byte.packed_fields)
+    descriptors = map(GetStructFieldDescriptor, byte.packed_fields)
     return '_descriptor.BooleanGroup([%s])' % ', '.join(descriptors)
   assert len(byte.packed_fields) == 1
-  return GetFieldDescriptor(byte.packed_fields[0])
+  return GetStructFieldDescriptor(byte.packed_fields[0])
 
 def MojomToPythonImport(mojom):
   return mojom.replace('.mojom', '_mojom')
 
 class Generator(generator.Generator):
 
   python_filters = {
     'expression_to_text': ExpressionToText,
     'field_group': GetFieldGroup,
+    'union_field_descriptor': GetUnionFieldDescriptor,
     'fully_qualified_name': GetFullyQualifiedName,
     'name': GetNameForElement,
   }
 
   @UseJinja('python_templates/module.py.tmpl', filters=python_filters)
   def GeneratePythonModule(self):
     return {
       'enums': self.module.enums,
       'imports': self.GetImports(),
       'interfaces': self.GetInterfaces(),
       'module': resolver.ResolveConstants(self.module, ExpressionToText),
       'namespace': self.module.namespace,
       'structs': self.GetStructs(),
+      'unions': self.GetUnions(),
     }
 
   def GenerateFiles(self, args):
     import_path = MojomToPythonImport(self.module.name)
     self.Write(self.GeneratePythonModule(),
                self.MatchMojomFilePath('%s.py' % import_path))
 
   def GetImports(self):
     for each in self.module.imports:
       each['python_module'] = MojomToPythonImport(each['module_name'])
     return self.module.imports
 
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }