Add an BufferFactoryD3D class to help mocking.

src/libANGLE/renderer/d3d/BufferD3D.cpp

@@ -7,18 +7,20 @@
 // BufferD3D.cpp Defines common functionality between the Buffer9 and Buffer11 classes.
 
 #include "libANGLE/renderer/d3d/BufferD3D.h"
-#include "libANGLE/renderer/d3d/VertexBuffer.h"
+
 #include "libANGLE/renderer/d3d/IndexBuffer.h"
+#include "libANGLE/renderer/d3d/VertexBuffer.h"
 
 namespace rx
 {
 
 unsigned int BufferD3D::mNextSerial = 1;
 
-BufferD3D::BufferD3D()
+BufferD3D::BufferD3D(BufferFactoryD3D *factory)
     : BufferImpl(),
-      mStaticVertexBuffer(NULL),
-      mStaticIndexBuffer(NULL)
+      mFactory(factory),
+      mStaticVertexBuffer(nullptr),
+      mStaticIndexBuffer(nullptr)
 {
     updateSerial();
 }
@@ -38,11 +40,11 @@ void BufferD3D::initializeStaticData()
 {
     if (!mStaticVertexBuffer)
     {
-        mStaticVertexBuffer = new StaticVertexBufferInterface(getRenderer());
+        mStaticVertexBuffer = new StaticVertexBufferInterface(mFactory);
     }
     if (!mStaticIndexBuffer)
     {
-        mStaticIndexBuffer = new StaticIndexBufferInterface(getRenderer());
+        mStaticIndexBuffer = new StaticIndexBufferInterface(mFactory);
     }
 }
 

src/libANGLE/renderer/d3d/BufferD3D.h

@@ -16,21 +16,20 @@
 
 namespace rx
 {
-class RendererD3D;
+class BufferFactoryD3D;
 class StaticIndexBufferInterface;
 class StaticVertexBufferInterface;
 
 class BufferD3D : public BufferImpl
 {
   public:
-    BufferD3D();
+    BufferD3D(BufferFactoryD3D *factory);
     virtual ~BufferD3D();
 
     unsigned int getSerial() const { return mSerial; }
 
     virtual size_t getSize() const = 0;
     virtual bool supportsDirectBinding() const = 0;
-    virtual RendererD3D *getRenderer() = 0;
     virtual void markTransformFeedbackUsage() = 0;
 
     StaticVertexBufferInterface *getStaticVertexBuffer() { return mStaticVertexBuffer; }
@@ -41,14 +40,17 @@ class BufferD3D : public BufferImpl
     void promoteStaticUsage(int dataSize);
 
   protected:
+    void updateSerial();
+
+    BufferFactoryD3D *mFactory;
     unsigned int mSerial;
     static unsigned int mNextSerial;
 
-    void updateSerial();
-
     StaticVertexBufferInterface *mStaticVertexBuffer;
     StaticIndexBufferInterface *mStaticIndexBuffer;
     unsigned int mUnmodifiedDataUse;
+
+    DISALLOW_COPY_AND_ASSIGN(BufferD3D);
 };
 
 }

src/libANGLE/renderer/d3d/IndexBuffer.cpp

@@ -35,9 +35,9 @@ void IndexBuffer::updateSerial()
 }
 
 
-IndexBufferInterface::IndexBufferInterface(RendererD3D *renderer, bool dynamic) : mRenderer(renderer)
+IndexBufferInterface::IndexBufferInterface(BufferFactoryD3D *factory, bool dynamic)
 {
-    mIndexBuffer = renderer->createIndexBuffer();
+    mIndexBuffer = factory->createIndexBuffer();
 
     mDynamic = dynamic;
     mWritePosition = 0;
@@ -66,7 +66,7 @@ unsigned int IndexBufferInterface::getSerial() const
     return mIndexBuffer->getSerial();
 }
 
-gl::Error IndexBufferInterface::mapBuffer(unsigned int size, void** outMappedMemory, unsigned int *streamOffset)
+gl::Error IndexBufferInterface::mapBuffer(unsigned int size, void **outMappedMemory, unsigned int *streamOffset)
 {
     // Protect against integer overflow
     if (mWritePosition + size < mWritePosition)
@@ -130,7 +130,8 @@ gl::Error IndexBufferInterface::setBufferSize(unsigned int bufferSize, GLenum in
     }
 }
 
-StreamingIndexBufferInterface::StreamingIndexBufferInterface(RendererD3D *renderer) : IndexBufferInterface(renderer, true)
+StreamingIndexBufferInterface::StreamingIndexBufferInterface(BufferFactoryD3D *factory)
+    : IndexBufferInterface(factory, true)
 {
 }
 
@@ -165,7 +166,8 @@ gl::Error StreamingIndexBufferInterface::reserveBufferSpace(unsigned int size, G
 }
 
 
-StaticIndexBufferInterface::StaticIndexBufferInterface(RendererD3D *renderer) : IndexBufferInterface(renderer, false)
+StaticIndexBufferInterface::StaticIndexBufferInterface(BufferFactoryD3D *factory)
+    : IndexBufferInterface(factory, false)
 {
 }
 

src/libANGLE/renderer/d3d/IndexBuffer.h

@@ -16,7 +16,7 @@
 
 namespace rx
 {
-class RendererD3D;
+class BufferFactoryD3D;
 
 class IndexBuffer
 {
@@ -50,7 +50,7 @@ class IndexBuffer
 class IndexBufferInterface
 {
   public:
-    IndexBufferInterface(RendererD3D *renderer, bool dynamic);
+    IndexBufferInterface(BufferFactoryD3D *factory, bool dynamic);
     virtual ~IndexBufferInterface();
 
     virtual gl::Error reserveBufferSpace(unsigned int size, GLenum indexType) = 0;
@@ -76,9 +76,7 @@ class IndexBufferInterface
   private:
     DISALLOW_COPY_AND_ASSIGN(IndexBufferInterface);
 
-    RendererD3D *const mRenderer;
-
-    IndexBuffer* mIndexBuffer;
+    IndexBuffer *mIndexBuffer;
 
     unsigned int mWritePosition;
     bool mDynamic;
@@ -87,19 +85,23 @@ class IndexBufferInterface
 class StreamingIndexBufferInterface : public IndexBufferInterface
 {
   public:
-    StreamingIndexBufferInterface(RendererD3D *renderer);
+    explicit StreamingIndexBufferInterface(BufferFactoryD3D *factory);
     ~StreamingIndexBufferInterface();
 
-    virtual gl::Error reserveBufferSpace(unsigned int size, GLenum indexType);
+    gl::Error reserveBufferSpace(unsigned int size, GLenum indexType) override;
+
+    DISALLOW_COPY_AND_ASSIGN(StreamingIndexBufferInterface);
 };
 
 class StaticIndexBufferInterface : public IndexBufferInterface
 {
   public:
-    explicit StaticIndexBufferInterface(RendererD3D *renderer);
+    explicit StaticIndexBufferInterface(BufferFactoryD3D *factory);
     ~StaticIndexBufferInterface();
 
-    virtual gl::Error reserveBufferSpace(unsigned int size, GLenum indexType);
+    gl::Error reserveBufferSpace(unsigned int size, GLenum indexType) override;
+
+    DISALLOW_COPY_AND_ASSIGN(StaticIndexBufferInterface);
 };
 
 }

src/libANGLE/renderer/d3d/IndexDataManager.cpp

@@ -10,7 +10,6 @@
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/BufferD3D.h"
 #include "libANGLE/renderer/d3d/IndexBuffer.h"
-#include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/Buffer.h"
 #include "libANGLE/formatutils.h"
 
@@ -56,10 +55,11 @@ static void ConvertIndices(GLenum sourceType, GLenum destinationType, const void
     else UNREACHABLE();
 }
 
-IndexDataManager::IndexDataManager(RendererD3D *renderer)
-    : mRenderer(renderer),
-      mStreamingBufferShort(NULL),
-      mStreamingBufferInt(NULL)
+IndexDataManager::IndexDataManager(BufferFactoryD3D *factory, RendererClass rendererClass)
+    : mFactory(factory),
+      mRendererClass(rendererClass),
+      mStreamingBufferShort(nullptr),
+      mStreamingBufferInt(nullptr)
 {
 }
 
@@ -128,7 +128,7 @@ gl::Error IndexDataManager::prepareIndexData(GLenum type, GLsizei count, gl::Buf
 
     // Avoid D3D11's primitive restart index value
     // see http://msdn.microsoft.com/en-us/library/windows/desktop/bb205124(v=vs.85).aspx
-    if (translated->indexRange.end == 0xFFFF && type == GL_UNSIGNED_SHORT && mRenderer->getMajorShaderModel() > 3)
+    if (translated->indexRange.end == 0xFFFF && type == GL_UNSIGNED_SHORT && mRendererClass == RENDERER_D3D11)
     {
         destinationIndexType = GL_UNSIGNED_INT;
         directStorage = false;
@@ -232,7 +232,7 @@ gl::Error IndexDataManager::getStreamingIndexBuffer(GLenum destinationIndexType,
     {
         if (!mStreamingBufferInt)
         {
-            mStreamingBufferInt = new StreamingIndexBufferInterface(mRenderer);
+            mStreamingBufferInt = new StreamingIndexBufferInterface(mFactory);
             gl::Error error = mStreamingBufferInt->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT);
             if (error.isError())
             {
@@ -250,7 +250,7 @@ gl::Error IndexDataManager::getStreamingIndexBuffer(GLenum destinationIndexType,
 
         if (!mStreamingBufferShort)
         {
-            mStreamingBufferShort = new StreamingIndexBufferInterface(mRenderer);
+            mStreamingBufferShort = new StreamingIndexBufferInterface(mFactory);
             gl::Error error = mStreamingBufferShort->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_SHORT);
             if (error.isError())
             {

src/libANGLE/renderer/d3d/IndexDataManager.h

@@ -10,11 +10,12 @@
 #ifndef LIBANGLE_INDEXDATAMANAGER_H_
 #define LIBANGLE_INDEXDATAMANAGER_H_
 
+#include <GLES2/gl2.h>
+
 #include "common/angleutils.h"
 #include "common/mathutil.h"
 #include "libANGLE/Error.h"
-
-#include <GLES2/gl2.h>
+#include "libANGLE/renderer/d3d/RendererD3D.h"
 
 namespace
 {
@@ -50,7 +51,7 @@ struct TranslatedIndexData
 class IndexDataManager
 {
   public:
-    explicit IndexDataManager(RendererD3D *renderer);
+    explicit IndexDataManager(BufferFactoryD3D *factory, RendererClass rendererClass);
     virtual ~IndexDataManager();
 
     gl::Error prepareIndexData(GLenum type, GLsizei count, gl::Buffer *arrayElementBuffer, const GLvoid *indices, TranslatedIndexData *translated);
@@ -60,8 +61,8 @@ class IndexDataManager
 
     DISALLOW_COPY_AND_ASSIGN(IndexDataManager);
 
-    RendererD3D *const mRenderer;
-
+    BufferFactoryD3D *const mFactory;
+    RendererClass mRendererClass;
     StreamingIndexBufferInterface *mStreamingBufferShort;
     StreamingIndexBufferInterface *mStreamingBufferInt;
 };

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -54,7 +54,24 @@ enum RendererClass
     RENDERER_D3D9,
 };
 
-class RendererD3D : public Renderer
+// Useful for unit testing
+class BufferFactoryD3D
+{
+  public:
+    BufferFactoryD3D() {}
+    virtual ~BufferFactoryD3D() {}
+
+    virtual VertexBuffer *createVertexBuffer() = 0;
+    virtual IndexBuffer *createIndexBuffer() = 0;
+
+    // TODO(jmadill): add VertexFormatCaps
+    virtual VertexConversionType getVertexConversionType(const gl::VertexFormat &vertexFormat) const = 0;
+    virtual GLenum getVertexComponentType(const gl::VertexFormat &vertexFormat) const = 0;
+
+    DISALLOW_COPY_AND_ASSIGN(BufferFactoryD3D);
+};
+
+class RendererD3D : public Renderer, public BufferFactoryD3D
 {
   public:
     explicit RendererD3D(egl::Display *display);
@@ -161,12 +178,6 @@ class RendererD3D : public Renderer
     virtual gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
                                               GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea) = 0;
 
-    virtual VertexConversionType getVertexConversionType(const gl::VertexFormat &vertexFormat) const = 0;
-    virtual GLenum getVertexComponentType(const gl::VertexFormat &vertexFormat) const = 0;
-
-    virtual VertexBuffer *createVertexBuffer() = 0;
-    virtual IndexBuffer *createIndexBuffer() = 0;
-
     // Device lost
     void notifyDeviceLost() override;
     virtual bool resetDevice() = 0;

src/libANGLE/renderer/d3d/VertexBuffer.cpp

@@ -38,13 +38,14 @@ unsigned int VertexBuffer::getSerial() const
     return mSerial;
 }
 
-VertexBufferInterface::VertexBufferInterface(RendererD3D *renderer, bool dynamic) : mRenderer(renderer)
+VertexBufferInterface::VertexBufferInterface(BufferFactoryD3D *factory, bool dynamic)
+    : mFactory(factory)
 {
     mDynamic = dynamic;
     mWritePosition = 0;
     mReservedSpace = 0;
 
-    mVertexBuffer = renderer->createVertexBuffer();
+    mVertexBuffer = factory->createVertexBuffer();
 }
 
 VertexBufferInterface::~VertexBufferInterface()
@@ -188,7 +189,8 @@ bool VertexBufferInterface::directStoragePossible(const gl::VertexAttribute &att
         getVertexBuffer()->getSpaceRequired(attrib, 1, 0, &outputElementSize);
         alignment = std::min<size_t>(outputElementSize, 4);
 
-        requiresConversion = (mRenderer->getVertexConversionType(vertexFormat) & VERTEX_CONVERT_CPU) != 0;
+        // TODO(jmadill): add VertexFormatCaps
+        requiresConversion = (mFactory->getVertexConversionType(vertexFormat) & VERTEX_CONVERT_CPU) != 0;
     }
 
     bool isAligned = (static_cast<size_t>(ComputeVertexAttributeStride(attrib)) % alignment == 0) &&
@@ -197,7 +199,8 @@ bool VertexBufferInterface::directStoragePossible(const gl::VertexAttribute &att
     return !requiresConversion && isAligned;
 }
 
-StreamingVertexBufferInterface::StreamingVertexBufferInterface(RendererD3D *renderer, std::size_t initialSize) : VertexBufferInterface(renderer, true)
+StreamingVertexBufferInterface::StreamingVertexBufferInterface(BufferFactoryD3D *factory, std::size_t initialSize)
+    : VertexBufferInterface(factory, true)
 {
     setBufferSize(initialSize);
 }
@@ -231,7 +234,8 @@ gl::Error StreamingVertexBufferInterface::reserveSpace(unsigned int size)
     return gl::Error(GL_NO_ERROR);
 }
 
-StaticVertexBufferInterface::StaticVertexBufferInterface(RendererD3D *renderer) : VertexBufferInterface(renderer, false)
+StaticVertexBufferInterface::StaticVertexBufferInterface(BufferFactoryD3D *factory)
+    : VertexBufferInterface(factory, false)
 {
 }
 

src/libANGLE/renderer/d3d/VertexBuffer.h

@@ -26,7 +26,7 @@ struct VertexAttribCurrentValueData;
 
 namespace rx
 {
-class RendererD3D;
+class BufferFactoryD3D;
 
 class VertexBuffer
 {
@@ -63,7 +63,7 @@ class VertexBuffer
 class VertexBufferInterface
 {
   public:
-    VertexBufferInterface(RendererD3D *renderer, bool dynamic);
+    VertexBufferInterface(BufferFactoryD3D *factory, bool dynamic);
     virtual ~VertexBufferInterface();
 
     gl::Error reserveVertexSpace(const gl::VertexAttribute &attribute, GLsizei count, GLsizei instances);
@@ -93,7 +93,7 @@ class VertexBufferInterface
   private:
     DISALLOW_COPY_AND_ASSIGN(VertexBufferInterface);
 
-    RendererD3D *const mRenderer;
+    BufferFactoryD3D *const mFactory;
 
     VertexBuffer* mVertexBuffer;
 
@@ -105,17 +105,19 @@ class VertexBufferInterface
 class StreamingVertexBufferInterface : public VertexBufferInterface
 {
   public:
-    StreamingVertexBufferInterface(RendererD3D *renderer, std::size_t initialSize);
+    StreamingVertexBufferInterface(BufferFactoryD3D *factory, std::size_t initialSize);
     ~StreamingVertexBufferInterface();
 
   protected:
     gl::Error reserveSpace(unsigned int size);
+
+    DISALLOW_COPY_AND_ASSIGN(StreamingVertexBufferInterface);
 };
 
 class StaticVertexBufferInterface : public VertexBufferInterface
 {
   public:
-    explicit StaticVertexBufferInterface(RendererD3D *renderer);
+    explicit StaticVertexBufferInterface(BufferFactoryD3D *factory);
     ~StaticVertexBufferInterface();
 
     gl::Error storeVertexAttributes(const gl::VertexAttribute &attrib, const gl::VertexAttribCurrentValueData &currentValue,
@@ -140,6 +142,8 @@ class StaticVertexBufferInterface : public VertexBufferInterface
     };
 
     std::vector<VertexElement> mCache;
+
+    DISALLOW_COPY_AND_ASSIGN(StaticVertexBufferInterface);
 };
 
 }

src/libANGLE/renderer/d3d/VertexDataManager.cpp

@@ -8,14 +8,14 @@
 // runs the Buffer translation process.
 
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
-#include "libANGLE/renderer/d3d/BufferD3D.h"
-#include "libANGLE/renderer/d3d/VertexBuffer.h"
-#include "libANGLE/renderer/Renderer.h"
+
 #include "libANGLE/Buffer.h"
 #include "libANGLE/Program.h"
+#include "libANGLE/State.h"
 #include "libANGLE/VertexAttribute.h"
 #include "libANGLE/VertexArray.h"
-#include "libANGLE/State.h"
+#include "libANGLE/renderer/d3d/BufferD3D.h"
+#include "libANGLE/renderer/d3d/VertexBuffer.h"
 
 namespace
 {
@@ -55,7 +55,8 @@ static int StreamingBufferElementCount(const gl::VertexAttribute &attrib, int ve
     return vertexDrawCount;
 }
 
-VertexDataManager::VertexDataManager(RendererD3D *renderer) : mRenderer(renderer)
+VertexDataManager::VertexDataManager(BufferFactoryD3D *factory)
+    : mFactory(factory)
 {
     for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
     {
@@ -68,7 +69,7 @@ VertexDataManager::VertexDataManager(RendererD3D *renderer) : mRenderer(renderer
         mCurrentValueOffsets[i] = 0;
     }
 
-    mStreamingBuffer = new StreamingVertexBufferInterface(renderer, INITIAL_STREAM_BUFFER_SIZE);
+    mStreamingBuffer = new StreamingVertexBufferInterface(factory, INITIAL_STREAM_BUFFER_SIZE);
 
     if (!mStreamingBuffer)
     {
@@ -170,7 +171,7 @@ gl::Error VertexDataManager::prepareVertexData(const gl::State &state, GLint sta
             {
                 if (!mCurrentValueBuffer[i])
                 {
-                    mCurrentValueBuffer[i] = new StreamingVertexBufferInterface(mRenderer, CONSTANT_VERTEX_BUFFER_SIZE);
+                    mCurrentValueBuffer[i] = new StreamingVertexBufferInterface(mFactory, CONSTANT_VERTEX_BUFFER_SIZE);
                 }
 
                 gl::Error error = storeCurrentValue(curAttrib, state.getVertexAttribCurrentValue(i), &translated[i],

src/libANGLE/renderer/d3d/VertexDataManager.h

@@ -24,9 +24,9 @@ struct VertexAttribCurrentValueData;
 namespace rx
 {
 class BufferD3D;
+class BufferFactoryD3D;
 class StreamingVertexBufferInterface;
 class VertexBuffer;
-class RendererD3D;
 
 struct TranslatedAttribute
 {
@@ -49,7 +49,7 @@ struct TranslatedAttribute
 class VertexDataManager
 {
   public:
-    VertexDataManager(RendererD3D *renderer);
+    VertexDataManager(BufferFactoryD3D *factory);
     virtual ~VertexDataManager();
 
     gl::Error prepareVertexData(const gl::State &state, GLint start, GLsizei count,
@@ -82,7 +82,7 @@ class VertexDataManager
 
     void hintUnmapAllResources(const std::vector<gl::VertexAttribute> &vertexAttributes);
 
-    RendererD3D *const mRenderer;
+    BufferFactoryD3D *const mFactory;
 
     StreamingVertexBufferInterface *mStreamingBuffer;
 

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

@@ -192,7 +192,7 @@ class Buffer11::SystemMemoryStorage : public Buffer11::BufferStorage
 };
 
 Buffer11::Buffer11(Renderer11 *renderer)
-    : BufferD3D(),
+    : BufferD3D(renderer),
       mRenderer(renderer),
       mSize(0),
       mMappedStorage(NULL),
@@ -448,11 +448,6 @@ void Buffer11::markBufferUsage()
     }
 }
 
-RendererD3D* Buffer11::getRenderer()
-{
-    return mRenderer;
-}
-
 ID3D11Buffer *Buffer11::getBuffer(BufferUsage usage)
 {
     markBufferUsage();

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

@@ -60,7 +60,6 @@ class Buffer11 : public BufferD3D
     // BufferD3D implementation
     virtual size_t getSize() const { return mSize; }
     virtual bool supportsDirectBinding() const;
-    RendererD3D *getRenderer() override;
 
     // BufferImpl implementation
     virtual gl::Error setData(const void* data, size_t size, GLenum usage);

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

@@ -496,7 +496,7 @@ void Renderer11::initializeDevice()
 
     ASSERT(!mVertexDataManager && !mIndexDataManager);
     mVertexDataManager = new VertexDataManager(this);
-    mIndexDataManager = new IndexDataManager(this);
+    mIndexDataManager = new IndexDataManager(this, getRendererClass());
 
     ASSERT(!mBlit);
     mBlit = new Blit11(this);

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

@@ -13,7 +13,7 @@ namespace rx
 {
 
 Buffer9::Buffer9(Renderer9 *renderer)
-    : BufferD3D(),
+    : BufferD3D(renderer),
       mRenderer(renderer),
       mSize(0)
 {}
@@ -113,9 +113,4 @@ void Buffer9::markTransformFeedbackUsage()
     UNREACHABLE();
 }
 
-RendererD3D *Buffer9::getRenderer()
-{
-    return mRenderer;
-}
-
 }

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

@@ -28,7 +28,6 @@ class Buffer9 : public BufferD3D
     // BufferD3D implementation
     virtual size_t getSize() const { return mSize; }
     virtual bool supportsDirectBinding() const { return false; }
-    RendererD3D *getRenderer() override;
 
     // BufferImpl implementation
     virtual gl::Error setData(const void* data, size_t size, GLenum usage);

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

@@ -378,7 +378,7 @@ void Renderer9::initializeDevice()
 
     ASSERT(!mVertexDataManager && !mIndexDataManager);
     mVertexDataManager = new VertexDataManager(this);
-    mIndexDataManager = new IndexDataManager(this);
+    mIndexDataManager = new IndexDataManager(this, getRendererClass());
 }
 
 D3DPRESENT_PARAMETERS Renderer9::getDefaultPresentParameters()