Move third_party/mojo/src/mojo/public to mojo/public

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

Index: third_party/mojo/src/mojo/public/cpp/bindings/lib/array_serialization.h
diff --git a/third_party/mojo/src/mojo/public/cpp/bindings/lib/array_serialization.h b/third_party/mojo/src/mojo/public/cpp/bindings/lib/array_serialization.h
deleted file mode 100644
index 854dd74f3e9c03ccd778b2d8af2defa26222c801..0000000000000000000000000000000000000000
--- a/third_party/mojo/src/mojo/public/cpp/bindings/lib/array_serialization.h
+++ /dev/null
@@ -1,338 +0,0 @@
-// 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 THIRD_PARTY_MOJO_SRC_MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
-#define THIRD_PARTY_MOJO_SRC_MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
-
-#include <string.h>  // For |memcpy()|.
-
-#include <vector>
-
-#include "third_party/mojo/src/mojo/public/c/system/macros.h"
-#include "third_party/mojo/src/mojo/public/cpp/bindings/lib/array_internal.h"
-#include "third_party/mojo/src/mojo/public/cpp/bindings/lib/map_serialization.h"
-#include "third_party/mojo/src/mojo/public/cpp/bindings/lib/string_serialization.h"
-#include "third_party/mojo/src/mojo/public/cpp/bindings/lib/template_util.h"
-#include "third_party/mojo/src/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 SerializeArray_(
-    Array<E> input,
-    internal::Buffer* buf,
-    internal::Array_Data<F>** output,
-    const internal::ArrayValidateParams* validate_params);
-
-template <typename E, typename F>
-inline void Deserialize_(internal::Array_Data<F>* data, Array<E>* output);
-
-namespace internal {
-
-template <typename E,
-          typename F,
-          bool is_union =
-              IsUnionDataType<typename RemovePointer<F>::type>::value>
-struct ArraySerializer;
-
-// Handles serialization and deserialization of arrays of pod types.
-template <typename E, typename F>
-struct ArraySerializer<E, F, false> {
-  static_assert(sizeof(E) == sizeof(F), "Incorrect array serializer");
-  static size_t GetSerializedSize(const Array<E>& input) {
-    return sizeof(Array_Data<F>) + Align(input.size() * sizeof(E));
-  }
-
-  static void SerializeElements(Array<E> input,
-                                Buffer* buf,
-                                Array_Data<F>* output,
-                                const ArrayValidateParams* validate_params) {
-    MOJO_DCHECK(!validate_params->element_is_nullable)
-        << "Primitive type should be non-nullable";
-    MOJO_DCHECK(!validate_params->element_validate_params)
-        << "Primitive type should not have array validate params";
-
-    if (input.size())
-      memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
-  }
-  static void DeserializeElements(Array_Data<F>* input, Array<E>* output) {
-    std::vector<E> result(input->size());
-    if (input->size())
-      memcpy(&result[0], input->storage(), input->size() * sizeof(E));
-    output->Swap(&result);
-  }
-};
-
-// Serializes and deserializes arrays of bools.
-template <>
-struct ArraySerializer<bool, bool, false> {
-  static size_t GetSerializedSize(const Array<bool>& input) {
-    return sizeof(Array_Data<bool>) + Align((input.size() + 7) / 8);
-  }
-
-  static void SerializeElements(Array<bool> input,
-                                Buffer* buf,
-                                Array_Data<bool>* output,
-                                const ArrayValidateParams* validate_params) {
-    MOJO_DCHECK(!validate_params->element_is_nullable)
-        << "Primitive type should be non-nullable";
-    MOJO_DCHECK(!validate_params->element_validate_params)
-        << "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 void DeserializeElements(Array_Data<bool>* input,
-                                  Array<bool>* output) {
-    Array<bool> result(input->size());
-    // TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
-    for (size_t i = 0; i < input->size(); ++i)
-      result.at(i) = input->at(i);
-    output->Swap(&result);
-  }
-};
-
-// Serializes and deserializes arrays of handles.
-template <typename H>
-struct ArraySerializer<ScopedHandleBase<H>, H, false> {
-  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,
-                                const ArrayValidateParams* validate_params) {
-    MOJO_DCHECK(!validate_params->element_validate_params)
-        << "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(
-          !validate_params->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) {
-    Array<ScopedHandleBase<H>> result(input->size());
-    for (size_t i = 0; i < input->size(); ++i)
-      result.at(i) = MakeScopedHandle(FetchAndReset(&input->at(i)));
-    output->Swap(&result);
-  }
-};
-
-// This template must only apply to pointer mojo entity (structs and arrays).
-// This is done by ensuring that WrapperTraits<S>::DataType is a pointer.
-template <typename S>
-struct ArraySerializer<
-    S,
-    typename EnableIf<IsPointer<typename WrapperTraits<S>::DataType>::value,
-                      typename WrapperTraits<S>::DataType>::type,
-    false> {
-  typedef
-      typename RemovePointer<typename WrapperTraits<S>::DataType>::type S_Data;
-  static size_t GetSerializedSize(const Array<S>& input) {
-    size_t size = sizeof(Array_Data<S_Data*>) +
-                  input.size() * sizeof(StructPointer<S_Data>);
-    for (size_t i = 0; i < input.size(); ++i)
-      size += GetSerializedSize_(input[i]);
-    return size;
-  }
-
-  static void SerializeElements(Array<S> input,
-                                Buffer* buf,
-                                Array_Data<S_Data*>* output,
-                                const ArrayValidateParams* validate_params) {
-    for (size_t i = 0; i < input.size(); ++i) {
-      S_Data* element;
-      SerializeCaller<S>::Run(input[i].Pass(), buf, &element,
-                              validate_params->element_validate_params);
-      output->at(i) = element;
-      MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
-          !validate_params->element_is_nullable && !element,
-          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
-          MakeMessageWithArrayIndex("null in array expecting valid pointers",
-                                    input.size(), i));
-    }
-  }
-  static void DeserializeElements(Array_Data<S_Data*>* input,
-                                  Array<S>* output) {
-    Array<S> result(input->size());
-    for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(input->at(i), &result[i]);
-    }
-    output->Swap(&result);
-  }
-
- private:
-  template <typename T>
-  struct SerializeCaller {
-    static void Run(T input,
-                    Buffer* buf,
-                    typename WrapperTraits<T>::DataType* output,
-                    const ArrayValidateParams* validate_params) {
-      MOJO_DCHECK(!validate_params)
-          << "Struct type should not have array validate params";
-
-      Serialize_(input.Pass(), buf, output);
-    }
-  };
-
-  template <typename T>
-  struct SerializeCaller<Array<T>> {
-    static void Run(Array<T> input,
-                    Buffer* buf,
-                    typename Array<T>::Data_** output,
-                    const ArrayValidateParams* validate_params) {
-      SerializeArray_(input.Pass(), buf, output, validate_params);
-    }
-  };
-
-  template <typename T, typename U>
-  struct SerializeCaller<Map<T, U>> {
-    static void Run(Map<T, U> input,
-                    Buffer* buf,
-                    typename Map<T, U>::Data_** output,
-                    const ArrayValidateParams* validate_params) {
-      SerializeMap_(input.Pass(), buf, output, validate_params);
-    }
-  };
-};
-
-// Handles serialization and deserialization of arrays of unions.
-template <typename U, typename U_Data>
-struct ArraySerializer<U, U_Data, true> {
-  static size_t GetSerializedSize(const Array<U>& input) {
-    size_t size = sizeof(Array_Data<U_Data>);
-    for (size_t i = 0; i < input.size(); ++i) {
-      // GetSerializedSize_ will account for both the data in the union and the
-      // space in the array used to hold the union.
-      size += GetSerializedSize_(input[i], false);
-    }
-    return size;
-  }
-
-  static void SerializeElements(Array<U> input,
-                                Buffer* buf,
-                                Array_Data<U_Data>* output,
-                                const ArrayValidateParams* validate_params) {
-    for (size_t i = 0; i < input.size(); ++i) {
-      U_Data* result = output->storage() + i;
-      SerializeUnion_(input[i].Pass(), buf, &result, true);
-      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",
-                                    input.size(), i));
-    }
-  }
-
-  static void DeserializeElements(Array_Data<U_Data>* input, Array<U>* output) {
-    Array<U> result(input->size());
-    for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(&input->at(i), &result[i]);
-    }
-    output->Swap(&result);
-  }
-};
-
-// Handles serialization and deserialization of arrays of strings.
-template <>
-struct ArraySerializer<String, String_Data*> {
-  static size_t GetSerializedSize(const Array<String>& input) {
-    size_t size =
-        sizeof(Array_Data<String_Data*>) + input.size() * sizeof(StringPointer);
-    for (size_t i = 0; i < input.size(); ++i)
-      size += GetSerializedSize_(input[i]);
-    return size;
-  }
-
-  static void SerializeElements(Array<String> input,
-                                Buffer* buf,
-                                Array_Data<String_Data*>* output,
-                                const ArrayValidateParams* validate_params) {
-    MOJO_DCHECK(
-        validate_params->element_validate_params &&
-        !validate_params->element_validate_params->element_validate_params &&
-        !validate_params->element_validate_params->element_is_nullable &&
-        validate_params->element_validate_params->expected_num_elements == 0)
-        << "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(
-          !validate_params->element_is_nullable && !element,
-          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
-          MakeMessageWithArrayIndex("null in array expecting valid strings",
-                                    input.size(), i));
-    }
-  }
-  static void DeserializeElements(Array_Data<String_Data*>* input,
-                                  Array<String>* output) {
-    Array<String> result(input->size());
-    for (size_t i = 0; i < input->size(); ++i)
-      Deserialize_(input->at(i), &result[i]);
-    output->Swap(&result);
-  }
-};
-
-}  // namespace internal
-
-template <typename E>
-inline size_t GetSerializedSize_(const Array<E>& input) {
-  if (!input)
-    return 0;
-  typedef typename internal::WrapperTraits<E>::DataType F;
-  return internal::ArraySerializer<E, F>::GetSerializedSize(input);
-}
-
-template <typename E, typename F>
-inline void SerializeArray_(
-    Array<E> input,
-    internal::Buffer* buf,
-    internal::Array_Data<F>** output,
-    const internal::ArrayValidateParams* validate_params) {
-  if (input) {
-    MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
-        validate_params->expected_num_elements != 0 &&
-            input.size() != validate_params->expected_num_elements,
-        internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
-        internal::MakeMessageWithExpectedArraySize(
-            "fixed-size array has wrong number of elements", input.size(),
-            validate_params->expected_num_elements));
-
-    internal::Array_Data<F>* result =
-        internal::Array_Data<F>::New(input.size(), buf);
-    if (result) {
-      internal::ArraySerializer<E, F>::SerializeElements(
-          internal::Forward(input), buf, result, validate_params);
-    }
-    *output = result;
-  } else {
-    *output = nullptr;
-  }
-}
-
-template <typename E, typename F>
-inline void Deserialize_(internal::Array_Data<F>* input, Array<E>* output) {
-  if (input) {
-    internal::ArraySerializer<E, F>::DeserializeElements(input, output);
-  } else {
-    output->reset();
-  }
-}
-
-}  // namespace mojo
-
-#endif  // THIRD_PARTY_MOJO_SRC_MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_