1 files changed, 0 insertions, 187 deletions
diff --git a/emulator/opengl/shared/OpenglCodecCommon/ProtocolUtils.h b/emulator/opengl/shared/OpenglCodecCommon/ProtocolUtils.h
deleted file mode 100644
index 472d7eadf..000000000
--- a/emulator/opengl/shared/OpenglCodecCommon/ProtocolUtils.h
+++ /dev/null
@@ -1,187 +0,0 @@
-#ifndef EMUGL_PROTOCOL_UTILS_H
-#define EMUGL_PROTOCOL_UTILS_H
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-namespace emugl {
-
-// Helper macro
-#define COMPILE_ASSERT(cond)  static char kAssert##__LINE__[1 - 2 * !(cond)] __attribute__((unused)) = { 0 }
-
-// Helper template: is_pointer.
-// is_pointer<T>::value is true iff |T| is a pointer type.
-template <typename T> struct is_pointer {
-    static const bool value = false;
-};
-
-template <typename T> struct is_pointer<T*> {
-    static const bool value = true;
-};
-
-// A helper template to extract values form the wire protocol stream
-// and convert them to appropriate host values.
-//
-// The wire protocol uses 32-bit exclusively when transferring
-// GLintptr or GLsizei values, as well as opaque handles like GLeglImage,
-// from the guest (even when the guest is 64-bit).
-//
-// The corresponding host definitions depend on the host bitness. For
-// example, GLintptr is 64-bit on linux-x86_64. The following is a set
-// of templates that can simplify the conversion of protocol values
-// into host ones.
-//
-// The most important one is:
-//
-//     unpack<HOST_TYPE,SIZE_TYPE>(const void* ptr)
-//
-// Which reads bytes from |ptr|, using |SIZE_TYPE| as the underlying
-// sized-integer specifier (e.g. 'uint32_t'), and converting the result
-// into a |HOST_TYPE| value. For example:
-//
-//     unpack<EGLImage,uint32_t>(ptr + 12);
-//
-// will read a 4-byte value from |ptr + 12| and convert it into
-// an EGLImage, which is a host void*. The template detects host
-// pointer types to perform proper type casting.
-//
-// TODO(digit): Add custom unpackers to handle generic opaque void* values.
-//              and map them to unique 32-bit values.
-
-template <typename T, typename S, bool IS_POINTER>
-struct UnpackerT {};
-
-template <typename T, typename S>
-struct UnpackerT<T,S,false> {
-    static inline T unpack(const void* ptr) {
-        COMPILE_ASSERT(sizeof(T) == sizeof(S));
-        return (T)(*(S*)(ptr));
-    }
-};
-
-template <typename T, typename S>
-struct UnpackerT<T,S,true> {
-    static inline T unpack(const void* ptr) {
-        return (T)(uintptr_t)(*(S*)(ptr));
-    }
-};
-
-template <>
-struct UnpackerT<float,uint32_t,false> {
-    static inline float unpack(const void* ptr) {
-        union {
-            float f;
-            uint32_t u;
-        } v;
-        v.u = *(uint32_t*)(ptr);
-        return v.f;
-    }
-};
-
-template <>
-struct UnpackerT<double,uint64_t,false> {
-    static inline double unpack(const void* ptr) {
-        union {
-            double d;
-            uint32_t u;
-        } v;
-        v.u = *(uint64_t*)(ptr);
-        return v.d;
-    }
-};
-
-template <>
-struct UnpackerT<ssize_t,uint32_t,false> {
-    static inline ssize_t unpack(const void* ptr) {
-        return (ssize_t)*(int32_t*)(ptr);
-    }
-};
-
-template <typename T, typename S>
-inline T Unpack(const void* ptr) {
-    return UnpackerT<T, S, is_pointer<T>::value>::unpack(ptr);
-}
-
-// Helper class used to ensure input buffers passed to EGL/GL functions
-// are properly aligned (preventing crashes with some backends).
-// Usage example:
-//
-//    InputBuffer inputBuffer(ptr, size);
-//    glDoStuff(inputBuffer.get());
-//
-// inputBuffer.get() will return the original value of |ptr| if it was
-// aligned on an 8-byte boundary. Otherwise, it will return the address
-// of an aligned heap-allocated copy of the original |size| bytes starting
-// from |ptr|. The heap block is released at scope exit.
-class InputBuffer {
-public:
-    InputBuffer(const void* input, size_t size, size_t align = 8) :
-            mBuff(input), mIsCopy(false) {
-        if (((uintptr_t)input & (align - 1U)) != 0) {
-            void* newBuff = malloc(size);
-            memcpy(newBuff, input, size);
-            mBuff = newBuff;
-            mIsCopy = true;
-        }
-    }
-
-    ~InputBuffer() {
-        if (mIsCopy) {
-            free((void*)mBuff);
-        }
-    }
-
-    const void* get() const {
-        return mBuff;
-    }
-
-private:
-    const void* mBuff;
-    bool mIsCopy;
-};
-
-// Helper class used to ensure that output buffers passed to EGL/GL functions
-// are aligned on 8-byte addresses.
-// Usage example:
-//
-//    ptr = stream->alloc(size);
-//    OutputBuffer outputBuffer(ptr, size);
-//    glGetStuff(outputBuffer.get());
-//    outputBuffer.flush();
-//
-// outputBuffer.get() returns the original value of |ptr| if it was already
-// aligned on an 8=byte boundary. Otherwise, it returns the size of an heap
-// allocated zeroed buffer of |size| bytes.
-//
-// outputBuffer.flush() copies the content of the heap allocated buffer back
-// to |ptr| explictly, if needed. If a no-op if |ptr| was aligned.
-class OutputBuffer {
-public:
-    OutputBuffer(unsigned char* ptr, size_t size, size_t align = 8) :
-            mOrgBuff(ptr), mBuff(ptr), mSize(size) {
-        if (((uintptr_t)ptr & (align - 1U)) != 0) {
-            void* newBuff = calloc(1, size);
-            mBuff = newBuff;
-        }
-    }
-
-    void* get() const {
-        return mBuff;
-    }
-
-    void flush() {
-        if (mBuff != mOrgBuff) {
-            memcpy(mOrgBuff, mBuff, mSize);
-        }
-    }
-private:
-    unsigned char* mOrgBuff;
-    void* mBuff;
-    size_t mSize;
-};
-
-}  // namespace emugl
-
-#endif  // EMUGL_PROTOCOL_UTILS_H