Implement binary streams.

src/build_angle.gyp

@@ -234,6 +234,7 @@
             'libGLESv2/vertexconversion.h',
             'libGLESv2/VertexDataManager.cpp',
             'libGLESv2/VertexDataManager.h',
+            'libGLESv2/BinaryStream.h',
             'libGLESv2/Blit.cpp',
             'libGLESv2/Blit.h',
             'libGLESv2/Buffer.cpp',

src/common/version.h

 #define MAJOR_VERSION 1
 #define MINOR_VERSION 0
 #define BUILD_VERSION 0
-#define BUILD_REVISION 1199
+#define BUILD_REVISION 1200
 
 #define STRINGIFY(x) #x
 #define MACRO_STRINGIFY(x) STRINGIFY(x)

src/libGLESv2/BinaryStream.h

+//
+// Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// BinaryStream.h: Provides binary serialization of simple types.
+
+#ifndef LIBGLESV2_BINARYSTREAM_H_
+#define LIBGLESV2_BINARYSTREAM_H_
+
+#include <string>
+#include <vector>
+
+#include "common/angleutils.h"
+
+namespace gl
+{
+
+class BinaryInputStream
+{
+  public:
+    BinaryInputStream(const void *data, size_t length)
+    {
+        mError = false;
+        mOffset = 0;
+        mData = static_cast<const char*>(data);
+        mLength = length;
+    }
+
+    template <typename T>
+    void read(T *v, size_t num)
+    {
+        union
+        {
+            T dummy;  // Compilation error for non-trivial types
+        } dummy;
+        (void) dummy;
+
+        if (mError)
+        {
+            return;
+        }
+
+        size_t length = num * sizeof(T);
+
+        if (mOffset + length > mLength)
+        {
+            mError = true;
+            return;
+        }
+
+        memcpy(v, mData + mOffset, length);
+        mOffset += length;
+    }
+
+    template <typename T>
+    void read(T * v)
+    {
+        read(v, 1);
+    }
+
+    void read(std::string *v)
+    {
+        size_t length;
+        read(&length);
+
+        if (mError)
+        {
+            return;
+        }
+
+        if (mOffset + length > mLength)
+        {
+            mError = true;
+            return;
+        }
+
+        v->assign(mData + mOffset, length);
+        mOffset += length;
+    }
+
+    bool error() const
+    {
+        return mError;
+    }
+
+    bool endOfStream() const
+    {
+        return mOffset == mLength;
+    }
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(BinaryInputStream);
+    bool mError;
+    size_t mOffset;
+    const char *mData;
+    size_t mLength;
+};
+
+class BinaryOutputStream
+{
+  public:
+    BinaryOutputStream()
+    {
+    }
+
+    template <typename T>
+    void write(const T *v, size_t num)
+    {
+        union
+        {
+            T dummy;  // Compilation error for non-trivial types
+        } dummy;
+        (void) dummy;
+
+        const char *asBytes = reinterpret_cast<const char*>(v);
+        mData.insert(mData.end(), asBytes, asBytes + num * sizeof(T));
+    }
+
+    template <typename T>
+    void write(const T &v)
+    {
+        write(&v, 1);
+    }
+
+    void write(const std::string &v)
+    {
+        size_t length = v.length();
+        write(length);
+
+        write(v.c_str(), length);
+    }
+
+    bool getData(void *buffer, size_t bufSize, size_t *length)
+    {
+        if (bufSize < mData.size())
+        {
+            if (length)
+            {
+                *length = 0;
+            }
+
+            return false;
+        }
+
+        if (length)
+        {
+            *length = mData.size();
+        }
+
+        if (mData.size())
+        {
+            memcpy(buffer, &mData[0], mData.size());
+        }
+
+        return true;
+    }
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(BinaryOutputStream);
+    std::vector<char> mData;
+};
+}
+
+#endif  // LIBGLESV2_BINARYSTREAM_H_

src/libGLESv2/libGLESv2.vcproj

@@ -443,6 +443,10 @@
 			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
 			>
 			<File
+				RelativePath=".\BinaryStream.h"
+				>
+			</File>
+			<File
 				RelativePath=".\Blit.h"
 				>
 			</File>