Implement unions as members of structs.

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

 {%- set class_name = struct.name ~ "_Data" %}
 
 {#- TODO(yzshen): Consider eliminating _validate_object() and
     _validate_handle(). #}
 
 {#- Validates the specified struct field, which is supposed to be an object
     (struct/array/string/map/union).
     This macro is expanded by the Validate() method. #}
 {%- macro _validate_object(struct, packed_field) %}
 {%-   set name = packed_field.field.name %}
 {%-   set kind = packed_field.field.kind %}
 {%-   set wrapper_type = kind|cpp_wrapper_type %}
 {%-   if not kind|is_nullable_kind %}
+{%-     if kind|is_union_kind %}
+  if (object->{{name}}.is_null()) {
+{%-     else %}
   if (!object->{{name}}.offset) {
+{%-     endif %}
     ReportValidationError(
         mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
         "null {{name}} field in {{struct.name}} struct");
     return false;
   }
 {%-   endif %}
+{%-   if not kind|is_union_kind %}
   if (!mojo::internal::ValidateEncodedPointer(&object->{{name}}.offset)) {
     ReportValidationError(mojo::internal::VALIDATION_ERROR_ILLEGAL_POINTER);
     return false;
   }
+{%-   endif %}
 {%-   if kind|is_array_kind or kind|is_string_kind %}
   if (!{{wrapper_type}}::Data_::Validate<
           {{kind|get_array_validate_params|indent(10)}}>(
               mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
               bounds_checker)) {
 {%-   elif kind|is_map_kind %}
   if (!{{wrapper_type}}::Data_::Validate<
           {{kind.value_kind|get_map_validate_params|indent(10)}}>(
               mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
               bounds_checker)) {
 {%-   elif kind|is_struct_kind %}
   if (!{{kind|get_name_for_kind}}::Data_::Validate(
           mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
           bounds_checker)) {
+{%-   elif kind|is_union_kind %}
+  if (!{{kind|get_name_for_kind}}::Data_::Validate(
+          &object->{{name}}, bounds_checker, true)) {
 {%-   else %}
   if (!{{wrapper_type}}::Data_::Validate(
           mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
           bounds_checker)) {
 {%-   endif %}
     return false;
   }
 {%- endmacro %}
 
 {#- Validates the specified struct field, which is supposed to be a handle.
@@ skipping 83 matching lines @@
 {%-   endif %}
 {%- endfor %}
 
   return true;
 }
 
 void {{class_name}}::EncodePointersAndHandles(
     std::vector<mojo::Handle>* handles) {
   MOJO_CHECK(header_.version == {{struct.versions[-1].version}});
 {%- for pf in struct.packed.packed_fields_in_ordinal_order %}
-{%-   if pf.field.kind|is_object_kind %}
+{%-   if pf.field.kind|is_object_kind and not pf.field.kind|is_union_kind %}
   mojo::internal::Encode(&{{pf.field.name}}, handles);
 {%-   elif pf.field.kind|is_any_handle_kind %}
   mojo::internal::EncodeHandle(&{{pf.field.name}}, handles);
 {%-   endif %}
 {%- endfor %}
 }
 
 void {{class_name}}::DecodePointersAndHandles(
     std::vector<mojo::Handle>* handles) {
   // NOTE: The memory backing |this| may has be smaller than |sizeof(*this)|, if
   // the message comes from an older version.
 {#- Before decoding fields introduced at a certain version, we need to add
     a version check, which makes sure we skip further decoding if |this|
     is from an earlier version. |last_checked_version| records the last
     version that we have added such version check. #}
 {%- set last_checked_version = 0 %}
 {%- for pf in struct.packed.packed_fields_in_ordinal_order %}
 {%-   set name = pf.field.name %}
 {%-   set kind = pf.field.kind %}
 {%-   if kind|is_object_kind or kind|is_any_handle_kind %}
 {%-     if pf.min_version > last_checked_version %}
 {%-       set last_checked_version = pf.min_version %}
   if (header_.version < {{pf.min_version}})
     return;
 {%-     endif %}
-{%-     if kind|is_object_kind %}
+{%-     if kind|is_union_kind %}
+  // TODO(azani): Decode handles in union.
+{%-     elif kind|is_object_kind %}
   mojo::internal::Decode(&{{name}}, handles);
 {%-     else %}
   mojo::internal::DecodeHandle(&{{name}}, handles);
 {%-     endif %}
 {%-   endif %}
 {%- endfor %}
 }
 
 {{class_name}}::{{class_name}}() {
   header_.num_bytes = sizeof(*this);
   header_.version = {{struct.versions[-1].version}};
 }