Mojo: Move mojo/public/bindings/lib to mojo/public/cpp/bindings/lib.

mojo/public/bindings/lib/array_internal.h

Index: mojo/public/bindings/lib/array_internal.h
diff --git a/mojo/public/bindings/lib/array_internal.h b/mojo/public/bindings/lib/array_internal.h
deleted file mode 100644
index 1ca84d0fc0db09324ed10819b34a6573285bcf58..0000000000000000000000000000000000000000
--- a/mojo/public/bindings/lib/array_internal.h
+++ /dev/null
@@ -1,372 +0,0 @@
-// 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_BINDINGS_LIB_ARRAY_INTERNAL_H_
-#define MOJO_PUBLIC_BINDINGS_LIB_ARRAY_INTERNAL_H_
-
-#include <new>
-
-#include "mojo/public/bindings/lib/bindings_internal.h"
-#include "mojo/public/bindings/lib/bindings_serialization.h"
-#include "mojo/public/cpp/bindings/buffer.h"
-#include "mojo/public/cpp/bindings/passable.h"
-#include "mojo/public/cpp/system/core.h"
-
-namespace mojo {
-template <typename T> class Array;
-
-namespace internal {
-
-template <typename T>
-struct ArrayDataTraits {
-  typedef T StorageType;
-  typedef Array<T> Wrapper;
-  typedef T& Ref;
-  typedef T const& ConstRef;
-
-  static size_t GetStorageSize(size_t num_elements) {
-    return 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*> {
-  typedef StructPointer<P> StorageType;
-  typedef Array<typename P::Wrapper> Wrapper;
-  typedef P*& Ref;
-  typedef P* const& ConstRef;
-
-  static size_t GetStorageSize(size_t num_elements) {
-    return 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 {
-   public:
-    ~BitRef();
-    BitRef& operator=(bool value);
-    BitRef& operator=(const BitRef& value);
-    operator bool() const;
-   private:
-    friend struct ArrayDataTraits<bool>;
-    BitRef(uint8_t* storage, uint8_t mask);
-    BitRef();
-    uint8_t* storage_;
-    uint8_t mask_;
-  };
-
-  typedef uint8_t StorageType;
-  typedef Array<bool> Wrapper;
-  typedef BitRef Ref;
-  typedef bool ConstRef;
-
-  static size_t GetStorageSize(size_t num_elements) {
-    return ((num_elements + 7) / 8);
-  }
-  static BitRef ToRef(StorageType* storage, size_t offset) {
-    return BitRef(&storage[offset / 8], 1 << (offset % 8));
-  }
-  static bool ToConstRef(const StorageType* storage, size_t offset) {
-    return (storage[offset / 8] & (1 << (offset % 8))) != 0;
-  }
-};
-
-// What follows is code to support the serialization of Array_Data<T>. There
-// are two interesting cases: arrays of primitives and arrays of objects.
-// Arrays of objects are represented as arrays of pointers to objects.
-
-template <typename T>
-struct ArraySerializationHelper {
-  typedef T ElementType;
-
-  static size_t ComputeSizeOfElements(const ArrayHeader* header,
-                                      const ElementType* elements) {
-    return 0;
-  }
-
-  static void CloneElements(const ArrayHeader* header,
-                            ElementType* elements,
-                            Buffer* buf) {
-  }
-
-  static void EncodePointersAndHandles(const ArrayHeader* header,
-                                       ElementType* elements,
-                                       std::vector<Handle>* handles) {
-  }
-
-  static bool DecodePointersAndHandles(const ArrayHeader* header,
-                                       ElementType* elements,
-                                       Message* message) {
-    return true;
-  }
-};
-
-template <>
-struct ArraySerializationHelper<Handle> {
-  typedef Handle ElementType;
-
-  static size_t ComputeSizeOfElements(const ArrayHeader* header,
-                                      const ElementType* elements) {
-    return 0;
-  }
-
-  static void CloneElements(const ArrayHeader* header,
-                            ElementType* elements,
-                            Buffer* buf) {
-  }
-
-  static void EncodePointersAndHandles(const ArrayHeader* header,
-                                       ElementType* elements,
-                                       std::vector<Handle>* handles);
-
-  static bool DecodePointersAndHandles(const ArrayHeader* header,
-                                       ElementType* elements,
-                                       Message* message);
-};
-
-template <typename P>
-struct ArraySerializationHelper<P*> {
-  typedef StructPointer<P> ElementType;
-
-  static size_t ComputeSizeOfElements(const ArrayHeader* header,
-                                      const ElementType* elements) {
-    size_t result = 0;
-    for (uint32_t i = 0; i < header->num_elements; ++i) {
-      if (elements[i].ptr)
-        result += elements[i].ptr->ComputeSize();
-    }
-    return result;
-  }
-
-  static void CloneElements(const ArrayHeader* header,
-                            ElementType* elements,
-                            Buffer* buf) {
-    for (uint32_t i = 0; i < header->num_elements; ++i) {
-      if (elements[i].ptr)
-        elements[i].ptr = elements[i].ptr->Clone(buf);
-    }
-  }
-
-  static void EncodePointersAndHandles(const ArrayHeader* header,
-                                       ElementType* elements,
-                                       std::vector<Handle>* handles) {
-    for (uint32_t i = 0; i < header->num_elements; ++i)
-      Encode(&elements[i], handles);
-  }
-
-  static bool DecodePointersAndHandles(const ArrayHeader* header,
-                                       ElementType* elements,
-                                       Message* message) {
-    for (uint32_t i = 0; i < header->num_elements; ++i) {
-      if (!Decode(&elements[i], message))
-        return false;
-    }
-    return true;
-  }
-};
-
-template <typename T>
-class Array_Data {
- public:
-  typedef ArrayDataTraits<T> Traits;
-  typedef typename Traits::StorageType StorageType;
-  typedef typename Traits::Wrapper Wrapper;
-  typedef typename Traits::Ref Ref;
-  typedef typename Traits::ConstRef ConstRef;
-
-  static Array_Data<T>* New(size_t num_elements, Buffer* buf) {
-    size_t num_bytes = sizeof(Array_Data<T>) +
-                       Traits::GetStorageSize(num_elements);
-    return new (buf->Allocate(num_bytes)) Array_Data<T>(num_bytes,
-                                                        num_elements);
-  }
-
-  size_t size() const { return header_.num_elements; }
-
-  Ref at(size_t offset) {
-    assert(offset < static_cast<size_t>(header_.num_elements));
-    return Traits::ToRef(storage(), offset);
-  }
-
-  ConstRef at(size_t offset) const {
-    assert(offset < static_cast<size_t>(header_.num_elements));
-    return Traits::ToConstRef(storage(), offset);
-  }
-
-  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));
-  }
-
-  size_t ComputeSize() const {
-    return Align(header_.num_bytes) +
-        ArraySerializationHelper<T>::ComputeSizeOfElements(&header_, storage());
-  }
-
-  Array_Data<T>* Clone(Buffer* buf) const {
-    Array_Data<T>* clone = New(header_.num_elements, buf);
-    memcpy(clone->storage(),
-           storage(),
-           header_.num_bytes - sizeof(Array_Data<T>));
-
-    ArraySerializationHelper<T>::CloneElements(&clone->header_,
-                                               clone->storage(), buf);
-    return clone;
-  }
-
-  void CloseHandles() {
-    // TODO(darin): Implement!
-  }
-
-  void EncodePointersAndHandles(std::vector<Handle>* handles) {
-    ArraySerializationHelper<T>::EncodePointersAndHandles(&header_, storage(),
-                                                          handles);
-  }
-
-  bool DecodePointersAndHandles(Message* message) {
-    return ArraySerializationHelper<T>::DecodePointersAndHandles(&header_,
-                                                                 storage(),
-                                                                 message);
-  }
-
- private:
-  Array_Data(size_t num_bytes, size_t num_elements) {
-    header_.num_bytes = static_cast<uint32_t>(num_bytes);
-    header_.num_elements = static_cast<uint32_t>(num_elements);
-  }
-  ~Array_Data() {}
-
-  internal::ArrayHeader header_;
-
-  // Elements of type internal::ArrayDataTraits<T>::StorageType follow.
-};
-MOJO_COMPILE_ASSERT(sizeof(Array_Data<char>) == 8, bad_sizeof_Array_Data);
-
-// UTF-8 encoded
-typedef Array_Data<char> String_Data;
-
-template <typename T, bool kIsObject> struct ArrayTraits {};
-
-template <typename T> struct ArrayTraits<T, true> {
-  typedef Array_Data<typename T::Data*> DataType;
-  typedef const T& ConstRef;
-  typedef T& Ref;
-  static typename T::Data* ToArrayElement(const T& value) {
-    return Unwrap(value);
-  }
-  // Something sketchy is indeed happening here...
-  static Ref ToRef(typename T::Data*& data) {
-    return *reinterpret_cast<T*>(&data);
-  }
-  static ConstRef ToConstRef(typename T::Data* const& data) {
-    return *reinterpret_cast<const T*>(&data);
-  }
-};
-
-template <typename T> struct ArrayTraits<T, false> {
-  typedef Array_Data<T> DataType;
-  typedef const T& ConstRef;
-  typedef T& Ref;
-  static T ToArrayElement(const T& value) {
-    return value;
-  }
-  static Ref ToRef(T& data) { return data; }
-  static ConstRef ToConstRef(const T& data) { return data; }
-};
-
-template <> struct ArrayTraits<bool, false> {
-  typedef Array_Data<bool> DataType;
-  typedef bool ConstRef;
-  typedef ArrayDataTraits<bool>::Ref Ref;
-  static bool ToArrayElement(const bool& value) {
-    return value;
-  }
-  static Ref ToRef(const Ref& data) { return data; }
-  static ConstRef ToConstRef(ConstRef data) { return data; }
-};
-
-template <> struct ArrayTraits<Handle, false> {
-  typedef Array_Data<Handle> DataType;
-  typedef Passable<Handle> ConstRef;
-  typedef AssignableAndPassable<Handle> Ref;
-  static Handle ToArrayElement(const Handle& value) {
-    return value;
-  }
-  static Ref ToRef(Handle& data) { return Ref(&data); }
-  static ConstRef ToConstRef(const Handle& data) {
-    return ConstRef(const_cast<Handle*>(&data));
-  }
-};
-
-template <> struct ArrayTraits<DataPipeConsumerHandle, false> {
-  typedef Array_Data<DataPipeConsumerHandle> DataType;
-  typedef Passable<DataPipeConsumerHandle> ConstRef;
-  typedef AssignableAndPassable<DataPipeConsumerHandle> Ref;
-  static DataPipeConsumerHandle ToArrayElement(
-      const DataPipeConsumerHandle& value) {
-    return value;
-  }
-  static Ref ToRef(DataPipeConsumerHandle& data) { return Ref(&data); }
-  static ConstRef ToConstRef(const DataPipeConsumerHandle& data) {
-    return ConstRef(const_cast<DataPipeConsumerHandle*>(&data));
-  }
-};
-
-template <> struct ArrayTraits<DataPipeProducerHandle, false> {
-  typedef Array_Data<DataPipeProducerHandle> DataType;
-  typedef Passable<DataPipeProducerHandle> ConstRef;
-  typedef AssignableAndPassable<DataPipeProducerHandle> Ref;
-  static DataPipeProducerHandle ToArrayElement(
-      const DataPipeProducerHandle& value) {
-    return value;
-  }
-  static Ref ToRef(DataPipeProducerHandle& data) { return Ref(&data); }
-  static ConstRef ToConstRef(const DataPipeProducerHandle& data) {
-    return ConstRef(const_cast<DataPipeProducerHandle*>(&data));
-  }
-};
-
-template <> struct ArrayTraits<MessagePipeHandle, false> {
-  typedef Array_Data<MessagePipeHandle> DataType;
-  typedef Passable<MessagePipeHandle> ConstRef;
-  typedef AssignableAndPassable<MessagePipeHandle> Ref;
-  static MessagePipeHandle ToArrayElement(const MessagePipeHandle& value) {
-    return value;
-  }
-  static Ref ToRef(MessagePipeHandle& data) { return Ref(&data); }
-  static ConstRef ToConstRef(const MessagePipeHandle& data) {
-    return ConstRef(const_cast<MessagePipeHandle*>(&data));
-  }
-};
-
-}  // namespace internal
-}  // namespace mojo
-
-#endif  // MOJO_PUBLIC_BINDINGS_LIB_ARRAY_INTERNAL_H_