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

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

 class {{export_attribute}} {{union.name}} {
  public:
   using DataView = {{union.name}}DataView;
   using Data_ = internal::{{union.name}}_Data;
   using Tag = Data_::{{union.name}}_Tag;
 
-  static {{union.name}}Ptr New();
+  struct TagTypes_ {
+{%- for field in union.fields %}
+    using {{field.name|under_to_camel}} = std::integral_constant<Tag, Tag::{{field.name|upper}}>;
+{%- endfor %}
+  };
+  // Tag values that can be passed to the constructor to specify which field
+  // should set at construction.
+{%- for field in union.fields %}
+  static constexpr TagTypes_::{{field.name|under_to_camel}} {{field.name}} = {};
+{%- endfor %}
+
+  template <typename... Args>
+  static {{union.name}}Ptr New(Args&&... args) {
+    return {{union.name}}Ptr(base::in_place, std::forward<Args>(args)...);
+  }
 
   template <typename U>
   static {{union.name}}Ptr From(const U& u) {
     return mojo::TypeConverter<{{union.name}}Ptr, U>::Convert(u);
   }
 
   template <typename U>
   U To() const {
     return mojo::TypeConverter<U, {{union.name}}>::Convert(*this);
   }
 
   {{union.name}}();
+  explicit {{union.name}}(Tag tag);

[yzshen1, 2017/03/07 17:13:43]

With the current constructors, users would do:
  FooUnion(FooUnion::Tag::BAR);
  FooUnion(FooUnion::bar, bar_value);

It seems unfortunate to have Tag and TagTypes_. We should avoid having two ways
of specifying tags. I would rather we use Tag values consistently, although we
lose some compile-time type safety.

More thoughts on naming for discussion: actually the current field getter
FooUnion::get_bar() is not very consistent with our style guide, we should have
used FooUnion::bar() as the getter name.

WDYT?

+{%  for field in union.fields %}
+
+  // Construct an instance holding |{{field.name}}|.
+  // Pass |{{union.name}}::{{field.name}}| to to match |TagTypes_::{{field.name|under_to_camel}}|.
+{%-   if union|is_distinct_kind(field) %}
+  explicit {{union.name}}({{field.kind|cpp_wrapper_param_type}} in)

[yzshen1, 2017/03/07 17:13:43]

I still think we should avoid this distinct-type-to-identify-field overload.

+      : {{union.name}}({{field.name}}, std::move(in)) {}
+{%-   endif %}
+{%-   if field.kind|is_object_kind  %}
+  {{union.name}}(TagTypes_::{{field.name|under_to_camel}});

[yzshen1, 2017/03/07 17:13:43]

There is already a similar one on line 34. And it is less consistent: a
constructor for object fields but not primitive type fields.

+{%-   endif %}
+  {{union.name}}(TagTypes_::{{field.name|under_to_camel}}, {{field.kind|cpp_wrapper_param_type}} in);
+{%- endfor %}
   ~{{union.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 UnionPtrType = {{union.name}}Ptr>
   {{union.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 21 matching lines @@
     return *(data_.{{field.name}});
 {%-   else %}
     return data_.{{field.name}};
 {%-   endif %}
   }
 
   void set_{{field.name}}({{field.kind|cpp_wrapper_param_type}} {{field.name}});
 {%- endfor %}
 
  private:
-  friend class mojo::internal::UnionAccessor<{{union.name}}>;
   union Union_ {
     Union_() {}
     ~Union_() {}
 
 {%- for field in union.fields %}
 {%-   if field.kind|is_object_kind or
          field.kind|is_any_handle_or_interface_kind %}
     {{field.kind|cpp_wrapper_type}}* {{field.name}};
 {%-   else %}
     {{field.kind|cpp_wrapper_type}} {{field.name}};
 {%-   endif %}
 {%- endfor %}
   };
-  void SwitchActive(Tag new_active);
-  void SetActive(Tag new_active);
   void DestroyActive();
-  Tag tag_;
+  Tag tag_ = static_cast<Tag>(-1);
   Union_ data_;
 };