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

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

 // Copyright 2013 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_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 40 matching lines @@
     return sizeof(ArrayHeader) + sizeof(StorageType) * num_elements;
   }
   static Ref ToRef(StorageType* storage, size_t offset) {
     return storage[offset];
   }
   static ConstRef ToConstRef(const StorageType* storage, size_t offset) {
     return storage[offset];
   }
 };
 
-template <typename P>
-struct ArrayDataTraits<P*> {
-  using StorageType = Pointer<P>;
-  using Ref = P*&;
-  using ConstRef = P* const&;
-
-  static const uint32_t kMaxNumElements =
-      (std::numeric_limits<uint32_t>::max() - sizeof(ArrayHeader)) /
-      sizeof(StorageType);
-
-  static uint32_t GetStorageSize(uint32_t num_elements) {
-    DCHECK(num_elements <= kMaxNumElements);
-    return sizeof(ArrayHeader) + sizeof(StorageType) * num_elements;
-  }
-  static Ref ToRef(StorageType* storage, size_t offset) {
-    return storage[offset].ptr;
-  }
-  static ConstRef ToConstRef(const StorageType* storage, size_t offset) {
-    return storage[offset].ptr;
-  }
-};
-
 // Specialization of Arrays for bools, optimized for space. It has the
 // following differences from a generalized Array:
 // * Each element takes up a single bit of memory.
 // * Accessing a non-const single element uses a helper class |BitRef|, which
 // emulates a reference to a bool.
 template <>
 struct ArrayDataTraits<bool> {
   // Helper class to emulate a reference to a bool, used for direct element
   // access.
   class BitRef {
@@ skipping 41 matching lines @@
 // wrapper type instead of the data type, that way we can use MojomTypeTraits
 // to determine the categories.
 
 template <typename T, bool is_union, bool is_handle_or_interface>
 struct ArraySerializationHelper;
 
 template <typename T>
 struct ArraySerializationHelper<T, false, false> {
   using ElementType = typename ArrayDataTraits<T>::StorageType;
 
-  static void EncodePointers(const ArrayHeader* header,
-                             ElementType* elements) {}
-
-  static void DecodePointers(const ArrayHeader* header,
-                             ElementType* elements) {}
-
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                ValidationContext* validation_context,
                                const ContainerValidateParams* validate_params) {
     DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     if (!validate_params->validate_enum_func)
       return true;
 
     // Enum validation.
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!validate_params->validate_enum_func(elements[i], validation_context))
         return false;
     }
     return true;
   }
 };
 
 template <typename T>
 struct ArraySerializationHelper<T, false, true> {
   using ElementType = typename ArrayDataTraits<T>::StorageType;
 
-  static void EncodePointers(const ArrayHeader* header,
-                             ElementType* elements) {}
-
-  static void DecodePointers(const ArrayHeader* header,
-                             ElementType* elements) {}
-
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                ValidationContext* validation_context,
                                const ContainerValidateParams* validate_params) {
     DCHECK(!validate_params->element_validate_params)
         << "Handle or interface type should not have array validate params";
 
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!validate_params->element_is_nullable &&
           !IsHandleOrInterfaceValid(elements[i])) {
@@ skipping 11 matching lines @@
                 .c_str());
         return false;
       }
       if (!ValidateHandleOrInterface(elements[i], validation_context))
         return false;
     }
     return true;
   }
 };
 
-template <typename P>
-struct ArraySerializationHelper<P*, false, false> {
-  using ElementType = typename ArrayDataTraits<P*>::StorageType;
-
-  static void EncodePointers(const ArrayHeader* header, ElementType* elements) {
-    for (uint32_t i = 0; i < header->num_elements; ++i)
-      Encode(&elements[i]);
-  }
-
-  static void DecodePointers(const ArrayHeader* header, ElementType* elements) {
-    for (uint32_t i = 0; i < header->num_elements; ++i)
-      Decode(&elements[i]);
-  }
+template <typename T>
+struct ArraySerializationHelper<Pointer<T>, false, false> {
+  using ElementType = typename ArrayDataTraits<Pointer<T>>::StorageType;
 
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                ValidationContext* validation_context,
                                const ContainerValidateParams* validate_params) {
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!validate_params->element_is_nullable && !elements[i].offset) {
         ReportValidationError(
             validation_context,
             VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
             MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                       header->num_elements,
                                       i).c_str());
         return false;
       }
-      if (!ValidateCaller<P>::Run(elements[i], validation_context,
+      if (!ValidateCaller<T>::Run(elements[i], validation_context,
                                   validate_params->element_validate_params)) {
         return false;
       }
     }
     return true;
   }
 
  private:
-  template <typename T>
+  template <typename U,
+            bool is_array_or_map = IsSpecializationOf<Array_Data, U>::value ||
+                                   IsSpecializationOf<Map_Data, U>::value>
   struct ValidateCaller {
-    static bool Run(const Pointer<T>& data,
+    static bool Run(const Pointer<U>& data,
                     ValidationContext* validation_context,
                     const ContainerValidateParams* validate_params) {
       DCHECK(!validate_params)
           << "Struct type should not have array validate params";
 
       return ValidateStruct(data, validation_context);
     }
   };
 
-  template <typename Key, typename Value>
-  struct ValidateCaller<Map_Data<Key, Value>> {
-    static bool Run(const Pointer<Map_Data<Key, Value>>& data,
+  template <typename U>
+  struct ValidateCaller<U, true> {
+    static bool Run(const Pointer<U>& data,
                     ValidationContext* validation_context,
                     const ContainerValidateParams* validate_params) {
-      return ValidateMap(data, validation_context, validate_params);
-    }
-  };
-
-  template <typename T>
-  struct ValidateCaller<Array_Data<T>> {
-    static bool Run(const Pointer<Array_Data<T>>& data,
-                    ValidationContext* validation_context,
-                    const ContainerValidateParams* validate_params) {
-      return ValidateArray(data, validation_context, validate_params);
+      return ValidateContainer(data, validation_context, validate_params);
     }
   };
 };
 
 template <typename U>
 struct ArraySerializationHelper<U, true, false> {
   using ElementType = typename ArrayDataTraits<U>::StorageType;
 
-  static void EncodePointers(const ArrayHeader* header, ElementType* elements) {
-    for (uint32_t i = 0; i < header->num_elements; ++i)
-      elements[i].EncodePointers();
-  }
-
-  static void DecodePointers(const ArrayHeader* header, ElementType* elements) {
-    for (uint32_t i = 0; i < header->num_elements; ++i)
-      elements[i].DecodePointers();
-  }
-
   static bool ValidateElements(const ArrayHeader* header,
                                const ElementType* elements,
                                ValidationContext* validation_context,
                                const ContainerValidateParams* validate_params) {
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!validate_params->element_is_nullable && elements[i].is_null()) {
         ReportValidationError(
             validation_context,
             VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
             MakeMessageWithArrayIndex("null in array expecting valid unions",
@@ skipping 95 matching lines @@
   StorageType* storage() {
     return reinterpret_cast<StorageType*>(reinterpret_cast<char*>(this) +
                                           sizeof(*this));
   }
 
   const StorageType* storage() const {
     return reinterpret_cast<const StorageType*>(
         reinterpret_cast<const char*>(this) + sizeof(*this));
   }
 
-  void EncodePointers() { Helper::EncodePointers(&header_, storage()); }
-  void DecodePointers() { Helper::DecodePointers(&header_, storage()); }
-
  private:
   Array_Data(uint32_t num_bytes, uint32_t num_elements) {
     header_.num_bytes = num_bytes;
     header_.num_elements = num_elements;
   }
   ~Array_Data() = delete;
 
   internal::ArrayHeader header_;
 
   // Elements of type internal::ArrayDataTraits<T>::StorageType follow.
 };
 static_assert(sizeof(Array_Data<char>) == 8, "Bad sizeof(Array_Data)");
 
 // UTF-8 encoded
 using String_Data = Array_Data<char>;
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_