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

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

 // Copyright 2015 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_VALIDATION_UTIL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_VALIDATION_UTIL_H_
 
 #include <stdint.h>
 
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/serialization_util.h"
 #include "mojo/public/cpp/bindings/lib/validate_params.h"
 #include "mojo/public/cpp/bindings/lib/validation_context.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/bindings/message.h"
 
 namespace mojo {
 namespace internal {
 
 // Checks whether decoding the pointer will overflow and produce a pointer
 // smaller than |offset|.
 bool ValidateEncodedPointer(const uint64_t* offset);
 
+template <typename T>
+bool ValidatePointer(const Pointer<T>& input,
+                     ValidationContext* validation_context) {
+  bool result = ValidateEncodedPointer(&input.offset);
+  if (!result)
+    ReportValidationError(validation_context, VALIDATION_ERROR_ILLEGAL_POINTER);
+
+  return result;
+}
+
 // Validates that |data| contains a valid struct header, in terms of alignment
 // and size (i.e., the |num_bytes| field of the header is sufficient for storing
 // the header itself). Besides, it checks that the memory range
 // [data, data + num_bytes) is not marked as occupied by other objects in
 // |validation_context|. On success, the memory range is marked as occupied.
 // Note: Does not verify |version| or that |num_bytes| is correct for the
 // claimed version.
 bool ValidateStructHeaderAndClaimMemory(const void* data,
                                         ValidationContext* validation_context);
 
@@ skipping 77 matching lines @@
 bool ValidateHandleOrInterfaceNonNullable(
     const Interface_Data& input,
     const char* error_message,
     ValidationContext* validation_context);
 bool ValidateHandleOrInterfaceNonNullable(
     const Handle_Data& input,
     const char* error_message,
     ValidationContext* validation_context);
 
 template <typename T>
-bool ValidateArray(const Pointer<Array_Data<T>>& input,
-                   ValidationContext* validation_context,
-                   const ContainerValidateParams* validate_params) {
-  if (!ValidateEncodedPointer(&input.offset)) {
-    ReportValidationError(validation_context, VALIDATION_ERROR_ILLEGAL_POINTER);
-    return false;
-  }
-
-  return Array_Data<T>::Validate(DecodePointerRaw(&input.offset),
-                                 validation_context, validate_params);
-}
-
-template <typename T>
-bool ValidateMap(const Pointer<T>& input,
-                 ValidationContext* validation_context,
-                 const ContainerValidateParams* validate_params) {
-  if (!ValidateEncodedPointer(&input.offset)) {
-    ReportValidationError(validation_context, VALIDATION_ERROR_ILLEGAL_POINTER);
-    return false;
-  }
-
-  return T::Validate(DecodePointerRaw(&input.offset), validation_context,
-                     validate_params);
+bool ValidateContainer(const Pointer<T>& input,
+                       ValidationContext* validation_context,
+                       const ContainerValidateParams* validate_params) {
+  return ValidatePointer(input, validation_context) &&
+         T::Validate(input.Get(), validation_context, validate_params);
 }
 
 template <typename T>
 bool ValidateStruct(const Pointer<T>& input,
                     ValidationContext* validation_context) {
-  if (!ValidateEncodedPointer(&input.offset)) {
-    ReportValidationError(validation_context, VALIDATION_ERROR_ILLEGAL_POINTER);
-    return false;
-  }
-
-  return T::Validate(DecodePointerRaw(&input.offset), validation_context);
+  return ValidatePointer(input, validation_context) &&
+         T::Validate(input.Get(), validation_context);
 }
 
 template <typename T>
 bool ValidateInlinedUnion(const T& input,
                           ValidationContext* validation_context) {
   return T::Validate(&input, validation_context, true);
 }
 
 template <typename T>
 bool ValidateNonInlinedUnion(const Pointer<T>& input,
                              ValidationContext* validation_context) {
-  if (!ValidateEncodedPointer(&input.offset)) {
-    ReportValidationError(validation_context, VALIDATION_ERROR_ILLEGAL_POINTER);
-    return false;
-  }
-
-  return T::Validate(DecodePointerRaw(&input.offset), validation_context,
-                     false);
+  return ValidatePointer(input, validation_context) &&
+         T::Validate(input.Get(), validation_context, false);
 }
 
 bool ValidateHandleOrInterface(const AssociatedInterface_Data& input,
                                ValidationContext* validation_context);
 bool ValidateHandleOrInterface(const AssociatedInterfaceRequest_Data& input,
                                ValidationContext* validation_context);
 bool ValidateHandleOrInterface(const Interface_Data& input,
                                ValidationContext* validation_context);
 bool ValidateHandleOrInterface(const Handle_Data& input,
                                ValidationContext* validation_context);
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_VALIDATION_UTIL_H_