Catch errors in TextureStorage creation in TextureD3D::getNativeTexture.

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -85,17 +85,28 @@ TextureD3D::~TextureD3D()
 {
 }
 
-TextureStorage *TextureD3D::getNativeTexture()
+gl::Error TextureD3D::getNativeTexture(TextureStorage **outStorage)
 {
     // ensure the underlying texture is created
-    initializeStorage(false);
+    gl::Error error = initializeStorage(false);
+    if (error.isError())
+    {
+        return error;
+    }
 
     if (mTexStorage)
     {
-        updateStorage();
+        error = updateStorage();
+        if (error.isError())
+        {
+            return error;
+        }
     }
 
-    return mTexStorage;
+    ASSERT(outStorage);
+
+    *outStorage = mTexStorage;
+    return gl::Error(GL_NO_ERROR);
 }
 
 GLint TextureD3D::getBaseLevelWidth() const
@@ -358,7 +369,14 @@ gl::Error TextureD3D::generateMipmaps()
     if (mTexStorage && mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
         // Switch to using the mipmapped texture.
-        gl::Error error = getNativeTexture()->useLevelZeroWorkaroundTexture(false);
+        TextureStorage *textureStorage = NULL;
+        gl::Error error = getNativeTexture(&textureStorage);
+        if (error.isError())
+        {
+            return error;
+        }
+
+        error = textureStorage->useLevelZeroWorkaroundTexture(false);
         if (error.isError())
         {
             return error;

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -33,7 +33,7 @@ class TextureD3D : public TextureImpl
     TextureD3D(RendererD3D *renderer);
     virtual ~TextureD3D();
 
-    TextureStorage *getNativeTexture();
+    gl::Error getNativeTexture(TextureStorage **outStorage);
 
     virtual void setUsage(GLenum usage) { mUsage = usage; }
     bool hasDirtyImages() const { return mDirtyImages; }

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

@@ -7,6 +7,8 @@
 // Framebuffer11.cpp: Implements the Framebuffer11 class.
 
 #include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h"
+
+#include "common/debug.h"
 #include "libANGLE/renderer/d3d/d3d11/Buffer11.h"
 #include "libANGLE/renderer/d3d/d3d11/Clear11.h"
 #include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h"
@@ -33,33 +35,57 @@ Framebuffer11::~Framebuffer11()
 {
 }
 
-static void InvalidateAttachmentSwizzles(const gl::FramebufferAttachment *attachment)
+static gl::Error InvalidateAttachmentSwizzles(const gl::FramebufferAttachment *attachment)
 {
     if (attachment && attachment->type() == GL_TEXTURE)
     {
         gl::Texture *texture = attachment->getTexture();
 
         TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
-        TextureStorage *texStorage = textureD3D->getNativeTexture();
+
+        TextureStorage *texStorage = NULL;
+        gl::Error error = textureD3D->getNativeTexture(&texStorage);
+        if (error.isError())
+        {
+            return error;
+        }
+
         if (texStorage)
         {
             TextureStorage11 *texStorage11 = TextureStorage11::makeTextureStorage11(texStorage);
-            if (!texStorage11)
-            {
-                ERR("texture storage pointer unexpectedly null.");
-                return;
-            }
+            ASSERT(texStorage11);
 
             texStorage11->invalidateSwizzleCacheLevel(attachment->mipLevel());
         }
     }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
-void Framebuffer11::invalidateSwizzles()
+gl::Error Framebuffer11::invalidateSwizzles() const
 {
-    std::for_each(mColorBuffers.begin(), mColorBuffers.end(), InvalidateAttachmentSwizzles);
-    InvalidateAttachmentSwizzles(mDepthbuffer);
-    InvalidateAttachmentSwizzles(mStencilbuffer);
+    for (size_t i = 0; i < mColorBuffers.size(); i++)
+    {
+        gl::Error error = InvalidateAttachmentSwizzles(mColorBuffers[i]);
+        if (error.isError())
+        {
+            return error;
+        }
+    }
+
+    gl::Error error = InvalidateAttachmentSwizzles(mDepthbuffer);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    error = InvalidateAttachmentSwizzles(mStencilbuffer);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error Framebuffer11::clear(const gl::State &state, const gl::ClearParameters &clearParams)
@@ -72,7 +98,11 @@ gl::Error Framebuffer11::clear(const gl::State &state, const gl::ClearParameters
         return error;
     }
 
-    invalidateSwizzles();
+    error = invalidateSwizzles();
+    if (error.isError())
+    {
+        return error;
+    }
 
     return gl::Error(GL_NO_ERROR);
 }
@@ -221,7 +251,11 @@ gl::Error Framebuffer11::blit(const gl::Rectangle &sourceArea, const gl::Rectang
         }
     }
 
-    invalidateSwizzles();
+    gl::Error error = invalidateSwizzles();
+    if (error.isError())
+    {
+        return error;
+    }
 
     return gl::Error(GL_NO_ERROR);
 }

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

@@ -22,7 +22,7 @@ class Framebuffer11 : public FramebufferD3D
     virtual ~Framebuffer11();
 
     // Invalidate the cached swizzles of all bound texture attachments.
-    void invalidateSwizzles();
+    gl::Error invalidateSwizzles() const;
 
   private:
     gl::Error clear(const gl::State &state, const gl::ClearParameters &clearParams) override;

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

@@ -597,7 +597,13 @@ gl::Error Renderer11::generateSwizzle(gl::Texture *texture)
         TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
         ASSERT(textureD3D);
 
-        TextureStorage *texStorage = textureD3D->getNativeTexture();
+        TextureStorage *texStorage = nullptr;
+        gl::Error error = textureD3D->getNativeTexture(&texStorage);
+        if (error.isError())
+        {
+            return error;
+        }
+
         if (texStorage)
         {
             TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage);
@@ -620,7 +626,18 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type, int index, gl::Textu
     // Make sure to add the level offset for our tiny compressed texture workaround
     TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
     gl::SamplerState samplerStateInternal = samplerStateParam;
-    samplerStateInternal.baseLevel += textureD3D->getNativeTexture()->getTopLevel();
+
+    TextureStorage *storage = nullptr;
+    gl::Error error = textureD3D->getNativeTexture(&storage);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    // Storage should exist, texture should be complete
+    ASSERT(storage);
+
+    samplerStateInternal.baseLevel += storage->getTopLevel();
 
     if (type == gl::SAMPLER_PIXEL)
     {
@@ -676,8 +693,16 @@ gl::Error Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *t
     if (texture)
     {
         TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
-        TextureStorage *texStorage = textureImpl->getNativeTexture();
-        ASSERT(texStorage != NULL);
+
+        TextureStorage *texStorage = nullptr;
+        gl::Error error = textureImpl->getNativeTexture(&texStorage);
+        if (error.isError())
+        {
+            return error;
+        }
+
+        // Texture should be complete and have a storage
+        ASSERT(texStorage);
 
         TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage);
 
@@ -685,7 +710,7 @@ gl::Error Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *t
         gl::SamplerState samplerState = texture->getSamplerState();
         samplerState.baseLevel += storage11->getTopLevel();
 
-        gl::Error error = storage11->getSRV(samplerState, &textureSRV);
+        error = storage11->getSRV(samplerState, &textureSRV);
         if (error.isError())
         {
             return error;
@@ -1162,7 +1187,12 @@ gl::Error Renderer11::applyRenderTarget(const gl::Framebuffer *framebuffer)
         mDepthStencilInitialized = true;
     }
 
-    invalidateFramebufferSwizzles(framebuffer);
+    const Framebuffer11 *framebuffer11 = GetImplAs<Framebuffer11>(framebuffer);
+    gl::Error error = framebuffer11->invalidateSwizzles();
+    if (error.isError())
+    {
+        return error;
+    }
 
     return gl::Error(GL_NO_ERROR);
 }
@@ -3277,50 +3307,6 @@ ID3D11Texture2D *Renderer11::resolveMultisampledTexture(ID3D11Texture2D *source,
     }
 }
 
-void Renderer11::invalidateFBOAttachmentSwizzles(gl::FramebufferAttachment *attachment, int mipLevel)
-{
-    ASSERT(attachment->type() == GL_TEXTURE);
-    gl::Texture *texture = attachment->getTexture();
-
-    TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
-    TextureStorage *texStorage = textureD3D->getNativeTexture();
-    if (texStorage)
-    {
-        TextureStorage11 *texStorage11 = TextureStorage11::makeTextureStorage11(texStorage);
-        if (!texStorage11)
-        {
-            ERR("texture storage pointer unexpectedly null.");
-            return;
-        }
-
-        texStorage11->invalidateSwizzleCacheLevel(mipLevel);
-    }
-}
-
-void Renderer11::invalidateFramebufferSwizzles(const gl::Framebuffer *framebuffer)
-{
-    for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
-    {
-        gl::FramebufferAttachment *attachment = framebuffer->getColorbuffer(colorAttachment);
-        if (attachment && attachment->type() == GL_TEXTURE)
-        {
-            invalidateFBOAttachmentSwizzles(attachment, attachment->mipLevel());
-        }
-    }
-
-    gl::FramebufferAttachment *depthAttachment = framebuffer->getDepthbuffer();
-    if (depthAttachment && depthAttachment->type() == GL_TEXTURE)
-    {
-        invalidateFBOAttachmentSwizzles(depthAttachment, depthAttachment->mipLevel());
-    }
-
-    gl::FramebufferAttachment *stencilAttachment = framebuffer->getStencilbuffer();
-    if (stencilAttachment && stencilAttachment->type() == GL_TEXTURE)
-    {
-        invalidateFBOAttachmentSwizzles(stencilAttachment, stencilAttachment->mipLevel());
-    }
-}
-
 bool Renderer11::getLUID(LUID *adapterLuid) const
 {
     adapterLuid->HighPart = 0;

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

@@ -224,9 +224,6 @@ class Renderer11 : public RendererD3D
     ID3D11Texture2D *resolveMultisampledTexture(ID3D11Texture2D *source, unsigned int subresource);
     void unsetConflictingSRVs(gl::SamplerType shaderType, uintptr_t resource, const gl::ImageIndex *index);
 
-    static void invalidateFBOAttachmentSwizzles(gl::FramebufferAttachment *attachment, int mipLevel);
-    static void invalidateFramebufferSwizzles(const gl::Framebuffer *framebuffer);
-
     HMODULE mD3d11Module;
     HMODULE mDxgiModule;
     HDC mDc;

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

@@ -753,7 +753,18 @@ gl::Error Renderer9::setSamplerState(gl::SamplerType type, int index, gl::Textur
 
         // Make sure to add the level offset for our tiny compressed texture workaround
         TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
-        DWORD baseLevel = samplerState.baseLevel + textureD3D->getNativeTexture()->getTopLevel();
+
+        TextureStorage *storage = nullptr;
+        gl::Error error = textureD3D->getNativeTexture(&storage);
+        if (error.isError())
+        {
+            return error;
+        }
+
+        // Storage should exist, texture should be complete
+        ASSERT(storage);
+
+        DWORD baseLevel = samplerState.baseLevel + storage->getTopLevel();
 
         mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSU, gl_d3d9::ConvertTextureWrap(samplerState.wrapS));
         mDevice->SetSamplerState(d3dSampler, D3DSAMP_ADDRESSV, gl_d3d9::ConvertTextureWrap(samplerState.wrapT));
@@ -790,17 +801,23 @@ gl::Error Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *te
     {
         TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
 
-        TextureStorage *texStorage = textureImpl->getNativeTexture();
-        if (texStorage)
+        TextureStorage *texStorage = nullptr;
+        gl::Error error = textureImpl->getNativeTexture(&texStorage);
+        if (error.isError())
         {
-            TextureStorage9 *storage9 = TextureStorage9::makeTextureStorage9(texStorage);
+            return error;
+        }
 
-            gl::Error error = storage9->getBaseTexture(&d3dTexture);
-            if (error.isError())
-            {
-                return error;
-            }
+        // Texture should be complete and have a storage
+        ASSERT(texStorage);
+
+        TextureStorage9 *storage9 = TextureStorage9::makeTextureStorage9(texStorage);
+        error = storage9->getBaseTexture(&d3dTexture);
+        if (error.isError())
+        {
+            return error;
         }
+
         // If we get NULL back from getBaseTexture here, something went wrong
         // in the texture class and we're unexpectedly missing the d3d texture
         ASSERT(d3dTexture != NULL);