MANGLE the ANGLE Renderer class.

src/libEGL/Display.cpp

@@ -99,6 +99,7 @@ Error Display::initialize()
         return Error(EGL_NOT_INITIALIZED);
     }
 
+    //TODO(jmadill): should be part of caps?
     EGLint minSwapInterval = mRenderer->getMinSwapInterval();
     EGLint maxSwapInterval = mRenderer->getMaxSwapInterval();
     EGLint maxTextureSize = mRenderer->getRendererCaps().max2DTextureSize;
@@ -431,6 +432,7 @@ Error Display::createContext(EGLConfig configHandle, EGLint clientVersion, const
         }
     }
 
+    //TODO(jmadill): shader model is not cross-platform
     if (clientVersion > 2 && mRenderer->getMajorShaderModel() < 4)
     {
         return Error(EGL_BAD_CONFIG);
@@ -628,6 +630,7 @@ void Display::initVendorString()
 
     LUID adapterLuid = {0};
 
+    //TODO(jmadill): LUID is not cross-platform
     if (mRenderer && mRenderer->getLUID(&adapterLuid))
     {
         char adapterLuidString[64];

src/libEGL/Surface.cpp

@@ -24,13 +24,17 @@
 
 #include "common/NativeWindow.h"
 
+//TODO(jmadill): phase this out
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
+
 namespace egl
 {
 
 Surface::Surface(Display *display, const Config *config, EGLNativeWindowType window, EGLint fixedSize, EGLint width, EGLint height, EGLint postSubBufferSupported) 
     : mDisplay(display), mConfig(config), mNativeWindow(window), mPostSubBufferSupported(postSubBufferSupported)
 {
-    mRenderer = mDisplay->getRenderer();
+    //TODO(jmadill): MANGLE refactor. (note, can't call makeRendererD3D because of dll export issues)
+    mRenderer = static_cast<rx::RendererD3D*>(mDisplay->getRenderer());
     mSwapChain = NULL;
     mShareHandle = NULL;
     mTexture = NULL;
@@ -52,7 +56,8 @@ Surface::Surface(Display *display, const Config *config, EGLNativeWindowType win
 Surface::Surface(Display *display, const Config *config, HANDLE shareHandle, EGLint width, EGLint height, EGLenum textureFormat, EGLenum textureType)
     : mDisplay(display), mNativeWindow(NULL), mConfig(config), mShareHandle(shareHandle), mWidth(width), mHeight(height), mPostSubBufferSupported(EGL_FALSE)
 {
-    mRenderer = mDisplay->getRenderer();
+    //TODO(jmadill): MANGLE refactor. (note, can't call makeRendererD3D because of dll export issues)
+    mRenderer = static_cast<rx::RendererD3D*>(mDisplay->getRenderer());
     mSwapChain = NULL;
     mWindowSubclassed = false;
     mTexture = NULL;

src/libEGL/Surface.h

@@ -24,8 +24,8 @@ class Texture2D;
 }
 namespace rx
 {
-class Renderer;
 class SwapChain;
+class RendererD3D; //TODO(jmadill): remove this
 }
 
 namespace egl
@@ -71,11 +71,11 @@ class Surface
 
     EGLint isFixedSize() const;
 
-private:
+  private:
     DISALLOW_COPY_AND_ASSIGN(Surface);
 
     Display *const mDisplay;
-    rx::Renderer *mRenderer;
+    rx::RendererD3D *mRenderer;
 
     HANDLE mShareHandle;
     rx::SwapChain *mSwapChain;

src/libGLESv2/Buffer.h

@@ -19,7 +19,6 @@
 
 namespace rx
 {
-class Renderer;
 class BufferImpl;
 };
 

src/libGLESv2/Context.h

@@ -63,7 +63,7 @@ class TransformFeedback;
 class Context
 {
   public:
-    Context(int clientVersion, const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess);
+    Context(int clientVersion, const Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess);
 
     virtual ~Context();
 

src/libGLESv2/Fence.h

@@ -17,7 +17,6 @@
 
 namespace rx
 {
-class Renderer;
 class FenceNVImpl;
 class FenceSyncImpl;
 }

src/libGLESv2/Framebuffer.h

@@ -38,7 +38,6 @@ class Framebuffer
 {
   public:
     Framebuffer(GLuint id);
-
     virtual ~Framebuffer();
 
     GLuint id() const { return mId; }

src/libGLESv2/FramebufferAttachment.h

@@ -16,13 +16,6 @@
 
 #include "angle_gl.h"
 
-namespace rx
-{
-class Renderer;
-class RenderTarget;
-class TextureStorage;
-}
-
 namespace gl
 {
 class Renderbuffer;

src/libGLESv2/ProgramBinary.h

@@ -39,7 +39,6 @@ class HLSLBlockEncoder;
 namespace rx
 {
 class ShaderExecutable;
-class Renderer;
 struct TranslatedAttribute;
 class UniformStorage;
 class ProgramImpl;

src/libGLESv2/Renderbuffer.cpp

@@ -12,7 +12,7 @@
 #include "libGLESv2/Texture.h"
 #include "libGLESv2/formatutils.h"
 #include "libGLESv2/FramebufferAttachment.h"
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 #include "libGLESv2/renderer/RenderTarget.h"
 #include "libGLESv2/renderer/RenderbufferImpl.h"
 

src/libGLESv2/ResourceManager.cpp

@@ -21,9 +21,9 @@
 namespace gl
 {
 ResourceManager::ResourceManager(rx::Renderer *renderer)
+    : mRenderer(renderer),
+      mRefCount(1)
 {
-    mRefCount = 1;
-    mRenderer = renderer;
 }
 
 ResourceManager::~ResourceManager()

src/libGLESv2/ResourceManager.h

@@ -78,8 +78,8 @@ class ResourceManager
   private:
     DISALLOW_COPY_AND_ASSIGN(ResourceManager);
 
-    std::size_t mRefCount;
     rx::Renderer *mRenderer;
+    std::size_t mRefCount;
 
     typedef std::unordered_map<GLuint, Buffer*> BufferMap;
     BufferMap mBufferMap;

src/libGLESv2/VertexArray.h

@@ -21,7 +21,6 @@
 
 namespace rx
 {
-class Renderer;
 class VertexArrayImpl;
 }
 

src/libGLESv2/renderer/Image.h

@@ -25,7 +25,7 @@ struct ImageIndex;
 
 namespace rx
 {
-class Renderer;
+class RendererD3D;
 class RenderTarget;
 class TextureStorage;
 
@@ -47,7 +47,7 @@ class Image
     void markClean() {mDirty = false;}
     virtual bool isDirty() const = 0;
 
-    virtual bool redefine(Renderer *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease) = 0;
+    virtual bool redefine(RendererD3D *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease) = 0;
 
     virtual gl::Error loadData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
                                GLint unpackAlignment, GLenum type, const void *input) = 0;

src/libGLESv2/renderer/ProgramImpl.h

@@ -21,8 +21,6 @@
 namespace rx
 {
 
-class Renderer;
-
 class ProgramImpl
 {
   public:

src/libGLESv2/renderer/Renderer.cpp

@@ -6,14 +6,12 @@
 
 // Renderer.cpp: Implements EGL dependencies for creating and destroying Renderer instances.
 
+#include "common/utilities.h"
+#include "libEGL/AttributeMap.h"
 #include "libGLESv2/main.h"
-#include "libGLESv2/Program.h"
 #include "libGLESv2/renderer/Renderer.h"
-#include "common/utilities.h"
-#include "third_party/trace_event/trace_event.h"
-#include "libGLESv2/Shader.h"
 
-#include "libEGL/AttributeMap.h"
+#include <EGL/eglext.h>
 
 #if defined (ANGLE_ENABLE_D3D9)
 #include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
@@ -32,16 +30,12 @@
 #define ANGLE_DEFAULT_D3D11 0
 #endif
 
-#include <EGL/eglext.h>
-
 namespace rx
 {
 
-Renderer::Renderer(egl::Display *display)
-    : mDisplay(display),
-      mCapsInitialized(false),
-      mWorkaroundsInitialized(false),
-      mCurrentClientVersion(2)
+Renderer::Renderer()
+    : mCapsInitialized(false),
+      mWorkaroundsInitialized(false)
 {
 }
 
@@ -171,7 +165,8 @@ rx::Renderer *glCreateRenderer(egl::Display *display, EGLNativeDisplayType nativ
 
 void glDestroyRenderer(rx::Renderer *renderer)
 {
-    delete renderer;
+    ASSERT(renderer);
+    SafeDelete(renderer);
 }
 
 }

src/libGLESv2/renderer/TextureImpl.h

@@ -32,8 +32,6 @@ namespace rx
 {
 
 class Image;
-class Renderer;
-class TextureStorage;
 
 class TextureImpl
 {

src/libGLESv2/renderer/d3d/BufferD3D.cpp

@@ -9,7 +9,6 @@
 #include "libGLESv2/renderer/d3d/BufferD3D.h"
 #include "libGLESv2/renderer/d3d/VertexBuffer.h"
 #include "libGLESv2/renderer/d3d/IndexBuffer.h"
-#include "libGLESv2/renderer/Renderer.h"
 #include "libGLESv2/main.h"
 
 namespace rx

src/libGLESv2/renderer/d3d/BufferD3D.h

@@ -16,8 +16,7 @@
 
 namespace rx
 {
-
-class Renderer;
+class RendererD3D;
 class StaticIndexBufferInterface;
 class StaticVertexBufferInterface;
 
@@ -35,7 +34,7 @@ class BufferD3D : public BufferImpl
     virtual gl::Error getData(const uint8_t **outData) = 0;
     virtual size_t getSize() const = 0;
     virtual bool supportsDirectBinding() const = 0;
-    virtual Renderer* getRenderer() = 0;
+    virtual RendererD3D *getRenderer() = 0;
 
     rx::StaticVertexBufferInterface *getStaticVertexBuffer() { return mStaticVertexBuffer; }
     rx::StaticIndexBufferInterface *getStaticIndexBuffer() { return mStaticIndexBuffer; }

src/libGLESv2/renderer/d3d/DynamicHLSL.cpp

@@ -8,7 +8,7 @@
 
 #include "libGLESv2/renderer/d3d/DynamicHLSL.h"
 #include "libGLESv2/renderer/d3d/ShaderD3D.h"
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 #include "libGLESv2/Shader.h"
 #include "libGLESv2/Program.h"
 #include "libGLESv2/ProgramBinary.h"
@@ -93,7 +93,7 @@ namespace rx
 const std::string VERTEX_ATTRIBUTE_STUB_STRING = "@@ VERTEX ATTRIBUTES @@";
 const std::string PIXEL_OUTPUT_STUB_STRING = "@@ PIXEL OUTPUT @@";
 
-DynamicHLSL::DynamicHLSL(rx::Renderer *const renderer)
+DynamicHLSL::DynamicHLSL(RendererD3D *const renderer)
     : mRenderer(renderer)
 {
 }

src/libGLESv2/renderer/d3d/DynamicHLSL.h

@@ -17,11 +17,6 @@
 #include <vector>
 #include <map>
 
-namespace rx
-{
-class Renderer;
-}
-
 namespace sh
 {
 struct Attribute;
@@ -40,7 +35,7 @@ struct PackedVarying;
 
 namespace rx
 {
-class Renderer;
+class RendererD3D;
 class ShaderD3D;
 
 typedef const gl::PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
@@ -56,7 +51,7 @@ struct PixelShaderOutputVariable
 class DynamicHLSL
 {
   public:
-    explicit DynamicHLSL(rx::Renderer *const renderer);
+    explicit DynamicHLSL(rx::RendererD3D *const renderer);
 
     int packVaryings(gl::InfoLog &infoLog, VaryingPacking packing, rx::ShaderD3D *fragmentShader,
                      rx::ShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
@@ -79,7 +74,7 @@ class DynamicHLSL
   private:
     DISALLOW_COPY_AND_ASSIGN(DynamicHLSL);
 
-    rx::Renderer *const mRenderer;
+    rx::RendererD3D *const mRenderer;
 
     struct SemanticInfo;
 

src/libGLESv2/renderer/d3d/IndexBuffer.cpp

@@ -8,7 +8,7 @@
 // class with derivations, classes that perform graphics API agnostic index buffer operations.
 
 #include "libGLESv2/renderer/d3d/IndexBuffer.h"
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 
 namespace rx
 {
@@ -35,7 +35,7 @@ void IndexBuffer::updateSerial()
 }
 
 
-IndexBufferInterface::IndexBufferInterface(Renderer *renderer, bool dynamic) : mRenderer(renderer)
+IndexBufferInterface::IndexBufferInterface(RendererD3D *renderer, bool dynamic) : mRenderer(renderer)
 {
     mIndexBuffer = renderer->createIndexBuffer();
 
@@ -130,7 +130,7 @@ gl::Error IndexBufferInterface::setBufferSize(unsigned int bufferSize, GLenum in
     }
 }
 
-StreamingIndexBufferInterface::StreamingIndexBufferInterface(Renderer *renderer) : IndexBufferInterface(renderer, true)
+StreamingIndexBufferInterface::StreamingIndexBufferInterface(RendererD3D *renderer) : IndexBufferInterface(renderer, true)
 {
 }
 
@@ -165,7 +165,7 @@ gl::Error StreamingIndexBufferInterface::reserveBufferSpace(unsigned int size, G
 }
 
 
-StaticIndexBufferInterface::StaticIndexBufferInterface(Renderer *renderer) : IndexBufferInterface(renderer, false)
+StaticIndexBufferInterface::StaticIndexBufferInterface(RendererD3D *renderer) : IndexBufferInterface(renderer, false)
 {
 }
 

src/libGLESv2/renderer/d3d/IndexBuffer.h

@@ -16,7 +16,7 @@
 
 namespace rx
 {
-class Renderer;
+class RendererD3D;
 
 class IndexBuffer
 {
@@ -50,7 +50,7 @@ class IndexBuffer
 class IndexBufferInterface
 {
   public:
-    IndexBufferInterface(Renderer *renderer, bool dynamic);
+    IndexBufferInterface(RendererD3D *renderer, bool dynamic);
     virtual ~IndexBufferInterface();
 
     virtual gl::Error reserveBufferSpace(unsigned int size, GLenum indexType) = 0;
@@ -76,7 +76,7 @@ class IndexBufferInterface
   private:
     DISALLOW_COPY_AND_ASSIGN(IndexBufferInterface);
 
-    rx::Renderer *const mRenderer;
+    rx::RendererD3D *const mRenderer;
 
     IndexBuffer* mIndexBuffer;
 
@@ -87,7 +87,7 @@ class IndexBufferInterface
 class StreamingIndexBufferInterface : public IndexBufferInterface
 {
   public:
-    StreamingIndexBufferInterface(Renderer *renderer);
+    StreamingIndexBufferInterface(RendererD3D *renderer);
     ~StreamingIndexBufferInterface();
 
     virtual gl::Error reserveBufferSpace(unsigned int size, GLenum indexType);
@@ -96,7 +96,7 @@ class StreamingIndexBufferInterface : public IndexBufferInterface
 class StaticIndexBufferInterface : public IndexBufferInterface
 {
   public:
-    explicit StaticIndexBufferInterface(Renderer *renderer);
+    explicit StaticIndexBufferInterface(RendererD3D *renderer);
     ~StaticIndexBufferInterface();
 
     virtual gl::Error reserveBufferSpace(unsigned int size, GLenum indexType);

src/libGLESv2/renderer/d3d/IndexDataManager.cpp

@@ -10,7 +10,7 @@
 #include "libGLESv2/renderer/d3d/IndexDataManager.h"
 #include "libGLESv2/renderer/d3d/BufferD3D.h"
 #include "libGLESv2/renderer/d3d/IndexBuffer.h"
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 #include "libGLESv2/Buffer.h"
 #include "libGLESv2/main.h"
 #include "libGLESv2/formatutils.h"
@@ -57,7 +57,7 @@ static void ConvertIndices(GLenum sourceType, GLenum destinationType, const void
     else UNREACHABLE();
 }
 
-IndexDataManager::IndexDataManager(Renderer *renderer)
+IndexDataManager::IndexDataManager(RendererD3D *renderer)
     : mRenderer(renderer),
       mStreamingBufferShort(NULL),
       mStreamingBufferInt(NULL)

src/libGLESv2/renderer/d3d/IndexDataManager.h

@@ -33,7 +33,7 @@ class StaticIndexBufferInterface;
 class StreamingIndexBufferInterface;
 class IndexBuffer;
 class BufferD3D;
-class Renderer;
+class RendererD3D;
 
 struct TranslatedIndexData
 {
@@ -50,7 +50,7 @@ struct TranslatedIndexData
 class IndexDataManager
 {
   public:
-    explicit IndexDataManager(Renderer *renderer);
+    explicit IndexDataManager(RendererD3D *renderer);
     virtual ~IndexDataManager();
 
     gl::Error prepareIndexData(GLenum type, GLsizei count, gl::Buffer *arrayElementBuffer, const GLvoid *indices, TranslatedIndexData *translated);
@@ -60,7 +60,7 @@ class IndexDataManager
 
     DISALLOW_COPY_AND_ASSIGN(IndexDataManager);
 
-    Renderer *const mRenderer;
+    RendererD3D *const mRenderer;
 
     StreamingIndexBufferInterface *mStreamingBufferShort;
     StreamingIndexBufferInterface *mStreamingBufferInt;

src/libGLESv2/renderer/d3d/ProgramD3D.cpp

@@ -14,11 +14,11 @@
 #include "libGLESv2/FramebufferAttachment.h"
 #include "libGLESv2/Program.h"
 #include "libGLESv2/ProgramBinary.h"
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/main.h"
 #include "libGLESv2/renderer/ShaderExecutable.h"
 #include "libGLESv2/renderer/d3d/DynamicHLSL.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 #include "libGLESv2/renderer/d3d/ShaderD3D.h"
-#include "libGLESv2/main.h"
 
 namespace rx
 {
@@ -149,7 +149,7 @@ ProgramD3D::Sampler::Sampler() : active(false), logicalTextureUnit(0), textureTy
 {
 }
 
-ProgramD3D::ProgramD3D(Renderer *renderer)
+ProgramD3D::ProgramD3D(RendererD3D *renderer)
     : ProgramImpl(),
       mRenderer(renderer),
       mDynamicHLSL(NULL),

src/libGLESv2/renderer/d3d/ProgramD3D.h

@@ -24,13 +24,13 @@ struct VertexFormat;
 
 namespace rx
 {
-
+class RendererD3D;
 class UniformStorage;
 
 class ProgramD3D : public ProgramImpl
 {
   public:
-    ProgramD3D(rx::Renderer *renderer);
+    ProgramD3D(rx::RendererD3D *renderer);
     virtual ~ProgramD3D();
 
     static ProgramD3D *makeProgramD3D(ProgramImpl *impl);
@@ -181,7 +181,7 @@ class ProgramD3D : public ProgramImpl
                                    sh::BlockLayoutEncoder *encoder, std::vector<unsigned int> *blockUniformIndexes,
                                    bool inRowMajorLayout);
 
-    Renderer *mRenderer;
+    RendererD3D *mRenderer;
     DynamicHLSL *mDynamicHLSL;
 
     std::vector<VertexExecutable *> mVertexExecutables;

src/libGLESv2/renderer/d3d/RenderbufferD3D.cpp

@@ -9,12 +9,12 @@
 
 #include "libGLESv2/renderer/d3d/RenderbufferD3D.h"
 
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 #include "libGLESv2/renderer/RenderTarget.h"
 
 namespace rx
 {
-RenderbufferD3D::RenderbufferD3D(Renderer *renderer) : mRenderer(renderer)
+RenderbufferD3D::RenderbufferD3D(RendererD3D *renderer) : mRenderer(renderer)
 {
     mRenderTarget = NULL;
 }

src/libGLESv2/renderer/d3d/RenderbufferD3D.h

@@ -16,14 +16,14 @@
 
 namespace rx
 {
-class Renderer;
+class RendererD3D;
 class RenderTarget;
 class SwapChain;
 
 class RenderbufferD3D : public RenderbufferImpl
 {
   public:
-    RenderbufferD3D(Renderer *renderer);
+    RenderbufferD3D(RendererD3D *renderer);
     virtual ~RenderbufferD3D();
 
     static RenderbufferD3D *makeRenderbufferD3D(RenderbufferImpl *renderbuffer);
@@ -43,7 +43,7 @@ class RenderbufferD3D : public RenderbufferImpl
   private:
     DISALLOW_COPY_AND_ASSIGN(RenderbufferD3D);
 
-    Renderer *mRenderer;
+    RendererD3D *mRenderer;
     RenderTarget *mRenderTarget;
 };
 }

src/libGLESv2/renderer/d3d/RendererD3D.cpp

@@ -12,7 +12,8 @@ namespace rx
 {
 
 RendererD3D::RendererD3D(egl::Display *display)
-    : Renderer(display)
+    : mDisplay(display),
+      mCurrentClientVersion(2)
 {
 }
 
@@ -20,4 +21,11 @@ RendererD3D::~RendererD3D()
 {
 }
 
-}  // namespace rx
+// static
+RendererD3D *RendererD3D::makeRendererD3D(Renderer *renderer)
+{
+    ASSERT(HAS_DYNAMIC_TYPE(RendererD3D*, renderer));
+    return static_cast<RendererD3D*>(renderer);
+}
+
+}

src/libGLESv2/renderer/d3d/RendererD3D.h

@@ -11,8 +11,24 @@
 
 #include "libGLESv2/renderer/Renderer.h"
 
+namespace gl
+{
+class InfoLog;
+struct LinkedVarying;
+class Texture;
+}
+
 namespace rx
 {
+class TextureStorage;
+class VertexBuffer;
+class IndexBuffer;
+class ShaderExecutable;
+class SwapChain;
+class RenderTarget;
+class Image;
+class TextureStorage;
+class UniformStorage;
 
 class RendererD3D : public Renderer
 {
@@ -20,8 +36,107 @@ class RendererD3D : public Renderer
     explicit RendererD3D(egl::Display *display);
     virtual ~RendererD3D();
 
+    static RendererD3D *makeRendererD3D(Renderer *renderer);
+
+    // Direct3D Specific methods
+    virtual SwapChain *createSwapChain(rx::NativeWindow nativeWindow, HANDLE shareHandle, GLenum backBufferFormat, GLenum depthBufferFormat) = 0;
+
+    virtual gl::Error generateSwizzle(gl::Texture *texture) = 0;
+    virtual gl::Error setSamplerState(gl::SamplerType type, int index, gl::Texture *texture, const gl::SamplerState &sampler) = 0;
+    virtual gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture) = 0;
+
+    virtual gl::Error setUniformBuffers(const gl::Buffer *vertexUniformBuffers[], const gl::Buffer *fragmentUniformBuffers[]) = 0;
+
+    virtual gl::Error setRasterizerState(const gl::RasterizerState &rasterState) = 0;
+    virtual gl::Error setBlendState(gl::Framebuffer *framebuffer, const gl::BlendState &blendState, const gl::ColorF &blendColor,
+                                    unsigned int sampleMask) = 0;
+    virtual gl::Error setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
+                                           int stencilBackRef, bool frontFaceCCW) = 0;
+
+    virtual void setScissorRectangle(const gl::Rectangle &scissor, bool enabled) = 0;
+    virtual void setViewport(const gl::Rectangle &viewport, float zNear, float zFar, GLenum drawMode, GLenum frontFace,
+                             bool ignoreViewport) = 0;
+
+    virtual gl::Error applyRenderTarget(gl::Framebuffer *frameBuffer) = 0;
+    virtual gl::Error applyShaders(gl::ProgramBinary *programBinary, const gl::VertexFormat inputLayout[], const gl::Framebuffer *framebuffer,
+                                   bool rasterizerDiscard, bool transformFeedbackActive) = 0;
+    virtual gl::Error applyUniforms(const ProgramImpl &program, const std::vector<gl::LinkedUniform*> &uniformArray) = 0;
+    virtual bool applyPrimitiveType(GLenum primitiveType, GLsizei elementCount) = 0;
+    virtual gl::Error applyVertexBuffer(const gl::State &state, GLint first, GLsizei count, GLsizei instances) = 0;
+    virtual gl::Error applyIndexBuffer(const GLvoid *indices, gl::Buffer *elementArrayBuffer, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo) = 0;
+    virtual void applyTransformFeedbackBuffers(const gl::State& state) = 0;
+
+    virtual void markAllStateDirty() = 0;
+
+    virtual unsigned int getReservedVertexUniformVectors() const = 0;
+    virtual unsigned int getReservedFragmentUniformVectors() const = 0;
+    virtual unsigned int getReservedVertexUniformBuffers() const = 0;
+    virtual unsigned int getReservedFragmentUniformBuffers() const = 0;
+    virtual bool getShareHandleSupport() const = 0;
+    virtual bool getPostSubBufferSupport() const = 0;
+
+    // Pixel operations
+    virtual gl::Error copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
+                                  GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level) = 0;
+    virtual gl::Error copyImageCube(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
+                                    GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level) = 0;
+    virtual gl::Error copyImage3D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
+                                  GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level) = 0;
+    virtual gl::Error copyImage2DArray(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
+                                       GLint xoffset, GLint yoffset, GLint zOffset, TextureStorage *storage, GLint level) = 0;
+
+    virtual gl::Error blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget, const gl::Rectangle &drawRect,
+                               const gl::Rectangle *scissor, bool blitRenderTarget, bool blitDepth, bool blitStencil, GLenum filter) = 0;
+
+    virtual gl::Error readPixels(gl::Framebuffer *framebuffer, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
+                                 GLenum type, GLuint outputPitch, const gl::PixelPackState &pack, uint8_t *pixels) = 0;
+
+    // RenderTarget creation
+    virtual gl::Error createRenderTarget(SwapChain *swapChain, bool depth, RenderTarget **outRT) = 0;
+    virtual gl::Error createRenderTarget(int width, int height, GLenum format, GLsizei samples, RenderTarget **outRT) = 0;
+
+    // Shader operations
+    virtual void releaseShaderCompiler() = 0;
+    virtual gl::Error loadExecutable(const void *function, size_t length, rx::ShaderType type,
+                                     const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
+                                     bool separatedOutputBuffers, ShaderExecutable **outExecutable) = 0;
+    virtual gl::Error compileToExecutable(gl::InfoLog &infoLog, const std::string &shaderHLSL, rx::ShaderType type,
+                                          const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
+                                          bool separatedOutputBuffers, D3DWorkaroundType workaround,
+                                          ShaderExecutable **outExectuable) = 0;
+    virtual UniformStorage *createUniformStorage(size_t storageSize) = 0;
+
+    // Image operations
+    virtual Image *createImage() = 0;
+    virtual gl::Error generateMipmap(Image *dest, Image *source) = 0;
+    virtual TextureStorage *createTextureStorage2D(SwapChain *swapChain) = 0;
+    virtual TextureStorage *createTextureStorage2D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels) = 0;
+    virtual TextureStorage *createTextureStorageCube(GLenum internalformat, bool renderTarget, int size, int levels) = 0;
+    virtual TextureStorage *createTextureStorage3D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels) = 0;
+    virtual TextureStorage *createTextureStorage2DArray(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels) = 0;
+
+    // Current GLES client version
+    void setCurrentClientVersion(int clientVersion) { mCurrentClientVersion = clientVersion; }
+    int getCurrentClientVersion() const { return mCurrentClientVersion; }
+
+    // Buffer-to-texture and Texture-to-buffer copies
+    virtual bool supportsFastCopyBufferToTexture(GLenum internalFormat) const = 0;
+    virtual gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTarget *destRenderTarget,
+                                              GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea) = 0;
+
+    virtual rx::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;
+
+  protected:
+    egl::Display *mDisplay;
+
   private:
     DISALLOW_COPY_AND_ASSIGN(RendererD3D);
+
+    int mCurrentClientVersion;
 };
 
 }

src/libGLESv2/renderer/d3d/ShaderD3D.cpp

@@ -6,10 +6,10 @@
 
 // ShaderD3D.cpp: Defines the rx::ShaderD3D class which implements rx::ShaderImpl.
 
-#include "libGLESv2/renderer/d3d/ShaderD3D.h"
-#include "libGLESv2/renderer/Renderer.h"
 #include "libGLESv2/Shader.h"
 #include "libGLESv2/main.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
+#include "libGLESv2/renderer/d3d/ShaderD3D.h"
 
 #include "common/features.h"
 #include "common/utilities.h"
@@ -67,7 +67,7 @@ const std::vector<VarT> *GetShaderVariables(const std::vector<VarT> *variableLis
     return variableList;
 }
 
-ShaderD3D::ShaderD3D(GLenum type, rx::Renderer *renderer)
+ShaderD3D::ShaderD3D(GLenum type, RendererD3D *renderer)
     : mType(type),
       mRenderer(renderer),
       mShaderVersion(100)

src/libGLESv2/renderer/d3d/ShaderD3D.h

@@ -18,14 +18,14 @@
 namespace rx
 {
 class DynamicHLSL;
-class Renderer;
+class RendererD3D;
 
 class ShaderD3D : public ShaderImpl
 {
     friend class DynamicHLSL;
 
   public:
-    ShaderD3D(GLenum type, rx::Renderer *renderer);
+    ShaderD3D(GLenum type, rx::RendererD3D *renderer);
     virtual ~ShaderD3D();
 
     static ShaderD3D *makeShaderD3D(ShaderImpl *impl);
@@ -70,7 +70,7 @@ class ShaderD3D : public ShaderImpl
     static void *mVertexCompiler;
 
     GLenum mType;
-    rx::Renderer *mRenderer;
+    RendererD3D *mRenderer;
 
     int mShaderVersion;
 

src/libGLESv2/renderer/d3d/TextureD3D.cpp

@@ -6,17 +6,18 @@
 
 // TextureD3D.cpp: Implementations of the Texture interfaces shared betweeen the D3D backends.
 
-#include "libGLESv2/renderer/d3d/TextureD3D.h"
-#include "libGLESv2/renderer/d3d/TextureStorage.h"
-#include "libGLESv2/renderer/d3d/ImageD3D.h"
-#include "libGLESv2/renderer/d3d/BufferD3D.h"
+#include "libGLESv2/Buffer.h"
 #include "libGLESv2/Framebuffer.h"
 #include "libGLESv2/Texture.h"
 #include "libGLESv2/main.h"
 #include "libGLESv2/formatutils.h"
 #include "libGLESv2/renderer/BufferImpl.h"
 #include "libGLESv2/renderer/RenderTarget.h"
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/BufferD3D.h"
+#include "libGLESv2/renderer/d3d/TextureD3D.h"
+#include "libGLESv2/renderer/d3d/TextureStorage.h"
+#include "libGLESv2/renderer/d3d/ImageD3D.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 
 #include "libEGL/Surface.h"
 
@@ -65,7 +66,7 @@ bool IsRenderTargetUsage(GLenum usage)
 
 }
 
-TextureD3D::TextureD3D(Renderer *renderer)
+TextureD3D::TextureD3D(RendererD3D *renderer)
     : mRenderer(renderer),
       mUsage(GL_NONE),
       mDirtyImages(true),
@@ -510,7 +511,7 @@ gl::Error TextureD3D::commitRegion(const gl::ImageIndex &index, const gl::Box &r
     return gl::Error(GL_NO_ERROR);
 }
 
-TextureD3D_2D::TextureD3D_2D(Renderer *renderer)
+TextureD3D_2D::TextureD3D_2D(RendererD3D *renderer)
     : TextureD3D(renderer)
 {
     for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
@@ -1123,7 +1124,7 @@ bool TextureD3D_2D::isValidIndex(const gl::ImageIndex &index) const
             index.mipIndex >= 0 && index.mipIndex < mTexStorage->getLevelCount());
 }
 
-TextureD3D_Cube::TextureD3D_Cube(Renderer *renderer)
+TextureD3D_Cube::TextureD3D_Cube(RendererD3D *renderer)
     : TextureD3D(renderer)
 {
     for (int i = 0; i < 6; i++)
@@ -1669,7 +1670,7 @@ bool TextureD3D_Cube::isValidIndex(const gl::ImageIndex &index) const
             index.mipIndex >= 0 && index.mipIndex < mTexStorage->getLevelCount());
 }
 
-TextureD3D_3D::TextureD3D_3D(Renderer *renderer)
+TextureD3D_3D::TextureD3D_3D(RendererD3D *renderer)
     : TextureD3D(renderer)
 {
     for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
@@ -2233,7 +2234,7 @@ bool TextureD3D_3D::isValidIndex(const gl::ImageIndex &index) const
             index.mipIndex >= 0 && index.mipIndex < mTexStorage->getLevelCount());
 }
 
-TextureD3D_2DArray::TextureD3D_2DArray(Renderer *renderer)
+TextureD3D_2DArray::TextureD3D_2DArray(RendererD3D *renderer)
     : TextureD3D(renderer)
 {
     for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level)

src/libGLESv2/renderer/d3d/TextureD3D.h

@@ -23,14 +23,14 @@ namespace rx
 
 class Image;
 class ImageD3D;
-class Renderer;
+class RendererD3D;
 class RenderTarget;
 class TextureStorage;
 
 class TextureD3D : public TextureImpl
 {
   public:
-    TextureD3D(Renderer *renderer);
+    TextureD3D(RendererD3D *renderer);
     virtual ~TextureD3D();
 
     static TextureD3D *makeTextureD3D(TextureImpl *texture);
@@ -87,7 +87,7 @@ class TextureD3D : public TextureImpl
     virtual gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage) = 0;
     gl::Error commitRegion(const gl::ImageIndex &index, const gl::Box &region);
 
-    Renderer *mRenderer;
+    RendererD3D *mRenderer;
 
     GLenum mUsage;
 
@@ -109,7 +109,7 @@ class TextureD3D : public TextureImpl
 class TextureD3D_2D : public TextureD3D
 {
   public:
-    TextureD3D_2D(Renderer *renderer);
+    TextureD3D_2D(RendererD3D *renderer);
     virtual ~TextureD3D_2D();
 
     virtual Image *getImage(int level, int layer) const;
@@ -164,7 +164,7 @@ class TextureD3D_2D : public TextureD3D
 class TextureD3D_Cube : public TextureD3D
 {
   public:
-    TextureD3D_Cube(Renderer *renderer);
+    TextureD3D_Cube(RendererD3D *renderer);
     virtual ~TextureD3D_Cube();
 
     virtual Image *getImage(int level, int layer) const;
@@ -220,7 +220,7 @@ class TextureD3D_Cube : public TextureD3D
 class TextureD3D_3D : public TextureD3D
 {
   public:
-    TextureD3D_3D(Renderer *renderer);
+    TextureD3D_3D(RendererD3D *renderer);
     virtual ~TextureD3D_3D();
 
     virtual Image *getImage(int level, int layer) const;
@@ -274,7 +274,7 @@ class TextureD3D_3D : public TextureD3D
 class TextureD3D_2DArray : public TextureD3D
 {
   public:
-    TextureD3D_2DArray(Renderer *renderer);
+    TextureD3D_2DArray(RendererD3D *renderer);
     virtual ~TextureD3D_2DArray();
 
     virtual Image *getImage(int level, int layer) const;

src/libGLESv2/renderer/d3d/TextureStorage.h

@@ -26,7 +26,6 @@ struct PixelUnpackState;
 
 namespace rx
 {
-class Renderer;
 class SwapChain;
 class RenderTarget;
 class Image;

src/libGLESv2/renderer/d3d/VertexBuffer.cpp

@@ -9,7 +9,7 @@
 
 #include "libGLESv2/renderer/d3d/VertexBuffer.h"
 #include "libGLESv2/renderer/d3d/BufferD3D.h"
-#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/RendererD3D.h"
 #include "libGLESv2/VertexAttribute.h"
 
 #include "common/mathutil.h"
@@ -38,7 +38,7 @@ unsigned int VertexBuffer::getSerial() const
     return mSerial;
 }
 
-VertexBufferInterface::VertexBufferInterface(rx::Renderer *renderer, bool dynamic) : mRenderer(renderer)
+VertexBufferInterface::VertexBufferInterface(RendererD3D *renderer, bool dynamic) : mRenderer(renderer)
 {
     mDynamic = dynamic;
     mWritePosition = 0;
@@ -197,7 +197,7 @@ bool VertexBufferInterface::directStoragePossible(const gl::VertexAttribute &att
     return !requiresConversion && isAligned;
 }
 
-StreamingVertexBufferInterface::StreamingVertexBufferInterface(rx::Renderer *renderer, std::size_t initialSize) : VertexBufferInterface(renderer, true)
+StreamingVertexBufferInterface::StreamingVertexBufferInterface(RendererD3D *renderer, std::size_t initialSize) : VertexBufferInterface(renderer, true)
 {
     setBufferSize(initialSize);
 }
@@ -231,7 +231,7 @@ gl::Error StreamingVertexBufferInterface::reserveSpace(unsigned int size)
     return gl::Error(GL_NO_ERROR);
 }
 
-StaticVertexBufferInterface::StaticVertexBufferInterface(rx::Renderer *renderer) : VertexBufferInterface(renderer, false)
+StaticVertexBufferInterface::StaticVertexBufferInterface(RendererD3D *renderer) : VertexBufferInterface(renderer, false)
 {
 }
 

src/libGLESv2/renderer/d3d/VertexBuffer.h

@@ -26,7 +26,7 @@ struct VertexAttribCurrentValueData;
 
 namespace rx
 {
-class Renderer;
+class RendererD3D;
 
 class VertexBuffer
 {
@@ -60,7 +60,7 @@ class VertexBuffer
 class VertexBufferInterface
 {
   public:
-    VertexBufferInterface(rx::Renderer *renderer, bool dynamic);
+    VertexBufferInterface(rx::RendererD3D *renderer, bool dynamic);
     virtual ~VertexBufferInterface();
 
     gl::Error reserveVertexSpace(const gl::VertexAttribute &attribute, GLsizei count, GLsizei instances);
@@ -90,7 +90,7 @@ class VertexBufferInterface
   private:
     DISALLOW_COPY_AND_ASSIGN(VertexBufferInterface);
 
-    rx::Renderer *const mRenderer;
+    rx::RendererD3D *const mRenderer;
 
     VertexBuffer* mVertexBuffer;
 
@@ -102,7 +102,7 @@ class VertexBufferInterface
 class StreamingVertexBufferInterface : public VertexBufferInterface
 {
   public:
-    StreamingVertexBufferInterface(rx::Renderer *renderer, std::size_t initialSize);
+    StreamingVertexBufferInterface(rx::RendererD3D *renderer, std::size_t initialSize);
     ~StreamingVertexBufferInterface();
 
   protected:
@@ -112,7 +112,7 @@ class StreamingVertexBufferInterface : public VertexBufferInterface
 class StaticVertexBufferInterface : public VertexBufferInterface
 {
   public:
-    explicit StaticVertexBufferInterface(rx::Renderer *renderer);
+    explicit StaticVertexBufferInterface(rx::RendererD3D *renderer);
     ~StaticVertexBufferInterface();
 
     gl::Error storeVertexAttributes(const gl::VertexAttribute &attrib, const gl::VertexAttribCurrentValueData &currentValue,

src/libGLESv2/renderer/d3d/VertexDataManager.cpp

@@ -52,7 +52,7 @@ static int StreamingBufferElementCount(const gl::VertexAttribute &attrib, int ve
     return vertexDrawCount;
 }
 
-VertexDataManager::VertexDataManager(Renderer *renderer) : mRenderer(renderer)
+VertexDataManager::VertexDataManager(RendererD3D *renderer) : mRenderer(renderer)
 {
     for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
     {

src/libGLESv2/renderer/d3d/VertexDataManager.h

@@ -27,7 +27,7 @@ namespace rx
 class BufferD3D;
 class StreamingVertexBufferInterface;
 class VertexBuffer;
-class Renderer;
+class RendererD3D;
 
 struct TranslatedAttribute
 {
@@ -50,7 +50,7 @@ struct TranslatedAttribute
 class VertexDataManager
 {
   public:
-    VertexDataManager(rx::Renderer *renderer);
+    VertexDataManager(rx::RendererD3D *renderer);
     virtual ~VertexDataManager();
 
     gl::Error prepareVertexData(const gl::State &state, GLint start, GLsizei count,
@@ -81,7 +81,7 @@ class VertexDataManager
                                 size_t *cachedOffset,
                                 StreamingVertexBufferInterface *buffer);
 
-    rx::Renderer *const mRenderer;
+    rx::RendererD3D *const mRenderer;
 
     StreamingVertexBufferInterface *mStreamingBuffer;
 

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

@@ -122,7 +122,7 @@ class Buffer11::NativeBuffer11 : public Buffer11::BufferStorage11
   private:
     ID3D11Buffer *mNativeBuffer;
 
-    static void fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Renderer *renderer, BufferUsage usage, unsigned int bufferSize);
+    static void fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Renderer11 *renderer, BufferUsage usage, unsigned int bufferSize);
 };
 
 // Pack storage represents internal storage for pack buffers. We implement pack buffers
@@ -414,7 +414,7 @@ void Buffer11::markBufferUsage()
     }
 }
 
-Renderer* Buffer11::getRenderer()
+RendererD3D* Buffer11::getRenderer()
 {
     return mRenderer;
 }
@@ -736,7 +736,7 @@ gl::Error Buffer11::NativeBuffer11::resize(size_t size, bool preserveData)
     return gl::Error(GL_NO_ERROR);
 }
 
-void Buffer11::NativeBuffer11::fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Renderer *renderer,
+void Buffer11::NativeBuffer11::fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Renderer11 *renderer,
                                                      BufferUsage usage, unsigned int bufferSize)
 {
     bufferDesc->ByteWidth = bufferSize;

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

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

src/libGLESv2/renderer/d3d/d3d11/Image11.cpp

@@ -201,7 +201,7 @@ void Image11::disassociateStorage()
     }
 }
 
-bool Image11::redefine(Renderer *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease)
+bool Image11::redefine(RendererD3D *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease)
 {
     if (mWidth != width ||
         mHeight != height ||

src/libGLESv2/renderer/d3d/d3d11/Image11.h

@@ -22,7 +22,6 @@ class Framebuffer;
 
 namespace rx
 {
-class Renderer;
 class Renderer11;
 class TextureStorage11;
 
@@ -40,7 +39,7 @@ class Image11 : public ImageD3D
 
     virtual gl::Error copyToStorage(TextureStorage *storage, const gl::ImageIndex &index, const gl::Box &region);
 
-    virtual bool redefine(Renderer *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease);
+    bool redefine(RendererD3D *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease) override;
 
     DXGI_FORMAT getDXGIFormat() const;
 

src/libGLESv2/renderer/d3d/d3d11/Renderer11.h

@@ -97,14 +97,14 @@ class Renderer11 : public RendererD3D
     virtual void markAllStateDirty();
 
     // lost device
-    void notifyDeviceLost();
-    virtual bool isDeviceLost();
-    virtual bool testDeviceLost(bool notify);
-    virtual bool testDeviceResettable();
+    void notifyDeviceLost() override;
+    bool isDeviceLost() override;
+    bool testDeviceLost(bool notify) override;
+    bool testDeviceResettable() override;
 
-    virtual DWORD getAdapterVendor() const;
-    virtual std::string getRendererDescription() const;
-    virtual GUID getAdapterIdentifier() const;
+    DWORD getAdapterVendor() const override;
+    std::string getRendererDescription() const override;
+    GUID getAdapterIdentifier() const override;
 
     virtual unsigned int getReservedVertexUniformVectors() const;
     virtual unsigned int getReservedFragmentUniformVectors() const;
@@ -142,7 +142,7 @@ class Renderer11 : public RendererD3D
     virtual ProgramImpl *createProgram();
 
     // Shader operations
-    virtual void releaseShaderCompiler();
+    void releaseShaderCompiler() override;
     virtual gl::Error loadExecutable(const void *function, size_t length, rx::ShaderType type,
                                      const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
                                      bool separatedOutputBuffers, ShaderExecutable **outExecutable);
@@ -154,7 +154,7 @@ class Renderer11 : public RendererD3D
 
     // Image operations
     virtual Image *createImage();
-    virtual gl::Error generateMipmap(Image *dest, Image *source);
+    gl::Error generateMipmap(Image *dest, Image *source) override;
     virtual TextureStorage *createTextureStorage2D(SwapChain *swapChain);
     virtual TextureStorage *createTextureStorage2D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
     virtual TextureStorage *createTextureStorageCube(GLenum internalformat, bool renderTarget, int size, int levels);
@@ -214,8 +214,8 @@ class Renderer11 : public RendererD3D
   private:
     DISALLOW_COPY_AND_ASSIGN(Renderer11);
 
-    virtual void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps, gl::Extensions *outExtensions) const;
-    virtual Workarounds generateWorkarounds() const;
+    void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps, gl::Extensions *outExtensions) const override;
+    Workarounds generateWorkarounds() const override;
 
     gl::Error drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer);
     gl::Error drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer, int instances);

src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp

@@ -61,7 +61,7 @@ bool TextureStorage11::SRVKey::operator<(const SRVKey &rhs) const
     return std::tie(baseLevel, mipLevels, swizzle) < std::tie(rhs.baseLevel, rhs.mipLevels, rhs.swizzle);
 }
 
-TextureStorage11::TextureStorage11(Renderer *renderer, UINT bindFlags)
+TextureStorage11::TextureStorage11(Renderer11 *renderer, UINT bindFlags)
     : mBindFlags(bindFlags),
       mTopLevel(0),
       mMipLevels(0),
@@ -540,7 +540,7 @@ gl::Error TextureStorage11::setData(const gl::ImageIndex &index, Image *image, c
     return gl::Error(GL_NO_ERROR);
 }
 
-TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapchain)
+TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swapchain)
     : TextureStorage11(renderer, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE),
       mTexture(swapchain->getOffscreenTexture()),
       mSwizzleTexture(NULL)
@@ -585,7 +585,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapch
     initializeSerials(1, 1);
 }
 
-TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
+TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
     : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget)),
       mTexture(NULL),
       mSwizzleTexture(NULL)
@@ -945,7 +945,7 @@ gl::Error TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel, ID3D11Render
     return gl::Error(GL_NO_ERROR);
 }
 
-TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
+TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
     : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget))
 {
     mTexture = NULL;
@@ -1367,7 +1367,7 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel, ID3D11Rend
     return gl::Error(GL_NO_ERROR);
 }
 
-TextureStorage11_3D::TextureStorage11_3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
+TextureStorage11_3D::TextureStorage11_3D(Renderer11 *renderer, GLenum internalformat, bool renderTarget,
                                          GLsizei width, GLsizei height, GLsizei depth, int levels)
     : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget))
 {
@@ -1753,7 +1753,7 @@ gl::Error TextureStorage11_3D::getSwizzleRenderTarget(int mipLevel, ID3D11Render
     return gl::Error(GL_NO_ERROR);
 }
 
-TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer *renderer, GLenum internalformat, bool renderTarget,
+TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer11 *renderer, GLenum internalformat, bool renderTarget,
                                                    GLsizei width, GLsizei height, GLsizei depth, int levels)
     : TextureStorage11(renderer, GetTextureBindFlags(internalformat, renderTarget))
 {

src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h

@@ -25,7 +25,6 @@ namespace rx
 {
 class RenderTarget;
 class RenderTarget11;
-class Renderer;
 class Renderer11;
 class SwapChain11;
 class Image11;
@@ -73,7 +72,7 @@ class TextureStorage11 : public TextureStorage
                               const gl::PixelUnpackState &unpack, const uint8_t *pixelData);
 
   protected:
-    TextureStorage11(Renderer *renderer, UINT bindFlags);
+    TextureStorage11(Renderer11 *renderer, UINT bindFlags);
     int getLevelWidth(int mipLevel) const;
     int getLevelHeight(int mipLevel) const;
     int getLevelDepth(int mipLevel) const;
@@ -142,8 +141,8 @@ class TextureStorage11 : public TextureStorage
 class TextureStorage11_2D : public TextureStorage11
 {
   public:
-    TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapchain);
-    TextureStorage11_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
+    TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swapchain);
+    TextureStorage11_2D(Renderer11 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
     virtual ~TextureStorage11_2D();
 
     static TextureStorage11_2D *makeTextureStorage11_2D(TextureStorage *storage);
@@ -178,7 +177,7 @@ class TextureStorage11_2D : public TextureStorage11
 class TextureStorage11_Cube : public TextureStorage11
 {
   public:
-    TextureStorage11_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels);
+    TextureStorage11_Cube(Renderer11 *renderer, GLenum internalformat, bool renderTarget, int size, int levels);
     virtual ~TextureStorage11_Cube();
 
     static TextureStorage11_Cube *makeTextureStorage11_Cube(TextureStorage *storage);
@@ -215,7 +214,7 @@ class TextureStorage11_Cube : public TextureStorage11
 class TextureStorage11_3D : public TextureStorage11
 {
   public:
-    TextureStorage11_3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
+    TextureStorage11_3D(Renderer11 *renderer, GLenum internalformat, bool renderTarget,
                         GLsizei width, GLsizei height, GLsizei depth, int levels);
     virtual ~TextureStorage11_3D();
 
@@ -257,7 +256,7 @@ class TextureStorage11_3D : public TextureStorage11
 class TextureStorage11_2DArray : public TextureStorage11
 {
   public:
-    TextureStorage11_2DArray(Renderer *renderer, GLenum internalformat, bool renderTarget,
+    TextureStorage11_2DArray(Renderer11 *renderer, GLenum internalformat, bool renderTarget,
                              GLsizei width, GLsizei height, GLsizei depth, int levels);
     virtual ~TextureStorage11_2DArray();
 

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

@@ -114,7 +114,7 @@ void Buffer9::markTransformFeedbackUsage()
     UNREACHABLE();
 }
 
-Renderer* Buffer9::getRenderer()
+RendererD3D *Buffer9::getRenderer()
 {
     return mRenderer;
 }

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

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

src/libGLESv2/renderer/d3d/d3d9/Image9.cpp

@@ -168,7 +168,7 @@ gl::Error Image9::copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface
     return gl::Error(GL_NO_ERROR);
 }
 
-bool Image9::redefine(rx::Renderer *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease)
+bool Image9::redefine(RendererD3D *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease)
 {
     // 3D textures are not supported by the D3D9 backend.
     ASSERT(depth <= 1);

src/libGLESv2/renderer/d3d/d3d9/Image9.h

@@ -20,7 +20,6 @@ class Framebuffer;
 
 namespace rx
 {
-class Renderer;
 class Renderer9;
 
 class Image9 : public ImageD3D
@@ -35,7 +34,7 @@ class Image9 : public ImageD3D
     static gl::Error generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9 *sourceSurface);
     static gl::Error copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface9 *source);
 
-    virtual bool redefine(Renderer *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease);
+    bool redefine(RendererD3D *renderer, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease) override;
 
     D3DFORMAT getD3DFormat() const;
 

src/libGLESv2/renderer/d3d/d3d9/RenderTarget9.h

@@ -14,7 +14,6 @@
 
 namespace rx
 {
-class Renderer;
 class Renderer9;
 
 class RenderTarget9 : public RenderTarget

src/libGLESv2/renderer/d3d/d3d9/Renderer9.h

@@ -100,15 +100,16 @@ class Renderer9 : public RendererD3D
     virtual void markAllStateDirty();
 
     // lost device
-    void notifyDeviceLost();
-    virtual bool isDeviceLost();
-    virtual bool testDeviceLost(bool notify);
-    virtual bool testDeviceResettable();
+    void notifyDeviceLost() override;
+    bool isDeviceLost() override;
+    bool testDeviceLost(bool notify) override;
+    bool testDeviceResettable() override;
+
+    DWORD getAdapterVendor() const override;
+    std::string getRendererDescription() const override;
+    GUID getAdapterIdentifier() const override;
 
     IDirect3DDevice9 *getDevice() { return mDevice; }
-    virtual DWORD getAdapterVendor() const;
-    virtual std::string getRendererDescription() const;
-    virtual GUID getAdapterIdentifier() const;
 
     virtual unsigned int getReservedVertexUniformVectors() const;
     virtual unsigned int getReservedFragmentUniformVectors() const;
@@ -147,7 +148,7 @@ class Renderer9 : public RendererD3D
     virtual ProgramImpl *createProgram();
 
     // Shader operations
-    virtual void releaseShaderCompiler();
+    void releaseShaderCompiler() override;
     virtual gl::Error loadExecutable(const void *function, size_t length, rx::ShaderType type,
                                      const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
                                      bool separatedOutputBuffers, ShaderExecutable **outExecutable);
@@ -159,7 +160,7 @@ class Renderer9 : public RendererD3D
 
     // Image operations
     virtual Image *createImage();
-    virtual gl::Error generateMipmap(Image *dest, Image *source);
+    gl::Error generateMipmap(Image *dest, Image *source) override;
     virtual TextureStorage *createTextureStorage2D(SwapChain *swapChain);
     virtual TextureStorage *createTextureStorage2D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
     virtual TextureStorage *createTextureStorageCube(GLenum internalformat, bool renderTarget, int size, int levels);
@@ -208,8 +209,8 @@ class Renderer9 : public RendererD3D
   private:
     DISALLOW_COPY_AND_ASSIGN(Renderer9);
 
-    virtual void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps, gl::Extensions *outExtensions) const;
-    virtual Workarounds generateWorkarounds() const;
+    void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps, gl::Extensions *outExtensions) const override;
+    Workarounds generateWorkarounds() const override;
 
     void release();
 

src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp

@@ -20,7 +20,7 @@
 
 namespace rx
 {
-TextureStorage9::TextureStorage9(Renderer *renderer, DWORD usage)
+TextureStorage9::TextureStorage9(Renderer9 *renderer, DWORD usage)
     : mTopLevel(0),
       mMipLevels(0),
       mTextureWidth(0),
@@ -99,7 +99,7 @@ gl::Error TextureStorage9::setData(const gl::ImageIndex &index, Image *image, co
     return gl::Error(GL_INVALID_OPERATION);
 }
 
-TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, SwapChain9 *swapchain)
+TextureStorage9_2D::TextureStorage9_2D(Renderer9 *renderer, SwapChain9 *swapchain)
     : TextureStorage9(renderer, D3DUSAGE_RENDERTARGET)
 {
     IDirect3DTexture9 *surfaceTexture = swapchain->getOffscreenTexture();
@@ -119,7 +119,7 @@ TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, SwapChain9 *swapchain
     initializeSerials(1, 1);
 }
 
-TextureStorage9_2D::TextureStorage9_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
+TextureStorage9_2D::TextureStorage9_2D(Renderer9 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels)
     : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
 {
     mTexture = NULL;
@@ -286,7 +286,7 @@ gl::Error TextureStorage9_2D::copyToStorage(TextureStorage *destStorage)
     return gl::Error(GL_NO_ERROR);
 }
 
-TextureStorage9_Cube::TextureStorage9_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
+TextureStorage9_Cube::TextureStorage9_Cube(Renderer9 *renderer, GLenum internalformat, bool renderTarget, int size, int levels)
     : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
 {
     mTexture = NULL;

src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.h

@@ -54,7 +54,7 @@ class TextureStorage9 : public TextureStorage
 
     Renderer9 *mRenderer;
 
-    TextureStorage9(Renderer *renderer, DWORD usage);
+    TextureStorage9(Renderer9 *renderer, DWORD usage);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage9);
@@ -66,8 +66,8 @@ class TextureStorage9 : public TextureStorage
 class TextureStorage9_2D : public TextureStorage9
 {
   public:
-    TextureStorage9_2D(Renderer *renderer, SwapChain9 *swapchain);
-    TextureStorage9_2D(Renderer *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
+    TextureStorage9_2D(Renderer9 *renderer, SwapChain9 *swapchain);
+    TextureStorage9_2D(Renderer9 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
     virtual ~TextureStorage9_2D();
 
     static TextureStorage9_2D *makeTextureStorage9_2D(TextureStorage *storage);
@@ -88,7 +88,7 @@ class TextureStorage9_2D : public TextureStorage9
 class TextureStorage9_Cube : public TextureStorage9
 {
   public:
-    TextureStorage9_Cube(Renderer *renderer, GLenum internalformat, bool renderTarget, int size, int levels);
+    TextureStorage9_Cube(Renderer9 *renderer, GLenum internalformat, bool renderTarget, int size, int levels);
     virtual ~TextureStorage9_Cube();
 
     static TextureStorage9_Cube *makeTextureStorage9_Cube(TextureStorage *storage);