Add field-initializing factory static methods to generated mojo unions.

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

 # Copyright 2013 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 C++ source files from a mojom.Module."""
 
+import collections
+
 import mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 from mojom.generate.template_expander import UseJinja
 
 
 _kind_to_cpp_type = {
   mojom.BOOL:                  "bool",
   mojom.INT8:                  "int8_t",
   mojom.UINT8:                 "uint8_t",
@@ skipping 155 matching lines @@
 
 def IsTypemappedKind(kind):
   return hasattr(kind, "name") and \
       GetFullMojomNameForKind(kind) in _current_typemap
 
 def IsNativeOnlyKind(kind):
   return (mojom.IsStructKind(kind) or mojom.IsEnumKind(kind)) and \
       kind.native_only
 
 
+def IsDistinctUnionKind(union, field):
+  """Returns whether a field in a union has a distinct type from other fields.
+
+  The fields of a union for which this returns True may form an overload set
+  without ambiguity. Due to the way integral and floating point type promotion
+  works, integral and floating point types are considered not distinct.
+  """
+  if (mojom.IsIntegralKind(field.kind) or mojom.IsFloatKind(field.kind) or
+      mojom.IsDoubleKind(field.kind)):
+    return False
+
+  if not hasattr(union, 'field_types'):
+    union.field_types = collections.defaultdict(lambda: -1)
+    for union_field in union.fields:
+      union.field_types[GetCppWrapperParamType(union_field.kind)] += 1
+  return not union.field_types[
+      GetCppWrapperParamType(field.kind)]
+
 def IsHashableKind(kind):
   """Check if the kind can be hashed.
 
   Args:
     kind: {Kind} The kind to check.
 
   Returns:
     {bool} True if a value of this kind can be hashed.
   """
   checked = set()
@@ skipping 439 matching lines @@
     "should_inline": ShouldInlineStruct,
     "should_inline_union": ShouldInlineUnion,
     "is_array_kind": mojom.IsArrayKind,
     "is_enum_kind": mojom.IsEnumKind,
     "is_integral_kind": mojom.IsIntegralKind,
     "is_native_only_kind": IsNativeOnlyKind,
     "is_any_handle_kind": mojom.IsAnyHandleKind,
     "is_any_interface_kind": mojom.IsAnyInterfaceKind,
     "is_any_handle_or_interface_kind": mojom.IsAnyHandleOrInterfaceKind,
     "is_associated_kind": mojom.IsAssociatedKind,
+    "is_distinct_kind": IsDistinctUnionKind,
     "is_hashable": IsHashableKind,
     "is_map_kind": mojom.IsMapKind,
     "is_nullable_kind": mojom.IsNullableKind,
     "is_object_kind": mojom.IsObjectKind,
     "is_reference_kind": mojom.IsReferenceKind,
     "is_string_kind": mojom.IsStringKind,
     "is_struct_kind": mojom.IsStructKind,
     "is_typemapped_kind": IsTypemappedKind,
     "is_union_kind": mojom.IsUnionKind,
     "passes_associated_kinds": mojom.PassesAssociatedKinds,
@@ skipping 158 matching lines @@
       global _variant
       _variant = self.variant
       global _export_attribute
       _export_attribute = self.export_attribute
       suffix = "-%s" % self.variant if self.variant else ""
       self.Write(self.GenerateModuleHeader(),
                  self.MatchMojomFilePath("%s%s.h" % (self.module.name, suffix)))
       self.Write(
           self.GenerateModuleSource(),
           self.MatchMojomFilePath("%s%s.cc" % (self.module.name, suffix)))