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) {
+  size_t size = sizeof(internal::{{union.name}}_Data);
   if (!input)
-    return 0;
+    return size;

[yzshen1, 2015/03/26 07:30:15]

I think this is incorrect.
When a struct calculates its size, it will call its union member's
GetSerializedSize_(). In that case, sizeof(internal::{{union.name}}_Data) is
caculated twice (because it is inlined).

[azani, 2015/03/26 22:27:40]

Removed that function because it was unused and therefore untested.

[yzshen1, 2015/03/27 16:26:33]

It seems the problem is not addressed. You could try out the following:

union Foo { uint32 a; };
struct Bar {
  Foo foo;
};

What is the serialized size of a non-null Bar instance?
It should be 24, right? But it seems your code will return a bigger size.

[yzshen1, 2015/03/27 21:52:42]

This comment is not addressed.

[azani, 2015/03/30 22:21:03]

Sorry, I finally understood what you meant. I've added GetInlinedSerializeSize_
which does not count the 16 bytes to store the size, tag and data. It's
currently only used with structs. (Arrays count both the inline and not-inline
part at the same time.)

[yzshen1, 2015/03/30 22:55:18]

It seems better to follow the same style as SerializeUnion_(), i.e., adding a
bool |inlined| parameter:
GetSerializedSize_(const FooPtr& input, bool inlined);

 
-  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;
 }
 
+size_t GetUnionInUnionSerializedSize_(const {{union.name}}Ptr& input) {

[yzshen1, 2015/03/26 07:30:15]

The names seem confusing.
Maybe we should just follow what we do for SerializeUnion_(), i.e., adding a
|inlined| parameter?

[azani, 2015/03/26 22:27:40]

It was unused, so this was premature anyways.

+  if (!input)
+    return 0;
 
-void Serialize_({{union.name}}Ptr input, mojo::internal::Buffer* buf,
-                internal::{{union.name}}_Data** output) {
+  return GetSerializedSize_(input);
+}
+
+void SerializeUnion_({{union.name}}Ptr input, mojo::internal::Buffer* buf,
+                     internal::{{union.name}}_Data** output, bool inlined) {
+  internal::{{union.name}}_Data* result = nullptr;
+  if (inlined) {
+    result = *output;
+  } else {
+    result = internal::{{union.name}}_Data::New(buf);
+  }
   if (input) {
     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->size = 16;
     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 %}
         break;
 {%- endfor %}
     }
-    *output = result;
-  } else {
-    *output = nullptr;
   }
+  *output = result;
 }
 
 void Deserialize_(internal::{{union.name}}_Data* input,
                   {{union.name}}Ptr* output) {
-  if (input) {
+  if (input && !input->is_null()) {
     {{union.name}}Ptr result({{union.name}}::New());
     mojo::internal::UnionAccessor<{{union.name}}> result_acc(result.get());
     switch (input->tag) {
 {%  for field in union.fields %}
       case {{union.name}}::Tag::{{field.name|upper}}:
 {%    if field.kind|is_string_kind %}
         result_acc.SwitchActive({{union.name}}::Tag::{{field.name|upper}});
         {{field.kind|cpp_field_type}}* {{field.name}}_ptr = reinterpret_cast<{{field.kind|cpp_field_type}}*>(&input->data.f_{{field.name}});
         Deserialize_({{field.name}}_ptr->ptr, result_acc.data()->{{field.name}});
 {%    else %}
         result->set_{{field.name}}(input->data.f_{{field.name}});
 {%-   endif %}
         break;
 {%- endfor %}
     }
     *output = result.Pass();
   } else {
     output->reset();
   }
 }