#include <vector>
+#include "mojo/public/c/system/macros.h"
#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/string_serialization.h"
+#include "mojo/public/cpp/bindings/lib/template_util.h"
+#include "mojo/public/cpp/bindings/lib/validation_errors.h"
namespace mojo {
template <typename E>
inline size_t GetSerializedSize_(const Array<E>& input);
-template <typename E, typename F>
-inline void Serialize_(Array<E> input, internal::Buffer* buf,
- internal::Array_Data<F>** output);
+// Because ValidateParams requires explicit argument specification, the
+// argument-dependent loopup technique used to omit namespace when calling
+// Serialize_() doesn't seem to work. Therefore, this function is named
+// differently from those Serialize_() overloads.
+template <typename ValidateParams, typename E, typename F>
+inline void SerializeArray_(Array<E> input, internal::Buffer* buf,
+ internal::Array_Data<F>** output);
+
template <typename E, typename F>
inline void Deserialize_(internal::Array_Data<F>* data, Array<E>* output);
static size_t GetSerializedSize(const Array<E>& input) {
return sizeof(Array_Data<F>) + Align(input.size() * sizeof(E));
}
+ template <bool element_is_nullable, typename ElementValidateParams>
static void SerializeElements(
Array<E> input, Buffer* buf, Array_Data<F>* output) {
+ MOJO_COMPILE_ASSERT(!element_is_nullable,
+ Primitive_type_should_be_non_nullable);
+ MOJO_COMPILE_ASSERT(
+ (IsSame<ElementValidateParams, NoValidateParams>::value),
+ Primitive_type_should_not_have_array_validate_params);
+
memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
}
static void DeserializeElements(
static size_t GetSerializedSize(const Array<bool>& input) {
return sizeof(Array_Data<bool>) + Align((input.size() + 7) / 8);
}
+ template <bool element_is_nullable, typename ElementValidateParams>
static void SerializeElements(
Array<bool> input, Buffer* buf, Array_Data<bool>* output) {
+ MOJO_COMPILE_ASSERT(!element_is_nullable,
+ Primitive_type_should_be_non_nullable);
+ MOJO_COMPILE_ASSERT(
+ (IsSame<ElementValidateParams, NoValidateParams>::value),
+ Primitive_type_should_not_have_array_validate_params);
+
// TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
for (size_t i = 0; i < input.size(); ++i)
output->at(i) = input[i];
static size_t GetSerializedSize(const Array<ScopedHandleBase<H> >& input) {
return sizeof(Array_Data<H>) + Align(input.size() * sizeof(H));
}
- static void SerializeElements(
- Array<ScopedHandleBase<H> > input,
- Buffer* buf,
- Array_Data<H>* output) {
- for (size_t i = 0; i < input.size(); ++i)
+ template <bool element_is_nullable, typename ElementValidateParams>
+ static void SerializeElements(Array<ScopedHandleBase<H> > input,
+ Buffer* buf,
+ Array_Data<H>* output) {
+ MOJO_COMPILE_ASSERT(
+ (IsSame<ElementValidateParams, NoValidateParams>::value),
+ Handle_type_should_not_have_array_validate_params);
+
+ for (size_t i = 0; i < input.size(); ++i) {
output->at(i) = input[i].release(); // Transfer ownership of the handle.
+ MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
+ !element_is_nullable && !output->at(i).is_valid(),
+ VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+ MakeMessageWithArrayIndex(
+ "invalid handle in array expecting valid handles",
+ input.size(), i));
+ }
}
static void DeserializeElements(
Array_Data<H>* input, Array<ScopedHandleBase<H> >* output) {
size += GetSerializedSize_(input[i]);
return size;
}
- static void SerializeElements(
- Array<S> input,
- Buffer* buf,
- Array_Data<typename S::Data_*>* output) {
+ template <bool element_is_nullable, typename ElementValidateParams>
+ static void SerializeElements(Array<S> input,
+ Buffer* buf,
+ Array_Data<typename S::Data_*>* output) {
for (size_t i = 0; i < input.size(); ++i) {
typename S::Data_* element;
- Serialize_(input[i].Pass(), buf, &element);
+ SerializeCaller<S, ElementValidateParams>::Run(
+ input[i].Pass(), buf, &element);
output->at(i) = element;
+ MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
+ !element_is_nullable && !element,
+ VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+ MakeMessageWithArrayIndex(
+ "null in array expecting valid pointers", input.size(), i));
}
}
static void DeserializeElements(
}
output->Swap(&result);
}
+
+ private:
+ template <typename T, typename Params>
+ struct SerializeCaller {
+ static void Run(T input, Buffer* buf, typename T::Data_** output) {
+ MOJO_COMPILE_ASSERT((IsSame<Params, NoValidateParams>::value),
+ Struct_type_should_not_have_array_validate_params);
+
+ Serialize_(input.Pass(), buf, output);
+ }
+ };
+
+ template <typename T, typename Params>
+ struct SerializeCaller<Array<T>, Params> {
+ static void Run(Array<T> input,
+ Buffer* buf,
+ typename Array<T>::Data_** output) {
+ SerializeArray_<Params>(input.Pass(), buf, output);
+ }
+ };
};
template <> struct ArraySerializer<String, String_Data*, false> {
size += GetSerializedSize_(input[i]);
return size;
}
+ template <bool element_is_nullable, typename ElementValidateParams>
static void SerializeElements(
Array<String> input,
Buffer* buf,
Array_Data<String_Data*>* output) {
+ MOJO_COMPILE_ASSERT(
+ (IsSame<ElementValidateParams,
+ ArrayValidateParams<0, false, NoValidateParams> >::value),
+ String_type_has_unexpected_array_validate_params);
+
for (size_t i = 0; i < input.size(); ++i) {
String_Data* element;
Serialize_(input[i], buf, &element);
output->at(i) = element;
+ MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
+ !element_is_nullable && !element,
+ VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+ MakeMessageWithArrayIndex(
+ "null in array expecting valid strings", input.size(), i));
}
}
static void DeserializeElements(
return internal::ArraySerializer<E, F>::GetSerializedSize(input);
}
-template <typename E, typename F>
-inline void Serialize_(Array<E> input, internal::Buffer* buf,
- internal::Array_Data<F>** output) {
+template <typename ValidateParams, typename E, typename F>
+inline void SerializeArray_(Array<E> input, internal::Buffer* buf,
+ internal::Array_Data<F>** output) {
if (input) {
+ MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
+ ValidateParams::expected_num_elements != 0 &&
+ input.size() != ValidateParams::expected_num_elements,
+ internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
+ internal::MakeMessageWithExpectedArraySize(
+ "fixed-size array has wrong number of elements",
+ input.size(), ValidateParams::expected_num_elements));
+
internal::Array_Data<F>* result =
internal::Array_Data<F>::New(input.size(), buf);
- internal::ArraySerializer<E, F>::SerializeElements(
- internal::Forward(input), buf, result);
+ if (result) {
+ internal::ArraySerializer<E, F>::template SerializeElements<
+ ValidateParams::element_is_nullable,
+ typename ValidateParams::ElementValidateParams>(
+ internal::Forward(input), buf, result);
+ }
*output = result;
} else {
*output = NULL;
}
template <typename E, typename F>
-inline void Deserialize_(internal::Array_Data<F>* input,
- Array<E>* output) {
+inline void Deserialize_(internal::Array_Data<F>* input, Array<E>* output) {
if (input) {
internal::ArraySerializer<E, F>::DeserializeElements(input, output);
} else {
projects / platform / framework / web / crosswalk.git / blobdiff