Introduce a gl::BufferState class.

src/libANGLE/Buffer.cpp

@@ -10,54 +10,62 @@
 
 #include "libANGLE/Buffer.h"
 #include "libANGLE/renderer/BufferImpl.h"
+#include "libANGLE/renderer/GLImplFactory.h"
 
 namespace gl
 {
 
-Buffer::Buffer(rx::BufferImpl *impl, GLuint id)
-    : RefCountObject(id),
-      mBuffer(impl),
-      mLabel(),
+BufferState::BufferState()
+    : mLabel(),
       mUsage(GL_STATIC_DRAW),
       mSize(0),
       mAccessFlags(0),
       mAccess(GL_WRITE_ONLY_OES),
       mMapped(GL_FALSE),
-      mMapPointer(NULL),
+      mMapPointer(nullptr),
       mMapOffset(0),
       mMapLength(0)
 {
 }
 
+BufferState::~BufferState()
+{
+}
+
+Buffer::Buffer(rx::GLImplFactory *factory, GLuint id)
+    : RefCountObject(id), mImpl(factory->createBuffer(mState))
+{
+}
+
 Buffer::~Buffer()
 {
-    SafeDelete(mBuffer);
+    SafeDelete(mImpl);
 }
 
 void Buffer::setLabel(const std::string &label)
 {
-    mLabel = label;
+    mState.mLabel = label;
 }
 
 const std::string &Buffer::getLabel() const
 {
-    return mLabel;
+    return mState.mLabel;
 }
 
 Error Buffer::bufferData(GLenum target, const void *data, GLsizeiptr size, GLenum usage)
 {
-    ANGLE_TRY(mBuffer->setData(target, data, size, usage));
+    ANGLE_TRY(mImpl->setData(target, data, size, usage));
 
     mIndexRangeCache.clear();
-    mUsage = usage;
-    mSize = size;
+    mState.mUsage = usage;
+    mState.mSize  = size;
 
     return NoError();
 }
 
 Error Buffer::bufferSubData(GLenum target, const void *data, GLsizeiptr size, GLintptr offset)
 {
-    ANGLE_TRY(mBuffer->setSubData(target, data, size, offset));
+    ANGLE_TRY(mImpl->setSubData(target, data, size, offset));
 
     mIndexRangeCache.invalidateRange(static_cast<unsigned int>(offset), static_cast<unsigned int>(size));
 
@@ -66,7 +74,7 @@ Error Buffer::bufferSubData(GLenum target, const void *data, GLsizeiptr size, GL
 
 Error Buffer::copyBufferSubData(Buffer* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size)
 {
-    ANGLE_TRY(mBuffer->copySubData(source->getImplementation(), sourceOffset, destOffset, size));
+    ANGLE_TRY(mImpl->copySubData(source->getImplementation(), sourceOffset, destOffset, size));
 
     mIndexRangeCache.invalidateRange(static_cast<unsigned int>(destOffset), static_cast<unsigned int>(size));
 
@@ -75,22 +83,22 @@ Error Buffer::copyBufferSubData(Buffer* source, GLintptr sourceOffset, GLintptr
 
 Error Buffer::map(GLenum access)
 {
-    ASSERT(!mMapped);
+    ASSERT(!mState.mMapped);
 
-    Error error = mBuffer->map(access, &mMapPointer);
+    Error error = mImpl->map(access, &mState.mMapPointer);
     if (error.isError())
     {
-        mMapPointer = NULL;
+        mState.mMapPointer = nullptr;
         return error;
     }
 
     ASSERT(access == GL_WRITE_ONLY_OES);
 
-    mMapped = GL_TRUE;
-    mMapOffset = 0;
-    mMapLength = mSize;
-    mAccess = access;
-    mAccessFlags = GL_MAP_WRITE_BIT;
+    mState.mMapped      = GL_TRUE;
+    mState.mMapOffset   = 0;
+    mState.mMapLength   = mState.mSize;
+    mState.mAccess      = access;
+    mState.mAccessFlags = GL_MAP_WRITE_BIT;
     mIndexRangeCache.clear();
 
     return error;
@@ -98,21 +106,21 @@ Error Buffer::map(GLenum access)
 
 Error Buffer::mapRange(GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    ASSERT(!mMapped);
-    ASSERT(offset + length <= mSize);
+    ASSERT(!mState.mMapped);
+    ASSERT(offset + length <= mState.mSize);
 
-    Error error = mBuffer->mapRange(offset, length, access, &mMapPointer);
+    Error error = mImpl->mapRange(offset, length, access, &mState.mMapPointer);
     if (error.isError())
     {
-        mMapPointer = NULL;
+        mState.mMapPointer = nullptr;
         return error;
     }
 
-    mMapped = GL_TRUE;
-    mMapOffset = static_cast<GLint64>(offset);
-    mMapLength = static_cast<GLint64>(length);
-    mAccess = GL_WRITE_ONLY_OES;
-    mAccessFlags = access;
+    mState.mMapped      = GL_TRUE;
+    mState.mMapOffset   = static_cast<GLint64>(offset);
+    mState.mMapLength   = static_cast<GLint64>(length);
+    mState.mAccess      = GL_WRITE_ONLY_OES;
+    mState.mAccessFlags = access;
 
     // The OES_mapbuffer extension states that GL_WRITE_ONLY_OES is the only valid
     // value for GL_BUFFER_ACCESS_OES because it was written against ES2.  Since there is
@@ -129,21 +137,21 @@ Error Buffer::mapRange(GLintptr offset, GLsizeiptr length, GLbitfield access)
 
 Error Buffer::unmap(GLboolean *result)
 {
-    ASSERT(mMapped);
+    ASSERT(mState.mMapped);
 
-    Error error = mBuffer->unmap(result);
+    Error error = mImpl->unmap(result);
     if (error.isError())
     {
         *result = GL_FALSE;
         return error;
     }
 
-    mMapped = GL_FALSE;
-    mMapPointer = NULL;
-    mMapOffset = 0;
-    mMapLength = 0;
-    mAccess = GL_WRITE_ONLY_OES;
-    mAccessFlags = 0;
+    mState.mMapped      = GL_FALSE;
+    mState.mMapPointer  = nullptr;
+    mState.mMapOffset   = 0;
+    mState.mMapLength   = 0;
+    mState.mAccess      = GL_WRITE_ONLY_OES;
+    mState.mAccessFlags = 0;
 
     return error;
 }
@@ -169,7 +177,7 @@ Error Buffer::getIndexRange(GLenum type,
         return NoError();
     }
 
-    ANGLE_TRY(mBuffer->getIndexRange(type, offset, count, primitiveRestartEnabled, outRange));
+    ANGLE_TRY(mImpl->getIndexRange(type, offset, count, primitiveRestartEnabled, outRange));
 
     mIndexRangeCache.addRange(type, offset, count, primitiveRestartEnabled, *outRange);
 

src/libANGLE/Buffer.h

@@ -20,16 +20,50 @@
 namespace rx
 {
 class BufferImpl;
+class GLImplFactory;
 };
 
 namespace gl
 {
+class Buffer;
+
+class BufferState final : angle::NonCopyable
+{
+  public:
+    BufferState();
+    ~BufferState();
+
+    const std::string &getLabel();
+
+    GLenum getUsage() const { return mUsage; }
+    GLbitfield getAccessFlags() const { return mAccessFlags; }
+    GLenum getAccess() const { return mAccess; }
+    GLboolean isMapped() const { return mMapped; }
+    GLvoid *getMapPointer() const { return mMapPointer; }
+    GLint64 getMapOffset() const { return mMapOffset; }
+    GLint64 getMapLength() const { return mMapLength; }
+    GLint64 getSize() const { return mSize; }
+
+  private:
+    friend class Buffer;
+
+    std::string mLabel;
+
+    GLenum mUsage;
+    GLint64 mSize;
+    GLbitfield mAccessFlags;
+    GLenum mAccess;
+    GLboolean mMapped;
+    GLvoid *mMapPointer;
+    GLint64 mMapOffset;
+    GLint64 mMapLength;
+};
 
 class Buffer final : public RefCountObject, public LabeledObject
 {
   public:
-    Buffer(rx::BufferImpl *impl, GLuint id);
-    virtual ~Buffer();
+    Buffer(rx::GLImplFactory *factory, GLuint id);
+    ~Buffer() override;
 
     void setLabel(const std::string &label) override;
     const std::string &getLabel() const override;
@@ -50,30 +84,20 @@ class Buffer final : public RefCountObject, public LabeledObject
                         bool primitiveRestartEnabled,
                         IndexRange *outRange) const;
 
-    GLenum getUsage() const { return mUsage; }
-    GLbitfield getAccessFlags() const { return mAccessFlags; }
-    GLenum getAccess() const { return mAccess; }
-    GLboolean isMapped() const { return mMapped; }
-    GLvoid *getMapPointer() const { return mMapPointer; }
-    GLint64 getMapOffset() const { return mMapOffset; }
-    GLint64 getMapLength() const { return mMapLength; }
-    GLint64 getSize() const { return mSize; }
+    GLenum getUsage() const { return mState.mUsage; }
+    GLbitfield getAccessFlags() const { return mState.mAccessFlags; }
+    GLenum getAccess() const { return mState.mAccess; }
+    GLboolean isMapped() const { return mState.mMapped; }
+    GLvoid *getMapPointer() const { return mState.mMapPointer; }
+    GLint64 getMapOffset() const { return mState.mMapOffset; }
+    GLint64 getMapLength() const { return mState.mMapLength; }
+    GLint64 getSize() const { return mState.mSize; }
 
-    rx::BufferImpl *getImplementation() const { return mBuffer; }
+    rx::BufferImpl *getImplementation() const { return mImpl; }
 
   private:
-    rx::BufferImpl *mBuffer;
-
-    std::string mLabel;
-
-    GLenum mUsage;
-    GLint64 mSize;
-    GLbitfield mAccessFlags;
-    GLenum mAccess;
-    GLboolean mMapped;
-    GLvoid *mMapPointer;
-    GLint64 mMapOffset;
-    GLint64 mMapLength;
+    BufferState mState;
+    rx::BufferImpl *mImpl;
 
     mutable IndexRangeCache mIndexRangeCache;
 };

src/libANGLE/ResourceManager.cpp

@@ -438,7 +438,7 @@ Buffer *ResourceManager::checkBufferAllocation(rx::GLImplFactory *factory, GLuin
         return bufferMapIt->second;
     }
 
-    Buffer *buffer = new Buffer(factory->createBuffer(), handle);
+    Buffer *buffer = new Buffer(factory, handle);
     buffer->addRef();
 
     if (handleAllocated)

src/libANGLE/ResourceManager_unittest.cpp

@@ -48,7 +48,7 @@ TEST_F(ResourceManagerTest, ReallocateBoundTexture)
 
 TEST_F(ResourceManagerTest, ReallocateBoundBuffer)
 {
-    EXPECT_CALL(mMockFactory, createBuffer()).Times(1).RetiresOnSaturation();
+    EXPECT_CALL(mMockFactory, createBuffer(_)).Times(1).RetiresOnSaturation();
 
     mResourceManager->checkBufferAllocation(&mMockFactory, 1);
     GLuint newBuffer = mResourceManager->createBuffer();

src/libANGLE/TransformFeedback_unittest.cpp

@@ -101,9 +101,16 @@ TEST_F(TransformFeedbackTest, SideEffectsOfPauseAndResume)
 TEST_F(TransformFeedbackTest, BufferBinding)
 {
     rx::MockBufferImpl *bufferImpl = new rx::MockBufferImpl;
-    gl::Buffer *buffer = new gl::Buffer(bufferImpl, 1);
     EXPECT_CALL(*bufferImpl, destructor()).Times(1).RetiresOnSaturation();
 
+    rx::MockGLFactory mockGLFactory;
+    EXPECT_CALL(mockGLFactory, createBuffer(_))
+        .Times(1)
+        .WillOnce(Return(bufferImpl))
+        .RetiresOnSaturation();
+
+    gl::Buffer *buffer = new gl::Buffer(&mockGLFactory, 1);
+
     static const size_t bindIndex = 0;
 
     EXPECT_EQ(mFeedback->getIndexedBufferCount(), mCaps.maxTransformFeedbackSeparateAttributes);

src/libANGLE/renderer/BufferImpl.h

@@ -15,12 +15,18 @@
 
 #include <stdint.h>
 
+namespace gl
+{
+class BufferState;
+}
+
 namespace rx
 {
 
 class BufferImpl : angle::NonCopyable
 {
   public:
+    BufferImpl(const gl::BufferState &state) : mState(state) {}
     virtual ~BufferImpl() { }
 
     virtual gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage)     = 0;
@@ -38,6 +44,9 @@ class BufferImpl : angle::NonCopyable
                                     size_t count,
                                     bool primitiveRestartEnabled,
                                     gl::IndexRange *outRange) = 0;
+
+  protected:
+    const gl::BufferState &mState;
 };
 
 }

src/libANGLE/renderer/BufferImpl_mock.h

@@ -19,6 +19,7 @@ namespace rx
 class MockBufferImpl : public BufferImpl
 {
   public:
+    MockBufferImpl() : BufferImpl(mMockState) {}
     ~MockBufferImpl() { destructor(); }
 
     MOCK_METHOD4(setData, gl::Error(GLenum, const void *, size_t, GLenum));
@@ -31,6 +32,9 @@ class MockBufferImpl : public BufferImpl
     MOCK_METHOD5(getIndexRange, gl::Error(GLenum, size_t, size_t, bool, gl::IndexRange *));
 
     MOCK_METHOD0(destructor, void());
+
+  protected:
+    gl::BufferState mMockState;
 };
 
 }

src/libANGLE/renderer/GLImplFactory.h

@@ -63,7 +63,7 @@ class GLImplFactory : angle::NonCopyable
     virtual RenderbufferImpl *createRenderbuffer() = 0;
 
     // Buffer creation
-    virtual BufferImpl *createBuffer() = 0;
+    virtual BufferImpl *createBuffer(const gl::BufferState &state) = 0;
 
     // Vertex Array creation
     virtual VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) = 0;

src/libANGLE/renderer/TextureImpl_mock.h

@@ -19,7 +19,7 @@ namespace rx
 class MockTextureImpl : public TextureImpl
 {
   public:
-    MockTextureImpl() : TextureImpl(gl::TextureState(GL_TEXTURE_2D)) {}
+    MockTextureImpl() : TextureImpl(mMockState), mMockState(GL_TEXTURE_2D) {}
     virtual ~MockTextureImpl() { destructor(); }
     MOCK_METHOD8(setImage, gl::Error(GLenum, size_t, GLenum, const gl::Extents &, GLenum, GLenum, const gl::PixelUnpackState &, const uint8_t *));
     MOCK_METHOD7(setSubImage, gl::Error(GLenum, size_t, const gl::Box &, GLenum, GLenum, const gl::PixelUnpackState &, const uint8_t *));
@@ -51,6 +51,9 @@ class MockTextureImpl : public TextureImpl
     MOCK_METHOD1(syncState, void(const gl::Texture::DirtyBits &));
 
     MOCK_METHOD0(destructor, void());
+
+  protected:
+    gl::TextureState mMockState;
 };
 
 }

src/libANGLE/renderer/d3d/BufferD3D.cpp

@@ -19,8 +19,8 @@ namespace rx
 
 unsigned int BufferD3D::mNextSerial = 1;
 
-BufferD3D::BufferD3D(BufferFactoryD3D *factory)
-    : BufferImpl(),
+BufferD3D::BufferD3D(const gl::BufferState &state, BufferFactoryD3D *factory)
+    : BufferImpl(state),
       mFactory(factory),
       mStaticIndexBuffer(nullptr),
       mStaticBufferCacheTotalSize(0),

src/libANGLE/renderer/d3d/BufferD3D.h

@@ -30,7 +30,7 @@ enum class D3DBufferUsage
 class BufferD3D : public BufferImpl
 {
   public:
-    BufferD3D(BufferFactoryD3D *factory);
+    BufferD3D(const gl::BufferState &state, BufferFactoryD3D *factory);
     virtual ~BufferD3D();
 
     unsigned int getSerial() const { return mSerial; }

src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp

@@ -249,8 +249,8 @@ class Buffer11::SystemMemoryStorage : public Buffer11::BufferStorage
     MemoryBuffer mSystemCopy;
 };
 
-Buffer11::Buffer11(Renderer11 *renderer)
-    : BufferD3D(renderer),
+Buffer11::Buffer11(const gl::BufferState &state, Renderer11 *renderer)
+    : BufferD3D(state, renderer),
       mRenderer(renderer),
       mSize(0),
       mMappedStorage(nullptr),

src/libANGLE/renderer/d3d/d3d11/Buffer11.h

@@ -48,7 +48,7 @@ typedef size_t DataRevision;
 class Buffer11 : public BufferD3D
 {
   public:
-    Buffer11(Renderer11 *renderer);
+    Buffer11(const gl::BufferState &state, Renderer11 *renderer);
     virtual ~Buffer11();
 
     gl::ErrorOrResult<ID3D11Buffer *> getBuffer(BufferUsage usage);

src/libANGLE/renderer/d3d/d3d11/Context11.cpp

@@ -94,9 +94,9 @@ RenderbufferImpl *Context11::createRenderbuffer()
     return new RenderbufferD3D(mRenderer);
 }
 
-BufferImpl *Context11::createBuffer()
+BufferImpl *Context11::createBuffer(const gl::BufferState &state)
 {
-    Buffer11 *buffer = new Buffer11(mRenderer);
+    Buffer11 *buffer = new Buffer11(state, mRenderer);
     mRenderer->onBufferCreate(buffer);
     return buffer;
 }

src/libANGLE/renderer/d3d/d3d11/Context11.h

@@ -39,7 +39,7 @@ class Context11 : public ContextImpl
     RenderbufferImpl *createRenderbuffer() override;
 
     // Buffer creation
-    BufferImpl *createBuffer() override;
+    BufferImpl *createBuffer(const gl::BufferState &state) override;
 
     // Vertex Array creation
     VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override;

src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp

@@ -12,9 +12,8 @@
 namespace rx
 {
 
-Buffer9::Buffer9(Renderer9 *renderer)
-    : BufferD3D(renderer),
-      mSize(0)
+Buffer9::Buffer9(const gl::BufferState &state, Renderer9 *renderer)
+    : BufferD3D(state, renderer), mSize(0)
 {}
 
 Buffer9::~Buffer9()

src/libANGLE/renderer/d3d/d3d9/Buffer9.h

@@ -20,7 +20,7 @@ class Renderer9;
 class Buffer9 : public BufferD3D
 {
   public:
-    Buffer9(Renderer9 *renderer);
+    Buffer9(const gl::BufferState &state, Renderer9 *renderer);
     virtual ~Buffer9();
 
     // BufferD3D implementation

src/libANGLE/renderer/d3d/d3d9/Context9.cpp

@@ -82,9 +82,9 @@ RenderbufferImpl *Context9::createRenderbuffer()
     return new RenderbufferD3D(mRenderer);
 }
 
-BufferImpl *Context9::createBuffer()
+BufferImpl *Context9::createBuffer(const gl::BufferState &state)
 {
-    return new Buffer9(mRenderer);
+    return new Buffer9(state, mRenderer);
 }
 
 VertexArrayImpl *Context9::createVertexArray(const gl::VertexArrayState &data)

src/libANGLE/renderer/d3d/d3d9/Context9.h

@@ -39,7 +39,7 @@ class Context9 : public ContextImpl
     RenderbufferImpl *createRenderbuffer() override;
 
     // Buffer creation
-    BufferImpl *createBuffer() override;
+    BufferImpl *createBuffer(const gl::BufferState &state) override;
 
     // Vertex Array creation
     VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override;

src/libANGLE/renderer/gl/BufferGL.cpp

@@ -29,8 +29,10 @@ static const GLenum SourceBufferOperationTarget = GL_COPY_READ_BUFFER;
 // supported GL versions and doesn't affect any current state when it changes.
 static const GLenum DestBufferOperationTarget = GL_ARRAY_BUFFER;
 
-BufferGL::BufferGL(const FunctionsGL *functions, StateManagerGL *stateManager)
-    : BufferImpl(),
+BufferGL::BufferGL(const gl::BufferState &state,
+                   const FunctionsGL *functions,
+                   StateManagerGL *stateManager)
+    : BufferImpl(state),
       mIsMapped(false),
       mMapOffset(0),
       mMapSize(0),

src/libANGLE/renderer/gl/BufferGL.h

@@ -21,7 +21,9 @@ class StateManagerGL;
 class BufferGL : public BufferImpl
 {
   public:
-    BufferGL(const FunctionsGL *functions, StateManagerGL *stateManager);
+    BufferGL(const gl::BufferState &state,
+             const FunctionsGL *functions,
+             StateManagerGL *stateManager);
     ~BufferGL() override;
 
     gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -78,9 +78,9 @@ RenderbufferImpl *ContextGL::createRenderbuffer()
                               getNativeTextureCaps());
 }
 
-BufferImpl *ContextGL::createBuffer()
+BufferImpl *ContextGL::createBuffer(const gl::BufferState &state)
 {
-    return new BufferGL(getFunctions(), getStateManager());
+    return new BufferGL(state, getFunctions(), getStateManager());
 }
 
 VertexArrayImpl *ContextGL::createVertexArray(const gl::VertexArrayState &data)

src/libANGLE/renderer/gl/ContextGL.h

@@ -47,7 +47,7 @@ class ContextGL : public ContextImpl
     RenderbufferImpl *createRenderbuffer() override;
 
     // Buffer creation
-    BufferImpl *createBuffer() override;
+    BufferImpl *createBuffer(const gl::BufferState &state) override;
 
     // Vertex Array creation
     VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override;

src/libANGLE/renderer/null/BufferNULL.cpp

@@ -14,7 +14,7 @@
 namespace rx
 {
 
-BufferNULL::BufferNULL() : BufferImpl()
+BufferNULL::BufferNULL(const gl::BufferState &state) : BufferImpl(state)
 {
 }
 

src/libANGLE/renderer/null/BufferNULL.h

@@ -18,7 +18,7 @@ namespace rx
 class BufferNULL : public BufferImpl
 {
   public:
-    BufferNULL();
+    BufferNULL(const gl::BufferState &state);
     ~BufferNULL() override;
 
     gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;

src/libANGLE/renderer/null/ContextNULL.cpp

@@ -124,7 +124,7 @@ RenderbufferImpl *ContextNULL::createRenderbuffer()
     return static_cast<RenderbufferImpl *>(0);
 }
 
-BufferImpl *ContextNULL::createBuffer()
+BufferImpl *ContextNULL::createBuffer(const gl::BufferState &state)
 {
     UNIMPLEMENTED();
     return static_cast<BufferImpl *>(0);

src/libANGLE/renderer/null/ContextNULL.h

@@ -70,7 +70,7 @@ class ContextNULL : public ContextImpl
     RenderbufferImpl *createRenderbuffer() override;
 
     // Buffer creation
-    BufferImpl *createBuffer() override;
+    BufferImpl *createBuffer(const gl::BufferState &state) override;
 
     // Vertex Array creation
     VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override;

src/libANGLE/renderer/vulkan/BufferVk.cpp

@@ -14,7 +14,7 @@
 namespace rx
 {
 
-BufferVk::BufferVk() : BufferImpl()
+BufferVk::BufferVk(const gl::BufferState &state) : BufferImpl(state)
 {
 }
 

src/libANGLE/renderer/vulkan/BufferVk.h

@@ -18,7 +18,7 @@ namespace rx
 class BufferVk : public BufferImpl
 {
   public:
-    BufferVk();
+    BufferVk(const gl::BufferState &state);
     ~BufferVk() override;
 
     gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -211,9 +211,9 @@ RenderbufferImpl *ContextVk::createRenderbuffer()
     return new RenderbufferVk();
 }
 
-BufferImpl *ContextVk::createBuffer()
+BufferImpl *ContextVk::createBuffer(const gl::BufferState &state)
 {
-    return new BufferVk();
+    return new BufferVk(state);
 }
 
 VertexArrayImpl *ContextVk::createVertexArray(const gl::VertexArrayState &state)

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -97,7 +97,7 @@ class ContextVk : public ContextImpl
     RenderbufferImpl *createRenderbuffer() override;
 
     // Buffer creation
-    BufferImpl *createBuffer() override;
+    BufferImpl *createBuffer(const gl::BufferState &state) override;
 
     // Vertex Array creation
     VertexArrayImpl *createVertexArray(const gl::VertexArrayState &state) override;

src/tests/angle_unittests_utils.h

@@ -41,7 +41,7 @@ class NullFactory : public GLImplFactory
     RenderbufferImpl *createRenderbuffer() override { return nullptr; }
 
     // Buffer creation
-    BufferImpl *createBuffer() override { return nullptr; }
+    BufferImpl *createBuffer(const gl::BufferState &state) override { return nullptr; }
 
     // Vertex Array creation
     VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override
@@ -80,7 +80,7 @@ class MockGLFactory : public GLImplFactory
     MOCK_METHOD1(createFramebuffer, FramebufferImpl *(const gl::FramebufferState &));
     MOCK_METHOD1(createTexture, TextureImpl *(const gl::TextureState &));
     MOCK_METHOD0(createRenderbuffer, RenderbufferImpl *());
-    MOCK_METHOD0(createBuffer, BufferImpl *());
+    MOCK_METHOD1(createBuffer, BufferImpl *(const gl::BufferState &));
     MOCK_METHOD1(createVertexArray, VertexArrayImpl *(const gl::VertexArrayState &));
     MOCK_METHOD1(createQuery, QueryImpl *(GLenum type));
     MOCK_METHOD0(createFenceNV, FenceNVImpl *());

src/tests/gl_tests/D3D11EmulatedIndexedBufferTest.cpp

@@ -35,7 +35,7 @@ class D3D11EmulatedIndexedBufferTest : public ANGLETest
         rx::Context11 *context11 = rx::GetImplAs<rx::Context11>(context);
         mRenderer                = context11->getRenderer();
 
-        mSourceBuffer = new rx::Buffer11(mRenderer);
+        mSourceBuffer      = new rx::Buffer11(mBufferState, mRenderer);
         GLfloat testData[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
         gl::Error error =
             mSourceBuffer->setData(GL_ARRAY_BUFFER, testData, sizeof(testData), GL_STATIC_DRAW);
@@ -127,6 +127,7 @@ class D3D11EmulatedIndexedBufferTest : public ANGLETest
     std::vector<GLubyte> mubyteIndices;
     std::vector<GLuint> muintIndices;
     std::vector<GLushort> mushortIndices;
+    gl::BufferState mBufferState;
 };
 
 // This tests that a GL_UNSIGNED_BYTE indices list can be successfully expanded
@@ -163,7 +164,8 @@ TEST_P(D3D11EmulatedIndexedBufferTest, TestNativeToExpandedUsingGLuintIndices)
 TEST_P(D3D11EmulatedIndexedBufferTest, TestSourceBufferRemainsUntouchedAfterExpandOperation)
 {
     // Copy the original source buffer before any expand calls have been made
-    rx::Buffer11 *cleanSourceBuffer = new rx::Buffer11(mRenderer);
+    gl::BufferState cleanSourceState;
+    rx::Buffer11 *cleanSourceBuffer = new rx::Buffer11(cleanSourceState, mRenderer);
     cleanSourceBuffer->copySubData(mSourceBuffer, 0, 0, mSourceBuffer->getSize());
 
     // Do a basic exanded and compare test.

src/tests/perf_tests/IndexDataManagerTest.cpp

@@ -11,6 +11,7 @@
 
 #include <gmock/gmock.h>
 
+#include "angle_unittests_utils.h"
 #include "libANGLE/renderer/d3d/BufferD3D.h"
 #include "libANGLE/renderer/d3d/IndexBuffer.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
@@ -75,11 +76,7 @@ class MockBufferFactoryD3D : public rx::BufferFactoryD3D
 class MockBufferD3D : public rx::BufferD3D
 {
   public:
-    MockBufferD3D(rx::BufferFactoryD3D *factory)
-        : BufferD3D(factory),
-          mData()
-    {
-    }
+    MockBufferD3D(rx::BufferFactoryD3D *factory) : BufferD3D(mockState, factory), mData() {}
 
     // BufferImpl
     gl::Error setData(GLenum target, const void *data, size_t size, GLenum) override
@@ -112,9 +109,30 @@ class MockBufferD3D : public rx::BufferD3D
     }
 
   private:
+    gl::BufferState mockState;
     std::vector<uint8_t> mData;
 };
 
+class MockGLFactoryD3D : public rx::MockGLFactory
+{
+  public:
+    MockGLFactoryD3D(MockBufferFactoryD3D *bufferFactory) : mBufferFactory(bufferFactory) {}
+
+    rx::BufferImpl *createBuffer(const gl::BufferState &state) override
+    {
+        MockBufferD3D *mockBufferD3D = new MockBufferD3D(mBufferFactory);
+
+        EXPECT_CALL(*mBufferFactory, createVertexBuffer())
+            .WillOnce(Return(nullptr))
+            .RetiresOnSaturation();
+        mockBufferD3D->initializeStaticData();
+
+        return mockBufferD3D;
+    }
+
+    MockBufferFactoryD3D *mBufferFactory;
+};
+
 class IndexDataManagerPerfTest : public ANGLEPerfTest
 {
   public:
@@ -125,27 +143,19 @@ class IndexDataManagerPerfTest : public ANGLEPerfTest
     rx::IndexDataManager mIndexDataManager;
     GLsizei mIndexCount;
     unsigned int mBufferSize;
-    MockBufferFactoryD3D mMockFactory;
+    MockBufferFactoryD3D mMockBufferFactory;
+    MockGLFactoryD3D mMockGLFactory;
     gl::Buffer mIndexBuffer;
 };
 
-MockBufferD3D *InitMockBufferD3D(MockBufferFactoryD3D *mockFactory)
-{
-    MockBufferD3D *mockBufferD3D = new MockBufferD3D(mockFactory);
-
-    EXPECT_CALL(*mockFactory, createVertexBuffer()).WillOnce(Return(nullptr)).RetiresOnSaturation();
-    mockBufferD3D->initializeStaticData();
-
-    return mockBufferD3D;
-}
-
 IndexDataManagerPerfTest::IndexDataManagerPerfTest()
     : ANGLEPerfTest("IndexDataManger", "_run"),
-      mIndexDataManager(&mMockFactory, rx::RENDERER_D3D11),
+      mIndexDataManager(&mMockBufferFactory, rx::RENDERER_D3D11),
       mIndexCount(4000),
       mBufferSize(mIndexCount * sizeof(GLushort)),
-      mMockFactory(mBufferSize, GL_UNSIGNED_SHORT),
-      mIndexBuffer(InitMockBufferD3D(&mMockFactory), 1)
+      mMockBufferFactory(mBufferSize, GL_UNSIGNED_SHORT),
+      mMockGLFactory(&mMockBufferFactory),
+      mIndexBuffer(&mMockGLFactory, 1)
 {
     std::vector<GLushort> indexData(mIndexCount);
     for (GLsizei index = 0; index < mIndexCount; ++index)
@@ -173,4 +183,4 @@ TEST_F(IndexDataManagerPerfTest, Run)
     run();
 }
 
-}
+}  // anonymous namespace