Implement unions as members of structs.

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

Index: mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl
index 8b82f7f404206e492e905bf85c96a6f486628fb8..23712a0ddb9bee6de96bad2ef364f6c21eeea2d4 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl
@@ -1,8 +1,8 @@
 size_t GetSerializedSize_(const {{union.name}}Ptr& input) {
+  size_t size = sizeof(internal::{{union.name}}_Data);
   if (!input)
-    return 0;
+    return size;

[yzshen1, 2015/02/25 21:07:00]

For non-inlined union, this is incorrect. :/

[azani, 2015/03/03 00:44:16]

This only applies if we have a pointer to a union which should only be the case
when it's a union within a union. I've added a new function to deal with that
situation.

 
-  size_t size = sizeof(internal::{{union.name}}_Data);
   switch (input->which()) {
 {%  for field in union.fields %}
 {%    if field.kind|is_string_kind %}
@@ -20,11 +20,17 @@ size_t GetSerializedSize_(const {{union.name}}Ptr& input) {
 
 void Serialize_({{union.name}}Ptr input, mojo::internal::Buffer* buf,
                 internal::{{union.name}}_Data** output) {
+  internal::{{union.name}}_Data* result = nullptr;
+  if (*output) {

[yzshen1, 2015/02/25 21:07:00]

Please consider the change that we discussed offline.

[azani, 2015/03/03 00:44:16]

Done.

+    result = *output;
+  } else {
+    result = internal::{{union.name}}_Data::New(buf);
+  }
   if (input) {

[yzshen1, 2015/02/25 21:07:00]

if input is null, we need to either set |output| to nullptr (non-inlined) or set
the contents to all-zero (inlined).

[azani, 2015/03/03 00:44:16]

It's not an inlined vs not inlined issue. It's "pointed to by a pointer" vs not.
Since this only applies to unions with union members, I would rather tackle that
when I add support for unions being members of unions.

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

I am not sure I understand your comment.

Let's say we have the following definition:
union Foo {};
struct Bar {
  Foo foo;
};

So the Serialize_() of Bar will call into SerializeUnion_() of Foo, passing a
FooPtr as input.

Because Foo_Data is part of the memory of Bar_Data (i.e., inlined), if the given
FooPtr is null, what we should do is to set the Foo_Data range of memory to
all-zero, right?

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

Done.

     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 %}
@@ -38,15 +44,13 @@ void Serialize_({{union.name}}Ptr input, mojo::internal::Buffer* buf,
         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) {