Update Renderer::copyToRenderTarget to return Error objects.

src/libGLESv2/renderer/Renderer.h

@@ -170,10 +170,10 @@ class Renderer
     virtual int getMaxSwapInterval() const = 0;
 
     // Pixel operations
-    virtual bool copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source) = 0;
-    virtual bool copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source) = 0;
-    virtual bool copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source) = 0;
-    virtual bool copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source) = 0;
+    virtual gl::Error copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source) = 0;
+    virtual gl::Error copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source) = 0;
+    virtual gl::Error copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source) = 0;
+    virtual gl::Error copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source) = 0;
 
     virtual gl::Error copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
                                   GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level) = 0;

src/libGLESv2/renderer/d3d/TextureD3D.cpp

@@ -664,7 +664,7 @@ bool TextureD3D_2D::ensureRenderTarget()
         {
             TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
-            if (!mRenderer->copyToRenderTarget2D(newRenderTargetStorage, mTexStorage))
+            if (mRenderer->copyToRenderTarget2D(newRenderTargetStorage, mTexStorage).isError())
             {
                 delete newRenderTargetStorage;
                 return gl::error(GL_OUT_OF_MEMORY, false);
@@ -1121,7 +1121,7 @@ bool TextureD3D_Cube::ensureRenderTarget()
         {
             TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
-            if (!mRenderer->copyToRenderTargetCube(newRenderTargetStorage, mTexStorage))
+            if (mRenderer->copyToRenderTargetCube(newRenderTargetStorage, mTexStorage).isError())
             {
                 delete newRenderTargetStorage;
                 return gl::error(GL_OUT_OF_MEMORY, false);
@@ -1609,7 +1609,7 @@ bool TextureD3D_3D::ensureRenderTarget()
         {
             TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
-            if (!mRenderer->copyToRenderTarget3D(newRenderTargetStorage, mTexStorage))
+            if (mRenderer->copyToRenderTarget3D(newRenderTargetStorage, mTexStorage).isError())
             {
                 delete newRenderTargetStorage;
                 return gl::error(GL_OUT_OF_MEMORY, false);
@@ -2090,7 +2090,7 @@ bool TextureD3D_2DArray::ensureRenderTarget()
         {
             TextureStorage *newRenderTargetStorage = createCompleteStorage(true);
 
-            if (!mRenderer->copyToRenderTarget2DArray(newRenderTargetStorage, mTexStorage))
+            if (mRenderer->copyToRenderTarget2DArray(newRenderTargetStorage, mTexStorage).isError())
             {
                 delete newRenderTargetStorage;
                 return gl::error(GL_OUT_OF_MEMORY, false);

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

@@ -1879,10 +1879,10 @@ int Renderer11::getMaxSwapInterval() const
     return 4;
 }
 
-bool Renderer11::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer11::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source)
 {
-    if (source && dest)
-    {
+    ASSERT(source && dest);
+
     TextureStorage11_2D *source11 = TextureStorage11_2D::makeTextureStorage11_2D(source);
     TextureStorage11_2D *dest11 = TextureStorage11_2D::makeTextureStorage11_2D(dest);
 
@@ -1890,16 +1890,13 @@ bool Renderer11::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *sour
 
     dest11->invalidateSwizzleCache();
 
-        return true;
-    }
-
-    return false;
+    return gl::Error(GL_NO_ERROR);
 }
 
-bool Renderer11::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer11::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source)
 {
-    if (source && dest)
-    {
+    ASSERT(source && dest);
+
     TextureStorage11_Cube *source11 = TextureStorage11_Cube::makeTextureStorage11_Cube(source);
     TextureStorage11_Cube *dest11 = TextureStorage11_Cube::makeTextureStorage11_Cube(dest);
 
@@ -1907,16 +1904,13 @@ bool Renderer11::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *so
 
     dest11->invalidateSwizzleCache();
 
-        return true;
-    }
-
-    return false;
+    return gl::Error(GL_NO_ERROR);
 }
 
-bool Renderer11::copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer11::copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source)
 {
-    if (source && dest)
-    {
+    ASSERT(source && dest);
+
     TextureStorage11_3D *source11 = TextureStorage11_3D::makeTextureStorage11_3D(source);
     TextureStorage11_3D *dest11 = TextureStorage11_3D::makeTextureStorage11_3D(dest);
 
@@ -1924,16 +1918,13 @@ bool Renderer11::copyToRenderTarget3D(TextureStorage *dest, TextureStorage *sour
 
     dest11->invalidateSwizzleCache();
 
-        return true;
-    }
-
-    return false;
+    return gl::Error(GL_NO_ERROR);
 }
 
-bool Renderer11::copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer11::copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source)
 {
-    if (source && dest)
-    {
+    ASSERT(source && dest);
+
     TextureStorage11_2DArray *source11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(source);
     TextureStorage11_2DArray *dest11 = TextureStorage11_2DArray::makeTextureStorage11_2DArray(dest);
 
@@ -1941,10 +1932,7 @@ bool Renderer11::copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage
 
     dest11->invalidateSwizzleCache();
 
-        return true;
-    }
-
-    return false;
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error Renderer11::copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,

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

@@ -115,10 +115,10 @@ class Renderer11 : public Renderer
     virtual int getMaxSwapInterval() const;
 
     // Pixel operations
-    virtual bool copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source);
-    virtual bool copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source);
-    virtual bool copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source);
-    virtual bool copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source);
 
     virtual gl::Error copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
                                   GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level);

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

@@ -2336,12 +2336,10 @@ int Renderer9::getMaxSwapInterval() const
     return mMaxSwapInterval;
 }
 
-bool Renderer9::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer9::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source)
 {
-    bool result = false;
+    ASSERT(source && dest);
 
-    if (source && dest)
-    {
     TextureStorage9_2D *source9 = TextureStorage9_2D::makeTextureStorage9_2D(source);
     TextureStorage9_2D *dest9 = TextureStorage9_2D::makeTextureStorage9_2D(dest);
 
@@ -2351,27 +2349,24 @@ bool Renderer9::copyToRenderTarget2D(TextureStorage *dest, TextureStorage *sourc
         IDirect3DSurface9 *srcSurf = source9->getSurfaceLevel(i, false);
         IDirect3DSurface9 *dstSurf = dest9->getSurfaceLevel(i, false);
 
-            result = copyToRenderTarget(dstSurf, srcSurf, source9->isManaged());
+        gl::Error error = copyToRenderTarget(dstSurf, srcSurf, source9->isManaged());
 
         SafeRelease(srcSurf);
         SafeRelease(dstSurf);
 
-            if (!result)
+        if (error.isError())
         {
-                return false;
-            }
+            return error;
         }
     }
 
-    return result;
+    return gl::Error(GL_NO_ERROR);
 }
 
-bool Renderer9::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer9::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source)
 {
-    bool result = false;
+    ASSERT(source && dest);
 
-    if (source && dest)
-    {
     TextureStorage9_Cube *source9 = TextureStorage9_Cube::makeTextureStorage9_Cube(source);
     TextureStorage9_Cube *dest9 = TextureStorage9_Cube::makeTextureStorage9_Cube(dest);
     int levels = source9->getLevelCount();
@@ -2382,34 +2377,33 @@ bool Renderer9::copyToRenderTargetCube(TextureStorage *dest, TextureStorage *sou
             IDirect3DSurface9 *srcSurf = source9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, false);
             IDirect3DSurface9 *dstSurf = dest9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, true);
 
-                result = copyToRenderTarget(dstSurf, srcSurf, source9->isManaged());
+            gl::Error error = copyToRenderTarget(dstSurf, srcSurf, source9->isManaged());
 
             SafeRelease(srcSurf);
             SafeRelease(dstSurf);
 
-                if (!result)
+            if (error.isError())
             {
-                    return false;
-                }
+                return error;
             }
         }
     }
 
-    return result;
+    return gl::Error(GL_NO_ERROR);
 }
 
-bool Renderer9::copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer9::copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source)
 {
     // 3D textures are not available in the D3D9 backend.
     UNREACHABLE();
-    return false;
+    return gl::Error(GL_INVALID_OPERATION);
 }
 
-bool Renderer9::copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source)
+gl::Error Renderer9::copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source)
 {
     // 2D array textures are not supported by the D3D9 backend.
     UNREACHABLE();
-    return false;
+    return gl::Error(GL_INVALID_OPERATION);
 }
 
 D3DPOOL Renderer9::getBufferPool(DWORD usage) const
@@ -2995,10 +2989,10 @@ D3DPOOL Renderer9::getTexturePool(DWORD usage) const
     return D3DPOOL_DEFAULT;
 }
 
-bool Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged)
+gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged)
 {
-    if (source && dest)
-    {
+    ASSERT(source && dest);
+
     HRESULT result = D3DERR_OUTOFVIDEOMEMORY;
 
     if (fromManaged)
@@ -3025,11 +3019,10 @@ bool Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *s
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return false;
-        }
+        return gl::Error(GL_OUT_OF_MEMORY, "Failed to blit internal texture, result: 0x%X.", result);
     }
 
-    return true;
+    return gl::Error(GL_NO_ERROR);
 }
 
 Image *Renderer9::createImage()

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

@@ -119,10 +119,10 @@ class Renderer9 : public Renderer
     virtual int getMaxSwapInterval() const;
 
     // Pixel operations
-    virtual bool copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source);
-    virtual bool copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source);
-    virtual bool copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source);
-    virtual bool copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTarget2D(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTargetCube(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTarget3D(TextureStorage *dest, TextureStorage *source);
+    virtual gl::Error copyToRenderTarget2DArray(TextureStorage *dest, TextureStorage *source);
 
     virtual gl::Error copyImage2D(gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
                                   GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level);
@@ -214,7 +214,7 @@ class Renderer9 : public Renderer
 
     gl::Error getCountingIB(size_t count, StaticIndexBufferInterface **outIB);
 
-    bool copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged);
+    gl::Error copyToRenderTarget(IDirect3DSurface9 *dest, IDirect3DSurface9 *source, bool fromManaged);
     gl::FramebufferAttachment *getNullColorbuffer(gl::FramebufferAttachment *depthbuffer);
 
     D3DPOOL getBufferPool(DWORD usage) const;