Use plain data arrays for Buffer storage

src/libGLESv2/Buffer.cpp

@@ -10,71 +10,47 @@
 
 #include "libGLESv2/Buffer.h"
 
-#include <cstdlib>
-#include <limits>
-#include <utility>
-
-#include "common/debug.h"
-
-#include "libGLESv2/geometry/backend.h"
-
 namespace gl
 {
 
-Buffer::Buffer(BufferBackEnd *backEnd)
-    : mBackEnd(backEnd)
+Buffer::Buffer()
 {
+    mContents = NULL;
+    mSize = 0;
+    mUsage = GL_DYNAMIC_DRAW;
 }
 
-GLenum Buffer::bufferData(const void* data, GLsizeiptr size, GLenum usage)
+Buffer::~Buffer()
 {
-    if (size < 0) return GL_INVALID_VALUE;
-
-    const GLubyte* newdata = static_cast<const GLubyte*>(data);
+    delete[] mContents;
+}
 
+void Buffer::bufferData(const void *data, GLsizeiptr size, GLenum usage)
+{
     if (size == 0)
     {
-        mContents.clear();
+        delete[] mContents;
+        mContents = NULL;
     }
-    else if (size != mContents.size())
+    else if (size != mSize)
     {
-        // vector::resize only provides the basic exception guarantee, so use temporaries & swap to get the strong exception guarantee.
-        std::vector<GLubyte> newContents;
-
-        if (newdata != NULL)
-        {
-            newContents.assign(newdata, newdata + size);
-        }
-        else
-        {
-            newContents.assign(size, 0);
-        }
-
-        // No exceptions allowed after this point.
-
-        mContents.swap(newContents);
-
+        delete[] mContents;
+        mContents = new GLubyte[size];
+        memset(mContents, 0, size);
     }
-    else if (newdata != NULL)
+
+    if (data != NULL && size > 0)
     {
-        mContents.assign(newdata, newdata + size);
+        memcpy(mContents, data, size);
     }
 
+    mSize = size;
     mUsage = usage;
-
-    return GL_NO_ERROR;
 }
 
-GLenum Buffer::bufferSubData(const void* data, GLsizeiptr size, GLintptr offset)
+void Buffer::bufferSubData(const void *data, GLsizeiptr size, GLintptr offset)
 {
-    if (size < 0 || offset < 0) return GL_INVALID_VALUE;
-    if (std::numeric_limits<GLsizeiptr>::max() - offset < size) return GL_INVALID_VALUE;
-    if (size + offset > static_cast<GLsizeiptr>(mContents.size())) return GL_INVALID_VALUE;
-
-    const GLubyte *newdata = static_cast<const GLubyte*>(data);
-    memcpy(&mContents[offset], newdata, size);
-
-    return GL_NO_ERROR;
+    memcpy(mContents + offset, data, size);
 }
 
 }

src/libGLESv2/Buffer.h

@@ -22,28 +22,26 @@
 namespace gl
 {
 
-class BufferBackEnd;
-class TranslatedVertexBuffer;
-
 class Buffer
 {
   public:
-    explicit Buffer(BufferBackEnd *backEnd);
+    Buffer();
+
+    virtual ~Buffer();
 
-    GLenum bufferData(const void *data, GLsizeiptr size, GLenum usage);
-    GLenum bufferSubData(const void *data, GLsizeiptr size, GLintptr offset);
+    void bufferData(const void *data, GLsizeiptr size, GLenum usage);
+    void bufferSubData(const void *data, GLsizeiptr size, GLintptr offset);
 
-    void *data() { return &mContents[0]; }
-    GLsizeiptr size() const { return mContents.size(); }
+    void *data() { return mContents; }
+    size_t size() const { return mSize; }
     GLenum usage() const { return mUsage; }
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Buffer);
 
-    std::vector<GLubyte> mContents;
+    GLubyte *mContents;
+    size_t mSize;
     GLenum mUsage;
-
-    BufferBackEnd *mBackEnd;
 };
 
 }

src/libGLESv2/Context.cpp

@@ -929,7 +929,7 @@ void Context::bindArrayBuffer(unsigned int buffer)
 {
     if (buffer != 0 && !getBuffer(buffer))
     {
-        mBufferMap[buffer] = new Buffer(mBufferBackEnd);
+        mBufferMap[buffer] = new Buffer();
     }
 
     mState.arrayBuffer = buffer;
@@ -939,7 +939,7 @@ void Context::bindElementArrayBuffer(unsigned int buffer)
 {
     if (buffer != 0 && !getBuffer(buffer))
     {
-        mBufferMap[buffer] = new Buffer(mBufferBackEnd);
+        mBufferMap[buffer] = new Buffer();
     }
 
     mState.elementArrayBuffer = buffer;

src/libGLESv2/libGLESv2.cpp

@@ -506,7 +506,7 @@ void __stdcall glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
 
     try
     {
-        if (size < 0)
+        if (size < 0 || offset < 0)
         {
             return error(GL_INVALID_VALUE);
         }
@@ -539,12 +539,12 @@ void __stdcall glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
                 return error(GL_INVALID_OPERATION);
             }
 
-            GLenum err = buffer->bufferSubData(data, size, offset);
-
-            if (err != GL_NO_ERROR)
+            if ((size_t)size + offset > buffer->size())
             {
-                return error(err);
+                return error(GL_INVALID_VALUE);
             }
+
+            buffer->bufferSubData(data, size, offset);
         }
     }
     catch(std::bad_alloc&)