D3D9: Use angle::Result error pattern.

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -238,4 +238,15 @@ unsigned int GetBlendSampleMask(const gl::State &glState, int samples)
     return mask;
 }
 
+GLenum DefaultGLErrorCode(HRESULT hr)
+{
+    switch (hr)
+    {
+        case D3DERR_OUTOFVIDEOMEMORY:
+        case E_OUTOFMEMORY:
+            return GL_OUT_OF_MEMORY;
+        default:
+            return GL_INVALID_OPERATION;
+    }
+}
 }  // namespace rx

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -427,7 +427,7 @@ class RendererD3D : public BufferFactoryD3D
 
 unsigned int GetBlendSampleMask(const gl::State &glState, int samples);
 bool InstancedPointSpritesActive(ProgramD3D *programD3D, gl::PrimitiveMode mode);
-
+GLenum DefaultGLErrorCode(HRESULT hr);
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_D3D_RENDERERD3D_H_

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

@@ -105,17 +105,6 @@ gl::Error ReadbackIndirectBuffer(const gl::Context *context,
     *bufferPtrOut = reinterpret_cast<const IndirectBufferT *>(bufferData + offset);
     return gl::NoError();
 }
-
-GLenum DefaultGLErrorCode(HRESULT hr)
-{
-    switch (hr)
-    {
-        case E_OUTOFMEMORY:
-            return GL_OUT_OF_MEMORY;
-        default:
-            return GL_INVALID_OPERATION;
-    }
-}
 }  // anonymous namespace
 
 Context11::Context11(const gl::ContextState &state, Renderer11 *renderer)

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

@@ -8,15 +8,16 @@
 
 #include "libANGLE/renderer/d3d/d3d9/Blit9.h"
 
+#include "libANGLE/Context.h"
+#include "libANGLE/Framebuffer.h"
+#include "libANGLE/FramebufferAttachment.h"
+#include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/d3d/TextureD3D.h"
-#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
-#include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
-#include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h"
 #include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h"
 #include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
-#include "libANGLE/angletypes.h"
-#include "libANGLE/Framebuffer.h"
-#include "libANGLE/FramebufferAttachment.h"
+#include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h"
+#include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
+#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
 
 namespace
 {
@@ -80,11 +81,11 @@ Blit9::~Blit9()
     }
 }
 
-gl::Error Blit9::initialize()
+angle::Result Blit9::initialize(Context9 *context9)
 {
     if (mGeometryLoaded)
     {
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     static const float quad[] =
@@ -100,23 +101,13 @@ gl::Error Blit9::initialize()
     HRESULT result = device->CreateVertexBuffer(sizeof(quad), D3DUSAGE_WRITEONLY, 0,
                                                 D3DPOOL_DEFAULT, &mQuadVertexBuffer, nullptr);
 
-    if (FAILED(result))
-    {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::OutOfMemory() << "Failed to create internal blit vertex shader, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to create internal blit vertex shader");
 
     void *lockPtr = nullptr;
     result = mQuadVertexBuffer->Lock(0, 0, &lockPtr, 0);
 
-    if (FAILED(result) || lockPtr == nullptr)
-    {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        SafeRelease(mQuadVertexBuffer);
-        return gl::OutOfMemory() << "Failed to lock internal blit vertex shader, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to lock internal blit vertex shader");
+    ASSERT(lockPtr);
 
     memcpy(lockPtr, quad, sizeof(quad));
     mQuadVertexBuffer->Unlock();
@@ -128,23 +119,21 @@ gl::Error Blit9::initialize()
     };
 
     result = device->CreateVertexDeclaration(elements, &mQuadVertexDeclaration);
-
-    if (FAILED(result))
-    {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        SafeRelease(mQuadVertexBuffer);
-        return gl::OutOfMemory() << "Failed to lock internal blit vertex declaration, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to create internal blit vertex shader declaration");
 
     mGeometryLoaded = true;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 template <class D3DShaderType>
-gl::Error Blit9::setShader(ShaderId source, const char *profile,
-                           gl::Error (Renderer9::*createShader)(const DWORD *, size_t length, D3DShaderType **outShader),
-                           HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType*))
+angle::Result Blit9::setShader(Context9 *context9,
+                               ShaderId source,
+                               const char *profile,
+                               angle::Result (Renderer9::*createShader)(Context9 *,
+                                                                        const DWORD *,
+                                                                        size_t length,
+                                                                        D3DShaderType **outShader),
+                               HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType *))
 {
     IDirect3DDevice9 *device = mRenderer->getDevice();
 
@@ -158,27 +147,28 @@ gl::Error Blit9::setShader(ShaderId source, const char *profile,
     {
         const BYTE* shaderCode = g_shaderCode[source];
         size_t shaderSize = g_shaderSize[source];
-        ANGLE_TRY((mRenderer->*createShader)(reinterpret_cast<const DWORD*>(shaderCode), shaderSize, &shader));
+        ANGLE_TRY((mRenderer->*createShader)(context9, reinterpret_cast<const DWORD *>(shaderCode),
+                                             shaderSize, &shader));
         mCompiledShaders[source] = shader;
     }
 
     HRESULT hr = (device->*setShader)(shader);
-    if (FAILED(hr))
-    {
-        return gl::OutOfMemory() << "Failed to set shader for blit operation, " << gl::FmtHR(hr);
-    }
-
-    return gl::NoError();
+    ANGLE_TRY_HR(context9, hr, "Failed to set shader for blit operation");
+    return angle::Result::Continue();
 }
 
-gl::Error Blit9::setVertexShader(ShaderId shader)
+angle::Result Blit9::setVertexShader(Context9 *context9, ShaderId shader)
 {
-    return setShader<IDirect3DVertexShader9>(shader, "vs_2_0", &Renderer9::createVertexShader, &IDirect3DDevice9::SetVertexShader);
+    return setShader<IDirect3DVertexShader9>(context9, shader, "vs_2_0",
+                                             &Renderer9::createVertexShader,
+                                             &IDirect3DDevice9::SetVertexShader);
 }
 
-gl::Error Blit9::setPixelShader(ShaderId shader)
+angle::Result Blit9::setPixelShader(Context9 *context9, ShaderId shader)
 {
-    return setShader<IDirect3DPixelShader9>(shader, "ps_2_0", &Renderer9::createPixelShader, &IDirect3DDevice9::SetPixelShader);
+    return setShader<IDirect3DPixelShader9>(context9, shader, "ps_2_0",
+                                            &Renderer9::createPixelShader,
+                                            &IDirect3DDevice9::SetPixelShader);
 }
 
 RECT Blit9::getSurfaceRect(IDirect3DSurface9 *surface) const
@@ -203,22 +193,24 @@ gl::Extents Blit9::getSurfaceSize(IDirect3DSurface9 *surface) const
     return gl::Extents(desc.Width, desc.Height, 1);
 }
 
-gl::Error Blit9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
+angle::Result Blit9::boxFilter(Context9 *context9,
+                               IDirect3DSurface9 *source,
+                               IDirect3DSurface9 *dest)
 {
-    ANGLE_TRY(initialize());
+    ANGLE_TRY(initialize(context9));
 
-    IDirect3DBaseTexture9 *texture = nullptr;
-    ANGLE_TRY(copySurfaceToTexture(source, getSurfaceRect(source), &texture));
+    angle::ComPtr<IDirect3DBaseTexture9> texture = nullptr;
+    ANGLE_TRY(copySurfaceToTexture(context9, source, getSurfaceRect(source), &texture));
 
     IDirect3DDevice9 *device = mRenderer->getDevice();
 
     saveState();
 
-    device->SetTexture(0, texture);
+    device->SetTexture(0, texture.Get());
     device->SetRenderTarget(0, dest);
 
-    ANGLE_TRY(setVertexShader(SHADER_VS_STANDARD));
-    ANGLE_TRY(setPixelShader(SHADER_PS_PASSTHROUGH));
+    ANGLE_TRY(setVertexShader(context9, SHADER_VS_STANDARD));
+    ANGLE_TRY(setPixelShader(context9, SHADER_PS_PASSTHROUGH));
 
     setCommonBlitState();
     device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
@@ -229,120 +221,96 @@ gl::Error Blit9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
 
     render();
 
-    SafeRelease(texture);
-
     restoreState();
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Blit9::copy2D(const gl::Context *context,
-                        const gl::Framebuffer *framebuffer,
-                        const RECT &sourceRect,
-                        GLenum destFormat,
-                        const gl::Offset &destOffset,
-                        TextureStorage *storage,
-                        GLint level)
+angle::Result Blit9::copy2D(const gl::Context *context,
+                            const gl::Framebuffer *framebuffer,
+                            const RECT &sourceRect,
+                            GLenum destFormat,
+                            const gl::Offset &destOffset,
+                            TextureStorage *storage,
+                            GLint level)
 {
-    ANGLE_TRY(initialize());
+    Context9 *context9 = GetImplAs<Context9>(context);
+
+    ANGLE_TRY(initialize(context9));
 
     const gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
     ASSERT(colorbuffer);
 
     RenderTarget9 *renderTarget9 = nullptr;
-    ANGLE_TRY(colorbuffer->getRenderTarget(context, &renderTarget9));
+    ANGLE_TRY_HANDLE(context, colorbuffer->getRenderTarget(context, &renderTarget9));
     ASSERT(renderTarget9);
 
-    IDirect3DSurface9 *source = renderTarget9->getSurface();
+    angle::ComPtr<IDirect3DSurface9> source = renderTarget9->getSurface();
     ASSERT(source);
 
-    IDirect3DSurface9 *destSurface = nullptr;
+    angle::ComPtr<IDirect3DSurface9> destSurface = nullptr;
     TextureStorage9 *storage9      = GetAs<TextureStorage9>(storage);
-    gl::Error error =
-        storage9->getSurfaceLevel(context, gl::TextureTarget::_2D, level, true, &destSurface);
-    if (error.isError())
-    {
-        SafeRelease(source);
-        return error;
-    }
+    ANGLE_TRY(
+        storage9->getSurfaceLevel(context, gl::TextureTarget::_2D, level, true, &destSurface));
     ASSERT(destSurface);
 
-    gl::Error result =
-        copy(source, nullptr, sourceRect, destFormat, destOffset, destSurface, false, false, false);
-
-    SafeRelease(destSurface);
-    SafeRelease(source);
-
-    return result;
+    ANGLE_TRY(copy(context9, source.Get(), nullptr, sourceRect, destFormat, destOffset,
+                   destSurface.Get(), false, false, false));
+    return angle::Result::Continue();
 }
 
-gl::Error Blit9::copyCube(const gl::Context *context,
-                          const gl::Framebuffer *framebuffer,
-                          const RECT &sourceRect,
-                          GLenum destFormat,
-                          const gl::Offset &destOffset,
-                          TextureStorage *storage,
-                          gl::TextureTarget target,
-                          GLint level)
+angle::Result Blit9::copyCube(const gl::Context *context,
+                              const gl::Framebuffer *framebuffer,
+                              const RECT &sourceRect,
+                              GLenum destFormat,
+                              const gl::Offset &destOffset,
+                              TextureStorage *storage,
+                              gl::TextureTarget target,
+                              GLint level)
 {
-    gl::Error error = initialize();
-    if (error.isError())
-    {
-        return error;
-    }
+    Context9 *context9 = GetImplAs<Context9>(context);
+
+    ANGLE_TRY(initialize(context9));
 
     const gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
     ASSERT(colorbuffer);
 
     RenderTarget9 *renderTarget9 = nullptr;
-    error                        = colorbuffer->getRenderTarget(context, &renderTarget9);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY_HANDLE(context, colorbuffer->getRenderTarget(context, &renderTarget9));
     ASSERT(renderTarget9);
 
-    IDirect3DSurface9 *source = renderTarget9->getSurface();
+    angle::ComPtr<IDirect3DSurface9> source = renderTarget9->getSurface();
     ASSERT(source);
 
-    IDirect3DSurface9 *destSurface = nullptr;
+    angle::ComPtr<IDirect3DSurface9> destSurface = nullptr;
     TextureStorage9 *storage9      = GetAs<TextureStorage9>(storage);
-    error = storage9->getSurfaceLevel(context, target, level, true, &destSurface);
-    if (error.isError())
-    {
-        SafeRelease(source);
-        return error;
-    }
+    ANGLE_TRY(storage9->getSurfaceLevel(context, target, level, true, &destSurface));
     ASSERT(destSurface);
 
-    gl::Error result =
-        copy(source, nullptr, sourceRect, destFormat, destOffset, destSurface, false, false, false);
-
-    SafeRelease(destSurface);
-    SafeRelease(source);
-
-    return result;
+    return copy(context9, source.Get(), nullptr, sourceRect, destFormat, destOffset,
+                destSurface.Get(), false, false, false);
 }
 
-gl::Error Blit9::copyTexture(const gl::Context *context,
-                             const gl::Texture *source,
-                             GLint sourceLevel,
-                             const RECT &sourceRect,
-                             GLenum destFormat,
-                             const gl::Offset &destOffset,
-                             TextureStorage *storage,
-                             gl::TextureTarget destTarget,
-                             GLint destLevel,
-                             bool flipY,
-                             bool premultiplyAlpha,
-                             bool unmultiplyAlpha)
+angle::Result Blit9::copyTexture(const gl::Context *context,
+                                 const gl::Texture *source,
+                                 GLint sourceLevel,
+                                 const RECT &sourceRect,
+                                 GLenum destFormat,
+                                 const gl::Offset &destOffset,
+                                 TextureStorage *storage,
+                                 gl::TextureTarget destTarget,
+                                 GLint destLevel,
+                                 bool flipY,
+                                 bool premultiplyAlpha,
+                                 bool unmultiplyAlpha)
 {
-    ANGLE_TRY(initialize());
+    Context9 *context9 = GetImplAs<Context9>(context);
+    ANGLE_TRY(initialize(context9));
 
-    const TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source);
+    TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source);
 
     TextureStorage *sourceStorage = nullptr;
-    ANGLE_TRY(const_cast<TextureD3D *>(sourceD3D)->getNativeTexture(context, &sourceStorage));
+    ANGLE_TRY_HANDLE(context, sourceD3D->getNativeTexture(context, &sourceStorage));
 
     TextureStorage9_2D *sourceStorage9 = GetAs<TextureStorage9_2D>(sourceStorage);
     ASSERT(sourceStorage9);
@@ -354,37 +322,27 @@ gl::Error Blit9::copyTexture(const gl::Context *context,
     IDirect3DBaseTexture9 *sourceTexture = nullptr;
     ANGLE_TRY(sourceStorage9->getBaseTexture(context, &sourceTexture));
 
-    IDirect3DSurface9 *sourceSurface = nullptr;
+    angle::ComPtr<IDirect3DSurface9> sourceSurface = nullptr;
     ANGLE_TRY(sourceStorage9->getSurfaceLevel(context, gl::TextureTarget::_2D, sourceLevel, true,
                                               &sourceSurface));
 
-    IDirect3DSurface9 *destSurface = nullptr;
-    gl::Error error =
-        destStorage9->getSurfaceLevel(context, destTarget, destLevel, true, &destSurface);
-    if (error.isError())
-    {
-        SafeRelease(sourceSurface);
-        return error;
-    }
-
-    error = copy(sourceSurface, sourceTexture, sourceRect, destFormat, destOffset, destSurface,
-                 flipY, premultiplyAlpha, unmultiplyAlpha);
+    angle::ComPtr<IDirect3DSurface9> destSurface = nullptr;
+    ANGLE_TRY(destStorage9->getSurfaceLevel(context, destTarget, destLevel, true, &destSurface));
 
-    SafeRelease(sourceSurface);
-    SafeRelease(destSurface);
-
-    return error;
+    return copy(context9, sourceSurface.Get(), sourceTexture, sourceRect, destFormat, destOffset,
+                destSurface.Get(), flipY, premultiplyAlpha, unmultiplyAlpha);
 }
 
-gl::Error Blit9::copy(IDirect3DSurface9 *source,
-                      IDirect3DBaseTexture9 *sourceTexture,
-                      const RECT &sourceRect,
-                      GLenum destFormat,
-                      const gl::Offset &destOffset,
-                      IDirect3DSurface9 *dest,
-                      bool flipY,
-                      bool premultiplyAlpha,
-                      bool unmultiplyAlpha)
+angle::Result Blit9::copy(Context9 *context9,
+                          IDirect3DSurface9 *source,
+                          IDirect3DBaseTexture9 *sourceTexture,
+                          const RECT &sourceRect,
+                          GLenum destFormat,
+                          const gl::Offset &destOffset,
+                          IDirect3DSurface9 *dest,
+                          bool flipY,
+                          bool premultiplyAlpha,
+                          bool unmultiplyAlpha)
 {
     ASSERT(source != nullptr && dest != nullptr);
 
@@ -402,61 +360,46 @@ gl::Error Blit9::copy(IDirect3DSurface9 *source,
     {
         RECT destRect = { destOffset.x, destOffset.y, destOffset.x + (sourceRect.right - sourceRect.left), destOffset.y + (sourceRect.bottom - sourceRect.top)};
         HRESULT result = device->StretchRect(source, &sourceRect, dest, &destRect, D3DTEXF_POINT);
+        ANGLE_TRY_HR(context9, result, "StretchRect failed to blit between textures");
+        return angle::Result::Continue();
+    }
 
-        if (FAILED(result))
-        {
-            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::OutOfMemory()
-                   << "Failed to blit between textures, StretchRect " << gl::FmtHR(result);
-        }
+    angle::ComPtr<IDirect3DBaseTexture9> texture = sourceTexture;
+    RECT adjustedSourceRect                      = sourceRect;
+    gl::Extents sourceSize(sourceDesc.Width, sourceDesc.Height, 1);
 
-        return gl::NoError();
-    }
-    else
+    if (texture == nullptr)
     {
-        IDirect3DBaseTexture9 *texture = sourceTexture;
-        RECT adjustedSourceRect        = sourceRect;
-        gl::Extents sourceSize(sourceDesc.Width, sourceDesc.Height, 1);
-
-        if (texture == nullptr)
-        {
-            ANGLE_TRY(copySurfaceToTexture(source, sourceRect, &texture));
-
-            // copySurfaceToTexture only copies in the sourceRect area of the source surface.
-            // Adjust sourceRect so that it is now covering the entire source texture
-            adjustedSourceRect.left   = 0;
-            adjustedSourceRect.right  = sourceRect.right - sourceRect.left;
-            adjustedSourceRect.top    = 0;
-            adjustedSourceRect.bottom = sourceRect.bottom - sourceRect.top;
-
-            sourceSize.width  = sourceRect.right - sourceRect.left;
-            sourceSize.height = sourceRect.bottom - sourceRect.top;
-        }
-        else
-        {
-            texture->AddRef();
-        }
-
-        gl::Error error = formatConvert(texture, adjustedSourceRect, sourceSize, destFormat,
-                                        destOffset, dest, flipY, premultiplyAlpha, unmultiplyAlpha);
-
-        SafeRelease(texture);
-
-        return error;
+        ANGLE_TRY(copySurfaceToTexture(context9, source, sourceRect, &texture));
+
+        // copySurfaceToTexture only copies in the sourceRect area of the source surface.
+        // Adjust sourceRect so that it is now covering the entire source texture
+        adjustedSourceRect.left   = 0;
+        adjustedSourceRect.right  = sourceRect.right - sourceRect.left;
+        adjustedSourceRect.top    = 0;
+        adjustedSourceRect.bottom = sourceRect.bottom - sourceRect.top;
+
+        sourceSize.width  = sourceRect.right - sourceRect.left;
+        sourceSize.height = sourceRect.bottom - sourceRect.top;
     }
+
+    ANGLE_TRY(formatConvert(context9, texture.Get(), adjustedSourceRect, sourceSize, destFormat,
+                            destOffset, dest, flipY, premultiplyAlpha, unmultiplyAlpha));
+    return angle::Result::Continue();
 }
 
-gl::Error Blit9::formatConvert(IDirect3DBaseTexture9 *source,
-                               const RECT &sourceRect,
-                               const gl::Extents &sourceSize,
-                               GLenum destFormat,
-                               const gl::Offset &destOffset,
-                               IDirect3DSurface9 *dest,
-                               bool flipY,
-                               bool premultiplyAlpha,
-                               bool unmultiplyAlpha)
+angle::Result Blit9::formatConvert(Context9 *context9,
+                                   IDirect3DBaseTexture9 *source,
+                                   const RECT &sourceRect,
+                                   const gl::Extents &sourceSize,
+                                   GLenum destFormat,
+                                   const gl::Offset &destOffset,
+                                   IDirect3DSurface9 *dest,
+                                   bool flipY,
+                                   bool premultiplyAlpha,
+                                   bool unmultiplyAlpha)
 {
-    ANGLE_TRY(initialize());
+    ANGLE_TRY(initialize(context9));
 
     IDirect3DDevice9 *device = mRenderer->getDevice();
 
@@ -475,23 +418,25 @@ gl::Error Blit9::formatConvert(IDirect3DBaseTexture9 *source,
 
     setCommonBlitState();
 
-    gl::Error error = setFormatConvertShaders(destFormat, flipY, premultiplyAlpha, unmultiplyAlpha);
-    if (!error.isError())
+    angle::Result result =
+        setFormatConvertShaders(context9, destFormat, flipY, premultiplyAlpha, unmultiplyAlpha);
+    if (result == angle::Result::Continue())
     {
         render();
     }
 
     restoreState();
 
-    return error;
+    return result;
 }
 
-gl::Error Blit9::setFormatConvertShaders(GLenum destFormat,
-                                         bool flipY,
-                                         bool premultiplyAlpha,
-                                         bool unmultiplyAlpha)
+angle::Result Blit9::setFormatConvertShaders(Context9 *context9,
+                                             GLenum destFormat,
+                                             bool flipY,
+                                             bool premultiplyAlpha,
+                                             bool unmultiplyAlpha)
 {
-    ANGLE_TRY(setVertexShader(SHADER_VS_STANDARD));
+    ANGLE_TRY(setVertexShader(context9, SHADER_VS_STANDARD));
 
     switch (destFormat)
     {
@@ -503,16 +448,16 @@ gl::Error Blit9::setFormatConvertShaders(GLenum destFormat,
       case GL_ALPHA:
           if (premultiplyAlpha == unmultiplyAlpha)
           {
-              ANGLE_TRY(setPixelShader(SHADER_PS_COMPONENTMASK));
+              ANGLE_TRY(setPixelShader(context9, SHADER_PS_COMPONENTMASK));
           }
           else if (premultiplyAlpha)
           {
-              ANGLE_TRY(setPixelShader(SHADER_PS_COMPONENTMASK_PREMULTIPLY_ALPHA));
+              ANGLE_TRY(setPixelShader(context9, SHADER_PS_COMPONENTMASK_PREMULTIPLY_ALPHA));
           }
           else
           {
               ASSERT(unmultiplyAlpha);
-              ANGLE_TRY(setPixelShader(SHADER_PS_COMPONENTMASK_UNMULTIPLY_ALPHA));
+              ANGLE_TRY(setPixelShader(context9, SHADER_PS_COMPONENTMASK_UNMULTIPLY_ALPHA));
           }
           break;
 
@@ -520,16 +465,16 @@ gl::Error Blit9::setFormatConvertShaders(GLenum destFormat,
       case GL_LUMINANCE_ALPHA:
           if (premultiplyAlpha == unmultiplyAlpha)
           {
-              ANGLE_TRY(setPixelShader(SHADER_PS_LUMINANCE));
+              ANGLE_TRY(setPixelShader(context9, SHADER_PS_LUMINANCE));
           }
           else if (premultiplyAlpha)
           {
-              ANGLE_TRY(setPixelShader(SHADER_PS_LUMINANCE_PREMULTIPLY_ALPHA));
+              ANGLE_TRY(setPixelShader(context9, SHADER_PS_LUMINANCE_PREMULTIPLY_ALPHA));
           }
           else
           {
               ASSERT(unmultiplyAlpha);
-              ANGLE_TRY(setPixelShader(SHADER_PS_LUMINANCE_UNMULTIPLY_ALPHA));
+              ANGLE_TRY(setPixelShader(context9, SHADER_PS_LUMINANCE_UNMULTIPLY_ALPHA));
           }
           break;
 
@@ -631,12 +576,13 @@ gl::Error Blit9::setFormatConvertShaders(GLenum destFormat,
 
     mRenderer->getDevice()->SetPixelShaderConstantF(0, psConst, 2);
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Blit9::copySurfaceToTexture(IDirect3DSurface9 *surface,
-                                      const RECT &sourceRect,
-                                      IDirect3DBaseTexture9 **outTexture)
+angle::Result Blit9::copySurfaceToTexture(Context9 *context9,
+                                          IDirect3DSurface9 *surface,
+                                          const RECT &sourceRect,
+                                          angle::ComPtr<IDirect3DBaseTexture9> *outTexture)
 {
     ASSERT(surface);
 
@@ -646,44 +592,22 @@ gl::Error Blit9::copySurfaceToTexture(IDirect3DSurface9 *surface,
     surface->GetDesc(&sourceDesc);
 
     // Copy the render target into a texture
-    IDirect3DTexture9 *texture;
+    angle::ComPtr<IDirect3DTexture9> texture;
     HRESULT result = device->CreateTexture(
         sourceRect.right - sourceRect.left, sourceRect.bottom - sourceRect.top, 1,
         D3DUSAGE_RENDERTARGET, sourceDesc.Format, D3DPOOL_DEFAULT, &texture, nullptr);
+    ANGLE_TRY_HR(context9, result, "Failed to allocate internal texture for blit");
 
-    if (FAILED(result))
-    {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::OutOfMemory() << "Failed to allocate internal texture for blit, "
-                                 << gl::FmtHR(result);
-    }
-
-    IDirect3DSurface9 *textureSurface;
+    angle::ComPtr<IDirect3DSurface9> textureSurface;
     result = texture->GetSurfaceLevel(0, &textureSurface);
-
-    if (FAILED(result))
-    {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        SafeRelease(texture);
-        return gl::OutOfMemory() << "Failed to query surface of internal blit texture, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to query surface of internal blit texture");
 
     mRenderer->endScene();
-    result = device->StretchRect(surface, &sourceRect, textureSurface, nullptr, D3DTEXF_NONE);
-
-    SafeRelease(textureSurface);
-
-    if (FAILED(result))
-    {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        SafeRelease(texture);
-        return gl::OutOfMemory() << "Failed to copy between internal blit textures, "
-                                 << gl::FmtHR(result);
-    }
-
+    result = device->StretchRect(surface, &sourceRect, textureSurface.Get(), nullptr, D3DTEXF_NONE);
+    ANGLE_TRY_HR(context9, result, "Failed to copy between internal blit textures");
     *outTexture = texture;
-    return gl::NoError();
+
+    return angle::Result::Continue();
 }
 
 void Blit9::setViewportAndShaderConstants(const RECT &sourceRect,

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

@@ -24,6 +24,7 @@ struct Offset;
 
 namespace rx
 {
+class Context9;
 class Renderer9;
 class TextureStorage;
 
@@ -33,41 +34,41 @@ class Blit9 : angle::NonCopyable
     explicit Blit9(Renderer9 *renderer);
     ~Blit9();
 
-    gl::Error initialize();
+    angle::Result initialize(Context9 *context9);
 
     // Copy from source surface to dest surface.
     // sourceRect, xoffset, yoffset are in D3D coordinates (0,0 in upper-left)
-    gl::Error copy2D(const gl::Context *context,
-                     const gl::Framebuffer *framebuffer,
-                     const RECT &sourceRect,
-                     GLenum destFormat,
-                     const gl::Offset &destOffset,
-                     TextureStorage *storage,
-                     GLint level);
-    gl::Error copyCube(const gl::Context *context,
-                       const gl::Framebuffer *framebuffer,
-                       const RECT &sourceRect,
-                       GLenum destFormat,
-                       const gl::Offset &destOffset,
-                       TextureStorage *storage,
-                       gl::TextureTarget target,
-                       GLint level);
-    gl::Error copyTexture(const gl::Context *context,
-                          const gl::Texture *source,
-                          GLint sourceLevel,
-                          const RECT &sourceRect,
-                          GLenum destFormat,
-                          const gl::Offset &destOffset,
-                          TextureStorage *storage,
-                          gl::TextureTarget destTarget,
-                          GLint destLevel,
-                          bool flipY,
-                          bool premultiplyAlpha,
-                          bool unmultiplyAlpha);
+    angle::Result copy2D(const gl::Context *context,
+                         const gl::Framebuffer *framebuffer,
+                         const RECT &sourceRect,
+                         GLenum destFormat,
+                         const gl::Offset &destOffset,
+                         TextureStorage *storage,
+                         GLint level);
+    angle::Result copyCube(const gl::Context *context,
+                           const gl::Framebuffer *framebuffer,
+                           const RECT &sourceRect,
+                           GLenum destFormat,
+                           const gl::Offset &destOffset,
+                           TextureStorage *storage,
+                           gl::TextureTarget target,
+                           GLint level);
+    angle::Result copyTexture(const gl::Context *context,
+                              const gl::Texture *source,
+                              GLint sourceLevel,
+                              const RECT &sourceRect,
+                              GLenum destFormat,
+                              const gl::Offset &destOffset,
+                              TextureStorage *storage,
+                              gl::TextureTarget destTarget,
+                              GLint destLevel,
+                              bool flipY,
+                              bool premultiplyAlpha,
+                              bool unmultiplyAlpha);
 
     // 2x2 box filter sample from source to dest.
     // Requires that source is RGB(A) and dest has the same format as source.
-    gl::Error boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest);
+    angle::Result boxFilter(Context9 *context9, IDirect3DSurface9 *source, IDirect3DSurface9 *dest);
 
   private:
     Renderer9 *mRenderer;
@@ -80,32 +81,36 @@ class Blit9 : angle::NonCopyable
     // sourceRect, xoffset, yoffset are in D3D coordinates (0,0 in upper-left)
     // source is interpreted as RGBA and destFormat specifies the desired result format. For
     // example, if destFormat = GL_RGB, the alpha channel will be forced to 0.
-    gl::Error formatConvert(IDirect3DBaseTexture9 *source,
-                            const RECT &sourceRect,
-                            const gl::Extents &sourceSize,
-                            GLenum destFormat,
-                            const gl::Offset &destOffset,
-                            IDirect3DSurface9 *dest,
-                            bool flipY,
-                            bool premultiplyAlpha,
-                            bool unmultiplyAlpha);
-    gl::Error setFormatConvertShaders(GLenum destFormat,
-                                      bool flipY,
-                                      bool premultiplyAlpha,
-                                      bool unmultiplyAlpha);
-
-    gl::Error copy(IDirect3DSurface9 *source,
-                   IDirect3DBaseTexture9 *sourceTexture,
-                   const RECT &sourceRect,
-                   GLenum destFormat,
-                   const gl::Offset &destOffset,
-                   IDirect3DSurface9 *dest,
-                   bool flipY,
-                   bool premultiplyAlpha,
-                   bool unmultiplyAlpha);
-    gl::Error copySurfaceToTexture(IDirect3DSurface9 *surface,
-                                   const RECT &sourceRect,
-                                   IDirect3DBaseTexture9 **outTexture);
+    angle::Result formatConvert(Context9 *context9,
+                                IDirect3DBaseTexture9 *source,
+                                const RECT &sourceRect,
+                                const gl::Extents &sourceSize,
+                                GLenum destFormat,
+                                const gl::Offset &destOffset,
+                                IDirect3DSurface9 *dest,
+                                bool flipY,
+                                bool premultiplyAlpha,
+                                bool unmultiplyAlpha);
+    angle::Result setFormatConvertShaders(Context9 *context9,
+                                          GLenum destFormat,
+                                          bool flipY,
+                                          bool premultiplyAlpha,
+                                          bool unmultiplyAlpha);
+
+    angle::Result copy(Context9 *context9,
+                       IDirect3DSurface9 *source,
+                       IDirect3DBaseTexture9 *sourceTexture,
+                       const RECT &sourceRect,
+                       GLenum destFormat,
+                       const gl::Offset &destOffset,
+                       IDirect3DSurface9 *dest,
+                       bool flipY,
+                       bool premultiplyAlpha,
+                       bool unmultiplyAlpha);
+    angle::Result copySurfaceToTexture(Context9 *context9,
+                                       IDirect3DSurface9 *surface,
+                                       const RECT &sourceRect,
+                                       angle::ComPtr<IDirect3DBaseTexture9> *outTexture);
     void setViewportAndShaderConstants(const RECT &sourceRect,
                                        const gl::Extents &sourceSize,
                                        const RECT &destRect,
@@ -132,15 +137,17 @@ class Blit9 : angle::NonCopyable
     IUnknown *mCompiledShaders[SHADER_COUNT];
 
     template <class D3DShaderType>
-    gl::Error setShader(ShaderId source,
-                        const char *profile,
-                        gl::Error (Renderer9::*createShader)(const DWORD *,
-                                                             size_t length,
-                                                             D3DShaderType **outShader),
-                        HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType *));
-
-    gl::Error setVertexShader(ShaderId shader);
-    gl::Error setPixelShader(ShaderId shader);
+    angle::Result setShader(Context9 *,
+                            ShaderId source,
+                            const char *profile,
+                            angle::Result (Renderer9::*createShader)(Context9 *context9,
+                                                                     const DWORD *,
+                                                                     size_t length,
+                                                                     D3DShaderType **outShader),
+                            HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType *));
+
+    angle::Result setVertexShader(Context9 *context9, ShaderId shader);
+    angle::Result setPixelShader(Context9 *context9, ShaderId shader);
     void render();
 
     void saveState();

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

@@ -138,12 +138,12 @@ std::vector<PathImpl *> Context9::createPaths(GLsizei)
 
 gl::Error Context9::flush(const gl::Context *context)
 {
-    return mRenderer->flush();
+    return mRenderer->flush(context);
 }
 
 gl::Error Context9::finish(const gl::Context *context)
 {
-    return mRenderer->finish();
+    return mRenderer->finish(context);
 }
 
 gl::Error Context9::drawArrays(const gl::Context *context,
@@ -334,4 +334,26 @@ gl::Error Context9::getIncompleteTexture(const gl::Context *context,
 {
     return mIncompleteTextures.getIncompleteTexture(context, type, nullptr, textureOut);
 }
+
+void Context9::handleError(HRESULT hr,
+                           const char *message,
+                           const char *file,
+                           const char *function,
+                           unsigned int line)
+{
+    ASSERT(FAILED(hr));
+
+    if (d3d9::isDeviceLostError(hr))
+    {
+        mRenderer->notifyDeviceLost();
+    }
+
+    GLenum glErrorCode = DefaultGLErrorCode(hr);
+
+    std::stringstream errorStream;
+    errorStream << "Internal D3D9 error: " << gl::FmtHR(hr) << ", in " << file << ", " << function
+                << ":" << line << ". " << message;
+
+    mErrors->handleError(gl::Error(glErrorCode, glErrorCode, errorStream.str()));
+}
 }  // namespace rx

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

@@ -151,6 +151,12 @@ class Context9 : public ContextImpl
                                    gl::TextureType type,
                                    gl::Texture **textureOut);
 
+    void handleError(HRESULT hr,
+                     const char *message,
+                     const char *file,
+                     const char *function,
+                     unsigned int line);
+
   private:
     Renderer9 *mRenderer;
     IncompleteTextureSet mIncompleteTextures;

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

@@ -7,8 +7,11 @@
 // Fence9.cpp: Defines the rx::FenceNV9 class.
 
 #include "libANGLE/renderer/d3d/d3d9/Fence9.h"
-#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
+
+#include "libANGLE/Context.h"
+#include "libANGLE/renderer/d3d/d3d9/Context9.h"
 #include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
+#include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
 
 namespace rx
 {
@@ -26,11 +29,7 @@ gl::Error FenceNV9::set(const gl::Context *context, GLenum condition)
 {
     if (!mQuery)
     {
-        gl::Error error = mRenderer->allocateEventQuery(&mQuery);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(mRenderer->allocateEventQuery(context, &mQuery));
     }
 
     HRESULT result = mQuery->Issue(D3DISSUE_END);
@@ -46,7 +45,7 @@ gl::Error FenceNV9::set(const gl::Context *context, GLenum condition)
 
 gl::Error FenceNV9::test(const gl::Context *context, GLboolean *outFinished)
 {
-    return testHelper(true, outFinished);
+    return testHelper(GetImplAs<Context9>(context), true, outFinished);
 }
 
 gl::Error FenceNV9::finish(const gl::Context *context)
@@ -54,38 +53,25 @@ gl::Error FenceNV9::finish(const gl::Context *context)
     GLboolean finished = GL_FALSE;
     while (finished != GL_TRUE)
     {
-        gl::Error error = testHelper(true, &finished);
-        if (error.isError())
-        {
-            return error;
-        }
-
+        ANGLE_TRY(testHelper(GetImplAs<Context9>(context), true, &finished));
         Sleep(0);
     }
 
     return gl::NoError();
 }
 
-gl::Error FenceNV9::testHelper(bool flushCommandBuffer, GLboolean *outFinished)
+angle::Result FenceNV9::testHelper(Context9 *context9,
+                                   bool flushCommandBuffer,
+                                   GLboolean *outFinished)
 {
     ASSERT(mQuery);
 
     DWORD getDataFlags = (flushCommandBuffer ? D3DGETDATA_FLUSH : 0);
     HRESULT result     = mQuery->GetData(nullptr, 0, getDataFlags);
-
-    if (d3d9::isDeviceLostError(result))
-    {
-        mRenderer->notifyDeviceLost();
-        return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
-    }
-    else if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to get query data, " << gl::FmtHR(result);
-    }
-
+    ANGLE_TRY_HR(context9, result, "Failed to get query data");
     ASSERT(result == S_OK || result == S_FALSE);
     *outFinished = ((result == S_OK) ? GL_TRUE : GL_FALSE);
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 }  // namespace rx

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

@@ -14,6 +14,7 @@
 
 namespace rx
 {
+class Context9;
 class Renderer9;
 
 class FenceNV9 : public FenceNVImpl
@@ -27,7 +28,7 @@ class FenceNV9 : public FenceNVImpl
     gl::Error finish(const gl::Context *context) override;
 
   private:
-    gl::Error testHelper(bool flushCommandBuffer, GLboolean *outFinished);
+    angle::Result testHelper(Context9 *context9, bool flushCommandBuffer, GLboolean *outFinished);
 
     Renderer9 *mRenderer;
     IDirect3DQuery9 *mQuery;

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

@@ -71,8 +71,9 @@ gl::Error Framebuffer9::clearImpl(const gl::Context *context, const ClearParamet
 
     mRenderer->setScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled());
 
-    return mRenderer->clear(context, clearParams, mRenderTargetCache.getColors()[0],
-                            mRenderTargetCache.getDepthStencil());
+    mRenderer->clear(clearParams, mRenderTargetCache.getColors()[0],
+                     mRenderTargetCache.getDepthStencil());
+    return gl::NoError();
 }
 
 gl::Error Framebuffer9::readPixelsImpl(const gl::Context *context,

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

@@ -8,12 +8,15 @@
 // the actual underlying surfaces of a Texture.
 
 #include "libANGLE/renderer/d3d/d3d9/Image9.h"
+
 #include "common/utilities.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/Renderbuffer.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/copyvertex.h"
+#include "libANGLE/renderer/d3d/d3d9/Context9.h"
 #include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h"
 #include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
 #include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h"
@@ -39,27 +42,22 @@ Image9::~Image9()
     SafeRelease(mSurface);
 }
 
-gl::Error Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9 *sourceSurface)
+// static
+angle::Result Image9::GenerateMip(Context9 *context9,
+                                  IDirect3DSurface9 *destSurface,
+                                  IDirect3DSurface9 *sourceSurface)
 {
     D3DSURFACE_DESC destDesc;
     HRESULT result = destSurface->GetDesc(&destDesc);
     ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory()
-               << "Failed to query the source surface description for mipmap generation, "
-               << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result,
+                 "Failed to query the source surface description for mipmap generation");
 
     D3DSURFACE_DESC sourceDesc;
     result = sourceSurface->GetDesc(&sourceDesc);
     ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory()
-               << "Failed to query the destination surface description for mipmap generation, "
-               << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result,
+                 "Failed to query the destination surface description for mipmap generation");
 
     ASSERT(sourceDesc.Format == destDesc.Format);
     ASSERT(sourceDesc.Width == 1 || sourceDesc.Width / 2 == destDesc.Width);
@@ -71,21 +69,12 @@ gl::Error Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9
     D3DLOCKED_RECT sourceLocked = {0};
     result                      = sourceSurface->LockRect(&sourceLocked, nullptr, D3DLOCK_READONLY);
     ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to lock the source surface for mipmap generation, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to lock the source surface for mipmap generation");
 
     D3DLOCKED_RECT destLocked = {0};
     result                    = destSurface->LockRect(&destLocked, nullptr, 0);
     ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        sourceSurface->UnlockRect();
-        return gl::OutOfMemory() << "Failed to lock the destination surface for mipmap generation, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to lock the destination surface for mipmap generation");
 
     const uint8_t *sourceData = static_cast<const uint8_t *>(sourceLocked.pBits);
     uint8_t *destData         = static_cast<uint8_t *>(destLocked.pBits);
@@ -99,25 +88,29 @@ gl::Error Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9
     destSurface->UnlockRect();
     sourceSurface->UnlockRect();
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Image9::generateMipmap(Image9 *dest, Image9 *source)
+// static
+angle::Result Image9::GenerateMipmap(Context9 *context9, Image9 *dest, Image9 *source)
 {
     IDirect3DSurface9 *sourceSurface = nullptr;
-    ANGLE_TRY(source->getSurface(&sourceSurface));
+    ANGLE_TRY(source->getSurface(context9, &sourceSurface));
 
     IDirect3DSurface9 *destSurface = nullptr;
-    ANGLE_TRY(dest->getSurface(&destSurface));
+    ANGLE_TRY(dest->getSurface(context9, &destSurface));
 
-    ANGLE_TRY(generateMip(destSurface, sourceSurface));
+    ANGLE_TRY(GenerateMip(context9, destSurface, sourceSurface));
 
     dest->markDirty();
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Image9::copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface9 *source)
+// static
+angle::Result Image9::CopyLockableSurfaces(Context9 *context9,
+                                           IDirect3DSurface9 *dest,
+                                           IDirect3DSurface9 *source)
 {
     D3DLOCKED_RECT sourceLock = {0};
     D3DLOCKED_RECT destLock = {0};
@@ -125,17 +118,14 @@ gl::Error Image9::copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface
     HRESULT result;
 
     result = source->LockRect(&sourceLock, nullptr, 0);
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to lock source surface for copy, " << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to lock source surface for copy");
 
     result = dest->LockRect(&destLock, nullptr, 0);
     if (FAILED(result))
     {
         source->UnlockRect();
-        return gl::OutOfMemory() << "Failed to lock source surface for copy, " << gl::FmtHR(result);
     }
+    ANGLE_TRY_HR(context9, result, "Failed to lock destination surface for copy");
 
     ASSERT(sourceLock.pBits && destLock.pBits);
 
@@ -157,55 +147,44 @@ gl::Error Image9::copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface
     source->UnlockRect();
     dest->UnlockRect();
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 // static
-gl::Error Image9::CopyImage(const gl::Context *context,
-                            Image9 *dest,
-                            Image9 *source,
-                            const gl::Rectangle &sourceRect,
-                            const gl::Offset &destOffset,
-                            bool unpackFlipY,
-                            bool unpackPremultiplyAlpha,
-                            bool unpackUnmultiplyAlpha)
+angle::Result Image9::CopyImage(const gl::Context *context,
+                                Image9 *dest,
+                                Image9 *source,
+                                const gl::Rectangle &sourceRect,
+                                const gl::Offset &destOffset,
+                                bool unpackFlipY,
+                                bool unpackPremultiplyAlpha,
+                                bool unpackUnmultiplyAlpha)
 {
+    Context9 *context9 = GetImplAs<Context9>(context);
+
     IDirect3DSurface9 *sourceSurface = nullptr;
-    ANGLE_TRY(source->getSurface(&sourceSurface));
+    ANGLE_TRY(source->getSurface(context9, &sourceSurface));
 
     IDirect3DSurface9 *destSurface = nullptr;
-    ANGLE_TRY(dest->getSurface(&destSurface));
+    ANGLE_TRY(dest->getSurface(context9, &destSurface));
 
     D3DSURFACE_DESC destDesc;
     HRESULT result = destSurface->GetDesc(&destDesc);
     ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory()
-               << "Failed to query the source surface description for mipmap generation, "
-               << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to query the source surface description for CopyImage");
     const d3d9::D3DFormat &destD3DFormatInfo = d3d9::GetD3DFormatInfo(destDesc.Format);
 
     D3DSURFACE_DESC sourceDesc;
     result = sourceSurface->GetDesc(&sourceDesc);
     ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory()
-               << "Failed to query the destination surface description for mipmap generation, "
-               << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result,
+                 "Failed to query the destination surface description for CopyImage");
     const d3d9::D3DFormat &sourceD3DFormatInfo = d3d9::GetD3DFormatInfo(sourceDesc.Format);
 
     D3DLOCKED_RECT sourceLocked = {0};
     result                      = sourceSurface->LockRect(&sourceLocked, nullptr, D3DLOCK_READONLY);
     ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to lock the source surface for CopyImage, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, result, "Failed to lock the source surface for CopyImage");
 
     D3DLOCKED_RECT destLocked = {0};
     result                    = destSurface->LockRect(&destLocked, nullptr, 0);
@@ -213,9 +192,8 @@ gl::Error Image9::CopyImage(const gl::Context *context,
     if (FAILED(result))
     {
         sourceSurface->UnlockRect();
-        return gl::OutOfMemory() << "Failed to lock the destination surface for CopyImage, "
-                                 << gl::FmtHR(result);
     }
+    ANGLE_TRY_HR(context9, result, "Failed to lock the destination surface for CopyImage");
 
     const uint8_t *sourceData = static_cast<const uint8_t *>(sourceLocked.pBits) +
                                 sourceRect.x * sourceD3DFormatInfo.pixelBytes +
@@ -235,7 +213,7 @@ gl::Error Image9::CopyImage(const gl::Context *context,
     destSurface->UnlockRect();
     sourceSurface->UnlockRect();
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 bool Image9::redefine(gl::TextureType type,
@@ -275,11 +253,11 @@ bool Image9::redefine(gl::TextureType type,
     return false;
 }
 
-gl::Error Image9::createSurface()
+angle::Result Image9::createSurface(Context9 *context9)
 {
     if (mSurface)
     {
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     IDirect3DTexture9 *newTexture = nullptr;
@@ -299,11 +277,7 @@ gl::Error Image9::createSurface()
         HRESULT result = device->CreateTexture(requestWidth, requestHeight, levelToFetch + 1, 0,
                                                d3dFormat, poolToUse, &newTexture, nullptr);
 
-        if (FAILED(result))
-        {
-            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::OutOfMemory() << "Failed to create image surface, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(context9, result, "Failed to create image surface");
 
         newTexture->GetSurfaceLevel(levelToFetch, &newSurface);
         SafeRelease(newTexture);
@@ -320,20 +294,14 @@ gl::Error Image9::createSurface()
             D3DLOCKED_RECT lockedRect;
             result = newSurface->LockRect(&lockedRect, &entireRect, 0);
             ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to lock image surface, " << gl::FmtHR(result);
-            }
+            ANGLE_TRY_HR(context9, result, "Failed to lock image surface");
 
             d3dFormatInfo.dataInitializerFunction(
                 mWidth, mHeight, 1, static_cast<uint8_t *>(lockedRect.pBits), lockedRect.Pitch, 0);
 
             result = newSurface->UnlockRect();
             ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to unlock image surface, " << gl::FmtHR(result);
-            }
+            ANGLE_TRY_HR(context9, result, "Failed to unlock image surface");
         }
     }
 
@@ -341,30 +309,22 @@ gl::Error Image9::createSurface()
     mDirty = false;
     mD3DPool = poolToUse;
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Image9::lock(D3DLOCKED_RECT *lockedRect, const RECT &rect)
+angle::Result Image9::lock(Context9 *context9, D3DLOCKED_RECT *lockedRect, const RECT &rect)
 {
-    gl::Error error = createSurface();
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(createSurface(context9));
 
     if (mSurface)
     {
         HRESULT result = mSurface->LockRect(lockedRect, &rect, 0);
         ASSERT(SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::OutOfMemory() << "Failed to lock image surface, " << gl::FmtHR(result);
-        }
-
+        ANGLE_TRY_HR(context9, result, "Failed to lock image surface");
         mDirty = true;
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 void Image9::unlock()
@@ -394,16 +354,11 @@ bool Image9::isDirty() const
            mDirty;
 }
 
-gl::Error Image9::getSurface(IDirect3DSurface9 **outSurface)
+angle::Result Image9::getSurface(Context9 *context9, IDirect3DSurface9 **outSurface)
 {
-    gl::Error error = createSurface();
-    if (error.isError())
-    {
-        return error;
-    }
-
+    ANGLE_TRY(createSurface(context9));
     *outSurface = mSurface;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error Image9::setManagedSurface2D(const gl::Context *context,
@@ -412,13 +367,8 @@ gl::Error Image9::setManagedSurface2D(const gl::Context *context,
 {
     IDirect3DSurface9 *surface = nullptr;
     TextureStorage9 *storage9  = GetAs<TextureStorage9>(storage);
-    gl::Error error =
-        storage9->getSurfaceLevel(context, gl::TextureTarget::_2D, level, false, &surface);
-    if (error.isError())
-    {
-        return error;
-    }
-    return setManagedSurface(surface);
+    ANGLE_TRY(storage9->getSurfaceLevel(context, gl::TextureTarget::_2D, level, false, &surface));
+    return setManagedSurface(GetImplAs<Context9>(context), surface);
 }
 
 gl::Error Image9::setManagedSurfaceCube(const gl::Context *context,
@@ -428,16 +378,12 @@ gl::Error Image9::setManagedSurfaceCube(const gl::Context *context,
 {
     IDirect3DSurface9 *surface = nullptr;
     TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage);
-    gl::Error error = storage9->getSurfaceLevel(context, gl::CubeFaceIndexToTextureTarget(face),
-                                                level, false, &surface);
-    if (error.isError())
-    {
-        return error;
-    }
-    return setManagedSurface(surface);
+    ANGLE_TRY(storage9->getSurfaceLevel(context, gl::CubeFaceIndexToTextureTarget(face), level,
+                                        false, &surface));
+    return setManagedSurface(GetImplAs<Context9>(context), surface);
 }
 
-gl::Error Image9::setManagedSurface(IDirect3DSurface9 *surface)
+angle::Result Image9::setManagedSurface(Context9 *context9, IDirect3DSurface9 *surface)
 {
     D3DSURFACE_DESC desc;
     surface->GetDesc(&desc);
@@ -447,19 +393,16 @@ gl::Error Image9::setManagedSurface(IDirect3DSurface9 *surface)
     {
         if (mSurface)
         {
-            gl::Error error = copyLockableSurfaces(surface, mSurface);
+            angle::Result result = CopyLockableSurfaces(context9, surface, mSurface);
             SafeRelease(mSurface);
-            if (error.isError())
-            {
-                return error;
-            }
+            ANGLE_TRY(result);
         }
 
         mSurface = surface;
         mD3DPool = desc.Pool;
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error Image9::copyToStorage(const gl::Context *context,
@@ -467,29 +410,27 @@ gl::Error Image9::copyToStorage(const gl::Context *context,
                                 const gl::ImageIndex &index,
                                 const gl::Box &region)
 {
-    ANGLE_TRY(createSurface());
+    ANGLE_TRY(createSurface(GetImplAs<Context9>(context)));
 
     TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage);
     IDirect3DSurface9 *destSurface = nullptr;
     ANGLE_TRY(storage9->getSurfaceLevel(context, index.getTarget(), index.getLevelIndex(), true,
                                         &destSurface));
 
-    gl::Error error = copyToSurface(destSurface, region);
+    angle::Result result = copyToSurface(GetImplAs<Context9>(context), destSurface, region);
     SafeRelease(destSurface);
-    return error;
+    return result;
 }
 
-gl::Error Image9::copyToSurface(IDirect3DSurface9 *destSurface, const gl::Box &area)
+angle::Result Image9::copyToSurface(Context9 *context9,
+                                    IDirect3DSurface9 *destSurface,
+                                    const gl::Box &area)
 {
     ASSERT(area.width > 0 && area.height > 0 && area.depth == 1);
     ASSERT(destSurface);
 
     IDirect3DSurface9 *sourceSurface = nullptr;
-    gl::Error error = getSurface(&sourceSurface);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(getSurface(context9, &sourceSurface));
 
     ASSERT(sourceSurface && sourceSurface != destSurface);
 
@@ -511,34 +452,24 @@ gl::Error Image9::copyToSurface(IDirect3DSurface9 *destSurface, const gl::Box &a
         IDirect3DSurface9 *surf = 0;
         HRESULT result = device->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format,
                                                              D3DPOOL_SYSTEMMEM, &surf, nullptr);
-        if (FAILED(result))
-        {
-            return gl::OutOfMemory()
-                   << "Internal CreateOffscreenPlainSurface call failed, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(context9, result, "Internal CreateOffscreenPlainSurface call failed");
 
-        auto err = copyLockableSurfaces(surf, sourceSurface);
+        auto err = CopyLockableSurfaces(context9, surf, sourceSurface);
         result = device->UpdateSurface(surf, &rect, destSurface, &point);
         SafeRelease(surf);
         ANGLE_TRY(err);
         ASSERT(SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::OutOfMemory() << "Internal UpdateSurface call failed, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(context9, result, "Internal UpdateSurface call failed");
     }
     else
     {
         // UpdateSurface: source must be SYSTEMMEM, dest must be DEFAULT pools
         HRESULT result = device->UpdateSurface(sourceSurface, &rect, destSurface, &point);
         ASSERT(SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::OutOfMemory() << "Internal UpdateSurface call failed, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(context9, result, "Internal UpdateSurface call failed");
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 // Store the pixel rectangle designated by xoffset,yoffset,width,height with pixels stored as format/type at input
@@ -571,11 +502,7 @@ gl::Error Image9::loadData(const gl::Context *context,
     };
 
     D3DLOCKED_RECT locked;
-    gl::Error error = lock(&locked, lockRect);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(lock(GetImplAs<Context9>(context), &locked, lockRect));
 
     d3dFormatInfo.loadFunction(area.width, area.height, area.depth,
                                static_cast<const uint8_t *>(input), inputRowPitch, 0,
@@ -616,11 +543,7 @@ gl::Error Image9::loadCompressedData(const gl::Context *context,
     };
 
     D3DLOCKED_RECT locked;
-    gl::Error error = lock(&locked, lockRect);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(lock(GetImplAs<Context9>(context), &locked, lockRect));
 
     d3d9FormatInfo.loadFunction(area.width, area.height, area.depth,
                                 static_cast<const uint8_t *>(input), inputRowPitch, inputDepthPitch,
@@ -632,9 +555,10 @@ gl::Error Image9::loadCompressedData(const gl::Context *context,
 }
 
 // This implements glCopyTex[Sub]Image2D for non-renderable internal texture formats and incomplete textures
-gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
-                                     const gl::Rectangle &sourceArea,
-                                     RenderTargetD3D *source)
+angle::Result Image9::copyFromRTInternal(Context9 *context9,
+                                         const gl::Offset &destOffset,
+                                         const gl::Rectangle &sourceArea,
+                                         RenderTargetD3D *source)
 {
     ASSERT(source);
 
@@ -643,35 +567,24 @@ gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
 
     RenderTarget9 *renderTarget = GetAs<RenderTarget9>(source);
 
-    IDirect3DSurface9 *surface = renderTarget->getSurface();
+    angle::ComPtr<IDirect3DSurface9> surface = renderTarget->getSurface();
     ASSERT(surface);
 
     IDirect3DDevice9 *device = mRenderer->getDevice();
 
-    IDirect3DSurface9 *renderTargetData = nullptr;
+    angle::ComPtr<IDirect3DSurface9> renderTargetData = nullptr;
     D3DSURFACE_DESC description;
     surface->GetDesc(&description);
 
-    HRESULT result = device->CreateOffscreenPlainSurface(description.Width, description.Height,
-                                                         description.Format, D3DPOOL_SYSTEMMEM,
-                                                         &renderTargetData, nullptr);
+    HRESULT hr = device->CreateOffscreenPlainSurface(description.Width, description.Height,
+                                                     description.Format, D3DPOOL_SYSTEMMEM,
+                                                     &renderTargetData, nullptr);
 
-    if (FAILED(result))
-    {
-        SafeRelease(surface);
-        return gl::OutOfMemory() << "Could not create matching destination surface, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, hr, "Could not create matching destination surface");
 
-    result = device->GetRenderTargetData(surface, renderTargetData);
+    hr = device->GetRenderTargetData(surface.Get(), renderTargetData.Get());
 
-    if (FAILED(result))
-    {
-        SafeRelease(renderTargetData);
-        SafeRelease(surface);
-        return gl::OutOfMemory() << "GetRenderTargetData unexpectedly failed, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, hr, "GetRenderTargetData unexpectedly failed");
 
     int width = sourceArea.width;
     int height = sourceArea.height;
@@ -680,26 +593,17 @@ gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
     RECT destRect = { destOffset.x, destOffset.y, destOffset.x + width, destOffset.y + height };
 
     D3DLOCKED_RECT sourceLock = {0};
-    result = renderTargetData->LockRect(&sourceLock, &sourceRect, 0);
+    hr                        = renderTargetData->LockRect(&sourceLock, &sourceRect, 0);
 
-    if (FAILED(result))
-    {
-        SafeRelease(renderTargetData);
-        SafeRelease(surface);
-        return gl::OutOfMemory()
-               << "Failed to lock the source surface (rectangle might be invalid), "
-               << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(context9, hr, "Failed to lock the source surface (rectangle might be invalid)");
 
     D3DLOCKED_RECT destLock = {0};
-    gl::Error error = lock(&destLock, destRect);
-    if (error.isError())
+    angle::Result result    = lock(context9, &destLock, destRect);
+    if (result == angle::Result::Stop())
     {
         renderTargetData->UnlockRect();
-        SafeRelease(renderTargetData);
-        SafeRelease(surface);
-        return error;
     }
+    ANGLE_TRY(result);
 
     ASSERT(destLock.pBits && sourceLock.pBits);
 
@@ -861,11 +765,8 @@ gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
     unlock();
     renderTargetData->UnlockRect();
 
-    SafeRelease(renderTargetData);
-    SafeRelease(surface);
-
     mDirty = true;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error Image9::copyFromTexStorage(const gl::Context *context,
@@ -873,14 +774,10 @@ gl::Error Image9::copyFromTexStorage(const gl::Context *context,
                                      TextureStorage *source)
 {
     RenderTargetD3D *renderTarget = nullptr;
-    gl::Error error               = source->getRenderTarget(context, imageIndex, &renderTarget);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(source->getRenderTarget(context, imageIndex, &renderTarget));
 
     gl::Rectangle sourceArea(0, 0, mWidth, mHeight);
-    return copyFromRTInternal(gl::Offset(), sourceArea, renderTarget);
+    return copyFromRTInternal(GetImplAs<Context9>(context), gl::Offset(), sourceArea, renderTarget);
 }
 
 gl::Error Image9::copyFromFramebuffer(const gl::Context *context,
@@ -892,14 +789,9 @@ gl::Error Image9::copyFromFramebuffer(const gl::Context *context,
     ASSERT(srcAttachment);
 
     RenderTargetD3D *renderTarget = nullptr;
-    gl::Error error               = srcAttachment->getRenderTarget(context, &renderTarget);
-    if (error.isError())
-    {
-        return error;
-    }
-
+    ANGLE_TRY(srcAttachment->getRenderTarget(context, &renderTarget));
     ASSERT(renderTarget);
-    return copyFromRTInternal(destOffset, sourceArea, renderTarget);
+    return copyFromRTInternal(GetImplAs<Context9>(context), destOffset, sourceArea, renderTarget);
 }
 
 }  // namespace rx

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

@@ -20,6 +20,7 @@ class Framebuffer;
 
 namespace rx
 {
+class Context9;
 class Renderer9;
 
 class Image9 : public ImageD3D
@@ -28,17 +29,21 @@ class Image9 : public ImageD3D
     Image9(Renderer9 *renderer);
     ~Image9() override;
 
-    static gl::Error generateMipmap(Image9 *dest, Image9 *source);
-    static gl::Error generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9 *sourceSurface);
-    static gl::Error copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface9 *source);
-    static gl::Error CopyImage(const gl::Context *context,
-                               Image9 *dest,
-                               Image9 *source,
-                               const gl::Rectangle &sourceRect,
-                               const gl::Offset &destOffset,
-                               bool unpackFlipY,
-                               bool unpackPremultiplyAlpha,
-                               bool unpackUnmultiplyAlpha);
+    static angle::Result GenerateMipmap(Context9 *context9, Image9 *dest, Image9 *source);
+    static angle::Result GenerateMip(Context9 *context9,
+                                     IDirect3DSurface9 *destSurface,
+                                     IDirect3DSurface9 *sourceSurface);
+    static angle::Result CopyLockableSurfaces(Context9 *context9,
+                                              IDirect3DSurface9 *dest,
+                                              IDirect3DSurface9 *source);
+    static angle::Result CopyImage(const gl::Context *context,
+                                   Image9 *dest,
+                                   Image9 *source,
+                                   const gl::Rectangle &sourceRect,
+                                   const gl::Offset &destOffset,
+                                   bool unpackFlipY,
+                                   bool unpackPremultiplyAlpha,
+                                   bool unpackUnmultiplyAlpha);
 
     bool redefine(gl::TextureType type,
                   GLenum internalformat,
@@ -80,18 +85,19 @@ class Image9 : public ImageD3D
                                   const gl::Framebuffer *source) override;
 
   private:
-    gl::Error getSurface(IDirect3DSurface9 **outSurface);
+    angle::Result getSurface(Context9 *context9, IDirect3DSurface9 **outSurface);
 
-    gl::Error createSurface();
-    gl::Error setManagedSurface(IDirect3DSurface9 *surface);
-    gl::Error copyToSurface(IDirect3DSurface9 *dest, const gl::Box &area);
+    angle::Result createSurface(Context9 *context9);
+    angle::Result setManagedSurface(Context9 *context9, IDirect3DSurface9 *surface);
+    angle::Result copyToSurface(Context9 *context9, IDirect3DSurface9 *dest, const gl::Box &area);
 
-    gl::Error lock(D3DLOCKED_RECT *lockedRect, const RECT &rect);
+    angle::Result lock(Context9 *context9, D3DLOCKED_RECT *lockedRect, const RECT &rect);
     void unlock();
 
-    gl::Error copyFromRTInternal(const gl::Offset &destOffset,
-                                 const gl::Rectangle &sourceArea,
-                                 RenderTargetD3D *source);
+    angle::Result copyFromRTInternal(Context9 *context9,
+                                     const gl::Offset &destOffset,
+                                     const gl::Rectangle &sourceArea,
+                                     RenderTargetD3D *source);
 
     Renderer9 *mRenderer;
 

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

@@ -66,6 +66,8 @@
 namespace rx
 {
 
+namespace
+{
 enum
 {
     MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256,
@@ -77,6 +79,18 @@ enum
     MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4
 };
 
+template <typename T>
+static void DrawPoints(IDirect3DDevice9 *device, GLsizei count, const void *indices, int minIndex)
+{
+    for (int i = 0; i < count; i++)
+    {
+        unsigned int indexValue =
+            static_cast<unsigned int>(static_cast<const T *>(indices)[i]) - minIndex;
+        device->DrawPrimitive(D3DPT_POINTLIST, indexValue, 1);
+    }
+}
+}  // anonymous namespace
+
 Renderer9::Renderer9(egl::Display *display) : RendererD3D(display), mStateManager(this)
 {
     mD3d9Module = nullptr;
@@ -372,7 +386,6 @@ egl::Error Renderer9::initializeDevice()
 
     ASSERT(!mBlit);
     mBlit = new Blit9(this);
-    ANGLE_TRY(mBlit->initialize());
 
     ASSERT(!mVertexDataManager && !mIndexDataManager);
     mIndexDataManager  = new IndexDataManager(this);
@@ -599,14 +612,10 @@ void Renderer9::endScene()
     }
 }
 
-gl::Error Renderer9::flush()
+gl::Error Renderer9::flush(const gl::Context *context)
 {
     IDirect3DQuery9 *query = nullptr;
-    gl::Error error        = allocateEventQuery(&query);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(allocateEventQuery(context, &query));
 
     HRESULT result = query->Issue(D3DISSUE_END);
     if (FAILED(result))
@@ -631,14 +640,10 @@ gl::Error Renderer9::flush()
     return gl::NoError();
 }
 
-gl::Error Renderer9::finish()
+gl::Error Renderer9::finish(const gl::Context *context)
 {
     IDirect3DQuery9 *query = nullptr;
-    gl::Error error        = allocateEventQuery(&query);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(allocateEventQuery(context, &query));
 
     HRESULT result = query->Issue(D3DISSUE_END);
     if (FAILED(result))
@@ -832,16 +837,12 @@ void *Renderer9::getD3DDevice()
     return mDevice;
 }
 
-gl::Error Renderer9::allocateEventQuery(IDirect3DQuery9 **outQuery)
+angle::Result Renderer9::allocateEventQuery(const gl::Context *context, IDirect3DQuery9 **outQuery)
 {
     if (mEventQueryPool.empty())
     {
         HRESULT result = mDevice->CreateQuery(D3DQUERYTYPE_EVENT, outQuery);
-        if (FAILED(result))
-        {
-            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::OutOfMemory() << "Failed to allocate event query, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to allocate event query");
     }
     else
     {
@@ -849,7 +850,7 @@ gl::Error Renderer9::allocateEventQuery(IDirect3DQuery9 **outQuery)
         mEventQueryPool.pop_back();
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 void Renderer9::freeEventQuery(IDirect3DQuery9 *query)
@@ -864,18 +865,20 @@ void Renderer9::freeEventQuery(IDirect3DQuery9 *query)
     }
 }
 
-gl::Error Renderer9::createVertexShader(const DWORD *function,
-                                        size_t length,
-                                        IDirect3DVertexShader9 **outShader)
+angle::Result Renderer9::createVertexShader(Context9 *context9,
+                                            const DWORD *function,
+                                            size_t length,
+                                            IDirect3DVertexShader9 **outShader)
 {
-    return mVertexShaderCache.create(function, length, outShader);
+    return mVertexShaderCache.create(context9, function, length, outShader);
 }
 
-gl::Error Renderer9::createPixelShader(const DWORD *function,
-                                       size_t length,
-                                       IDirect3DPixelShader9 **outShader)
+angle::Result Renderer9::createPixelShader(Context9 *context9,
+                                           const DWORD *function,
+                                           size_t length,
+                                           IDirect3DPixelShader9 **outShader)
 {
-    return mPixelShaderCache.create(function, length, outShader);
+    return mPixelShaderCache.create(context9, function, length, outShader);
 }
 
 HRESULT Renderer9::createVertexBuffer(UINT Length,
@@ -933,11 +936,11 @@ gl::Error Renderer9::fastCopyBufferToTexture(const gl::Context *context,
     return gl::InternalError();
 }
 
-gl::Error Renderer9::setSamplerState(const gl::Context *context,
-                                     gl::ShaderType type,
-                                     int index,
-                                     gl::Texture *texture,
-                                     const gl::SamplerState &samplerState)
+angle::Result Renderer9::setSamplerState(const gl::Context *context,
+                                         gl::ShaderType type,
+                                         int index,
+                                         gl::Texture *texture,
+                                         const gl::SamplerState &samplerState)
 {
     CurSamplerState &appliedSampler = (type == gl::ShaderType::Fragment)
                                           ? mCurPixelSamplerStates[index]
@@ -947,7 +950,7 @@ gl::Error Renderer9::setSamplerState(const gl::Context *context,
     TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
 
     TextureStorage *storage = nullptr;
-    ANGLE_TRY(textureD3D->getNativeTexture(context, &storage));
+    ANGLE_TRY_HANDLE(context, textureD3D->getNativeTexture(context, &storage));
 
     // Storage should exist, texture should be complete
     ASSERT(storage);
@@ -989,13 +992,13 @@ gl::Error Renderer9::setSamplerState(const gl::Context *context,
     appliedSampler.samplerState = samplerState;
     appliedSampler.baseLevel    = baseLevel;
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::setTexture(const gl::Context *context,
-                                gl::ShaderType type,
-                                int index,
-                                gl::Texture *texture)
+angle::Result Renderer9::setTexture(const gl::Context *context,
+                                    gl::ShaderType type,
+                                    int index,
+                                    gl::Texture *texture)
 {
     int d3dSamplerOffset = (type == gl::ShaderType::Fragment) ? 0 : D3DVERTEXTEXTURESAMPLER0;
     int d3dSampler                    = index + d3dSamplerOffset;
@@ -1010,13 +1013,13 @@ gl::Error Renderer9::setTexture(const gl::Context *context,
         TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
 
         TextureStorage *texStorage = nullptr;
-        ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage));
+        ANGLE_TRY_HANDLE(context, textureImpl->getNativeTexture(context, &texStorage));
 
         // Texture should be complete and have a storage
         ASSERT(texStorage);
 
         TextureStorage9 *storage9 = GetAs<TextureStorage9>(texStorage);
-        ANGLE_TRY(storage9->getBaseTexture(context, &d3dTexture));
+        ANGLE_TRY_HANDLE(context, storage9->getBaseTexture(context, &d3dTexture));
 
         // If we get NULL back from getBaseTexture here, something went wrong
         // in the texture class and we're unexpectedly missing the d3d texture
@@ -1033,10 +1036,10 @@ gl::Error Renderer9::setTexture(const gl::Context *context,
 
     appliedTextures[index] = reinterpret_cast<uintptr_t>(d3dTexture);
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::updateState(const gl::Context *context, gl::PrimitiveMode drawMode)
+angle::Result Renderer9::updateState(const gl::Context *context, gl::PrimitiveMode drawMode)
 {
     const auto &glState = context->getGLState();
 
@@ -1067,7 +1070,7 @@ gl::Error Renderer9::updateState(const gl::Context *context, gl::PrimitiveMode d
     {
         ASSERT(firstColorAttachment->isAttached());
         RenderTarget9 *renderTarget = nullptr;
-        ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
+        ANGLE_TRY_HANDLE(context, firstColorAttachment->getRenderTarget(context, &renderTarget));
         samples = renderTarget->getSamples();
     }
     gl::RasterizerState rasterizer = glState.getRasterizerState();
@@ -1078,7 +1081,7 @@ gl::Error Renderer9::updateState(const gl::Context *context, gl::PrimitiveMode d
 
     mStateManager.resetDirtyBits();
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
@@ -1086,8 +1089,8 @@ void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
     mStateManager.setScissorState(scissor, enabled);
 }
 
-gl::Error Renderer9::setBlendDepthRasterStates(const gl::Context *context,
-                                               gl::PrimitiveMode drawMode)
+angle::Result Renderer9::setBlendDepthRasterStates(const gl::Context *context,
+                                                   gl::PrimitiveMode drawMode)
 {
     const auto &glState              = context->getGLState();
     gl::Framebuffer *drawFramebuffer = glState.getDrawFramebuffer();
@@ -1101,7 +1104,7 @@ gl::Error Renderer9::setBlendDepthRasterStates(const gl::Context *context,
     {
         ASSERT(firstColorAttachment->isAttached());
         RenderTarget9 *renderTarget = nullptr;
-        ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
+        ANGLE_TRY_HANDLE(context, firstColorAttachment->getRenderTarget(context, &renderTarget));
         samples = renderTarget->getSamples();
     }
     gl::RasterizerState rasterizer = glState.getRasterizerState();
@@ -1109,7 +1112,8 @@ gl::Error Renderer9::setBlendDepthRasterStates(const gl::Context *context,
     rasterizer.multiSample         = (samples != 0);
 
     unsigned int mask = GetBlendSampleMask(glState, samples);
-    return mStateManager.setBlendDepthRasterStates(glState, mask);
+    mStateManager.setBlendDepthRasterStates(glState, mask);
+    return angle::Result::Continue();
 }
 
 void Renderer9::setViewport(const gl::Rectangle &viewport,
@@ -1163,9 +1167,9 @@ bool Renderer9::applyPrimitiveType(gl::PrimitiveMode mode, GLsizei count, bool u
     return mPrimitiveCount > 0;
 }
 
-gl::Error Renderer9::getNullColorRenderTarget(const gl::Context *context,
-                                              const RenderTarget9 *depthRenderTarget,
-                                              const RenderTarget9 **outColorRenderTarget)
+angle::Result Renderer9::getNullColorRenderTarget(const gl::Context *context,
+                                                  const RenderTarget9 *depthRenderTarget,
+                                                  const RenderTarget9 **outColorRenderTarget)
 {
     ASSERT(depthRenderTarget);
 
@@ -1180,12 +1184,13 @@ gl::Error Renderer9::getNullColorRenderTarget(const gl::Context *context,
         {
             mNullRenderTargetCache[i].lruCount = ++mMaxNullColorbufferLRU;
             *outColorRenderTarget              = mNullRenderTargetCache[i].renderTarget;
-            return gl::NoError();
+            return angle::Result::Continue();
         }
     }
 
     RenderTargetD3D *nullRenderTarget = nullptr;
-    ANGLE_TRY(createRenderTarget(context, size.width, size.height, GL_NONE, 0, &nullRenderTarget));
+    ANGLE_TRY_HANDLE(context, createRenderTarget(context, size.width, size.height, GL_NONE, 0,
+                                                 &nullRenderTarget));
 
     // add nullbuffer to the cache
     NullRenderTargetCacheEntry *oldest = &mNullRenderTargetCache[0];
@@ -1204,12 +1209,12 @@ gl::Error Renderer9::getNullColorRenderTarget(const gl::Context *context,
     oldest->height       = size.height;
 
     *outColorRenderTarget = oldest->renderTarget;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
-                                       const RenderTarget9 *colorRenderTargetIn,
-                                       const RenderTarget9 *depthStencilRenderTarget)
+angle::Result Renderer9::applyRenderTarget(const gl::Context *context,
+                                           const RenderTarget9 *colorRenderTargetIn,
+                                           const RenderTarget9 *depthStencilRenderTarget)
 {
     // if there is no color attachment we must synthesize a NULL colorattachment
     // to keep the D3D runtime happy.  This should only be possible if depth texturing.
@@ -1289,45 +1294,44 @@ gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
         mRenderTargetDescInitialized = true;
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::applyVertexBuffer(const gl::Context *context,
-                                       gl::PrimitiveMode mode,
-                                       GLint first,
-                                       GLsizei count,
-                                       GLsizei instances,
-                                       TranslatedIndexData * /*indexInfo*/)
+angle::Result Renderer9::applyVertexBuffer(const gl::Context *context,
+                                           gl::PrimitiveMode mode,
+                                           GLint first,
+                                           GLsizei count,
+                                           GLsizei instances,
+                                           TranslatedIndexData * /*indexInfo*/)
 {
     const gl::State &state = context->getGLState();
-    gl::Error error        = mVertexDataManager->prepareVertexData(context, first, count,
-                                                            &mTranslatedAttribCache, instances);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY_HANDLE(context, mVertexDataManager->prepareVertexData(
+                                  context, first, count, &mTranslatedAttribCache, instances));
 
-    return mVertexDeclarationCache.applyDeclaration(
-        mDevice, mTranslatedAttribCache, state.getProgram(), first, instances, &mRepeatDraw);
+    return mVertexDeclarationCache.applyDeclaration(context, mDevice, mTranslatedAttribCache,
+                                                    state.getProgram(), first, instances,
+                                                    &mRepeatDraw);
 }
 
 // Applies the indices and element array bindings to the Direct3D 9 device
-gl::Error Renderer9::applyIndexBuffer(const gl::Context *context,
-                                      const void *indices,
-                                      GLsizei count,
-                                      gl::PrimitiveMode mode,
-                                      GLenum type,
-                                      TranslatedIndexData *indexInfo)
+angle::Result Renderer9::applyIndexBuffer(const gl::Context *context,
+                                          const void *indices,
+                                          GLsizei count,
+                                          gl::PrimitiveMode mode,
+                                          GLenum type,
+                                          TranslatedIndexData *indexInfo)
 {
     gl::VertexArray *vao                     = context->getGLState().getVertexArray();
     gl::Buffer *elementArrayBuffer           = vao->getElementArrayBuffer().get();
     const gl::DrawCallParams &drawCallParams = context->getParams<gl::DrawCallParams>();
 
     GLenum dstType = GL_NONE;
-    ANGLE_TRY(GetIndexTranslationDestType(context, drawCallParams, false, &dstType));
+    ANGLE_TRY_HANDLE(context,
+                     GetIndexTranslationDestType(context, drawCallParams, false, &dstType));
 
-    ANGLE_TRY(mIndexDataManager->prepareIndexData(context, type, dstType, count, elementArrayBuffer,
-                                                  indices, indexInfo));
+    ANGLE_TRY_HANDLE(context,
+                     mIndexDataManager->prepareIndexData(context, type, dstType, count,
+                                                         elementArrayBuffer, indices, indexInfo));
 
     // Directly binding the storage buffer is not supported for d3d9
     ASSERT(indexInfo->storage == nullptr);
@@ -1340,14 +1344,14 @@ gl::Error Renderer9::applyIndexBuffer(const gl::Context *context,
         mAppliedIBSerial = indexInfo->serial;
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::drawArraysImpl(const gl::Context *context,
-                                    gl::PrimitiveMode mode,
-                                    GLint startVertex,
-                                    GLsizei count,
-                                    GLsizei instances)
+angle::Result Renderer9::drawArraysImpl(const gl::Context *context,
+                                        gl::PrimitiveMode mode,
+                                        GLint startVertex,
+                                        GLsizei count,
+                                        GLsizei instances)
 {
     ASSERT(!context->getGLState().isTransformFeedbackActiveUnpaused());
 
@@ -1376,27 +1380,27 @@ gl::Error Renderer9::drawArraysImpl(const gl::Context *context,
             mDevice->DrawIndexedPrimitive(mPrimitiveType, 0, 0, count, 0, mPrimitiveCount);
         }
 
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     // Regular case
     mDevice->DrawPrimitive(mPrimitiveType, 0, mPrimitiveCount);
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::drawElementsImpl(const gl::Context *context,
-                                      gl::PrimitiveMode mode,
-                                      GLsizei count,
-                                      GLenum type,
-                                      const void *indices,
-                                      GLsizei instances)
+angle::Result Renderer9::drawElementsImpl(const gl::Context *context,
+                                          gl::PrimitiveMode mode,
+                                          GLsizei count,
+                                          GLenum type,
+                                          const void *indices,
+                                          GLsizei instances)
 {
     TranslatedIndexData indexInfo;
 
     ANGLE_TRY(applyIndexBuffer(context, indices, count, mode, type, &indexInfo));
 
     const auto &drawCallParams = context->getParams<gl::DrawCallParams>();
-    ANGLE_TRY(drawCallParams.ensureIndexRangeResolved(context));
+    ANGLE_TRY_HANDLE(context, drawCallParams.ensureIndexRangeResolved(context));
 
     const gl::IndexRange &indexRange = drawCallParams.getIndexRange();
     size_t vertexCount               = indexRange.vertexCount();
@@ -1414,28 +1418,27 @@ gl::Error Renderer9::drawElementsImpl(const gl::Context *context,
     {
         return drawIndexedPoints(context, count, type, indices, minIndex, elementArrayBuffer);
     }
-    else if (mode == gl::PrimitiveMode::LineLoop)
+
+    if (mode == gl::PrimitiveMode::LineLoop)
     {
         return drawLineLoop(context, count, type, indices, minIndex, elementArrayBuffer);
     }
-    else
+
+    for (int i = 0; i < mRepeatDraw; i++)
     {
-        for (int i = 0; i < mRepeatDraw; i++)
-        {
-            mDevice->DrawIndexedPrimitive(mPrimitiveType, -minIndex, minIndex,
-                                          static_cast<UINT>(vertexCount), indexInfo.startIndex,
-                                          mPrimitiveCount);
-        }
-        return gl::NoError();
+        mDevice->DrawIndexedPrimitive(mPrimitiveType, -minIndex, minIndex,
+                                      static_cast<UINT>(vertexCount), indexInfo.startIndex,
+                                      mPrimitiveCount);
     }
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::drawLineLoop(const gl::Context *context,
-                                  GLsizei count,
-                                  GLenum type,
-                                  const void *indices,
-                                  int minIndex,
-                                  gl::Buffer *elementArrayBuffer)
+angle::Result Renderer9::drawLineLoop(const gl::Context *context,
+                                      GLsizei count,
+                                      GLenum type,
+                                      const void *indices,
+                                      int minIndex,
+                                      gl::Buffer *elementArrayBuffer)
 {
     // Get the raw indices for an indexed draw
     if (type != GL_NONE && elementArrayBuffer)
@@ -1443,38 +1446,41 @@ gl::Error Renderer9::drawLineLoop(const gl::Context *context,
         BufferD3D *storage        = GetImplAs<BufferD3D>(elementArrayBuffer);
         intptr_t offset           = reinterpret_cast<intptr_t>(indices);
         const uint8_t *bufferData = nullptr;
-        ANGLE_TRY(storage->getData(context, &bufferData));
+        ANGLE_TRY_HANDLE(context, storage->getData(context, &bufferData));
         indices = bufferData + offset;
     }
 
     unsigned int startIndex = 0;
+    Context9 *context9      = GetImplAs<Context9>(context);
 
     if (getNativeExtensions().elementIndexUint)
     {
         if (!mLineLoopIB)
         {
             mLineLoopIB = new StreamingIndexBufferInterface(this);
-            ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, INITIAL_INDEX_BUFFER_SIZE,
-                                                      GL_UNSIGNED_INT));
+            ANGLE_TRY_HANDLE(context, mLineLoopIB->reserveBufferSpace(
+                                          context, INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT));
         }
 
         // Checked by Renderer9::applyPrimitiveType
         ASSERT(count >= 0);
 
-        if (static_cast<unsigned int>(count) + 1 >
-            (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
-        {
-            return gl::OutOfMemory() << "Failed to create a 32-bit looping index buffer for "
-                                        "GL_LINE_LOOP, too many indices required.";
-        }
+        ANGLE_CHECK_HR(context9,
+                       static_cast<unsigned int>(count) + 1 <=
+                           (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)),
+                       "Failed to create a 32-bit looping index buffer for "
+                       "GL_LINE_LOOP, too many indices required.",
+                       E_OUTOFMEMORY);
 
         const unsigned int spaceNeeded =
             (static_cast<unsigned int>(count) + 1) * sizeof(unsigned int);
-        ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_INT));
+        ANGLE_TRY_HANDLE(context,
+                         mLineLoopIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_INT));
 
         void *mappedMemory  = nullptr;
         unsigned int offset = 0;
-        ANGLE_TRY(mLineLoopIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset));
+        ANGLE_TRY_HANDLE(context,
+                         mLineLoopIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset));
 
         startIndex         = static_cast<unsigned int>(offset) / 4;
         unsigned int *data = static_cast<unsigned int *>(mappedMemory);
@@ -1513,34 +1519,36 @@ gl::Error Renderer9::drawLineLoop(const gl::Context *context,
                 UNREACHABLE();
         }
 
-        ANGLE_TRY(mLineLoopIB->unmapBuffer(context));
+        ANGLE_TRY_HANDLE(context, mLineLoopIB->unmapBuffer(context));
     }
     else
     {
         if (!mLineLoopIB)
         {
             mLineLoopIB = new StreamingIndexBufferInterface(this);
-            ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, INITIAL_INDEX_BUFFER_SIZE,
-                                                      GL_UNSIGNED_SHORT));
+            ANGLE_TRY_HANDLE(context, mLineLoopIB->reserveBufferSpace(
+                                          context, INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_SHORT));
         }
 
         // Checked by Renderer9::applyPrimitiveType
         ASSERT(count >= 0);
 
-        if (static_cast<unsigned int>(count) + 1 >
-            (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)))
-        {
-            return gl::OutOfMemory() << "Failed to create a 16-bit looping index buffer for "
-                                        "GL_LINE_LOOP, too many indices required.";
-        }
+        ANGLE_CHECK_HR(context9,
+                       static_cast<unsigned int>(count) + 1 <=
+                           (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)),
+                       "Failed to create a 16-bit looping index buffer for "
+                       "GL_LINE_LOOP, too many indices required.",
+                       E_OUTOFMEMORY);
 
         const unsigned int spaceNeeded =
             (static_cast<unsigned int>(count) + 1) * sizeof(unsigned short);
-        ANGLE_TRY(mLineLoopIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_SHORT));
+        ANGLE_TRY_HANDLE(context,
+                         mLineLoopIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_SHORT));
 
         void *mappedMemory = nullptr;
         unsigned int offset;
-        ANGLE_TRY(mLineLoopIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset));
+        ANGLE_TRY_HANDLE(context,
+                         mLineLoopIB->mapBuffer(context, spaceNeeded, &mappedMemory, &offset));
 
         startIndex           = static_cast<unsigned int>(offset) / 2;
         unsigned short *data = static_cast<unsigned short *>(mappedMemory);
@@ -1579,7 +1587,7 @@ gl::Error Renderer9::drawLineLoop(const gl::Context *context,
                 UNREACHABLE();
         }
 
-        ANGLE_TRY(mLineLoopIB->unmapBuffer(context));
+        ANGLE_TRY_HANDLE(context, mLineLoopIB->unmapBuffer(context));
     }
 
     if (mAppliedIBSerial != mLineLoopIB->getSerial())
@@ -1592,31 +1600,15 @@ gl::Error Renderer9::drawLineLoop(const gl::Context *context,
 
     mDevice->DrawIndexedPrimitive(D3DPT_LINESTRIP, -minIndex, minIndex, count, startIndex, count);
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-template <typename T>
-static gl::Error drawPoints(IDirect3DDevice9 *device,
-                            GLsizei count,
-                            const void *indices,
-                            int minIndex)
-{
-    for (int i = 0; i < count; i++)
-    {
-        unsigned int indexValue =
-            static_cast<unsigned int>(static_cast<const T *>(indices)[i]) - minIndex;
-        device->DrawPrimitive(D3DPT_POINTLIST, indexValue, 1);
-    }
-
-    return gl::NoError();
-}
-
-gl::Error Renderer9::drawIndexedPoints(const gl::Context *context,
-                                       GLsizei count,
-                                       GLenum type,
-                                       const void *indices,
-                                       int minIndex,
-                                       gl::Buffer *elementArrayBuffer)
+angle::Result Renderer9::drawIndexedPoints(const gl::Context *context,
+                                           GLsizei count,
+                                           GLenum type,
+                                           const void *indices,
+                                           int minIndex,
+                                           gl::Buffer *elementArrayBuffer)
 {
     // Drawing index point lists is unsupported in d3d9, fall back to a regular DrawPrimitive call
     // for each individual point. This call is not expected to happen often.
@@ -1627,32 +1619,31 @@ gl::Error Renderer9::drawIndexedPoints(const gl::Context *context,
         intptr_t offset    = reinterpret_cast<intptr_t>(indices);
 
         const uint8_t *bufferData = nullptr;
-        gl::Error error           = storage->getData(context, &bufferData);
-        if (error.isError())
-        {
-            return error;
-        }
-
+        ANGLE_TRY_HANDLE(context, storage->getData(context, &bufferData));
         indices = bufferData + offset;
     }
 
     switch (type)
     {
         case GL_UNSIGNED_BYTE:
-            return drawPoints<GLubyte>(mDevice, count, indices, minIndex);
+            DrawPoints<GLubyte>(mDevice, count, indices, minIndex);
+            return angle::Result::Continue();
         case GL_UNSIGNED_SHORT:
-            return drawPoints<GLushort>(mDevice, count, indices, minIndex);
+            DrawPoints<GLushort>(mDevice, count, indices, minIndex);
+            return angle::Result::Continue();
         case GL_UNSIGNED_INT:
-            return drawPoints<GLuint>(mDevice, count, indices, minIndex);
+            DrawPoints<GLuint>(mDevice, count, indices, minIndex);
+            return angle::Result::Continue();
         default:
             UNREACHABLE();
-            return gl::InternalError();
+            context->handleError(gl::InternalError());
+            return angle::Result::Stop();
     }
 }
 
-gl::Error Renderer9::getCountingIB(const gl::Context *context,
-                                   size_t count,
-                                   StaticIndexBufferInterface **outIB)
+angle::Result Renderer9::getCountingIB(const gl::Context *context,
+                                       size_t count,
+                                       StaticIndexBufferInterface **outIB)
 {
     // Update the counting index buffer if it is not large enough or has not been created yet.
     if (count <= 65536)  // 16-bit indices
@@ -1663,10 +1654,12 @@ gl::Error Renderer9::getCountingIB(const gl::Context *context,
         {
             SafeDelete(mCountingIB);
             mCountingIB = new StaticIndexBufferInterface(this);
-            ANGLE_TRY(mCountingIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_SHORT));
+            ANGLE_TRY_HANDLE(
+                context, mCountingIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_SHORT));
 
             void *mappedMemory = nullptr;
-            ANGLE_TRY(mCountingIB->mapBuffer(context, spaceNeeded, &mappedMemory, nullptr));
+            ANGLE_TRY_HANDLE(context,
+                             mCountingIB->mapBuffer(context, spaceNeeded, &mappedMemory, nullptr));
 
             unsigned short *data = static_cast<unsigned short *>(mappedMemory);
             for (size_t i = 0; i < count; i++)
@@ -1674,7 +1667,7 @@ gl::Error Renderer9::getCountingIB(const gl::Context *context,
                 data[i] = static_cast<unsigned short>(i);
             }
 
-            ANGLE_TRY(mCountingIB->unmapBuffer(context));
+            ANGLE_TRY_HANDLE(context, mCountingIB->unmapBuffer(context));
         }
     }
     else if (getNativeExtensions().elementIndexUint)
@@ -1685,10 +1678,12 @@ gl::Error Renderer9::getCountingIB(const gl::Context *context,
         {
             SafeDelete(mCountingIB);
             mCountingIB = new StaticIndexBufferInterface(this);
-            ANGLE_TRY(mCountingIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_INT));
+            ANGLE_TRY_HANDLE(
+                context, mCountingIB->reserveBufferSpace(context, spaceNeeded, GL_UNSIGNED_INT));
 
             void *mappedMemory = nullptr;
-            ANGLE_TRY(mCountingIB->mapBuffer(context, spaceNeeded, &mappedMemory, nullptr));
+            ANGLE_TRY_HANDLE(context,
+                             mCountingIB->mapBuffer(context, spaceNeeded, &mappedMemory, nullptr));
 
             unsigned int *data = static_cast<unsigned int *>(mappedMemory);
             for (unsigned int i = 0; i < count; i++)
@@ -1696,37 +1691,39 @@ gl::Error Renderer9::getCountingIB(const gl::Context *context,
                 data[i] = i;
             }
 
-            ANGLE_TRY(mCountingIB->unmapBuffer(context));
+            ANGLE_TRY_HANDLE(context, mCountingIB->unmapBuffer(context));
         }
     }
     else
     {
-        return gl::OutOfMemory()
-               << "Could not create a counting index buffer for glDrawArraysInstanced.";
+        ANGLE_TRY_HR(GetImplAs<Context9>(context), E_OUTOFMEMORY,
+                     "Could not create a counting index buffer for glDrawArraysInstanced.");
     }
 
     *outIB = mCountingIB;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::applyShaders(const gl::Context *context, gl::PrimitiveMode drawMode)
+angle::Result Renderer9::applyShaders(const gl::Context *context, gl::PrimitiveMode drawMode)
 {
     const gl::State &state = context->getContextState().getState();
     // This method is called single-threaded.
-    ANGLE_TRY(ensureHLSLCompilerInitialized(context));
+    ANGLE_TRY_HANDLE(context, ensureHLSLCompilerInitialized(context));
 
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(state.getProgram());
     VertexArray9 *vao      = GetImplAs<VertexArray9>(state.getVertexArray());
     programD3D->updateCachedInputLayout(vao->getCurrentStateSerial(), state);
 
     ShaderExecutableD3D *vertexExe = nullptr;
-    ANGLE_TRY(programD3D->getVertexExecutableForCachedInputLayout(context, &vertexExe, nullptr));
+    ANGLE_TRY_HANDLE(
+        context, programD3D->getVertexExecutableForCachedInputLayout(context, &vertexExe, nullptr));
 
     const gl::Framebuffer *drawFramebuffer = state.getDrawFramebuffer();
     programD3D->updateCachedOutputLayout(context, drawFramebuffer);
 
     ShaderExecutableD3D *pixelExe = nullptr;
-    ANGLE_TRY(programD3D->getPixelExecutableForCachedOutputLayout(context, &pixelExe, nullptr));
+    ANGLE_TRY_HANDLE(
+        context, programD3D->getPixelExecutableForCachedOutputLayout(context, &pixelExe, nullptr));
 
     IDirect3DVertexShader9 *vertexShader =
         (vertexExe ? GetAs<ShaderExecutable9>(vertexExe)->getVertexShader() : nullptr);
@@ -1758,20 +1755,20 @@ gl::Error Renderer9::applyShaders(const gl::Context *context, gl::PrimitiveMode
         mAppliedProgramSerial = programSerial;
     }
 
-    ANGLE_TRY(applyUniforms(programD3D));
+    applyUniforms(programD3D);
 
     // Driver uniforms
     mStateManager.setShaderConstants();
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::applyUniforms(ProgramD3D *programD3D)
+void Renderer9::applyUniforms(ProgramD3D *programD3D)
 {
     // Skip updates if we're not dirty. Note that D3D9 cannot have compute or geometry.
     if (!programD3D->anyShaderUniformsDirty())
     {
-        return gl::NoError();
+        return;
     }
 
     const auto &uniformArray = programD3D->getD3DUniforms();
@@ -1819,7 +1816,6 @@ gl::Error Renderer9::applyUniforms(ProgramD3D *programD3D)
     }
 
     programD3D->markUniformsClean();
-    return gl::NoError();
 }
 
 void Renderer9::applyUniformnfv(const D3DUniform *targetUniform, const GLfloat *v)
@@ -1871,28 +1867,18 @@ void Renderer9::applyUniformnbv(const D3DUniform *targetUniform, const GLint *v)
     applyUniformnfv(targetUniform, (GLfloat *)vector);
 }
 
-gl::Error Renderer9::clear(const gl::Context *context,
-                           const ClearParameters &clearParams,
-                           const RenderTarget9 *colorRenderTarget,
-                           const RenderTarget9 *depthStencilRenderTarget)
+void Renderer9::clear(const ClearParameters &clearParams,
+                      const RenderTarget9 *colorRenderTarget,
+                      const RenderTarget9 *depthStencilRenderTarget)
 {
-    if (clearParams.colorType != GL_FLOAT)
-    {
-        // Clearing buffers with non-float values is not supported by Renderer9 and ES 2.0
-        UNREACHABLE();
-        return gl::InternalError();
-    }
+    // Clearing buffers with non-float values is not supported by Renderer9 and ES 2.0
+    ASSERT(clearParams.colorType == GL_FLOAT);
 
+    // Clearing individual buffers other than buffer zero is not supported by Renderer9 and ES 2.0
     bool clearColor = clearParams.clearColor[0];
     for (unsigned int i = 0; i < ArraySize(clearParams.clearColor); i++)
     {
-        if (clearParams.clearColor[i] != clearColor)
-        {
-            // Clearing individual buffers other than buffer zero is not supported by Renderer9 and
-            // ES 2.0
-            UNREACHABLE();
-            return gl::InternalError();
-        }
+        ASSERT(clearParams.clearColor[i] == clearColor);
     }
 
     float depth   = gl::clamp01(clearParams.depthValue);
@@ -2109,8 +2095,6 @@ gl::Error Renderer9::clear(const gl::Context *context,
 
         mDevice->Clear(0, nullptr, dxClearFlags, color, depth, stencil);
     }
-
-    return gl::NoError();
 }
 
 void Renderer9::markAllStateDirty()
@@ -2618,27 +2602,21 @@ gl::Error Renderer9::loadExecutable(const gl::Context *context,
     // Transform feedback is not supported in ES2 or D3D9
     ASSERT(streamOutVaryings.empty());
 
+    Context9 *context9 = GetImplAs<Context9>(context);
+
     switch (type)
     {
         case gl::ShaderType::Vertex:
         {
             IDirect3DVertexShader9 *vshader = nullptr;
-            gl::Error error = createVertexShader((DWORD *)function, length, &vshader);
-            if (error.isError())
-            {
-                return error;
-            }
+            ANGLE_TRY(createVertexShader(context9, (DWORD *)function, length, &vshader));
             *outExecutable = new ShaderExecutable9(function, length, vshader);
         }
         break;
         case gl::ShaderType::Fragment:
         {
             IDirect3DPixelShader9 *pshader = nullptr;
-            gl::Error error                = createPixelShader((DWORD *)function, length, &pshader);
-            if (error.isError())
-            {
-                return error;
-            }
+            ANGLE_TRY(createPixelShader(context9, (DWORD *)function, length, &pshader));
             *outExecutable = new ShaderExecutable9(function, length, pshader);
         }
         break;
@@ -2757,9 +2735,11 @@ UniformStorageD3D *Renderer9::createUniformStorage(size_t storageSize)
     return new UniformStorageD3D(storageSize);
 }
 
-gl::Error Renderer9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
+angle::Result Renderer9::boxFilter(Context9 *context9,
+                                   IDirect3DSurface9 *source,
+                                   IDirect3DSurface9 *dest)
 {
-    return mBlit->boxFilter(source, dest);
+    return mBlit->boxFilter(context9, source, dest);
 }
 
 D3DPOOL Renderer9::getTexturePool(DWORD usage) const
@@ -2779,12 +2759,15 @@ D3DPOOL Renderer9::getTexturePool(DWORD usage) const
     return D3DPOOL_DEFAULT;
 }
 
-gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest,
-                                        IDirect3DSurface9 *source,
-                                        bool fromManaged)
+angle::Result Renderer9::copyToRenderTarget(const gl::Context *context,
+                                            IDirect3DSurface9 *dest,
+                                            IDirect3DSurface9 *source,
+                                            bool fromManaged)
 {
     ASSERT(source && dest);
 
+    Context9 *context9 = GetImplAs<Context9>(context);
+
     HRESULT result = D3DERR_OUTOFVIDEOMEMORY;
 
     if (fromManaged)
@@ -2798,7 +2781,7 @@ gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest,
 
         if (SUCCEEDED(result))
         {
-            ANGLE_TRY(Image9::copyLockableSurfaces(surf, source));
+            ANGLE_TRY(Image9::CopyLockableSurfaces(context9, surf, source));
             result = mDevice->UpdateSurface(surf, nullptr, dest, nullptr);
             SafeRelease(surf);
         }
@@ -2809,13 +2792,8 @@ gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest,
         result = mDevice->StretchRect(source, nullptr, dest, nullptr, D3DTEXF_NONE);
     }
 
-    if (FAILED(result))
-    {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::OutOfMemory() << "Failed to blit internal texture, " << gl::FmtHR(result);
-    }
-
-    return gl::NoError();
+    ANGLE_TRY_HR(context9, result, "Failed to blit internal texture");
+    return angle::Result::Continue();
 }
 
 RendererClass Renderer9::getRendererClass() const
@@ -2832,7 +2810,7 @@ gl::Error Renderer9::generateMipmap(const gl::Context *context, ImageD3D *dest,
 {
     Image9 *src9 = GetAs<Image9>(src);
     Image9 *dst9 = GetAs<Image9>(dest);
-    return Image9::generateMipmap(dst9, src9);
+    return Image9::GenerateMipmap(GetImplAs<Context9>(context), dst9, src9);
 }
 
 gl::Error Renderer9::generateMipmapUsingD3D(const gl::Context *context,
@@ -3023,12 +3001,12 @@ Renderer9::CurSamplerState::CurSamplerState()
 {
 }
 
-gl::Error Renderer9::genericDrawElements(const gl::Context *context,
-                                         gl::PrimitiveMode mode,
-                                         GLsizei count,
-                                         GLenum type,
-                                         const void *indices,
-                                         GLsizei instances)
+angle::Result Renderer9::genericDrawElements(const gl::Context *context,
+                                             gl::PrimitiveMode mode,
+                                             GLsizei count,
+                                             GLenum type,
+                                             const void *indices,
+                                             GLsizei instances)
 {
     const auto &data     = context->getContextState();
     gl::Program *program = context->getGLState().getProgram();
@@ -3040,7 +3018,7 @@ gl::Error Renderer9::genericDrawElements(const gl::Context *context,
 
     if (!applyPrimitiveType(mode, count, usesPointSize))
     {
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     ANGLE_TRY(updateState(context, mode));
@@ -3052,14 +3030,14 @@ gl::Error Renderer9::genericDrawElements(const gl::Context *context,
         ANGLE_TRY(drawElementsImpl(context, mode, count, type, indices, instances));
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::genericDrawArrays(const gl::Context *context,
-                                       gl::PrimitiveMode mode,
-                                       GLint first,
-                                       GLsizei count,
-                                       GLsizei instances)
+angle::Result Renderer9::genericDrawArrays(const gl::Context *context,
+                                           gl::PrimitiveMode mode,
+                                           GLint first,
+                                           GLsizei count,
+                                           GLsizei instances)
 {
     gl::Program *program = context->getGLState().getProgram();
     ASSERT(program != nullptr);
@@ -3070,7 +3048,7 @@ gl::Error Renderer9::genericDrawArrays(const gl::Context *context,
 
     if (!applyPrimitiveType(mode, count, usesPointSize))
     {
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     ANGLE_TRY(updateState(context, mode));
@@ -3083,7 +3061,7 @@ gl::Error Renderer9::genericDrawArrays(const gl::Context *context,
         ANGLE_TRY(drawArraysImpl(context, mode, first, count, instances));
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 FramebufferImpl *Renderer9::createDefaultFramebuffer(const gl::FramebufferState &state)
@@ -3160,7 +3138,7 @@ bool Renderer9::canSelectViewInVertexShader() const
 // looks up the corresponding OpenGL texture image unit and texture type,
 // and sets the texture and its addressing/filtering state (or NULL when inactive).
 // Sampler mapping needs to be up-to-date on the program object before this is called.
-gl::Error Renderer9::applyTextures(const gl::Context *context, gl::ShaderType shaderType)
+angle::Result Renderer9::applyTextures(const gl::Context *context, gl::ShaderType shaderType)
 {
     const auto &glState    = context->getGLState();
     const auto &caps       = context->getCaps();
@@ -3197,7 +3175,8 @@ gl::Error Renderer9::applyTextures(const gl::Context *context, gl::ShaderType sh
             // Texture is not sampler complete or it is in use by the framebuffer.  Bind the
             // incomplete texture.
             gl::Texture *incompleteTexture = nullptr;
-            ANGLE_TRY(getIncompleteTexture(context, textureType, &incompleteTexture));
+            ANGLE_TRY_HANDLE(context,
+                             getIncompleteTexture(context, textureType, &incompleteTexture));
             ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, incompleteTexture,
                                       incompleteTexture->getSamplerState()));
             ANGLE_TRY(setTexture(context, shaderType, samplerIndex, incompleteTexture));
@@ -3215,14 +3194,14 @@ gl::Error Renderer9::applyTextures(const gl::Context *context, gl::ShaderType sh
         ANGLE_TRY(setTexture(context, shaderType, static_cast<int>(samplerIndex), nullptr));
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Renderer9::applyTextures(const gl::Context *context)
+angle::Result Renderer9::applyTextures(const gl::Context *context)
 {
     ANGLE_TRY(applyTextures(context, gl::ShaderType::Vertex));
     ANGLE_TRY(applyTextures(context, gl::ShaderType::Fragment));
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error Renderer9::getIncompleteTexture(const gl::Context *context,
@@ -3232,14 +3211,14 @@ gl::Error Renderer9::getIncompleteTexture(const gl::Context *context,
     return GetImplAs<Context9>(context)->getIncompleteTexture(context, type, textureOut);
 }
 
-gl::Error Renderer9::ensureVertexDataManagerInitialized(const gl::Context *context)
+angle::Result Renderer9::ensureVertexDataManagerInitialized(const gl::Context *context)
 {
     if (!mVertexDataManager)
     {
         mVertexDataManager = new VertexDataManager(this);
-        ANGLE_TRY(mVertexDataManager->initialize(context));
+        ANGLE_TRY_HANDLE(context, mVertexDataManager->initialize(context));
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 }  // namespace rx

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

@@ -79,8 +79,8 @@ class Renderer9 : public RendererD3D
     void startScene();
     void endScene();
 
-    gl::Error flush();
-    gl::Error finish();
+    gl::Error flush(const gl::Context *context);
+    gl::Error finish(const gl::Context *context);
 
     bool isValidNativeWindow(EGLNativeWindowType window) const override;
     NativeWindowD3D *createNativeWindow(EGLNativeWindowType window,
@@ -105,32 +105,34 @@ class Renderer9 : public RendererD3D
 
     ContextImpl *createContext(const gl::ContextState &state) override;
 
-    gl::Error allocateEventQuery(IDirect3DQuery9 **outQuery);
+    angle::Result allocateEventQuery(const gl::Context *context, IDirect3DQuery9 **outQuery);
     void freeEventQuery(IDirect3DQuery9 *query);
 
     // resource creation
-    gl::Error createVertexShader(const DWORD *function,
-                                 size_t length,
-                                 IDirect3DVertexShader9 **outShader);
-    gl::Error createPixelShader(const DWORD *function,
-                                size_t length,
-                                IDirect3DPixelShader9 **outShader);
+    angle::Result createVertexShader(Context9 *context9,
+                                     const DWORD *function,
+                                     size_t length,
+                                     IDirect3DVertexShader9 **outShader);
+    angle::Result createPixelShader(Context9 *context9,
+                                    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);
-    gl::Error setSamplerState(const gl::Context *context,
-                              gl::ShaderType type,
-                              int index,
-                              gl::Texture *texture,
-                              const gl::SamplerState &sampler);
-    gl::Error setTexture(const gl::Context *context,
-                         gl::ShaderType type,
-                         int index,
-                         gl::Texture *texture);
-
-    gl::Error updateState(const gl::Context *context, gl::PrimitiveMode drawMode);
+    angle::Result setSamplerState(const gl::Context *context,
+                                  gl::ShaderType type,
+                                  int index,
+                                  gl::Texture *texture,
+                                  const gl::SamplerState &sampler);
+    angle::Result setTexture(const gl::Context *context,
+                             gl::ShaderType type,
+                             int index,
+                             gl::Texture *texture);
+
+    angle::Result updateState(const gl::Context *context, gl::PrimitiveMode drawMode);
 
     void setScissorRectangle(const gl::Rectangle &scissor, bool enabled);
     void setViewport(const gl::Rectangle &viewport,
@@ -140,30 +142,29 @@ class Renderer9 : public RendererD3D
                      GLenum frontFace,
                      bool ignoreViewport);
 
-    gl::Error applyRenderTarget(const gl::Context *context,
-                                const RenderTarget9 *colorRenderTarget,
-                                const RenderTarget9 *depthStencilRenderTarget);
-    gl::Error applyUniforms(ProgramD3D *programD3D);
+    angle::Result applyRenderTarget(const gl::Context *context,
+                                    const RenderTarget9 *colorRenderTarget,
+                                    const RenderTarget9 *depthStencilRenderTarget);
+    void applyUniforms(ProgramD3D *programD3D);
     bool applyPrimitiveType(gl::PrimitiveMode primitiveType,
                             GLsizei elementCount,
                             bool usesPointSize);
-    gl::Error applyVertexBuffer(const gl::Context *context,
-                                gl::PrimitiveMode mode,
-                                GLint first,
-                                GLsizei count,
-                                GLsizei instances,
-                                TranslatedIndexData *indexInfo);
-    gl::Error applyIndexBuffer(const gl::Context *context,
-                               const void *indices,
-                               GLsizei count,
-                               gl::PrimitiveMode mode,
-                               GLenum type,
-                               TranslatedIndexData *indexInfo);
-
-    gl::Error clear(const gl::Context *context,
-                    const ClearParameters &clearParams,
-                    const RenderTarget9 *colorRenderTarget,
-                    const RenderTarget9 *depthStencilRenderTarget);
+    angle::Result applyVertexBuffer(const gl::Context *context,
+                                    gl::PrimitiveMode mode,
+                                    GLint first,
+                                    GLsizei count,
+                                    GLsizei instances,
+                                    TranslatedIndexData *indexInfo);
+    angle::Result applyIndexBuffer(const gl::Context *context,
+                                   const void *indices,
+                                   GLsizei count,
+                                   gl::PrimitiveMode mode,
+                                   GLenum type,
+                                   TranslatedIndexData *indexInfo);
+
+    void clear(const ClearParameters &clearParams,
+               const RenderTarget9 *colorRenderTarget,
+               const RenderTarget9 *depthStencilRenderTarget);
 
     void markAllStateDirty();
 
@@ -340,7 +341,7 @@ class Renderer9 : public RendererD3D
                                       const gl::Box &destArea) override;
 
     // D3D9-renderer specific methods
-    gl::Error boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest);
+    angle::Result boxFilter(Context9 *context9, IDirect3DSurface9 *source, IDirect3DSurface9 *dest);
 
     D3DPOOL getTexturePool(DWORD usage) const;
 
@@ -358,9 +359,10 @@ class Renderer9 : public RendererD3D
                                      GLsizei instances,
                                      unsigned int *bytesRequiredOut) const override;
 
-    gl::Error copyToRenderTarget(IDirect3DSurface9 *dest,
-                                 IDirect3DSurface9 *source,
-                                 bool fromManaged);
+    angle::Result copyToRenderTarget(const gl::Context *context,
+                                     IDirect3DSurface9 *dest,
+                                     IDirect3DSurface9 *source,
+                                     bool fromManaged);
 
     RendererClass getRendererClass() const override;
 
@@ -370,18 +372,18 @@ class Renderer9 : public RendererD3D
 
     StateManager9 *getStateManager() { return &mStateManager; }
 
-    gl::Error genericDrawArrays(const gl::Context *context,
-                                gl::PrimitiveMode mode,
-                                GLint first,
-                                GLsizei count,
-                                GLsizei instances);
+    angle::Result genericDrawArrays(const gl::Context *context,
+                                    gl::PrimitiveMode mode,
+                                    GLint first,
+                                    GLsizei count,
+                                    GLsizei instances);
 
-    gl::Error genericDrawElements(const gl::Context *context,
-                                  gl::PrimitiveMode mode,
-                                  GLsizei count,
-                                  GLenum type,
-                                  const void *indices,
-                                  GLsizei instances);
+    angle::Result genericDrawElements(const gl::Context *context,
+                                      gl::PrimitiveMode mode,
+                                      GLsizei count,
+                                      GLenum type,
+                                      const void *indices,
+                                      GLsizei instances);
 
     // Necessary hack for default framebuffers in D3D.
     FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override;
@@ -402,25 +404,25 @@ class Renderer9 : public RendererD3D
                                    gl::TextureType type,
                                    gl::Texture **textureOut) override;
 
-    gl::Error ensureVertexDataManagerInitialized(const gl::Context *context);
+    angle::Result ensureVertexDataManagerInitialized(const gl::Context *context);
 
   private:
-    gl::Error drawArraysImpl(const gl::Context *context,
-                             gl::PrimitiveMode mode,
-                             GLint startVertex,
-                             GLsizei count,
-                             GLsizei instances);
-    gl::Error drawElementsImpl(const gl::Context *context,
-                               gl::PrimitiveMode mode,
-                               GLsizei count,
-                               GLenum type,
-                               const void *indices,
-                               GLsizei instances);
-
-    gl::Error applyShaders(const gl::Context *context, gl::PrimitiveMode drawMode);
-
-    gl::Error applyTextures(const gl::Context *context);
-    gl::Error applyTextures(const gl::Context *context, gl::ShaderType shaderType);
+    angle::Result drawArraysImpl(const gl::Context *context,
+                                 gl::PrimitiveMode mode,
+                                 GLint startVertex,
+                                 GLsizei count,
+                                 GLsizei instances);
+    angle::Result drawElementsImpl(const gl::Context *context,
+                                   gl::PrimitiveMode mode,
+                                   GLsizei count,
+                                   GLenum type,
+                                   const void *indices,
+                                   GLsizei instances);
+
+    angle::Result applyShaders(const gl::Context *context, gl::PrimitiveMode drawMode);
+
+    angle::Result applyTextures(const gl::Context *context);
+    angle::Result applyTextures(const gl::Context *context, gl::ShaderType shaderType);
 
     void generateCaps(gl::Caps *outCaps,
                       gl::TextureCapsMap *outTextureCaps,
@@ -429,7 +431,7 @@ class Renderer9 : public RendererD3D
 
     angle::WorkaroundsD3D generateWorkarounds() const override;
 
-    gl::Error setBlendDepthRasterStates(const gl::Context *context, gl::PrimitiveMode drawMode);
+    angle::Result setBlendDepthRasterStates(const gl::Context *context, gl::PrimitiveMode drawMode);
 
     void release();
 
@@ -437,26 +439,26 @@ class Renderer9 : public RendererD3D
     void applyUniformniv(const D3DUniform *targetUniform, const GLint *v);
     void applyUniformnbv(const D3DUniform *targetUniform, const GLint *v);
 
-    gl::Error drawLineLoop(const gl::Context *context,
-                           GLsizei count,
-                           GLenum type,
-                           const void *indices,
-                           int minIndex,
-                           gl::Buffer *elementArrayBuffer);
-    gl::Error drawIndexedPoints(const gl::Context *context,
-                                GLsizei count,
-                                GLenum type,
-                                const void *indices,
-                                int minIndex,
-                                gl::Buffer *elementArrayBuffer);
-
-    gl::Error getCountingIB(const gl::Context *context,
-                            size_t count,
-                            StaticIndexBufferInterface **outIB);
-
-    gl::Error getNullColorRenderTarget(const gl::Context *context,
-                                       const RenderTarget9 *depthRenderTarget,
-                                       const RenderTarget9 **outColorRenderTarget);
+    angle::Result drawLineLoop(const gl::Context *context,
+                               GLsizei count,
+                               GLenum type,
+                               const void *indices,
+                               int minIndex,
+                               gl::Buffer *elementArrayBuffer);
+    angle::Result drawIndexedPoints(const gl::Context *context,
+                                    GLsizei count,
+                                    GLenum type,
+                                    const void *indices,
+                                    int minIndex,
+                                    gl::Buffer *elementArrayBuffer);
+
+    angle::Result getCountingIB(const gl::Context *context,
+                                size_t count,
+                                StaticIndexBufferInterface **outIB);
+
+    angle::Result getNullColorRenderTarget(const gl::Context *context,
+                                           const RenderTarget9 *depthRenderTarget,
+                                           const RenderTarget9 **outColorRenderTarget);
 
     D3DPOOL getBufferPool(DWORD usage) const;
 

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

@@ -13,6 +13,7 @@
 #include "libANGLE/Error.h"
 
 #include "common/debug.h"
+#include "libANGLE/renderer/d3d/d3d9/Context9.h"
 
 #include <cstddef>
 #include <unordered_map>
@@ -37,7 +38,10 @@ class ShaderCache : angle::NonCopyable
         mDevice = device;
     }
 
-    gl::Error create(const DWORD *function, size_t length, ShaderObject **outShaderObject)
+    angle::Result create(Context9 *context9,
+                         const DWORD *function,
+                         size_t length,
+                         ShaderObject **outShaderObject)
     {
         std::string key(reinterpret_cast<const char*>(function), length);
         typename Map::iterator it = mMap.find(key);
@@ -45,15 +49,12 @@ class ShaderCache : angle::NonCopyable
         {
             it->second->AddRef();
             *outShaderObject = it->second;
-            return gl::NoError();
+            return angle::Result::Continue();
         }
 
         ShaderObject *shader;
         HRESULT result = createShader(function, &shader);
-        if (FAILED(result))
-        {
-            return gl::OutOfMemory() << "Failed to create shader, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(context9, result, "Failed to create shader");
 
         // Random eviction policy.
         if (mMap.size() >= kMaxMapSize)
@@ -66,7 +67,7 @@ class ShaderCache : angle::NonCopyable
         mMap[key] = shader;
 
         *outShaderObject = shader;
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     void clear()

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

@@ -377,8 +377,7 @@ void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits
     }
 }
 
-gl::Error StateManager9::setBlendDepthRasterStates(const gl::State &glState,
-                                                   unsigned int sampleMask)
+void StateManager9::setBlendDepthRasterStates(const gl::State &glState, unsigned int sampleMask)
 {
     const gl::Framebuffer *framebuffer = glState.getDrawFramebuffer();
 
@@ -470,8 +469,6 @@ gl::Error StateManager9::setBlendDepthRasterStates(const gl::State &glState,
     {
         setSampleMask(sampleMask);
     }
-
-    return gl::NoError();
 }
 
 void StateManager9::setViewportState(const gl::Rectangle &viewport,

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

@@ -43,7 +43,7 @@ class StateManager9 final : angle::NonCopyable
 
     void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
 
-    gl::Error setBlendDepthRasterStates(const gl::State &glState, unsigned int sampleMask);
+    void setBlendDepthRasterStates(const gl::State &glState, unsigned int sampleMask);
     void setScissorState(const gl::Rectangle &scissor, bool enabled);
     void setViewportState(const gl::Rectangle &viewport,
                           float zNear,

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

@@ -11,6 +11,7 @@
 #include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h"
 
 #include "common/utilities.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Texture.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/EGLImageD3D.h"
@@ -153,31 +154,21 @@ TextureStorage9_2D::~TextureStorage9_2D()
 
 // Increments refcount on surface.
 // caller must Release() the returned surface
-gl::Error TextureStorage9_2D::getSurfaceLevel(const gl::Context *context,
-                                              gl::TextureTarget target,
-                                              int level,
-                                              bool dirty,
-                                              IDirect3DSurface9 **outSurface)
+angle::Result TextureStorage9_2D::getSurfaceLevel(const gl::Context *context,
+                                                  gl::TextureTarget target,
+                                                  int level,
+                                                  bool dirty,
+                                                  IDirect3DSurface9 **outSurface)
 {
     ASSERT(target == gl::TextureTarget::_2D);
 
     IDirect3DBaseTexture9 *baseTexture = nullptr;
-    gl::Error error                    = getBaseTexture(context, &baseTexture);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(getBaseTexture(context, &baseTexture));
 
     IDirect3DTexture9 *texture = static_cast<IDirect3DTexture9*>(baseTexture);
 
     HRESULT result = texture->GetSurfaceLevel(level + mTopLevel, outSurface);
-
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to get the surface from a texture, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to get the surface from a texture");
 
     // With managed textures the driver needs to be informed of updates to the lower mipmap levels
     if (level + mTopLevel != 0 && isManaged() && dirty)
@@ -185,7 +176,7 @@ gl::Error TextureStorage9_2D::getSurfaceLevel(const gl::Context *context,
         texture->AddDirtyRect(nullptr);
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error TextureStorage9_2D::getRenderTarget(const gl::Context *context,
@@ -197,19 +188,11 @@ gl::Error TextureStorage9_2D::getRenderTarget(const gl::Context *context,
     if (!mRenderTargets[index.getLevelIndex()] && isRenderTarget())
     {
         IDirect3DBaseTexture9 *baseTexture = nullptr;
-        gl::Error error                    = getBaseTexture(context, &baseTexture);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(getBaseTexture(context, &baseTexture));
 
         IDirect3DSurface9 *surface = nullptr;
-        error = getSurfaceLevel(context, gl::TextureTarget::_2D, index.getLevelIndex(), false,
-                                &surface);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(getSurfaceLevel(context, gl::TextureTarget::_2D, index.getLevelIndex(), false,
+                                  &surface));
 
         size_t textureMipLevel = mTopLevel + index.getLevelIndex();
         size_t mipWidth        = std::max<size_t>(mTextureWidth >> textureMipLevel, 1u);
@@ -230,34 +213,20 @@ gl::Error TextureStorage9_2D::generateMipmap(const gl::Context *context,
                                              const gl::ImageIndex &sourceIndex,
                                              const gl::ImageIndex &destIndex)
 {
-    IDirect3DSurface9 *upper = nullptr;
-    gl::Error error = getSurfaceLevel(context, gl::TextureTarget::_2D, sourceIndex.getLevelIndex(),
-                                      false, &upper);
-    if (error.isError())
-    {
-        return error;
-    }
+    angle::ComPtr<IDirect3DSurface9> upper = nullptr;
+    ANGLE_TRY(getSurfaceLevel(context, gl::TextureTarget::_2D, sourceIndex.getLevelIndex(), false,
+                              &upper));
 
-    IDirect3DSurface9 *lower = nullptr;
-    error =
-        getSurfaceLevel(context, gl::TextureTarget::_2D, destIndex.getLevelIndex(), true, &lower);
-    if (error.isError())
-    {
-        SafeRelease(upper);
-        return error;
-    }
+    angle::ComPtr<IDirect3DSurface9> lower = nullptr;
+    ANGLE_TRY(
+        getSurfaceLevel(context, gl::TextureTarget::_2D, destIndex.getLevelIndex(), true, &lower));
 
     ASSERT(upper && lower);
-    error = mRenderer->boxFilter(upper, lower);
-
-    SafeRelease(upper);
-    SafeRelease(lower);
-
-    return error;
+    return mRenderer->boxFilter(GetImplAs<Context9>(context), upper.Get(), lower.Get());
 }
 
-gl::Error TextureStorage9_2D::getBaseTexture(const gl::Context *context,
-                                             IDirect3DBaseTexture9 **outTexture)
+angle::Result TextureStorage9_2D::getBaseTexture(const gl::Context *context,
+                                                 IDirect3DBaseTexture9 **outTexture)
 {
     // if the width or height is not positive this should be treated as an incomplete texture
     // we handle that here by skipping the d3d texture creation
@@ -270,17 +239,11 @@ gl::Error TextureStorage9_2D::getBaseTexture(const gl::Context *context,
                                                static_cast<unsigned int>(mTextureHeight),
                                                static_cast<unsigned int>(mMipLevels), getUsage(),
                                                mTextureFormat, getPool(), &mTexture, nullptr);
-
-        if (FAILED(result))
-        {
-            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::OutOfMemory()
-                   << "Failed to create 2D storage texture, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to create 2D storage texture");
     }
 
     *outTexture = mTexture;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error TextureStorage9_2D::copyToStorage(const gl::Context *context, TextureStorage *destStorage)
@@ -292,30 +255,14 @@ gl::Error TextureStorage9_2D::copyToStorage(const gl::Context *context, TextureS
     int levels = getLevelCount();
     for (int i = 0; i < levels; ++i)
     {
-        IDirect3DSurface9 *srcSurf = nullptr;
-        gl::Error error = getSurfaceLevel(context, gl::TextureTarget::_2D, i, false, &srcSurf);
-        if (error.isError())
-        {
-            return error;
-        }
+        angle::ComPtr<IDirect3DSurface9> srcSurf = nullptr;
+        ANGLE_TRY(getSurfaceLevel(context, gl::TextureTarget::_2D, i, false, &srcSurf));
 
-        IDirect3DSurface9 *dstSurf = nullptr;
-        error = dest9->getSurfaceLevel(context, gl::TextureTarget::_2D, i, true, &dstSurf);
-        if (error.isError())
-        {
-            SafeRelease(srcSurf);
-            return error;
-        }
-
-        error = mRenderer->copyToRenderTarget(dstSurf, srcSurf, isManaged());
+        angle::ComPtr<IDirect3DSurface9> dstSurf = nullptr;
+        ANGLE_TRY(dest9->getSurfaceLevel(context, gl::TextureTarget::_2D, i, true, &dstSurf));
 
-        SafeRelease(srcSurf);
-        SafeRelease(dstSurf);
-
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(
+            mRenderer->copyToRenderTarget(context, dstSurf.Get(), srcSurf.Get(), isManaged()));
     }
 
     return gl::NoError();
@@ -338,26 +285,22 @@ TextureStorage9_EGLImage::~TextureStorage9_EGLImage()
 {
 }
 
-gl::Error TextureStorage9_EGLImage::getSurfaceLevel(const gl::Context *context,
-                                                    gl::TextureTarget target,
-                                                    int level,
-                                                    bool,
-                                                    IDirect3DSurface9 **outSurface)
+angle::Result TextureStorage9_EGLImage::getSurfaceLevel(const gl::Context *context,
+                                                        gl::TextureTarget target,
+                                                        int level,
+                                                        bool,
+                                                        IDirect3DSurface9 **outSurface)
 {
     ASSERT(target == gl::TextureTarget::_2D);
     ASSERT(level == 0);
 
     RenderTargetD3D *renderTargetD3D = nullptr;
-    gl::Error error                  = mImage->getRenderTarget(context, &renderTargetD3D);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY_HANDLE(context, mImage->getRenderTarget(context, &renderTargetD3D));
 
     RenderTarget9 *renderTarget9 = GetAs<RenderTarget9>(renderTargetD3D);
 
     *outSurface = renderTarget9->getSurface();
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error TextureStorage9_EGLImage::getRenderTarget(const gl::Context *context,
@@ -370,21 +313,17 @@ gl::Error TextureStorage9_EGLImage::getRenderTarget(const gl::Context *context,
     return mImage->getRenderTarget(context, outRT);
 }
 
-gl::Error TextureStorage9_EGLImage::getBaseTexture(const gl::Context *context,
-                                                   IDirect3DBaseTexture9 **outTexture)
+angle::Result TextureStorage9_EGLImage::getBaseTexture(const gl::Context *context,
+                                                       IDirect3DBaseTexture9 **outTexture)
 {
     RenderTargetD3D *renderTargetD3D = nullptr;
-    gl::Error error                  = mImage->getRenderTarget(context, &renderTargetD3D);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY_HANDLE(context, mImage->getRenderTarget(context, &renderTargetD3D));
 
     RenderTarget9 *renderTarget9 = GetAs<RenderTarget9>(renderTargetD3D);
     *outTexture = renderTarget9->getTexture();
     ASSERT(*outTexture != nullptr);
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error TextureStorage9_EGLImage::generateMipmap(const gl::Context *context,
@@ -404,15 +343,11 @@ gl::Error TextureStorage9_EGLImage::copyToStorage(const gl::Context *context,
     TextureStorage9 *dest9 = GetAs<TextureStorage9>(destStorage);
 
     IDirect3DBaseTexture9 *destBaseTexture9 = nullptr;
-    gl::Error error                         = dest9->getBaseTexture(context, &destBaseTexture9);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(dest9->getBaseTexture(context, &destBaseTexture9));
 
     IDirect3DTexture9 *destTexture9 = static_cast<IDirect3DTexture9 *>(destBaseTexture9);
 
-    IDirect3DSurface9 *destSurface = nullptr;
+    angle::ComPtr<IDirect3DSurface9> destSurface = nullptr;
     HRESULT result = destTexture9->GetSurfaceLevel(destStorage->getTopLevel(), &destSurface);
     if (FAILED(result))
     {
@@ -421,28 +356,17 @@ gl::Error TextureStorage9_EGLImage::copyToStorage(const gl::Context *context,
     }
 
     RenderTargetD3D *sourceRenderTarget = nullptr;
-    error                               = mImage->getRenderTarget(context, &sourceRenderTarget);
-    if (error.isError())
-    {
-        SafeRelease(destSurface);
-        return error;
-    }
+    ANGLE_TRY(mImage->getRenderTarget(context, &sourceRenderTarget));
 
     RenderTarget9 *sourceRenderTarget9 = GetAs<RenderTarget9>(sourceRenderTarget);
-    error =
-        mRenderer->copyToRenderTarget(destSurface, sourceRenderTarget9->getSurface(), isManaged());
-    if (error.isError())
-    {
-        SafeRelease(destSurface);
-        return error;
-    }
+    ANGLE_TRY(mRenderer->copyToRenderTarget(context, destSurface.Get(),
+                                            sourceRenderTarget9->getSurface(), isManaged()));
 
     if (destStorage->getTopLevel() != 0)
     {
         destTexture9->AddDirtyRect(nullptr);
     }
 
-    SafeRelease(destSurface);
     return gl::NoError();
 }
 
@@ -479,30 +403,20 @@ TextureStorage9_Cube::~TextureStorage9_Cube()
 
 // Increments refcount on surface.
 // caller must Release() the returned surface
-gl::Error TextureStorage9_Cube::getSurfaceLevel(const gl::Context *context,
-                                                gl::TextureTarget target,
-                                                int level,
-                                                bool dirty,
-                                                IDirect3DSurface9 **outSurface)
+angle::Result TextureStorage9_Cube::getSurfaceLevel(const gl::Context *context,
+                                                    gl::TextureTarget target,
+                                                    int level,
+                                                    bool dirty,
+                                                    IDirect3DSurface9 **outSurface)
 {
     IDirect3DBaseTexture9 *baseTexture = nullptr;
-    gl::Error error                    = getBaseTexture(context, &baseTexture);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(getBaseTexture(context, &baseTexture));
 
     IDirect3DCubeTexture9 *texture = static_cast<IDirect3DCubeTexture9*>(baseTexture);
 
     D3DCUBEMAP_FACES face = gl_d3d9::ConvertCubeFace(target);
     HRESULT result        = texture->GetCubeMapSurface(face, level, outSurface);
-
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to get the surface from a texture, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to get the surface from a texture");
 
     // With managed textures the driver needs to be informed of updates to the lower mipmap levels
     if (level != 0 && isManaged() && dirty)
@@ -510,7 +424,7 @@ gl::Error TextureStorage9_Cube::getSurfaceLevel(const gl::Context *context,
         texture->AddDirtyRect(face, nullptr);
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error TextureStorage9_Cube::getRenderTarget(const gl::Context *context,
@@ -527,19 +441,11 @@ gl::Error TextureStorage9_Cube::getRenderTarget(const gl::Context *context,
     if (mRenderTarget[renderTargetIndex] == nullptr && isRenderTarget())
     {
         IDirect3DBaseTexture9 *baseTexture = nullptr;
-        gl::Error error                    = getBaseTexture(context, &baseTexture);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(getBaseTexture(context, &baseTexture));
 
         IDirect3DSurface9 *surface = nullptr;
-        error = getSurfaceLevel(context, index.getTarget(), mTopLevel + index.getLevelIndex(),
-                                false, &surface);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(getSurfaceLevel(context, index.getTarget(), mTopLevel + index.getLevelIndex(),
+                                  false, &surface));
 
         baseTexture->AddRef();
         mRenderTarget[renderTargetIndex] = new TextureRenderTarget9(
@@ -555,34 +461,20 @@ gl::Error TextureStorage9_Cube::generateMipmap(const gl::Context *context,
                                                const gl::ImageIndex &sourceIndex,
                                                const gl::ImageIndex &destIndex)
 {
-    IDirect3DSurface9 *upper = nullptr;
-    gl::Error error = getSurfaceLevel(context, sourceIndex.getTarget(), sourceIndex.getLevelIndex(),
-                                      false, &upper);
-    if (error.isError())
-    {
-        return error;
-    }
+    angle::ComPtr<IDirect3DSurface9> upper = nullptr;
+    ANGLE_TRY(getSurfaceLevel(context, sourceIndex.getTarget(), sourceIndex.getLevelIndex(), false,
+                              &upper));
 
-    IDirect3DSurface9 *lower = nullptr;
-    error =
-        getSurfaceLevel(context, destIndex.getTarget(), destIndex.getLevelIndex(), true, &lower);
-    if (error.isError())
-    {
-        SafeRelease(upper);
-        return error;
-    }
+    angle::ComPtr<IDirect3DSurface9> lower = nullptr;
+    ANGLE_TRY(
+        getSurfaceLevel(context, destIndex.getTarget(), destIndex.getLevelIndex(), true, &lower));
 
     ASSERT(upper && lower);
-    error = mRenderer->boxFilter(upper, lower);
-
-    SafeRelease(upper);
-    SafeRelease(lower);
-
-    return error;
+    return mRenderer->boxFilter(GetImplAs<Context9>(context), upper.Get(), lower.Get());
 }
 
-gl::Error TextureStorage9_Cube::getBaseTexture(const gl::Context *context,
-                                               IDirect3DBaseTexture9 **outTexture)
+angle::Result TextureStorage9_Cube::getBaseTexture(const gl::Context *context,
+                                                   IDirect3DBaseTexture9 **outTexture)
 {
     // if the size is not positive this should be treated as an incomplete texture
     // we handle that here by skipping the d3d texture creation
@@ -595,17 +487,11 @@ gl::Error TextureStorage9_Cube::getBaseTexture(const gl::Context *context,
         HRESULT result           = device->CreateCubeTexture(
             static_cast<unsigned int>(mTextureWidth), static_cast<unsigned int>(mMipLevels),
             getUsage(), mTextureFormat, getPool(), &mTexture, nullptr);
-
-        if (FAILED(result))
-        {
-            ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::OutOfMemory()
-                   << "Failed to create cube storage texture, " << gl::FmtHR(result);
-        }
+        ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to create cube storage texture");
     }
 
     *outTexture = mTexture;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 gl::Error TextureStorage9_Cube::copyToStorage(const gl::Context *context,
@@ -620,34 +506,17 @@ gl::Error TextureStorage9_Cube::copyToStorage(const gl::Context *context,
     {
         for (int i = 0; i < levels; i++)
         {
-            IDirect3DSurface9 *srcSurf = nullptr;
-            gl::Error error            = getSurfaceLevel(context, face, i, false, &srcSurf);
-            if (error.isError())
-            {
-                return error;
-            }
-
-            IDirect3DSurface9 *dstSurf = nullptr;
-            error                      = dest9->getSurfaceLevel(context, face, i, true, &dstSurf);
-            if (error.isError())
-            {
-                SafeRelease(srcSurf);
-                return error;
-            }
-
-            error = mRenderer->copyToRenderTarget(dstSurf, srcSurf, isManaged());
-
-            SafeRelease(srcSurf);
-            SafeRelease(dstSurf);
-
-            if (error.isError())
-            {
-                return error;
-            }
+            angle::ComPtr<IDirect3DSurface9> srcSurf = nullptr;
+            ANGLE_TRY(getSurfaceLevel(context, face, i, false, &srcSurf));
+
+            angle::ComPtr<IDirect3DSurface9> dstSurf = nullptr;
+            ANGLE_TRY(dest9->getSurfaceLevel(context, face, i, true, &dstSurf));
+
+            ANGLE_TRY(
+                mRenderer->copyToRenderTarget(context, dstSurf.Get(), srcSurf.Get(), isManaged()));
         }
     }
 
     return gl::NoError();
 }
-
-}
+}  // namespace rx

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

@@ -32,13 +32,13 @@ class TextureStorage9 : public TextureStorage
     D3DPOOL getPool() const;
     DWORD getUsage() const;
 
-    virtual gl::Error getSurfaceLevel(const gl::Context *context,
-                                      gl::TextureTarget target,
-                                      int level,
-                                      bool dirty,
-                                      IDirect3DSurface9 **outSurface)    = 0;
-    virtual gl::Error getBaseTexture(const gl::Context *context,
-                                     IDirect3DBaseTexture9 **outTexture) = 0;
+    virtual angle::Result getSurfaceLevel(const gl::Context *context,
+                                          gl::TextureTarget target,
+                                          int level,
+                                          bool dirty,
+                                          IDirect3DSurface9 **outSurface)    = 0;
+    virtual angle::Result getBaseTexture(const gl::Context *context,
+                                         IDirect3DBaseTexture9 **outTexture) = 0;
 
     int getTopLevel() const override;
     bool isRenderTarget() const override;
@@ -78,16 +78,16 @@ class TextureStorage9_2D : public TextureStorage9
     TextureStorage9_2D(Renderer9 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
     ~TextureStorage9_2D() override;
 
-    gl::Error getSurfaceLevel(const gl::Context *context,
-                              gl::TextureTarget target,
-                              int level,
-                              bool dirty,
-                              IDirect3DSurface9 **outSurface) override;
+    angle::Result getSurfaceLevel(const gl::Context *context,
+                                  gl::TextureTarget target,
+                                  int level,
+                                  bool dirty,
+                                  IDirect3DSurface9 **outSurface) override;
     gl::Error getRenderTarget(const gl::Context *context,
                               const gl::ImageIndex &index,
                               RenderTargetD3D **outRT) override;
-    gl::Error getBaseTexture(const gl::Context *context,
-                             IDirect3DBaseTexture9 **outTexture) override;
+    angle::Result getBaseTexture(const gl::Context *context,
+                                 IDirect3DBaseTexture9 **outTexture) override;
     gl::Error generateMipmap(const gl::Context *context,
                              const gl::ImageIndex &sourceIndex,
                              const gl::ImageIndex &destIndex) override;
@@ -104,16 +104,16 @@ class TextureStorage9_EGLImage final : public TextureStorage9
     TextureStorage9_EGLImage(Renderer9 *renderer, EGLImageD3D *image, RenderTarget9 *renderTarget9);
     ~TextureStorage9_EGLImage() override;
 
-    gl::Error getSurfaceLevel(const gl::Context *context,
-                              gl::TextureTarget target,
-                              int level,
-                              bool dirty,
-                              IDirect3DSurface9 **outSurface) override;
+    angle::Result getSurfaceLevel(const gl::Context *context,
+                                  gl::TextureTarget target,
+                                  int level,
+                                  bool dirty,
+                                  IDirect3DSurface9 **outSurface) override;
     gl::Error getRenderTarget(const gl::Context *context,
                               const gl::ImageIndex &index,
                               RenderTargetD3D **outRT) override;
-    gl::Error getBaseTexture(const gl::Context *context,
-                             IDirect3DBaseTexture9 **outTexture) override;
+    angle::Result getBaseTexture(const gl::Context *context,
+                                 IDirect3DBaseTexture9 **outTexture) override;
     gl::Error generateMipmap(const gl::Context *context,
                              const gl::ImageIndex &sourceIndex,
                              const gl::ImageIndex &destIndex) override;
@@ -129,16 +129,16 @@ class TextureStorage9_Cube : public TextureStorage9
     TextureStorage9_Cube(Renderer9 *renderer, GLenum internalformat, bool renderTarget, int size, int levels, bool hintLevelZeroOnly);
     ~TextureStorage9_Cube() override;
 
-    gl::Error getSurfaceLevel(const gl::Context *context,
-                              gl::TextureTarget target,
-                              int level,
-                              bool dirty,
-                              IDirect3DSurface9 **outSurface) override;
+    angle::Result getSurfaceLevel(const gl::Context *context,
+                                  gl::TextureTarget target,
+                                  int level,
+                                  bool dirty,
+                                  IDirect3DSurface9 **outSurface) override;
     gl::Error getRenderTarget(const gl::Context *context,
                               const gl::ImageIndex &index,
                               RenderTargetD3D **outRT) override;
-    gl::Error getBaseTexture(const gl::Context *context,
-                             IDirect3DBaseTexture9 **outTexture) override;
+    angle::Result getBaseTexture(const gl::Context *context,
+                                 IDirect3DBaseTexture9 **outTexture) override;
     gl::Error generateMipmap(const gl::Context *context,
                              const gl::ImageIndex &sourceIndex,
                              const gl::ImageIndex &destIndex) override;

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

@@ -8,9 +8,11 @@
 
 #include "libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h"
 
+#include "libANGLE/Context.h"
 #include "libANGLE/VertexAttribute.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
+#include "libANGLE/renderer/d3d/d3d9/Context9.h"
 #include "libANGLE/renderer/d3d/d3d9/VertexBuffer9.h"
 #include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
 
@@ -42,7 +44,8 @@ VertexDeclarationCache::~VertexDeclarationCache()
     }
 }
 
-gl::Error VertexDeclarationCache::applyDeclaration(
+angle::Result VertexDeclarationCache::applyDeclaration(
+    const gl::Context *context,
     IDirect3DDevice9 *device,
     const std::vector<TranslatedAttribute> &attributes,
     gl::Program *program,
@@ -152,7 +155,7 @@ gl::Error VertexDeclarationCache::applyDeclaration(
             VertexBuffer9 *vertexBuffer = GetAs<VertexBuffer9>(attributes[i].vertexBuffer.get());
 
             unsigned int offset = 0;
-            ANGLE_TRY(attributes[i].computeOffset(start, &offset));
+            ANGLE_TRY_HANDLE(context, attributes[i].computeOffset(start, &offset));
 
             if (mAppliedVBs[stream].serial != attributes[i].serial ||
                 mAppliedVBs[stream].stride != attributes[i].stride ||
@@ -207,7 +210,7 @@ gl::Error VertexDeclarationCache::applyDeclaration(
                 mLastSetVDecl = entry->vertexDeclaration;
             }
 
-            return gl::NoError();
+            return angle::Result::Continue();
         }
     }
 
@@ -230,17 +233,14 @@ gl::Error VertexDeclarationCache::applyDeclaration(
 
     memcpy(lastCache->cachedElements, elements, (element - elements) * sizeof(D3DVERTEXELEMENT9));
     HRESULT result = device->CreateVertexDeclaration(elements, &lastCache->vertexDeclaration);
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create internal vertex declaration, "
-                                 << gl::FmtHR(result);
-    }
+    ANGLE_TRY_HR(GetImplAs<Context9>(context), result,
+                 "Failed to create internal vertex declaration");
 
     device->SetVertexDeclaration(lastCache->vertexDeclaration);
     mLastSetVDecl = lastCache->vertexDeclaration;
     lastCache->lruCount = ++mMaxLru;
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 void VertexDeclarationCache::markStateDirty()

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

@@ -20,19 +20,19 @@ class Program;
 
 namespace rx
 {
-
 class VertexDeclarationCache
 {
   public:
     VertexDeclarationCache();
     ~VertexDeclarationCache();
 
-    gl::Error applyDeclaration(IDirect3DDevice9 *device,
-                               const std::vector<TranslatedAttribute> &attributes,
-                               gl::Program *program,
-                               GLint start,
-                               GLsizei instances,
-                               GLsizei *repeatDraw);
+    angle::Result applyDeclaration(const gl::Context *context,
+                                   IDirect3DDevice9 *device,
+                                   const std::vector<TranslatedAttribute> &attributes,
+                                   gl::Program *program,
+                                   GLint start,
+                                   GLsizei instances,
+                                   GLsizei *repeatDraw);
 
     void markStateDirty();