Mojo C++ bindings: switch union to use the new serialization interface.

mojo/public/cpp/bindings/lib/array_serialization.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
 
 #include <stddef.h>
 #include <string.h>  // For |memcpy()|.
 
@@ skipping 277 matching lines @@
   };
 };
 
 // Handles serialization and deserialization of arrays of unions.
 template <typename MojomType, typename MaybeConstUserType>
 struct ArraySerializer<MojomType,
                        MaybeConstUserType,
                        ArraySerializerType::UNION> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Data = typename MojomType::Data_;
+  using Element = typename MojomType::Element;
   using Traits = ArrayTraits<UserType>;
 
   static_assert(std::is_same<typename MojomType::Element,
                              typename Traits::Element>::value,
                 "Incorrect array serializer");
 
   static size_t GetSerializedSize(MaybeConstUserType& input,
                                   SerializationContext* context) {
     size_t element_count = Traits::GetSize(input);
     size_t size = sizeof(Data);
     for (size_t i = 0; i < element_count; ++i) {
-      // Call GetSerializedSize_ with |inlined| set to false, so that it will
-      // account for both the data in the union and the space in the array used
-      // to hold the union.
-      size += GetSerializedSize_(Traits::GetAt(input, i), false, context);
+      // Call with |inlined| set to false, so that it will account for both the
+      // data in the union and the space in the array used to hold the union.
+      size +=
+          PrepareToSerialize<Element>(Traits::GetAt(input, i), false, context);
     }
     return size;
   }
 
   static void SerializeElements(MaybeConstUserType& input,
                                 Buffer* buf,
                                 Data* output,
                                 const ArrayValidateParams* validate_params,
                                 SerializationContext* context) {
     size_t size = Traits::GetSize(input);
     for (size_t i = 0; i < size; ++i) {
       typename Data::Element* result = output->storage() + i;
-      SerializeUnion_(std::move(Traits::GetAt(input, i)), buf, &result, true,
-                      context);
+      Serialize<Element>(Traits::GetAt(input, i), buf, &result, true, context);
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && output->at(i).is_null(),
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid unions",
                                     size, i));
     }
   }
 
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
     bool success = true;
     Traits::Resize(*output, input->size());
     for (size_t i = 0; i < input->size(); ++i) {
       // Note that we rely on complete deserialization taking place in order to
       // transfer ownership of all encoded handles. Therefore we don't
       // short-circuit on failure here.
-      if (!Deserialize_(&input->at(i), &Traits::GetAt(*output, i), context))
+      if (!Deserialize<Element>(&input->at(i), &Traits::GetAt(*output, i),
+                                context)) {
         success = false;
+      }
     }
     return success;
   }
 };
 
 template <typename Element, typename MaybeConstUserType>
 struct Serializer<Array<Element>, MaybeConstUserType> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Impl = ArraySerializer<Array<Element>, MaybeConstUserType>;
   using Traits = ArrayTraits<UserType>;
@@ skipping 35 matching lines @@
       return Impl::DeserializeElements(input, output, context);
     Traits::SetToNull(*output);
     return true;
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_