Make RendererD3D a bit smaller.

Move some D3D11-specific stuff into Renderer11, and remove a few
virtual methods that weren't needed to be virtual.

BUG=angleproject:1369

Change-Id: Id37e7271ffc28b089dbea123dca70f38c1a06ffb
Reviewed-on: https://chromium-review.googlesource.com/345913
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>

src/common/string_utils.cpp

@@ -12,6 +12,8 @@
 #include <fstream>
 #include <sstream>
 
+#include "common/platform.h"
+
 namespace angle
 {
 
@@ -133,4 +135,24 @@ bool ReadFileToString(const std::string &path, std::string *stringOut)
     return !inFile.fail();
 }
 
+Optional<std::vector<wchar_t>> WidenString(size_t length, const char *cString)
+{
+    std::vector<wchar_t> wcstring(length + 1);
+#if !defined(ANGLE_PLATFORM_WINDOWS)
+    size_t written = mbstowcs(wcstring.data(), cString, length + 1);
+    if (written == 0)
+    {
+        return Optional<std::vector<wchar_t>>::Invalid();
+    }
+#else
+    size_t convertedChars = 0;
+    errno_t err = mbstowcs_s(&convertedChars, wcstring.data(), length + 1, cString, _TRUNCATE);
+    if (err != 0)
+    {
+        return Optional<std::vector<wchar_t>>::Invalid();
+    }
+#endif
+    return Optional<std::vector<wchar_t>>(wcstring);
 }
+
+}  // namespace angle

src/common/string_utils.h

@@ -13,6 +13,8 @@
 #include <string>
 #include <vector>
 
+#include "common/Optional.h"
+
 namespace angle
 {
 
@@ -44,6 +46,7 @@ bool HexStringToUInt(const std::string &input, unsigned int *uintOut);
 
 bool ReadFileToString(const std::string &path, std::string *stringOut);
 
+Optional<std::vector<wchar_t>> WidenString(size_t length, const char *cString);
 }
 
 #endif // LIBANGLE_STRING_UTILS_H_

src/common/utilities.cpp

@@ -715,7 +715,7 @@ bool IsRenderbufferTarget(EGLenum target)
 {
     return target == EGL_GL_RENDERBUFFER_KHR;
 }
-}
+}  // namespace egl
 
 namespace egl_gl
 {
@@ -753,7 +753,7 @@ GLuint EGLClientBufferToGLObjectHandle(EGLClientBuffer buffer)
 {
     return static_cast<GLuint>(reinterpret_cast<uintptr_t>(buffer));
 }
-}
+}  // namespace egl_gl
 
 #if !defined(ANGLE_ENABLE_WINDOWS_STORE)
 std::string getTempPath()

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -29,22 +29,11 @@
 namespace rx
 {
 
-namespace
-{
-// If we request a scratch buffer requesting a smaller size this many times,
-// release and recreate the scratch buffer. This ensures we don't have a
-// degenerate case where we are stuck hogging memory.
-const int ScratchMemoryBufferLifetime = 1000;
-
-}  // anonymous namespace
-
 RendererD3D::RendererD3D(egl::Display *display)
     : mDisplay(display),
       mDeviceLost(false),
-      mAnnotator(nullptr),
       mPresentPathFastEnabled(false),
       mCapsInitialized(false),
-      mScratchMemoryBufferResetCounter(0),
       mWorkaroundsInitialized(false),
       mDisjoint(false)
 {
@@ -57,49 +46,11 @@ RendererD3D::~RendererD3D()
 
 void RendererD3D::cleanup()
 {
-    mScratchMemoryBuffer.resize(0);
     for (auto &incompleteTexture : mIncompleteTextures)
     {
         incompleteTexture.second.set(nullptr);
     }
     mIncompleteTextures.clear();
-
-    if (mAnnotator != nullptr)
-    {
-        gl::UninitializeDebugAnnotations();
-        SafeDelete(mAnnotator);
-    }
-}
-
-gl::Error RendererD3D::generateSwizzles(const gl::ContextState &data, gl::SamplerType type)
-{
-    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram());
-
-    unsigned int samplerRange = programD3D->getUsedSamplerRange(type);
-
-    for (unsigned int i = 0; i < samplerRange; i++)
-    {
-        GLenum textureType = programD3D->getSamplerTextureType(type, i);
-        GLint textureUnit = programD3D->getSamplerMapping(type, i, *data.caps);
-        if (textureUnit != -1)
-        {
-            gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType);
-            ASSERT(texture);
-            if (texture->getTextureState().swizzleRequired())
-            {
-                ANGLE_TRY(generateSwizzle(texture));
-            }
-        }
-    }
-
-    return gl::NoError();
-}
-
-gl::Error RendererD3D::generateSwizzles(const gl::ContextState &data)
-{
-    ANGLE_TRY(generateSwizzles(data, gl::SAMPLER_VERTEX));
-    ANGLE_TRY(generateSwizzles(data, gl::SAMPLER_PIXEL));
-    return gl::NoError();
 }
 
 unsigned int RendererD3D::GetBlendSampleMask(const gl::ContextState &data, int samples)
@@ -138,18 +89,6 @@ unsigned int RendererD3D::GetBlendSampleMask(const gl::ContextState &data, int s
     return mask;
 }
 
-// Applies the shaders and shader constants to the Direct3D device
-gl::Error RendererD3D::applyShaders(const gl::ContextState &data, GLenum drawMode)
-{
-    gl::Program *program = data.state->getProgram();
-    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
-    programD3D->updateCachedInputLayout(*data.state);
-
-    ANGLE_TRY(applyShadersImpl(data, drawMode));
-
-    return programD3D->applyUniforms(drawMode);
-}
-
 // For each Direct3D sampler of either the pixel or vertex stage,
 // looks up the corresponding OpenGL texture image unit and texture type,
 // and sets the texture and its addressing/filtering state (or NULL when inactive).
@@ -358,63 +297,6 @@ std::string RendererD3D::getVendorString() const
     return std::string("");
 }
 
-gl::Error RendererD3D::getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer **bufferOut)
-{
-    if (mScratchMemoryBuffer.size() == requestedSize)
-    {
-        mScratchMemoryBufferResetCounter = ScratchMemoryBufferLifetime;
-        *bufferOut = &mScratchMemoryBuffer;
-        return gl::Error(GL_NO_ERROR);
-    }
-
-    if (mScratchMemoryBuffer.size() > requestedSize)
-    {
-        mScratchMemoryBufferResetCounter--;
-    }
-
-    if (mScratchMemoryBufferResetCounter <= 0 || mScratchMemoryBuffer.size() < requestedSize)
-    {
-        mScratchMemoryBuffer.resize(0);
-        if (!mScratchMemoryBuffer.resize(requestedSize))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal buffer.");
-        }
-        mScratchMemoryBufferResetCounter = ScratchMemoryBufferLifetime;
-    }
-
-    ASSERT(mScratchMemoryBuffer.size() >= requestedSize);
-
-    *bufferOut = &mScratchMemoryBuffer;
-    return gl::Error(GL_NO_ERROR);
-}
-
-void RendererD3D::insertEventMarker(GLsizei length, const char *marker)
-{
-    std::vector<wchar_t> wcstring (length + 1);
-    size_t convertedChars = 0;
-    errno_t err = mbstowcs_s(&convertedChars, wcstring.data(), length + 1, marker, _TRUNCATE);
-    if (err == 0)
-    {
-        getAnnotator()->setMarker(wcstring.data());
-    }
-}
-
-void RendererD3D::pushGroupMarker(GLsizei length, const char *marker)
-{
-    std::vector<wchar_t> wcstring(length + 1);
-    size_t convertedChars = 0;
-    errno_t err = mbstowcs_s(&convertedChars, wcstring.data(), length + 1, marker, _TRUNCATE);
-    if (err == 0)
-    {
-        getAnnotator()->beginEvent(wcstring.data());
-    }
-}
-
-void RendererD3D::popGroupMarker()
-{
-    getAnnotator()->endEvent();
-}
-
 void RendererD3D::setGPUDisjoint()
 {
     mDisjoint = true;
@@ -436,19 +318,6 @@ GLint64 RendererD3D::getTimestamp()
     return 0;
 }
 
-void RendererD3D::initializeDebugAnnotator()
-{
-    createAnnotator();
-    ASSERT(mAnnotator);
-    gl::InitializeDebugAnnotations(mAnnotator);
-}
-
-gl::DebugAnnotator *RendererD3D::getAnnotator()
-{
-    ASSERT(mAnnotator);
-    return mAnnotator;
-}
-
 void RendererD3D::ensureCapsInitialized() const
 {
     if (!mCapsInitialized)

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -28,7 +28,6 @@ class ConfigSet;
 
 namespace gl
 {
-class DebugAnnotator;
 class FramebufferState;
 class InfoLog;
 class Texture;
@@ -133,7 +132,6 @@ class RendererD3D : public BufferFactoryD3D
                                           GLenum depthBufferFormat,
                                           EGLint orientation) = 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;
 
@@ -145,8 +143,6 @@ class RendererD3D : public BufferFactoryD3D
                                     GLenum drawMode,
                                     const std::vector<D3DUniform *> &uniformArray) = 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;
 
@@ -210,13 +206,6 @@ class RendererD3D : public BufferFactoryD3D
     virtual RendererClass getRendererClass() const = 0;
     virtual void *getD3DDevice() = 0;
 
-    gl::Error getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer **bufferOut);
-
-    // EXT_debug_marker
-    void insertEventMarker(GLsizei length, const char *marker);
-    void pushGroupMarker(GLsizei length, const char *marker);
-    void popGroupMarker();
-
     void setGPUDisjoint();
 
     GLint getGPUDisjoint();
@@ -244,7 +233,6 @@ class RendererD3D : public BufferFactoryD3D
 
   protected:
     virtual bool getLUID(LUID *adapterLuid) const = 0;
-    virtual gl::Error applyShadersImpl(const gl::ContextState &data, GLenum drawMode) = 0;
     virtual void generateCaps(gl::Caps *outCaps,
                               gl::TextureCapsMap *outTextureCaps,
                               gl::Extensions *outExtensions,
@@ -252,13 +240,9 @@ class RendererD3D : public BufferFactoryD3D
 
     void cleanup();
 
-    virtual void createAnnotator() = 0;
-
     static unsigned int GetBlendSampleMask(const gl::ContextState &data, int samples);
     // dirtyPointer is a special value that will make the comparison with any valid pointer fail and force the renderer to re-apply the state.
 
-    gl::Error generateSwizzles(const gl::ContextState &data);
-    gl::Error applyShaders(const gl::ContextState &data, GLenum drawMode);
     gl::Error applyTextures(GLImplFactory *implFactory, const gl::ContextState &data);
     bool skipDraw(const gl::ContextState &data, GLenum drawMode);
     gl::Error markTransformFeedbackUsage(const gl::ContextState &data);
@@ -266,32 +250,13 @@ class RendererD3D : public BufferFactoryD3D
     egl::Display *mDisplay;
     bool mDeviceLost;
 
-    void initializeDebugAnnotator();
-    gl::DebugAnnotator *mAnnotator;
-
     bool mPresentPathFastEnabled;
 
   private:
     void ensureCapsInitialized() const;
 
-    virtual gl::Error drawArraysImpl(const gl::ContextState &data,
-                                     GLenum mode,
-                                     GLint startVertex,
-                                     GLsizei count,
-                                     GLsizei instances) = 0;
-    virtual gl::Error drawElementsImpl(const gl::ContextState &data,
-                                       const TranslatedIndexData &indexInfo,
-                                       GLenum mode,
-                                       GLsizei count,
-                                       GLenum type,
-                                       const GLvoid *indices,
-                                       GLsizei instances) = 0;
-
     typedef std::array<gl::Texture*, gl::IMPLEMENTATION_MAX_FRAMEBUFFER_ATTACHMENTS> FramebufferTextureArray;
 
-    gl::Error generateSwizzles(const gl::ContextState &data, gl::SamplerType type);
-
-    gl::Error applyState(const gl::ContextState &data, GLenum drawMode);
     gl::Error applyTextures(GLImplFactory *implFactory,
                             const gl::ContextState &data,
                             gl::SamplerType shaderType,
@@ -302,8 +267,6 @@ class RendererD3D : public BufferFactoryD3D
                                        FramebufferTextureArray *outTextureArray);
     gl::Texture *getIncompleteTexture(GLImplFactory *implFactory, GLenum type);
 
-    gl::DebugAnnotator *getAnnotator();
-
     virtual WorkaroundsD3D generateWorkarounds() const = 0;
 
     mutable bool mCapsInitialized;
@@ -313,8 +276,6 @@ class RendererD3D : public BufferFactoryD3D
     mutable gl::Limitations mNativeLimitations;
 
     gl::TextureMap mIncompleteTextures;
-    MemoryBuffer mScratchMemoryBuffer;
-    unsigned int mScratchMemoryBufferResetCounter;
 
     mutable bool mWorkaroundsInitialized;
     mutable WorkaroundsD3D mWorkarounds;

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

@@ -9,6 +9,7 @@
 
 #include "libANGLE/renderer/d3d/d3d11/Context11.h"
 
+#include "common/string_utils.h"
 #include "libANGLE/renderer/d3d/CompilerD3D.h"
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
@@ -215,17 +216,25 @@ std::string Context11::getRendererDescription() const
 
 void Context11::insertEventMarker(GLsizei length, const char *marker)
 {
-    mRenderer->insertEventMarker(length, marker);
+    auto optionalString = angle::WidenString(static_cast<size_t>(length), marker);
+    if (optionalString.valid())
+    {
+        mRenderer->getAnnotator()->setMarker(optionalString.value().data());
+    }
 }
 
 void Context11::pushGroupMarker(GLsizei length, const char *marker)
 {
-    mRenderer->pushGroupMarker(length, marker);
+    auto optionalString = angle::WidenString(static_cast<size_t>(length), marker);
+    if (optionalString.valid())
+    {
+        mRenderer->getAnnotator()->beginEvent(optionalString.value().data());
+    }
 }
 
 void Context11::popGroupMarker()
 {
-    mRenderer->popGroupMarker();
+    mRenderer->getAnnotator()->endEvent();
 }
 
 void Context11::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)

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

@@ -385,6 +385,11 @@ int GetWrapBits(GLenum wrap)
     }
 }
 
+// If we request a scratch buffer requesting a smaller size this many times,
+// release and recreate the scratch buffer. This ensures we don't have a
+// degenerate case where we are stuck hogging memory.
+const int ScratchMemoryBufferLifetime = 1000;
+
 }  // anonymous namespace
 
 Renderer11::Renderer11(egl::Display *display)
@@ -392,7 +397,9 @@ Renderer11::Renderer11(egl::Display *display)
       mStateCache(this),
       mStateManager(this),
       mLastHistogramUpdateTime(ANGLEPlatformCurrent()->monotonicallyIncreasingTime()),
-      mDebug(nullptr)
+      mDebug(nullptr),
+      mAnnotator(nullptr),
+      mScratchMemoryBufferResetCounter(0)
 {
     mVertexDataManager = NULL;
     mIndexDataManager = NULL;
@@ -514,7 +521,18 @@ Renderer11::Renderer11(egl::Display *display)
         mPresentPathFastEnabled = false;
     }
 
-    initializeDebugAnnotator();
+// The D3D11 renderer must choose the D3D9 debug annotator because the D3D11 interface
+// method ID3DUserDefinedAnnotation::GetStatus on desktop builds doesn't work with the Graphics
+// Diagnostics tools in Visual Studio 2013.
+// The D3D9 annotator works properly for both D3D11 and D3D9.
+// Incorrect status reporting can cause ANGLE to log unnecessary debug events.
+#ifdef ANGLE_ENABLE_D3D9
+    mAnnotator = new DebugAnnotator9();
+#else
+    mAnnotator = new DebugAnnotator11();
+#endif
+    ASSERT(mAnnotator);
+    gl::InitializeDebugAnnotations(mAnnotator);
 }
 
 Renderer11::~Renderer11()
@@ -1178,6 +1196,36 @@ gl::Error Renderer11::generateSwizzle(gl::Texture *texture)
     return gl::Error(GL_NO_ERROR);
 }
 
+gl::Error Renderer11::generateSwizzles(const gl::ContextState &data, gl::SamplerType type)
+{
+    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram());
+
+    unsigned int samplerRange = programD3D->getUsedSamplerRange(type);
+
+    for (unsigned int i = 0; i < samplerRange; i++)
+    {
+        GLenum textureType = programD3D->getSamplerTextureType(type, i);
+        GLint textureUnit = programD3D->getSamplerMapping(type, i, *data.caps);
+        if (textureUnit != -1)
+        {
+            gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType);
+            ASSERT(texture);
+            if (texture->getTextureState().swizzleRequired())
+            {
+                ANGLE_TRY(generateSwizzle(texture));
+            }
+        }
+    }
+
+    return gl::NoError();
+}
+
+gl::Error Renderer11::generateSwizzles(const gl::ContextState &data)
+{
+    ANGLE_TRY(generateSwizzles(data, gl::SAMPLER_VERTEX));
+    ANGLE_TRY(generateSwizzles(data, gl::SAMPLER_PIXEL));
+    return gl::NoError();
+}
 gl::Error Renderer11::setSamplerState(gl::SamplerType type,
                                       int index,
                                       gl::Texture *texture,
@@ -2122,33 +2170,23 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer11::applyShadersImpl(const gl::ContextState &data, GLenum drawMode)
+gl::Error Renderer11::applyShaders(const gl::ContextState &data, GLenum drawMode)
 {
-    ProgramD3D *programD3D  = GetImplAs<ProgramD3D>(data.state->getProgram());
+    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram());
+    programD3D->updateCachedInputLayout(*data.state);
+
     const auto &inputLayout = programD3D->getCachedInputLayout();
 
     ShaderExecutableD3D *vertexExe = NULL;
-    gl::Error error = programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr);
+    ANGLE_TRY(programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr));
-    if (error.isError())
-    {
-        return error;
-    }
 
     const gl::Framebuffer *drawFramebuffer = data.state->getDrawFramebuffer();
     ShaderExecutableD3D *pixelExe = NULL;
-    error = programD3D->getPixelExecutableForFramebuffer(drawFramebuffer, &pixelExe);
+    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(drawFramebuffer, &pixelExe));
-    if (error.isError())
-    {
-        return error;
-    }
 
     ShaderExecutableD3D *geometryExe = nullptr;
-    error =
+    ANGLE_TRY(
-        programD3D->getGeometryExecutableForPrimitiveType(data, drawMode, &geometryExe, nullptr);
+        programD3D->getGeometryExecutableForPrimitiveType(data, drawMode, &geometryExe, nullptr));
-    if (error.isError())
-    {
-        return error;
-    }
 
     ID3D11VertexShader *vertexShader = (vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : NULL);
 
@@ -2199,7 +2237,7 @@ gl::Error Renderer11::applyShadersImpl(const gl::ContextState &data, GLenum draw
         programD3D->dirtyAllUniforms();
     }
 
-    return gl::Error(GL_NO_ERROR);
+    return programD3D->applyUniforms(drawMode);
 }
 
 gl::Error Renderer11::applyUniforms(const ProgramD3D &programD3D,
@@ -2654,6 +2692,14 @@ void Renderer11::release()
 {
     RendererD3D::cleanup();
 
+    mScratchMemoryBuffer.resize(0);
+
+    if (mAnnotator != nullptr)
+    {
+        gl::UninitializeDebugAnnotations();
+        SafeDelete(mAnnotator);
+    }
+
     releaseDeviceResources();
 
     if (!mCreatedWithDeviceEXT)
@@ -4327,20 +4373,6 @@ WorkaroundsD3D Renderer11::generateWorkarounds() const
     return d3d11::GenerateWorkarounds(mRenderer11DeviceCaps.featureLevel);
 }
 
-void Renderer11::createAnnotator()
-{
-    // The D3D11 renderer must choose the D3D9 debug annotator because the D3D11 interface
-    // method ID3DUserDefinedAnnotation::GetStatus on desktop builds doesn't work with the Graphics
-    // Diagnostics tools in Visual Studio 2013.
-    // The D3D9 annotator works properly for both D3D11 and D3D9.
-    // Incorrect status reporting can cause ANGLE to log unnecessary debug events.
-#ifdef ANGLE_ENABLE_D3D9
-    mAnnotator = new DebugAnnotator9();
-#else
-    mAnnotator = new DebugAnnotator11();
-#endif
-}
-
 gl::Error Renderer11::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd)
 {
     return mStateManager.clearTextures(samplerType, rangeStart, rangeEnd);
@@ -4467,4 +4499,39 @@ FramebufferImpl *Renderer11::createDefaultFramebuffer(const gl::FramebufferState
     return new Framebuffer11(state, this);
 }
 
+gl::Error Renderer11::getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer **bufferOut)
+{
+    if (mScratchMemoryBuffer.size() == requestedSize)
+    {
+        mScratchMemoryBufferResetCounter = ScratchMemoryBufferLifetime;
+        *bufferOut = &mScratchMemoryBuffer;
+        return gl::NoError();
+    }
+
+    if (mScratchMemoryBuffer.size() > requestedSize)
+    {
+        mScratchMemoryBufferResetCounter--;
+    }
+
+    if (mScratchMemoryBufferResetCounter <= 0 || mScratchMemoryBuffer.size() < requestedSize)
+    {
+        mScratchMemoryBuffer.resize(0);
+        if (!mScratchMemoryBuffer.resize(requestedSize))
+        {
+            return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal buffer.");
+        }
+        mScratchMemoryBufferResetCounter = ScratchMemoryBufferLifetime;
+    }
+
+    ASSERT(mScratchMemoryBuffer.size() >= requestedSize);
+
+    *bufferOut = &mScratchMemoryBuffer;
+    return gl::NoError();
+}
+
+gl::DebugAnnotator *Renderer11::getAnnotator()
+{
+    return mAnnotator;
+}
+
 }  // namespace rx

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

@@ -126,7 +126,6 @@ class Renderer11 : public RendererD3D
                                   GLenum depthBufferFormat,
                                   EGLint orientation) override;
 
-    virtual gl::Error generateSwizzle(gl::Texture *texture);
     virtual gl::Error setSamplerState(gl::SamplerType type, int index, gl::Texture *texture, const gl::SamplerState &sampler);
     virtual gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture);
 
@@ -162,8 +161,8 @@ class Renderer11 : public RendererD3D
     std::string getRendererDescription() const;
     DeviceIdentifier getAdapterIdentifier() const override;
 
-    unsigned int getReservedVertexUniformVectors() const override;
+    unsigned int getReservedVertexUniformVectors() const;
-    unsigned int getReservedFragmentUniformVectors() const override;
+    unsigned int getReservedFragmentUniformVectors() const;
     unsigned int getReservedVertexUniformBuffers() const override;
     unsigned int getReservedFragmentUniformBuffers() const override;
 
@@ -279,6 +278,7 @@ class Renderer11 : public RendererD3D
 
     Blit11 *getBlitter() { return mBlit; }
     Clear11 *getClearer() { return mClear; }
+    gl::DebugAnnotator *getAnnotator();
 
     // Buffer-to-texture and Texture-to-buffer copies
     virtual bool supportsFastCopyBufferToTexture(GLenum internalFormat) const;
@@ -339,24 +339,24 @@ class Renderer11 : public RendererD3D
     // Necessary hack for default framebuffers in D3D.
     FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override;
 
+    gl::Error getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer **bufferOut);
+
   protected:
-    void createAnnotator() override;
     gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) override;
-    gl::Error applyShadersImpl(const gl::ContextState &data, GLenum drawMode) override;
 
   private:
     gl::Error drawArraysImpl(const gl::ContextState &data,
                              GLenum mode,
                              GLint startVertex,
                              GLsizei count,
-                             GLsizei instances) override;
+                             GLsizei instances);
     gl::Error drawElementsImpl(const gl::ContextState &data,
                                const TranslatedIndexData &indexInfo,
                                GLenum mode,
                                GLsizei count,
                                GLenum type,
                                const GLvoid *indices,
-                               GLsizei instances) override;
+                               GLsizei instances);
 
     void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps,
                       gl::Extensions *outExtensions,
@@ -377,6 +377,11 @@ class Renderer11 : public RendererD3D
                               int minIndex,
                               int instances);
 
+    gl::Error applyShaders(const gl::ContextState &data, GLenum drawMode);
+    gl::Error generateSwizzle(gl::Texture *texture);
+    gl::Error generateSwizzles(const gl::ContextState &data, gl::SamplerType type);
+    gl::Error generateSwizzles(const gl::ContextState &data);
+
     ID3D11Texture2D *resolveMultisampledTexture(ID3D11Texture2D *source, unsigned int subresource);
 
     void populateRenderer11DeviceCaps();
@@ -528,6 +533,11 @@ class Renderer11 : public RendererD3D
 
     std::vector<GLuint> mScratchIndexDataBuffer;
 
+    MemoryBuffer mScratchMemoryBuffer;
+    unsigned int mScratchMemoryBufferResetCounter;
+
+    gl::DebugAnnotator *mAnnotator;
+
     mutable Optional<bool> mSupportsShareHandles;
 };
 

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

@@ -9,6 +9,7 @@
 
 #include "libANGLE/renderer/d3d/d3d9/Context9.h"
 
+#include "common/string_utils.h"
 #include "libANGLE/renderer/d3d/CompilerD3D.h"
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
@@ -204,17 +205,25 @@ std::string Context9::getRendererDescription() const
 
 void Context9::insertEventMarker(GLsizei length, const char *marker)
 {
-    mRenderer->insertEventMarker(length, marker);
+    auto optionalString = angle::WidenString(static_cast<size_t>(length), marker);
+    if (optionalString.valid())
+    {
+        mRenderer->getAnnotator()->setMarker(optionalString.value().data());
+    }
 }
 
 void Context9::pushGroupMarker(GLsizei length, const char *marker)
 {
-    mRenderer->pushGroupMarker(length, marker);
+    auto optionalString = angle::WidenString(static_cast<size_t>(length), marker);
+    if (optionalString.valid())
+    {
+        mRenderer->getAnnotator()->beginEvent(optionalString.value().data());
+    }
 }
 
 void Context9::popGroupMarker()
 {
-    mRenderer->popGroupMarker();
+    mRenderer->getAnnotator()->endEvent();
 }
 
 void Context9::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)

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

@@ -133,7 +133,7 @@ Renderer9::Renderer9(egl::Display *display) : RendererD3D(display), mStateManage
     mAppliedPixelShader = NULL;
     mAppliedProgramSerial = 0;
 
-    initializeDebugAnnotator();
+    gl::InitializeDebugAnnotations(&mAnnotator);
 
     mEGLDevice = nullptr;
 }
@@ -156,6 +156,8 @@ void Renderer9::release()
 {
     RendererD3D::cleanup();
 
+    gl::UninitializeDebugAnnotations();
+
     mTranslatedAttribCache.clear();
 
     releaseDeviceResources();
@@ -778,13 +780,6 @@ gl::Error Renderer9::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack,
     return gl::Error(GL_INVALID_OPERATION);
 }
 
-gl::Error Renderer9::generateSwizzle(gl::Texture *texture)
-{
-    // Swizzled textures are not available in ES2 or D3D9
-    UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
-}
-
 gl::Error Renderer9::setSamplerState(gl::SamplerType type, int index, gl::Texture *texture, const gl::SamplerState &samplerState)
 {
     CurSamplerState &appliedSampler = (type == gl::SAMPLER_PIXEL) ? mCurPixelSamplerStates[index]
@@ -1590,25 +1585,19 @@ gl::Error Renderer9::getCountingIB(size_t count, StaticIndexBufferInterface **ou
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer9::applyShadersImpl(const gl::ContextState &data, GLenum /*drawMode*/)
+gl::Error Renderer9::applyShaders(const gl::ContextState &data, GLenum drawMode)
 {
     ProgramD3D *programD3D  = GetImplAs<ProgramD3D>(data.state->getProgram());
+    programD3D->updateCachedInputLayout(*data.state);
+
     const auto &inputLayout = programD3D->getCachedInputLayout();
 
     ShaderExecutableD3D *vertexExe = NULL;
-    gl::Error error = programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr);
+    ANGLE_TRY(programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr));
-    if (error.isError())
-    {
-        return error;
-    }
 
     const gl::Framebuffer *drawFramebuffer = data.state->getDrawFramebuffer();
     ShaderExecutableD3D *pixelExe = NULL;
-    error = programD3D->getPixelExecutableForFramebuffer(drawFramebuffer, &pixelExe);
+    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(drawFramebuffer, &pixelExe));
-    if (error.isError())
-    {
-        return error;
-    }
 
     IDirect3DVertexShader9 *vertexShader = (vertexExe ? GetAs<ShaderExecutable9>(vertexExe)->getVertexShader() : nullptr);
     IDirect3DPixelShader9 *pixelShader = (pixelExe ? GetAs<ShaderExecutable9>(pixelExe)->getPixelShader() : nullptr);
@@ -1638,7 +1627,7 @@ gl::Error Renderer9::applyShadersImpl(const gl::ContextState &data, GLenum /*dra
         mAppliedProgramSerial = programSerial;
     }
 
-    return gl::Error(GL_NO_ERROR);
+    return programD3D->applyUniforms(drawMode);
 }
 
 gl::Error Renderer9::applyUniforms(const ProgramD3D &programD3D,
@@ -2760,11 +2749,6 @@ WorkaroundsD3D Renderer9::generateWorkarounds() const
     return d3d9::GenerateWorkarounds();
 }
 
-void Renderer9::createAnnotator()
-{
-    mAnnotator = new DebugAnnotator9();
-}
-
 gl::Error Renderer9::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd)
 {
     // TODO(jmadill): faster way?
@@ -2823,8 +2807,6 @@ gl::Error Renderer9::genericDrawElements(Context9 *context,
 
     programD3D->updateSamplerMapping();
 
-    ANGLE_TRY(generateSwizzles(data));
-
     if (!applyPrimitiveType(mode, count, usesPointSize))
     {
         return gl::NoError();
@@ -2872,7 +2854,6 @@ gl::Error Renderer9::genericDrawArrays(Context9 *context,
 
     programD3D->updateSamplerMapping();
 
-    ANGLE_TRY(generateSwizzles(data));
     if (!applyPrimitiveType(mode, count, usesPointSize))
     {
         return gl::NoError();

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

@@ -101,7 +101,6 @@ class Renderer9 : public RendererD3D
     gl::Error createPixelShader(const DWORD *function, size_t length, IDirect3DPixelShader9 **outShader);
     HRESULT createVertexBuffer(UINT Length, DWORD Usage, IDirect3DVertexBuffer9 **ppVertexBuffer);
     HRESULT createIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, IDirect3DIndexBuffer9 **ppIndexBuffer);
-    virtual gl::Error generateSwizzle(gl::Texture *texture);
     virtual gl::Error setSamplerState(gl::SamplerType type, int index, gl::Texture *texture, const gl::SamplerState &sampler);
     virtual gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture);
 
@@ -159,8 +158,8 @@ class Renderer9 : public RendererD3D
     IDirect3DDevice9 *getDevice() { return mDevice; }
     void *getD3DDevice() override;
 
-    unsigned int getReservedVertexUniformVectors() const override;
+    unsigned int getReservedVertexUniformVectors() const;
-    unsigned int getReservedFragmentUniformVectors() const override;
+    unsigned int getReservedFragmentUniformVectors() const;
     unsigned int getReservedVertexUniformBuffers() const override;
     unsigned int getReservedFragmentUniformBuffers() const override;
 
@@ -271,6 +270,11 @@ class Renderer9 : public RendererD3D
     virtual gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
                                               GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea);
 
+    // EXT_debug_marker
+    void insertEventMarker(GLsizei length, const char *marker);
+    void pushGroupMarker(GLsizei length, const char *marker);
+    void popGroupMarker();
+
     // D3D9-renderer specific methods
     gl::Error boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest);
 
@@ -310,24 +314,26 @@ class Renderer9 : public RendererD3D
     // Necessary hack for default framebuffers in D3D.
     FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override;
 
+    DebugAnnotator9 *getAnnotator() { return &mAnnotator; }
+
   protected:
-    void createAnnotator() override;
     gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) override;
-    gl::Error applyShadersImpl(const gl::ContextState &data, GLenum drawMode) override;
 
   private:
     gl::Error drawArraysImpl(const gl::ContextState &data,
                              GLenum mode,
                              GLint startVertex,
                              GLsizei count,
-                             GLsizei instances) override;
+                             GLsizei instances);
     gl::Error drawElementsImpl(const gl::ContextState &data,
                                const TranslatedIndexData &indexInfo,
                                GLenum mode,
                                GLsizei count,
                                GLenum type,
                                const GLvoid *indices,
-                               GLsizei instances) override;
+                               GLsizei instances);
+
+    gl::Error applyShaders(const gl::ContextState &data, GLenum drawMode);
 
     void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps,
                       gl::Extensions *outExtensions,
@@ -443,6 +449,8 @@ class Renderer9 : public RendererD3D
 
     DeviceD3D *mEGLDevice;
     std::vector<TranslatedAttribute> mTranslatedAttribCache;
+
+    DebugAnnotator9 mAnnotator;
 };
 
 }  // namespace rx