Add field-initializing constructors to generated mojo structs.

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 mojom.generate.generator as generator
 import mojom.generate.module as mojom
 import mojom.generate.pack as pack
 from mojom.generate.template_expander import UseJinja
@@ skipping 464 matching lines @@
   for field in struct.fields:
     if IsMoveOnlyKind(field.kind):
       return True
   return False
 
 def ShouldInlineUnion(union):
   return not any(
       mojom.IsReferenceKind(field.kind) and not mojom.IsStringKind(field.kind)
            for field in union.fields)
 
+
+class StructConstructor(object):
+  """Represents a constructor for a generated struct.
+
+  Fields:
+    fields: {[Field]} All struct fields in order.
+    params: {[Field]} The fields that are passed as params.
+  """
+
+  def __init__(self, fields, params):
+    self._fields = fields
+    self._params = set(params)
+
+  @property
+  def params(self):
+    return [field for field in self._fields if field in self._params]
+
+  @property
+  def fields(self):
+    for field in self._fields:
+      yield (field, field in self._params)
+
+
+def GetStructConstructors(struct):
+  """Returns a list of constructors for a struct.
+
+  Params:
+    struct: {Struct} The struct to return constructors for.
+
+  Returns:
+    {[StructConstructor]} A list of StructConstructors that should be generated
+    for |struct|.
+  """
+  if not mojom.IsStructKind(struct):
+    raise TypeError
+  # Types that are neither copyable nor movable can't be passed to a struct
+  # constructor so only generate a default constructor.
+  if any(IsTypemappedKind(field.kind) and _current_typemap[
+      GetFullMojomNameForKind(field.kind)]["non_copyable_non_movable"]
+         for field in struct.fields):
+    return [StructConstructor(struct.fields, [])]
+
+  param_counts = [0]
+  for version in struct.versions:
+    if param_counts[-1] != version.num_fields:
+      param_counts.append(version.num_fields)
+
+  ordinal_fields = sorted(struct.fields, key=lambda field: field.ordinal)
+  return (StructConstructor(struct.fields, ordinal_fields[:param_count])
+          for param_count in param_counts)
+
+
 def GetContainerValidateParamsCtorArgs(kind):
   if mojom.IsStringKind(kind):
     expected_num_elements = 0
     element_is_nullable = False
     key_validate_params = "nullptr"
     element_validate_params = "nullptr"
     enum_validate_func = "nullptr"
   elif mojom.IsMapKind(kind):
     expected_num_elements = 0
     element_is_nullable = False
@@ skipping 70 matching lines @@
     "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,
+    "struct_constructors": GetStructConstructors,
     "stylize_method": generator.StudlyCapsToCamel,
     "under_to_camel": generator.UnderToCamel,
     "unmapped_type_for_serializer": GetUnmappedTypeForSerializer,
   }
 
   def GetExtraTraitsHeaders(self):
     extra_headers = set()
     for typemap in self._GetAllUsedTypemaps():
       extra_headers.update(typemap.get("traits_headers", []))
     return sorted(extra_headers)
@@ skipping 144 matching lines @@
       global _use_once_callback
       _use_once_callback = self.use_once_callback
       global _variant
       _variant = self.variant
       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)))