Implement unions as members of structs.

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

 size_t GetSerializedSize_(const {{union.name}}Ptr& input) {
   if (!input)
     return 0;
 
   size_t size = sizeof(internal::{{union.name}}_Data);
   switch (input->which()) {
 {%  for field in union.fields %}
 {%    if field.kind|is_string_kind %}
     case {{union.name}}::Tag::{{field.name|upper}}:
       size += GetSerializedSize_(input->get_{{field.name}}());
       break;
 {%-   endif %}
 {%- endfor %}
     default:
       break;
   }
   return size;
 }
 
 
 void Serialize_({{union.name}}Ptr input, mojo::internal::Buffer* buf,
                 internal::{{union.name}}_Data** output) {
   if (input) {
+    internal::{{union.name}}_Data* result = nullptr;
+    if (*output) {

[yzshen1, 2015/02/17 19:34:35]

Unfortunately, we don't initialize |*output|. (For example, if you look at
struct_definition.tmpl, the constructor doesn't do anything about the fields.)
So it may be a random non-zero value.

That is why we have line 49.


As a comparison, we do initialization for the wrapper class, because that one is
user facing.

[azani, 2015/02/18 00:27:58]

The problem I'm trying to solve is again related to inlining.

If we are serializing a free-standing union, we need to allocate some new memory
for the union. But if the union is inlined, then memory has already been
allocated for it.

The code above works when dealing with inlined unions since |*output| is the
location where the union needs to be inlined. Is your concern that if the union
is free-standing, *output might not be initialized to nullptr?

+      result = *output;
+    } else {
+      result = internal::{{union.name}}_Data::New(buf);
+    }
     mojo::internal::UnionAccessor<{{union.name}}> input_acc(input.get());
-    internal::{{union.name}}_Data* result =
-        internal::{{union.name}}_Data::New(buf);
     // TODO(azani): Handle unknown and objects.
+    // Set the not-null flag.
+    result->flags = 0x1;

[yzshen1, 2015/02/17 19:34:35]

This is the size for the non-inlined case.

     result->tag = input->which();
     switch (input->which()) {
 {%  for field in union.fields %}
       case {{union.name}}::Tag::{{field.name|upper}}:
 {%    if field.kind|is_string_kind %}
         {{field.kind|cpp_field_type}}* {{field.name}}_ptr = reinterpret_cast<{{field.kind|cpp_field_type}}*>(&result->data.f_{{field.name}});
         Serialize_(*(input_acc.data()->{{field.name}}), buf, &{{field.name}}_ptr->ptr);
 {%    else %}
         result->data.f_{{field.name}} = input_acc.data()->{{field.name}};
 {%-   endif %}
@@ skipping 22 matching lines @@
         result->set_{{field.name}}(input->data.f_{{field.name}});
 {%-   endif %}
         break;
 {%- endfor %}
     }
     *output = result.Pass();
   } else {
     output->reset();
   }
 }