Add field-initializing constructors to generated mojo structs.

mojo/public/tools/bindings/generators/cpp_templates/wrapper_class_declaration.tmpl

 class {{export_attribute}} {{struct.name}} {
  public:
   using DataView = {{struct.name}}DataView;
   using Data_ = internal::{{struct.name}}_Data;
 
 {#--- Enums #}
 {%- for enum in struct.enums -%}
   using {{enum.name}} = {{enum|get_name_for_kind(flatten_nested_kind=True)}};
 {%- endfor %}
 
 {#--- Constants #}
 {%- for constant in struct.constants %}
   static {{constant|format_constant_declaration(nested=True)}};
 {%- endfor %}
 
-  static {{struct.name}}Ptr New();
+  template <typename... Args>
+  static {{struct.name}}Ptr New(Args&&... args) {
+    {{struct.name}}Ptr rv;
+    mojo::internal::StructHelper<{{struct.name}}>::Initialize(
+        &rv, std::forward<Args>(args)...);
+    return rv;
+  }
 
   template <typename U>
   static {{struct.name}}Ptr From(const U& u) {
     return mojo::TypeConverter<{{struct.name}}Ptr, U>::Convert(u);
   }
 
   template <typename U>
   U To() const {
     return mojo::TypeConverter<U, {{struct.name}}>::Convert(*this);
   }
 
-  {{struct.name}}();
+{% for num_params in range(struct|num_constructor_params) %}

[yzshen1, 2017/02/13 17:45:53]

I feel that it may be sufficient to have the default constructor (no params) and
an all-params constructor. WDYT?

[Sam McNally, 2017/02/14 02:32:24]

I prefer keeping the flexibility. With only those two, adding new fields could
require updating many users.

[yzshen1, 2017/02/14 17:21:52]

I see. That makes sense.

Have you considered the alternative of using default value?
  Foo(int a = 0, bool b = false);
Is there any difference between these two approaches in terms of generated code
size?

[Sam McNally, 2017/02/15 06:35:49]

I tried that approach; it causes the caller to construct field values outside
the constructor and move them in. It increased the binary size of chrome in
Linux by 48k while the current approach added only 4k (I'm guessing the linker
is discarding the unused constructors).

[yzshen1, 2017/02/15 17:25:42]

Thanks for getting these numbers! It is understandable that the current approach
has smaller binary size footprint when only one overload is used. However, when
people use multiple overloads, the size could go up.

I thought about it some more and wonder whether it makes sense to be
conservative (i.e., only no-param/all-params constructors) until we see a need
to support all variants. In some cases, forcing people to revisit the
initialization is not a bad thing. Imagine users insert a field in the middle of
a mojom struct. If the types are compatible, existing code of initialization
could still pass compilation but has got totally different meaning.

How about adding a constructor variant for each version? It makes sense to me
because each version is supposed to be "semantically complete"; and new versions
must only append fields.

WDYT? Thanks!

[Sam McNally, 2017/02/20 09:08:58]

Done.

+  {%   if num_params == 1 %}explicit {% endif %}{{struct.name}}(

[yzshen1, 2017/02/13 17:45:53]

style nit: usually for the in-line case we only have one space following "{%":
  {% if num_params == 1 %}explicit...

[Sam McNally, 2017/02/14 02:32:24]

Done.

+{%-   set fields = struct.fields[:num_params] %}
+{%-   for field in fields %}
+{%-     set type = field.kind|cpp_wrapper_param_type %}
+{%-     set name = field.name %}
+      {{type}} {{name}}
+{%-     if not loop.last -%},{%- endif %}
+{%-   endfor %});
+{% endfor %}
   ~{{struct.name}}();
 
   // Clone() is a template so it is only instantiated if it is used. Thus, the
   // bindings generator does not need to know whether Clone() or copy
   // constructor/assignment are available for members.
   template <typename StructPtrType = {{struct.name}}Ptr>
   {{struct.name}}Ptr Clone() const;
 
   // Equals() is a template so it is only instantiated if it is used. Thus, the
   // bindings generator does not need to know whether Equals() or == operator
@@ skipping 30 matching lines @@
 {%-   set name = field.name %}
   {{type}} {{name}};
 {%- endfor %}
 
 {%- if struct|contains_move_only_members %}
  private:
   DISALLOW_COPY_AND_ASSIGN({{struct.name}});
 {%- endif %}
 };