Mojo C++ bindings: Merge EncodePointers/DecodePointers into Serialize/Deserialize, respectively.

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 335 matching lines @@
 struct ArraySerializer<MojomType,
                        MaybeConstUserType,
                        UserTypeIterator,
                        typename std::enable_if<BelongsTo<
                            typename MojomType::Element,
                            MojomTypeCategory::ARRAY | MojomTypeCategory::MAP |
                                MojomTypeCategory::STRING |
                                MojomTypeCategory::STRUCT>::value>::type> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Data = typename MojomTypeTraits<MojomType>::Data;
-  using DataElement = typename Data::Element;
   using Element = typename MojomType::Element;
+  using DataElementPtr = typename MojomTypeTraits<Element>::Data*;
   using Traits = ArrayTraits<UserType>;
 
   static size_t GetSerializedSize(UserTypeIterator* input,
                                   SerializationContext* context) {
     size_t element_count = input->GetSize();
-    size_t size =
-        sizeof(Data) +
-        element_count *
-            sizeof(Pointer<typename std::remove_pointer<DataElement>::type>);
+    size_t size = sizeof(Data) + element_count * sizeof(typename Data::Element);
     for (size_t i = 0; i < element_count; ++i)
       size += PrepareToSerialize<Element>(input->GetNext(), context);
     return size;
   }
 
   static void SerializeElements(UserTypeIterator* input,
                                 Buffer* buf,
                                 Data* output,
                                 const ContainerValidateParams* validate_params,
                                 SerializationContext* context) {
     size_t size = input->GetSize();
     for (size_t i = 0; i < size; ++i) {
-      DataElement element;
-      SerializeCaller<Element>::Run(input->GetNext(), buf, &element,
+      DataElementPtr data_ptr;
+      SerializeCaller<Element>::Run(input->GetNext(), buf, &data_ptr,
                                     validate_params->element_validate_params,
                                     context);
-      output->at(i) = element;
+      output->at(i).Set(data_ptr);
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
-          !validate_params->element_is_nullable && !element,
+          !validate_params->element_is_nullable && !data_ptr,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                     size, i));
     }
   }
   static bool DeserializeElements(Data* input,
                                   UserType* output,
                                   SerializationContext* context) {
-    bool success = true;
     if (!Traits::Resize(*output, input->size()))
       return false;
     ArrayIterator<Traits, UserType> iterator(*output);
     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<Element>(input->at(i), &iterator.GetNext(), context)) {
-        success = false;
-      }
+      if (!Deserialize<Element>(input->at(i).Get(), &iterator.GetNext(),
+                                context))
+        return false;
     }
-    return success;
+    return true;
   }
 
  private:
   template <typename T,
             bool is_array_or_map = BelongsTo<T,
                                              MojomTypeCategory::ARRAY |
                                                  MojomTypeCategory::MAP>::value>
   struct SerializeCaller {
     template <typename InputElementType>
     static void Run(InputElementType&& input,
                     Buffer* buf,
-                    DataElement* output,
+                    DataElementPtr* output,
                     const ContainerValidateParams* validate_params,
                     SerializationContext* context) {
       Serialize<T>(std::forward<InputElementType>(input), buf, output, context);
     }
   };
 
   template <typename T>
   struct SerializeCaller<T, true> {
     template <typename InputElementType>
     static void Run(InputElementType&& input,
                     Buffer* buf,
-                    DataElement* output,
+                    DataElementPtr* output,
                     const ContainerValidateParams* validate_params,
                     SerializationContext* context) {
       Serialize<T>(std::forward<InputElementType>(input), buf, output,
                    validate_params, context);
     }
   };
 };
 
 // Handles serialization and deserialization of arrays of unions.
 template <typename MojomType,
@@ skipping 39 matching lines @@
           !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;
     if (!Traits::Resize(*output, input->size()))
       return false;
     ArrayIterator<Traits, UserType> iterator(*output);
     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<Element>(&input->at(i), &iterator.GetNext(), context)) {
-        success = false;
-      }
+      if (!Deserialize<Element>(&input->at(i), &iterator.GetNext(), context))
+        return false;
     }
-    return success;
+    return true;
   }
 };
 
 template <typename Element, typename MaybeConstUserType>
 struct Serializer<Array<Element>, MaybeConstUserType> {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Traits = ArrayTraits<UserType>;
   using Impl = ArraySerializer<Array<Element>,
                                MaybeConstUserType,
                                ArrayIterator<Traits, MaybeConstUserType>>;
@@ skipping 38 matching lines @@
     if (!input)
       return CallSetToNullIfExists<Traits>(output);
     return Impl::DeserializeElements(input, output, context);
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_