BASELINE: Update Chromium to 61.0.3163.99

Change-Id: I8452f34574d88ca2b27af9bd56fc9ff3f16b1367
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

105 files changed, 7683 insertions, 5665 deletions

diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/BufferD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/BufferD3D.h
index e8abdc35366..bce6145184d 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/BufferD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/BufferD3D.h
@@ -18,7 +18,7 @@
 namespace gl
 {
 struct VertexAttribute;
-struct VertexBinding;
+class VertexBinding;
 }
 
 namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DeviceD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DeviceD3D.cpp
index f40e6e6cab5..7123ac80130 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DeviceD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DeviceD3D.cpp
@@ -39,11 +39,11 @@ egl::Error DeviceD3D::getDevice(void **outValue)
     if (!mIsInitialized)
     {
         *outValue = nullptr;
-        return egl::Error(EGL_BAD_DEVICE_EXT);
+        return egl::EglBadDevice();
     }
 
     *outValue = mDevice;
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 egl::Error DeviceD3D::initialize(void *device,
@@ -53,15 +53,11 @@ egl::Error DeviceD3D::initialize(void *device,
     ASSERT(!mIsInitialized);
     if (mIsInitialized)
     {
-        return egl::Error(EGL_BAD_DEVICE_EXT);
+        return egl::EglBadDevice();
     }
 
-    mDevice                  = device;
-    mDeviceType              = deviceType;
-    mDeviceExternallySourced = !!deviceExternallySourced;
-
 #if defined(ANGLE_ENABLE_D3D11)
-    if (mDeviceType == EGL_D3D11_DEVICE_ANGLE)
+    if (deviceType == EGL_D3D11_DEVICE_ANGLE)
     {
         // Validate the device
         IUnknown *iunknown = reinterpret_cast<IUnknown *>(device);
@@ -71,7 +67,7 @@ egl::Error DeviceD3D::initialize(void *device,
             iunknown->QueryInterface(__uuidof(ID3D11Device), reinterpret_cast<void **>(&d3dDevice));
         if (FAILED(hr))
         {
-            return egl::Error(EGL_BAD_ATTRIBUTE, "Invalid D3D device passed into EGLDeviceEXT");
+            return egl::EglBadAttribute() << "Invalid D3D device passed into EGLDeviceEXT";
         }
 
         // The QI to ID3D11Device adds a ref to the D3D11 device.
@@ -81,12 +77,15 @@ egl::Error DeviceD3D::initialize(void *device,
     else
 #endif
     {
-        ASSERT(!mDeviceExternallySourced);
+        ASSERT(deviceExternallySourced == EGL_FALSE);
     }
 
-    mIsInitialized = true;
+    mDevice                  = device;
+    mDeviceType              = deviceType;
+    mDeviceExternallySourced = !!deviceExternallySourced;
+    mIsInitialized           = true;
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 EGLint DeviceD3D::getType()
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.cpp
index cb8c44e7f28..ad227b21508 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.cpp
@@ -10,16 +10,17 @@
 
 #include <EGL/eglext.h>
 
-#include "libANGLE/Context.h"
 #include "libANGLE/Config.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
 #include "libANGLE/Surface.h"
+#include "libANGLE/Thread.h"
 #include "libANGLE/histogram_macros.h"
+#include "libANGLE/renderer/d3d/DeviceD3D.h"
 #include "libANGLE/renderer/d3d/EGLImageD3D.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/SurfaceD3D.h"
 #include "libANGLE/renderer/d3d/SwapChainD3D.h"
-#include "libANGLE/renderer/d3d/DeviceD3D.h"
 
 #if defined (ANGLE_ENABLE_D3D9)
 #   include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
@@ -148,7 +149,7 @@ egl::Error CreateRendererD3D(egl::Display *display, RendererD3D **outRenderer)
         SafeDelete(renderer);
     }
 
-    return egl::Error(EGL_NOT_INITIALIZED, "No available renderers.");
+    return egl::EglNotInitialized() << "No available renderers.";
 }
 
 DisplayD3D::DisplayD3D(const egl::DisplayState &state) : DisplayImpl(state), mRenderer(nullptr)
@@ -215,7 +216,7 @@ StreamProducerImpl *DisplayD3D::createStreamProducerD3DTextureNV12(
 
 egl::Error DisplayD3D::makeCurrent(egl::Surface *drawSurface, egl::Surface *readSurface, gl::Context *context)
 {
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 egl::Error DisplayD3D::initialize(egl::Display *display)
@@ -223,7 +224,7 @@ egl::Error DisplayD3D::initialize(egl::Display *display)
     ASSERT(mRenderer == nullptr && display != nullptr);
     mDisplay = display;
     ANGLE_TRY(CreateRendererD3D(display, &mRenderer));
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 void DisplayD3D::terminate()
@@ -243,14 +244,14 @@ bool DisplayD3D::testDeviceLost()
     return mRenderer->testDeviceLost();
 }
 
-egl::Error DisplayD3D::restoreLostDevice()
+egl::Error DisplayD3D::restoreLostDevice(const egl::Display *display)
 {
     // Release surface resources to make the Reset() succeed
     for (auto &surface : mState.surfaceSet)
     {
         if (surface->getBoundTexture())
         {
-            surface->releaseTexImage(EGL_BACK_BUFFER);
+            ANGLE_TRY(surface->releaseTexImage(display->getProxyContext(), EGL_BACK_BUFFER));
         }
         SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface);
         surfaceD3D->releaseSwapChain();
@@ -258,7 +259,7 @@ egl::Error DisplayD3D::restoreLostDevice()
 
     if (!mRenderer->resetDevice())
     {
-        return egl::Error(EGL_BAD_ALLOC);
+        return egl::EglBadAlloc();
     }
 
     // Restore any surfaces that may have been lost
@@ -266,14 +267,10 @@ egl::Error DisplayD3D::restoreLostDevice()
     {
         SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface);
 
-        egl::Error error = surfaceD3D->resetSwapChain();
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(surfaceD3D->resetSwapChain(display));
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 bool DisplayD3D::isValidNativeWindow(EGLNativeWindowType window) const
@@ -325,34 +322,35 @@ void DisplayD3D::generateCaps(egl::Caps *outCaps) const
     outCaps->textureNPOT = mRenderer->getNativeExtensions().textureNPOT;
 }
 
-egl::Error DisplayD3D::waitClient() const
+egl::Error DisplayD3D::waitClient(const gl::Context *context) const
 {
     for (auto &surface : mState.surfaceSet)
     {
         SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface);
-        surfaceD3D->checkForOutOfDateSwapChain();
+        surfaceD3D->checkForOutOfDateSwapChain(context);
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
-egl::Error DisplayD3D::waitNative(EGLint engine,
-                                  egl::Surface *drawSurface,
-                                  egl::Surface *readSurface) const
+egl::Error DisplayD3D::waitNative(const gl::Context *context, EGLint engine) const
 {
+    egl::Surface *drawSurface = context->getCurrentDrawSurface();
+    egl::Surface *readSurface = context->getCurrentReadSurface();
+
     if (drawSurface != nullptr)
     {
         SurfaceD3D *drawSurfaceD3D = GetImplAs<SurfaceD3D>(drawSurface);
-        drawSurfaceD3D->checkForOutOfDateSwapChain();
+        drawSurfaceD3D->checkForOutOfDateSwapChain(context);
     }
 
     if (readSurface != nullptr)
     {
         SurfaceD3D *readurfaceD3D = GetImplAs<SurfaceD3D>(readSurface);
-        readurfaceD3D->checkForOutOfDateSwapChain();
+        readurfaceD3D->checkForOutOfDateSwapChain(context);
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 gl::Version DisplayD3D::getMaxSupportedESVersion() const
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.h
index 944e623affd..ecad1319d1a 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DisplayD3D.h
@@ -53,7 +53,7 @@ class DisplayD3D : public DisplayImpl
     egl::ConfigSet generateConfigs() override;
 
     bool testDeviceLost() override;
-    egl::Error restoreLostDevice() override;
+    egl::Error restoreLostDevice(const egl::Display *display) override;
 
     bool isValidNativeWindow(EGLNativeWindowType window) const override;
     egl::Error validateClientBuffer(const egl::Config *configuration,
@@ -65,10 +65,8 @@ class DisplayD3D : public DisplayImpl
 
     std::string getVendorString() const override;
 
-    egl::Error waitClient() const override;
-    egl::Error waitNative(EGLint engine,
-                          egl::Surface *drawSurface,
-                          egl::Surface *readSurface) const override;
+    egl::Error waitClient(const gl::Context *context) const override;
+    egl::Error waitNative(const gl::Context *context, EGLint engine) const override;
     gl::Version getMaxSupportedESVersion() const override;
 
   private:
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp
index b4366e7d621..27d29948b7f 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp
@@ -10,13 +10,14 @@
 
 #include "common/utilities.h"
 #include "compiler/translator/blocklayoutHLSL.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Program.h"
 #include "libANGLE/Shader.h"
+#include "libANGLE/VaryingPacking.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
-#include "libANGLE/VaryingPacking.h"
 
 using namespace gl;
 
@@ -26,7 +27,28 @@ namespace rx
 namespace
 {
 
-std::string HLSLComponentTypeString(GLenum componentType)
+// This class needs to match OutputHLSL::decorate
+class DecorateVariable final : angle::NonCopyable
+{
+  public:
+    explicit DecorateVariable(const std::string &str) : mName(str) {}
+    const std::string &getName() const { return mName; }
+
+  private:
+    const std::string &mName;
+};
+
+std::ostream &operator<<(std::ostream &o, const DecorateVariable &dv)
+{
+    if (dv.getName().compare(0, 3, "gl_") != 0)
+    {
+        o << "_";
+    }
+    o << dv.getName();
+    return o;
+}
+
+const char *HLSLComponentTypeString(GLenum componentType)
 {
     switch (componentType)
     {
@@ -44,12 +66,16 @@ std::string HLSLComponentTypeString(GLenum componentType)
     }
 }
 
-std::string HLSLComponentTypeString(GLenum componentType, int componentCount)
+void HLSLComponentTypeString(std::ostringstream &ostream, GLenum componentType, int componentCount)
 {
-    return HLSLComponentTypeString(componentType) + (componentCount > 1 ? Str(componentCount) : "");
+    ostream << HLSLComponentTypeString(componentType);
+    if (componentCount > 1)
+    {
+        ostream << componentCount;
+    }
 }
 
-std::string HLSLMatrixTypeString(GLenum type)
+const char *HLSLMatrixTypeString(GLenum type)
 {
     switch (type)
     {
@@ -77,15 +103,16 @@ std::string HLSLMatrixTypeString(GLenum type)
     }
 }
 
-std::string HLSLTypeString(GLenum type)
+void HLSLTypeString(std::ostringstream &ostream, GLenum type)
 {
     if (gl::IsMatrixType(type))
     {
-        return HLSLMatrixTypeString(type);
+        ostream << HLSLMatrixTypeString(type);
+        return;
     }
 
-    return HLSLComponentTypeString(gl::VariableComponentType(type),
-                                   gl::VariableComponentCount(type));
+    HLSLComponentTypeString(ostream, gl::VariableComponentType(type),
+                            gl::VariableComponentCount(type));
 }
 
 const PixelShaderOutputVariable *FindOutputAtLocation(
@@ -103,7 +130,7 @@ const PixelShaderOutputVariable *FindOutputAtLocation(
     return nullptr;
 }
 
-void WriteArrayString(std::stringstream &strstr, unsigned int i)
+void WriteArrayString(std::ostringstream &strstr, unsigned int i)
 {
     static_assert(GL_INVALID_INDEX == UINT_MAX,
                   "GL_INVALID_INDEX must be equal to the max unsigned int.");
@@ -132,8 +159,8 @@ std::string DynamicHLSL::generateVertexShaderForInputLayout(
     const InputLayout &inputLayout,
     const std::vector<sh::Attribute> &shaderAttributes) const
 {
-    std::stringstream structStream;
-    std::stringstream initStream;
+    std::ostringstream structStream;
+    std::ostringstream initStream;
 
     structStream << "struct VS_INPUT\n"
                  << "{\n";
@@ -191,13 +218,13 @@ std::string DynamicHLSL::generateVertexShaderForInputLayout(
                 }
                 else
                 {
-                    structStream << "    " << HLSLComponentTypeString(
-                                                  componentType,
-                                                  VariableComponentCount(shaderAttribute.type));
+                    structStream << "    ";
+                    HLSLComponentTypeString(structStream, componentType,
+                                            VariableComponentCount(shaderAttribute.type));
                 }
             }
 
-            structStream << " " << decorateVariable(shaderAttribute.name) << " : ";
+            structStream << " " << DecorateVariable(shaderAttribute.name) << " : ";
 
             if (shaderAttribute.name == "gl_InstanceID")
             {
@@ -216,7 +243,7 @@ std::string DynamicHLSL::generateVertexShaderForInputLayout(
             structStream << ";\n";
 
             // HLSL code for initialization
-            initStream << "    " << decorateVariable(shaderAttribute.name) << " = ";
+            initStream << "    " << DecorateVariable(shaderAttribute.name) << " = ";
 
             // Mismatched vertex attribute to vertex input may result in an undefined
             // data reinterpretation (eg for pure integer->float, float->pure integer)
@@ -224,11 +251,11 @@ std::string DynamicHLSL::generateVertexShaderForInputLayout(
             if (IsMatrixType(shaderAttribute.type) ||
                 (mRenderer->getVertexConversionType(vertexFormatType) & VERTEX_CONVERT_GPU) != 0)
             {
-                initStream << generateAttributeConversionHLSL(vertexFormatType, shaderAttribute);
+                GenerateAttributeConversionHLSL(vertexFormatType, shaderAttribute, initStream);
             }
             else
             {
-                initStream << "input." << decorateVariable(shaderAttribute.name);
+                initStream << "input." << DecorateVariable(shaderAttribute.name);
             }
 
             initStream << ";\n";
@@ -261,8 +288,8 @@ std::string DynamicHLSL::generatePixelShaderForOutputSignature(
     std::string targetSemantic = (shaderModel >= 4) ? "SV_TARGET" : "COLOR";
     std::string depthSemantic  = (shaderModel >= 4) ? "SV_Depth" : "DEPTH";
 
-    std::stringstream declarationStream;
-    std::stringstream copyStream;
+    std::ostringstream declarationStream;
+    std::ostringstream copyStream;
 
     declarationStream << "struct PS_OUTPUT\n"
                          "{\n";
@@ -289,8 +316,9 @@ std::string DynamicHLSL::generatePixelShaderForOutputSignature(
             // corresponding to unwritten variables are similarly undefined.
             if (outputVariable)
             {
-                declarationStream << "    " + HLSLTypeString(outputVariable->type) << " "
-                                  << outputVariable->name << " : " << targetSemantic
+                declarationStream << "    ";
+                HLSLTypeString(declarationStream, outputVariable->type);
+                declarationStream << " " << outputVariable->name << " : " << targetSemantic
                                   << static_cast<int>(layoutIndex) << ";\n";
 
                 copyStream << "    output." << outputVariable->name << " = "
@@ -325,7 +353,7 @@ std::string DynamicHLSL::generatePixelShaderForOutputSignature(
 void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking,
                                           const BuiltinInfo &builtins,
                                           bool programUsesPointSize,
-                                          std::stringstream &hlslStream) const
+                                          std::ostringstream &hlslStream) const
 {
     ASSERT(builtins.dxPosition.enabled);
     hlslStream << "{\n"
@@ -384,7 +412,7 @@ void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking,
         GLenum transposedType = gl::TransposeMatrixType(varying.type);
         GLenum componentType  = gl::VariableComponentType(transposedType);
         int columnCount       = gl::VariableColumnCount(transposedType);
-        hlslStream << HLSLComponentTypeString(componentType, columnCount);
+        HLSLComponentTypeString(hlslStream, componentType, columnCount);
         unsigned int semanticIndex = registerInfo.semanticIndex;
         hlslStream << " v" << semanticIndex << " : " << varyingSemantic << semanticIndex << ";\n";
     }
@@ -392,7 +420,7 @@ void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking,
     hlslStream << "};\n";
 }
 
-void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
+void DynamicHLSL::generateShaderLinkHLSL(const gl::Context *context,
                                          const gl::ProgramState &programData,
                                          const ProgramD3DMetadata &programMetadata,
                                          const VaryingPacking &varyingPacking,
@@ -402,8 +430,9 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
 {
     ASSERT(pixelHLSL->empty() && vertexHLSL->empty());
 
-    const gl::Shader *vertexShaderGL   = programData.getAttachedVertexShader();
-    const gl::Shader *fragmentShaderGL = programData.getAttachedFragmentShader();
+    const auto &data                   = context->getContextState();
+    gl::Shader *vertexShaderGL         = programData.getAttachedVertexShader();
+    gl::Shader *fragmentShaderGL       = programData.getAttachedFragmentShader();
     const ShaderD3D *fragmentShader    = GetImplAs<ShaderD3D>(fragmentShaderGL);
     const int shaderModel              = mRenderer->getMajorShaderModel();
 
@@ -417,8 +446,8 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
     // Validation done in the compiler
     ASSERT(!fragmentShader->usesFragColor() || !fragmentShader->usesFragData());
 
-    std::stringstream vertexStream;
-    vertexStream << vertexShaderGL->getTranslatedSource();
+    std::ostringstream vertexStream;
+    vertexStream << vertexShaderGL->getTranslatedSource(context);
 
     // Instanced PointSprite emulation requires additional entries originally generated in the
     // GeometryShader HLSL. These include pointsize clamp values.
@@ -518,10 +547,10 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
 
         if (packedVarying.isStructField())
         {
-            vertexStream << decorateVariable(packedVarying.parentStructName) << ".";
+            vertexStream << DecorateVariable(packedVarying.parentStructName) << ".";
         }
 
-        vertexStream << decorateVariable(varying.name);
+        vertexStream << DecorateVariable(varying.name);
 
         if (varying.isArray())
         {
@@ -585,8 +614,8 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
 
     const auto &pixelBuiltins = builtinsD3D[SHADER_PIXEL];
 
-    std::stringstream pixelStream;
-    pixelStream << fragmentShaderGL->getTranslatedSource();
+    std::ostringstream pixelStream;
+    pixelStream << fragmentShaderGL->getTranslatedSource(context);
     pixelStream << "struct PS_INPUT\n";
     generateVaryingLinkHLSL(varyingPacking, pixelBuiltins, builtinsD3D.usesPointSize(),
                             pixelStream);
@@ -712,20 +741,19 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
         const auto &varying = *packedVarying.varying;
         ASSERT(!varying.isBuiltIn() && !varying.isStruct());
 
-        // Don't reference VS-only transform feedback varyings in the PS.
-        // TODO: Consider updating the fragment shader's varyings with a parameter signaling that a
-        // varying is only used in the vertex shader in MergeVaryings
-        if (packedVarying.vertexOnly || (!varying.staticUse && !packedVarying.isStructField()))
+        // Don't reference VS-only transform feedback varyings in the PS. Note that we're relying on
+        // that the staticUse flag is set according to usage in the fragment shader.
+        if (packedVarying.vertexOnly || !varying.staticUse)
             continue;
 
         pixelStream << "    ";
 
         if (packedVarying.isStructField())
         {
-            pixelStream << decorateVariable(packedVarying.parentStructName) << ".";
+            pixelStream << DecorateVariable(packedVarying.parentStructName) << ".";
         }
 
-        pixelStream << decorateVariable(varying.name);
+        pixelStream << DecorateVariable(varying.name);
 
         if (varying.isArray())
         {
@@ -769,11 +797,12 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
     *pixelHLSL  = pixelStream.str();
 }
 
-std::string DynamicHLSL::generateComputeShaderLinkHLSL(const gl::ProgramState &programData) const
+std::string DynamicHLSL::generateComputeShaderLinkHLSL(const gl::Context *context,
+                                                       const gl::ProgramState &programData) const
 {
-    const gl::Shader *computeShaderGL = programData.getAttachedComputeShader();
+    gl::Shader *computeShaderGL = programData.getAttachedComputeShader();
     std::stringstream computeStream;
-    std::string translatedSource = computeShaderGL->getTranslatedSource();
+    std::string translatedSource = computeShaderGL->getTranslatedSource(context);
     computeStream << translatedSource;
 
     bool usesWorkGroupID = translatedSource.find("GL_USES_WORK_GROUP_ID") != std::string::npos;
@@ -811,7 +840,7 @@ std::string DynamicHLSL::generateComputeShaderLinkHLSL(const gl::ProgramState &p
 
     computeStream << "};\n\n";
 
-    const sh::WorkGroupSize &localSize = computeShaderGL->getWorkGroupSize();
+    const sh::WorkGroupSize &localSize = computeShaderGL->getWorkGroupSize(context);
     computeStream << "[numthreads(" << localSize[0] << ", " << localSize[1] << ", " << localSize[2]
                   << ")]\n";
 
@@ -847,7 +876,7 @@ std::string DynamicHLSL::generateGeometryShaderPreamble(const VaryingPacking &va
 {
     ASSERT(mRenderer->getMajorShaderModel() >= 4);
 
-    std::stringstream preambleStream;
+    std::ostringstream preambleStream;
 
     const auto &vertexBuiltins = builtinsD3D[SHADER_VERTEX];
 
@@ -1056,46 +1085,34 @@ std::string DynamicHLSL::generateGeometryShaderHLSL(gl::PrimitiveType primitiveT
     return shaderStream.str();
 }
 
-// This method needs to match OutputHLSL::decorate
-std::string DynamicHLSL::decorateVariable(const std::string &name)
+// static
+void DynamicHLSL::GenerateAttributeConversionHLSL(gl::VertexFormatType vertexFormatType,
+                                                  const sh::ShaderVariable &shaderAttrib,
+                                                  std::ostringstream &outStream)
 {
-    if (name.compare(0, 3, "gl_") != 0)
-    {
-        return "_" + name;
-    }
-
-    return name;
-}
-
-std::string DynamicHLSL::generateAttributeConversionHLSL(
-    gl::VertexFormatType vertexFormatType,
-    const sh::ShaderVariable &shaderAttrib) const
-{
-    const gl::VertexFormat &vertexFormat = gl::GetVertexFormatFromType(vertexFormatType);
-    std::string attribString             = "input." + decorateVariable(shaderAttrib.name);
-
     // Matrix
     if (IsMatrixType(shaderAttrib.type))
     {
-        return "transpose(" + attribString + ")";
+        outStream << "transpose(input." << DecorateVariable(shaderAttrib.name) << ")";
+        return;
     }
 
     GLenum shaderComponentType = VariableComponentType(shaderAttrib.type);
     int shaderComponentCount   = VariableComponentCount(shaderAttrib.type);
+    const gl::VertexFormat &vertexFormat = gl::GetVertexFormatFromType(vertexFormatType);
 
     // Perform integer to float conversion (if necessary)
-    bool requiresTypeConversion =
-        (shaderComponentType == GL_FLOAT && vertexFormat.type != GL_FLOAT);
-
-    if (requiresTypeConversion)
+    if (shaderComponentType == GL_FLOAT && vertexFormat.type != GL_FLOAT)
     {
         // TODO: normalization for 32-bit integer formats
         ASSERT(!vertexFormat.normalized && !vertexFormat.pureInteger);
-        return "float" + Str(shaderComponentCount) + "(" + attribString + ")";
+        outStream << "float" << shaderComponentCount << "(input."
+                  << DecorateVariable(shaderAttrib.name) << ")";
+        return;
     }
 
     // No conversion necessary
-    return attribString;
+    outStream << "input." << DecorateVariable(shaderAttrib.name);
 }
 
 void DynamicHLSL::getPixelShaderOutputKey(const gl::ContextState &data,
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.h
index 0972a62cc2d..4ab0626cc2c 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.h
@@ -117,14 +117,15 @@ class DynamicHLSL : angle::NonCopyable
         const std::vector<PixelShaderOutputVariable> &outputVariables,
         bool usesFragDepth,
         const std::vector<GLenum> &outputLayout) const;
-    void generateShaderLinkHLSL(const gl::ContextState &data,
+    void generateShaderLinkHLSL(const gl::Context *context,
                                 const gl::ProgramState &programData,
                                 const ProgramD3DMetadata &programMetadata,
                                 const gl::VaryingPacking &varyingPacking,
                                 const BuiltinVaryingsD3D &builtinsD3D,
                                 std::string *pixelHLSL,
                                 std::string *vertexHLSL) const;
-    std::string generateComputeShaderLinkHLSL(const gl::ProgramState &programData) const;
+    std::string generateComputeShaderLinkHLSL(const gl::Context *context,
+                                              const gl::ProgramState &programData) const;
 
     std::string generateGeometryShaderPreamble(const gl::VaryingPacking &varyingPacking,
                                                const BuiltinVaryingsD3D &builtinsD3D) const;
@@ -146,13 +147,11 @@ class DynamicHLSL : angle::NonCopyable
     void generateVaryingLinkHLSL(const gl::VaryingPacking &varyingPacking,
                                  const BuiltinInfo &builtins,
                                  bool programUsesPointSize,
-                                 std::stringstream &hlslStream) const;
+                                 std::ostringstream &hlslStream) const;
 
-    // Prepend an underscore
-    static std::string decorateVariable(const std::string &name);
-
-    std::string generateAttributeConversionHLSL(gl::VertexFormatType vertexFormatType,
-                                                const sh::ShaderVariable &shaderAttrib) const;
+    static void GenerateAttributeConversionHLSL(gl::VertexFormatType vertexFormatType,
+                                                const sh::ShaderVariable &shaderAttrib,
+                                                std::ostringstream &outStream);
 };
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.cpp
index caee47d7ec3..f78bf2b702f 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.cpp
@@ -39,26 +39,27 @@ EGLImageD3D::~EGLImageD3D()
 
 egl::Error EGLImageD3D::initialize()
 {
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
-gl::Error EGLImageD3D::orphan(egl::ImageSibling *sibling)
+gl::Error EGLImageD3D::orphan(const gl::Context *context, egl::ImageSibling *sibling)
 {
     if (sibling == mState.source.get())
     {
-        ANGLE_TRY(copyToLocalRendertarget());
+        ANGLE_TRY(copyToLocalRendertarget(context));
     }
 
     return gl::NoError();
 }
 
-gl::Error EGLImageD3D::getRenderTarget(RenderTargetD3D **outRT) const
+gl::Error EGLImageD3D::getRenderTarget(const gl::Context *context, RenderTargetD3D **outRT) const
 {
     if (mState.source.get())
     {
         ASSERT(!mRenderTarget);
         FramebufferAttachmentRenderTarget *rt = nullptr;
-        ANGLE_TRY(mState.source->getAttachmentRenderTarget(GL_NONE, mState.imageIndex, &rt));
+        ANGLE_TRY(
+            mState.source->getAttachmentRenderTarget(context, GL_NONE, mState.imageIndex, &rt));
         *outRT = static_cast<RenderTargetD3D *>(rt);
         return gl::NoError();
     }
@@ -70,13 +71,13 @@ gl::Error EGLImageD3D::getRenderTarget(RenderTargetD3D **outRT) const
     }
 }
 
-gl::Error EGLImageD3D::copyToLocalRendertarget()
+gl::Error EGLImageD3D::copyToLocalRendertarget(const gl::Context *context)
 {
     ASSERT(mState.source.get() != nullptr);
     ASSERT(mRenderTarget == nullptr);
 
     RenderTargetD3D *curRenderTarget = nullptr;
-    ANGLE_TRY(getRenderTarget(&curRenderTarget));
+    ANGLE_TRY(getRenderTarget(context, &curRenderTarget));
 
     // This only currently applies do D3D11, where it invalidates FBOs with this Image attached.
     curRenderTarget->signalDirty();
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.h
index 98e78a3baea..1ee79844263 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/EGLImageD3D.h
@@ -11,6 +11,11 @@
 
 #include "libANGLE/renderer/ImageImpl.h"
 
+namespace gl
+{
+class Context;
+}
+
 namespace egl
 {
 class AttributeMap;
@@ -35,12 +40,12 @@ class EGLImageD3D final : public ImageImpl
 
     egl::Error initialize() override;
 
-    gl::Error orphan(egl::ImageSibling *sibling) override;
+    gl::Error orphan(const gl::Context *context, egl::ImageSibling *sibling) override;
 
-    gl::Error getRenderTarget(RenderTargetD3D **outRT) const;
+    gl::Error getRenderTarget(const gl::Context *context, RenderTargetD3D **outRT) const;
 
   private:
-    gl::Error copyToLocalRendertarget();
+    gl::Error copyToLocalRendertarget(const gl::Context *context);
 
     RendererD3D *mRenderer;
     RenderTargetD3D *mRenderTarget;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.cpp
index 86653f64536..e1f9bc5dad7 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.cpp
@@ -9,6 +9,7 @@
 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
 
 #include "common/bitset_utils.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/Surface.h"
@@ -95,13 +96,13 @@ FramebufferD3D::~FramebufferD3D()
 {
 }
 
-gl::Error FramebufferD3D::clear(ContextImpl *context, GLbitfield mask)
+gl::Error FramebufferD3D::clear(const gl::Context *context, GLbitfield mask)
 {
     ClearParameters clearParams = GetClearParameters(context->getGLState(), mask);
     return clearImpl(context, clearParams);
 }
 
-gl::Error FramebufferD3D::clearBufferfv(ContextImpl *context,
+gl::Error FramebufferD3D::clearBufferfv(const gl::Context *context,
                                         GLenum buffer,
                                         GLint drawbuffer,
                                         const GLfloat *values)
@@ -128,7 +129,7 @@ gl::Error FramebufferD3D::clearBufferfv(ContextImpl *context,
     return clearImpl(context, clearParams);
 }
 
-gl::Error FramebufferD3D::clearBufferuiv(ContextImpl *context,
+gl::Error FramebufferD3D::clearBufferuiv(const gl::Context *context,
                                          GLenum buffer,
                                          GLint drawbuffer,
                                          const GLuint *values)
@@ -145,7 +146,7 @@ gl::Error FramebufferD3D::clearBufferuiv(ContextImpl *context,
     return clearImpl(context, clearParams);
 }
 
-gl::Error FramebufferD3D::clearBufferiv(ContextImpl *context,
+gl::Error FramebufferD3D::clearBufferiv(const gl::Context *context,
                                         GLenum buffer,
                                         GLint drawbuffer,
                                         const GLint *values)
@@ -172,7 +173,7 @@ gl::Error FramebufferD3D::clearBufferiv(ContextImpl *context,
     return clearImpl(context, clearParams);
 }
 
-gl::Error FramebufferD3D::clearBufferfi(ContextImpl *context,
+gl::Error FramebufferD3D::clearBufferfi(const gl::Context *context,
                                         GLenum buffer,
                                         GLint drawbuffer,
                                         GLfloat depth,
@@ -188,7 +189,7 @@ gl::Error FramebufferD3D::clearBufferfi(ContextImpl *context,
     return clearImpl(context, clearParams);
 }
 
-GLenum FramebufferD3D::getImplementationColorReadFormat() const
+GLenum FramebufferD3D::getImplementationColorReadFormat(const gl::Context *context) const
 {
     const gl::FramebufferAttachment *readAttachment = mState.getReadAttachment();
 
@@ -198,7 +199,7 @@ GLenum FramebufferD3D::getImplementationColorReadFormat() const
     }
 
     RenderTargetD3D *attachmentRenderTarget = nullptr;
-    gl::Error error = readAttachment->getRenderTarget(&attachmentRenderTarget);
+    gl::Error error = readAttachment->getRenderTarget(context, &attachmentRenderTarget);
     if (error.isError())
     {
         return GL_NONE;
@@ -211,7 +212,7 @@ GLenum FramebufferD3D::getImplementationColorReadFormat() const
     return implementationFormatInfo.getReadPixelsFormat();
 }
 
-GLenum FramebufferD3D::getImplementationColorReadType() const
+GLenum FramebufferD3D::getImplementationColorReadType(const gl::Context *context) const
 {
     const gl::FramebufferAttachment *readAttachment = mState.getReadAttachment();
 
@@ -221,7 +222,7 @@ GLenum FramebufferD3D::getImplementationColorReadType() const
     }
 
     RenderTargetD3D *attachmentRenderTarget = nullptr;
-    gl::Error error = readAttachment->getRenderTarget(&attachmentRenderTarget);
+    gl::Error error = readAttachment->getRenderTarget(context, &attachmentRenderTarget);
     if (error.isError())
     {
         return GL_NONE;
@@ -234,29 +235,41 @@ GLenum FramebufferD3D::getImplementationColorReadType() const
     return implementationFormatInfo.getReadPixelsType();
 }
 
-gl::Error FramebufferD3D::readPixels(ContextImpl *context,
-                                     const gl::Rectangle &area,
+gl::Error FramebufferD3D::readPixels(const gl::Context *context,
+                                     const gl::Rectangle &origArea,
                                      GLenum format,
                                      GLenum type,
                                      void *pixels) const
 {
+    // Clip read area to framebuffer.
+    const gl::Extents fbSize = getState().getReadAttachment()->getSize();
+    const gl::Rectangle fbRect(0, 0, fbSize.width, fbSize.height);
+    gl::Rectangle area;
+    if (!ClipRectangle(origArea, fbRect, &area))
+    {
+        // nothing to read
+        return gl::NoError();
+    }
+
     const gl::PixelPackState &packState = context->getGLState().getPackState();
 
     const gl::InternalFormat &sizedFormatInfo = gl::GetInternalFormatInfo(format, type);
 
     GLuint outputPitch = 0;
-    ANGLE_TRY_RESULT(
-        sizedFormatInfo.computeRowPitch(type, area.width, packState.alignment, packState.rowLength),
-        outputPitch);
+    ANGLE_TRY_RESULT(sizedFormatInfo.computeRowPitch(type, origArea.width, packState.alignment,
+                                                     packState.rowLength),
+                     outputPitch);
     GLuint outputSkipBytes = 0;
     ANGLE_TRY_RESULT(sizedFormatInfo.computeSkipBytes(outputPitch, 0, packState, false),
                      outputSkipBytes);
+    outputSkipBytes +=
+        (area.x - origArea.x) * sizedFormatInfo.pixelBytes + (area.y - origArea.y) * outputPitch;
 
-    return readPixelsImpl(area, format, type, outputPitch, packState,
+    return readPixelsImpl(context, area, format, type, outputPitch, packState,
                           reinterpret_cast<uint8_t *>(pixels) + outputSkipBytes);
 }
 
-gl::Error FramebufferD3D::blit(ContextImpl *context,
+gl::Error FramebufferD3D::blit(const gl::Context *context,
                                const gl::Rectangle &sourceArea,
                                const gl::Rectangle &destArea,
                                GLbitfield mask,
@@ -265,7 +278,7 @@ gl::Error FramebufferD3D::blit(ContextImpl *context,
     const auto &glState                      = context->getGLState();
     const gl::Framebuffer *sourceFramebuffer = glState.getReadFramebuffer();
     const gl::Rectangle *scissor = glState.isScissorTestEnabled() ? &glState.getScissor() : nullptr;
-    ANGLE_TRY(blitImpl(sourceArea, destArea, scissor, (mask & GL_COLOR_BUFFER_BIT) != 0,
+    ANGLE_TRY(blitImpl(context, sourceArea, destArea, scissor, (mask & GL_COLOR_BUFFER_BIT) != 0,
                        (mask & GL_DEPTH_BUFFER_BIT) != 0, (mask & GL_STENCIL_BUFFER_BIT) != 0,
                        filter, sourceFramebuffer));
 
@@ -297,14 +310,12 @@ bool FramebufferD3D::checkStatus() const
     return true;
 }
 
-void FramebufferD3D::syncState(ContextImpl *contextImpl,
+void FramebufferD3D::syncState(const gl::Context *context,
                                const gl::Framebuffer::DirtyBits &dirtyBits)
 {
-    bool invalidateColorAttachmentCache = false;
-
     if (!mColorAttachmentsForRender.valid())
     {
-        invalidateColorAttachmentCache = true;
+        return;
     }
 
     for (auto dirtyBit : dirtyBits)
@@ -313,13 +324,19 @@ void FramebufferD3D::syncState(ContextImpl *contextImpl,
              dirtyBit < gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_MAX) ||
             dirtyBit == gl::Framebuffer::DIRTY_BIT_DRAW_BUFFERS)
         {
-            invalidateColorAttachmentCache = true;
+            mColorAttachmentsForRender.reset();
         }
     }
+}
 
-    if (!invalidateColorAttachmentCache)
+const gl::AttachmentList &FramebufferD3D::getColorAttachmentsForRender(const gl::Context *context)
+{
+    gl::DrawBufferMask activeProgramOutputs =
+        context->getContextState().getState().getProgram()->getActiveOutputVariables();
+
+    if (mColorAttachmentsForRender.valid() && mCurrentActiveProgramOutputs == activeProgramOutputs)
     {
-        return;
+        return mColorAttachmentsForRender.value();
     }
 
     // Does not actually free memory
@@ -334,7 +351,8 @@ void FramebufferD3D::syncState(ContextImpl *contextImpl,
         GLenum drawBufferState                           = drawBufferStates[attachmentIndex];
         const gl::FramebufferAttachment &colorAttachment = colorAttachments[attachmentIndex];
 
-        if (colorAttachment.isAttached() && drawBufferState != GL_NONE)
+        if (colorAttachment.isAttached() && drawBufferState != GL_NONE &&
+            activeProgramOutputs[attachmentIndex])
         {
             ASSERT(drawBufferState == GL_BACK ||
                    drawBufferState == (GL_COLOR_ATTACHMENT0_EXT + attachmentIndex));
@@ -347,11 +365,8 @@ void FramebufferD3D::syncState(ContextImpl *contextImpl,
     }
 
     mColorAttachmentsForRender = std::move(colorAttachmentsForRender);
-}
+    mCurrentActiveProgramOutputs = activeProgramOutputs;
 
-const gl::AttachmentList &FramebufferD3D::getColorAttachmentsForRender() const
-{
-    ASSERT(mColorAttachmentsForRender.valid());
     return mColorAttachmentsForRender.value();
 }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.h
index 903b3febf72..ff0be310eed 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/FramebufferD3D.h
@@ -59,34 +59,34 @@ class FramebufferD3D : public FramebufferImpl
     FramebufferD3D(const gl::FramebufferState &data, RendererD3D *renderer);
     virtual ~FramebufferD3D();
 
-    gl::Error clear(ContextImpl *impl, GLbitfield mask) override;
-    gl::Error clearBufferfv(ContextImpl *impl,
+    gl::Error clear(const gl::Context *context, GLbitfield mask) override;
+    gl::Error clearBufferfv(const gl::Context *context,
                             GLenum buffer,
                             GLint drawbuffer,
                             const GLfloat *values) override;
-    gl::Error clearBufferuiv(ContextImpl *impl,
+    gl::Error clearBufferuiv(const gl::Context *context,
                              GLenum buffer,
                              GLint drawbuffer,
                              const GLuint *values) override;
-    gl::Error clearBufferiv(ContextImpl *impl,
+    gl::Error clearBufferiv(const gl::Context *context,
                             GLenum buffer,
                             GLint drawbuffer,
                             const GLint *values) override;
-    gl::Error clearBufferfi(ContextImpl *impl,
+    gl::Error clearBufferfi(const gl::Context *context,
                             GLenum buffer,
                             GLint drawbuffer,
                             GLfloat depth,
                             GLint stencil) override;
 
-    GLenum getImplementationColorReadFormat() const override;
-    GLenum getImplementationColorReadType() const override;
-    gl::Error readPixels(ContextImpl *impl,
+    GLenum getImplementationColorReadFormat(const gl::Context *context) const override;
+    GLenum getImplementationColorReadType(const gl::Context *context) const override;
+    gl::Error readPixels(const gl::Context *context,
                          const gl::Rectangle &area,
                          GLenum format,
                          GLenum type,
                          void *pixels) const override;
 
-    gl::Error blit(ContextImpl *impl,
+    gl::Error blit(const gl::Context *context,
                    const gl::Rectangle &sourceArea,
                    const gl::Rectangle &destArea,
                    GLbitfield mask,
@@ -94,23 +94,26 @@ class FramebufferD3D : public FramebufferImpl
 
     bool checkStatus() const override;
 
-    void syncState(ContextImpl *contextImpl, const gl::Framebuffer::DirtyBits &dirtyBits) override;
+    void syncState(const gl::Context *context,
+                   const gl::Framebuffer::DirtyBits &dirtyBits) override;
 
-    const gl::AttachmentList &getColorAttachmentsForRender() const;
+    const gl::AttachmentList &getColorAttachmentsForRender(const gl::Context *context);
 
     gl::Error getSamplePosition(size_t index, GLfloat *xy) const override;
 
   private:
-    virtual gl::Error clearImpl(ContextImpl *impl, const ClearParameters &clearParams) = 0;
+    virtual gl::Error clearImpl(const gl::Context *context, const ClearParameters &clearParams) = 0;
 
-    virtual gl::Error readPixelsImpl(const gl::Rectangle &area,
+    virtual gl::Error readPixelsImpl(const gl::Context *context,
+                                     const gl::Rectangle &area,
                                      GLenum format,
                                      GLenum type,
                                      size_t outputPitch,
                                      const gl::PixelPackState &pack,
                                      uint8_t *pixels) const = 0;
 
-    virtual gl::Error blitImpl(const gl::Rectangle &sourceArea,
+    virtual gl::Error blitImpl(const gl::Context *context,
+                               const gl::Rectangle &sourceArea,
                                const gl::Rectangle &destArea,
                                const gl::Rectangle *scissor,
                                bool blitRenderTarget,
@@ -123,6 +126,7 @@ class FramebufferD3D : public FramebufferImpl
 
     RendererD3D *mRenderer;
     Optional<gl::AttachmentList> mColorAttachmentsForRender;
+    gl::DrawBufferMask mCurrentActiveProgramOutputs;
 };
 }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/HLSLCompiler.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/HLSLCompiler.cpp
index 65ec0bd241c..3953100e3bd 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/HLSLCompiler.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/HLSLCompiler.cpp
@@ -137,7 +137,7 @@ gl::Error HLSLCompiler::ensureInitialized()
     if (!mD3DCompilerModule)
     {
         ERR() << "D3D compiler module not found.";
-        return gl::Error(GL_OUT_OF_MEMORY, "D3D compiler module not found.");
+        return gl::OutOfMemory() << "D3D compiler module not found.";
     }
 
     mD3DCompileFunc = reinterpret_cast<pD3DCompile>(GetProcAddress(mD3DCompilerModule, "D3DCompile"));
@@ -156,7 +156,7 @@ gl::Error HLSLCompiler::ensureInitialized()
 
     if (mD3DCompileFunc == nullptr)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Error finding D3DCompile entry point.");
+        return gl::OutOfMemory() << "Error finding D3DCompile entry point.";
     }
 
     mInitialized = true;
@@ -278,7 +278,8 @@ gl::Error HLSLCompiler::compileToBinary(gl::InfoLog &infoLog, const std::string
         if (result == E_OUTOFMEMORY)
         {
             *outCompiledBlob = nullptr;
-            return gl::Error(GL_OUT_OF_MEMORY, "HLSL compiler had an unexpected failure, result: 0x%X.", result);
+            return gl::OutOfMemory()
+                   << "HLSL compiler had an unexpected failure, " << gl::FmtHR(result);
         }
 
         infoLog << "Warning: D3D shader compilation failed with " << configs[i].name << " flags. ("
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/ImageD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/ImageD3D.h
index ff6036230da..9d559da7a2b 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/ImageD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/ImageD3D.h
@@ -17,6 +17,7 @@
 
 namespace gl
 {
+class Context;
 class Framebuffer;
 struct ImageIndex;
 struct Box;
@@ -51,34 +52,52 @@ class ImageD3D : angle::NonCopyable
 
     virtual bool redefine(GLenum target, GLenum internalformat, const gl::Extents &size, bool forceRelease) = 0;
 
-    virtual gl::Error loadData(const gl::Box &area,
+    virtual gl::Error loadData(const gl::Context *context,
+                               const gl::Box &area,
                                const gl::PixelUnpackState &unpack,
                                GLenum type,
                                const void *input,
                                bool applySkipImages) = 0;
-    virtual gl::Error loadCompressedData(const gl::Box &area, const void *input) = 0;
+    virtual gl::Error loadCompressedData(const gl::Context *context,
+                                         const gl::Box &area,
+                                         const void *input) = 0;
 
-    virtual gl::Error setManagedSurface2D(TextureStorage *storage, int level)
+    virtual gl::Error setManagedSurface2D(const gl::Context *context,
+                                          TextureStorage *storage,
+                                          int level)
     {
         return gl::NoError();
-    };
-    virtual gl::Error setManagedSurfaceCube(TextureStorage *storage, int face, int level)
+    }
+    virtual gl::Error setManagedSurfaceCube(const gl::Context *context,
+                                            TextureStorage *storage,
+                                            int face,
+                                            int level)
     {
         return gl::NoError();
-    };
-    virtual gl::Error setManagedSurface3D(TextureStorage *storage, int level)
+    }
+    virtual gl::Error setManagedSurface3D(const gl::Context *context,
+                                          TextureStorage *storage,
+                                          int level)
     {
         return gl::NoError();
-    };
-    virtual gl::Error setManagedSurface2DArray(TextureStorage *storage, int layer, int level)
+    }
+    virtual gl::Error setManagedSurface2DArray(const gl::Context *context,
+                                               TextureStorage *storage,
+                                               int layer,
+                                               int level)
     {
         return gl::NoError();
-    };
-    virtual gl::Error copyToStorage(TextureStorage *storage, const gl::ImageIndex &index, const gl::Box &region) = 0;
-
-    virtual gl::Error copyFromTexStorage(const gl::ImageIndex &imageIndex,
+    }
+    virtual gl::Error copyToStorage(const gl::Context *context,
+                                    TextureStorage *storage,
+                                    const gl::ImageIndex &index,
+                                    const gl::Box &region) = 0;
+
+    virtual gl::Error copyFromTexStorage(const gl::Context *context,
+                                         const gl::ImageIndex &imageIndex,
                                          TextureStorage *source) = 0;
-    virtual gl::Error copyFromFramebuffer(const gl::Offset &destOffset,
+    virtual gl::Error copyFromFramebuffer(const gl::Context *context,
+                                          const gl::Offset &destOffset,
                                           const gl::Rectangle &sourceArea,
                                           const gl::Framebuffer *source) = 0;
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexBuffer.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexBuffer.cpp
index e87097540a7..ae8dff4cb28 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexBuffer.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexBuffer.cpp
@@ -71,7 +71,8 @@ gl::Error IndexBufferInterface::mapBuffer(unsigned int size, void **outMappedMem
     // Protect against integer overflow
     if (mWritePosition + size < mWritePosition)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Mapping of internal index buffer would cause an integer overflow.");
+        return gl::OutOfMemory()
+               << "Mapping of internal index buffer would cause an integer overflow.";
     }
 
     gl::Error error = mIndexBuffer->mapBuffer(mWritePosition, size, outMappedMemory);
@@ -189,7 +190,7 @@ gl::Error StaticIndexBufferInterface::reserveBufferSpace(unsigned int size, GLen
     else
     {
         UNREACHABLE();
-        return gl::Error(GL_INVALID_OPERATION, "Internal static index buffers can't be resized");
+        return gl::InternalError() << "Internal static index buffers can't be resized";
     }
 }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexDataManager.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexDataManager.cpp
index 184b89cd3ce..47c68ec85b8 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexDataManager.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/IndexDataManager.cpp
@@ -92,9 +92,8 @@ gl::Error StreamInIndexBuffer(IndexBufferInterface *buffer,
 
     if (count > (std::numeric_limits<unsigned int>::max() >> dstTypeInfo.bytesShift))
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Reserving %u indices of %u bytes each exceeds the maximum buffer size.",
-                         count, dstTypeInfo.bytes);
+        return gl::OutOfMemory() << "Reserving " << count << " indices of " << dstTypeInfo.bytes
+                                 << " bytes each exceeds the maximum buffer size.";
     }
 
     unsigned int bufferSizeRequired = count << dstTypeInfo.bytesShift;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.cpp
index b8df596bdd1..c8cc0ca21b9 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.cpp
@@ -10,6 +10,7 @@
 
 #include "common/bitset_utils.h"
 #include "common/utilities.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/Program.h"
@@ -33,10 +34,11 @@ namespace rx
 namespace
 {
 
-gl::InputLayout GetDefaultInputLayoutFromShader(const gl::Shader *vertexShader)
+gl::InputLayout GetDefaultInputLayoutFromShader(const gl::Context *context,
+                                                gl::Shader *vertexShader)
 {
     gl::InputLayout defaultLayout;
-    for (const sh::Attribute &shaderAttr : vertexShader->getActiveAttributes())
+    for (const sh::Attribute &shaderAttr : vertexShader->getActiveAttributes(context))
     {
         if (shaderAttr.type != GL_NONE)
         {
@@ -329,7 +331,8 @@ int ProgramD3DMetadata::getRendererMajorShaderModel() const
 
 bool ProgramD3DMetadata::usesBroadcast(const gl::ContextState &data) const
 {
-    return (mFragmentShader->usesFragColor() && data.getClientMajorVersion() < 3);
+    return (mFragmentShader->usesFragColor() && mFragmentShader->usesMultipleRenderTargets() &&
+            data.getClientMajorVersion() < 3);
 }
 
 bool ProgramD3DMetadata::usesFragDepth() const
@@ -691,9 +694,9 @@ void ProgramD3D::updateSamplerMapping()
     }
 }
 
-LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
-                            gl::InfoLog &infoLog,
-                            gl::BinaryInputStream *stream)
+gl::LinkResult ProgramD3D::load(const gl::Context *context,
+                                gl::InfoLog &infoLog,
+                                gl::BinaryInputStream *stream)
 {
     // TODO(jmadill): Use Renderer from contextImpl.
 
@@ -956,7 +959,7 @@ LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
     return true;
 }
 
-gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
+void ProgramD3D::save(const gl::Context *context, gl::BinaryOutputStream *stream)
 {
     // Output the DeviceIdentifier before we output any shader code
     // When we load the binary again later, we can validate the device identifier before trying to
@@ -1120,8 +1123,6 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
     {
         stream->writeInt(0);
     }
-
-    return gl::NoError();
 }
 
 void ProgramD3D::setBinaryRetrievableHint(bool /* retrievable */)
@@ -1132,13 +1133,14 @@ void ProgramD3D::setSeparable(bool /* separable */)
 {
 }
 
-gl::Error ProgramD3D::getPixelExecutableForFramebuffer(const gl::Framebuffer *fbo,
+gl::Error ProgramD3D::getPixelExecutableForFramebuffer(const gl::Context *context,
+                                                       const gl::Framebuffer *fbo,
                                                        ShaderExecutableD3D **outExecutable)
 {
     mPixelShaderOutputFormatCache.clear();
 
-    const FramebufferD3D *fboD3D = GetImplAs<FramebufferD3D>(fbo);
-    const gl::AttachmentList &colorbuffers = fboD3D->getColorAttachmentsForRender();
+    FramebufferD3D *fboD3D                 = GetImplAs<FramebufferD3D>(fbo);
+    const gl::AttachmentList &colorbuffers = fboD3D->getColorAttachmentsForRender(context);
 
     for (size_t colorAttachment = 0; colorAttachment < colorbuffers.size(); ++colorAttachment)
     {
@@ -1308,7 +1310,7 @@ class ProgramD3D::GetExecutableTask : public Closure
 {
   public:
     GetExecutableTask(ProgramD3D *program)
-        : mProgram(program), mError(GL_NO_ERROR), mInfoLog(), mResult(nullptr)
+        : mProgram(program), mError(gl::NoError()), mInfoLog(), mResult(nullptr)
     {
     }
 
@@ -1330,17 +1332,23 @@ class ProgramD3D::GetExecutableTask : public Closure
 class ProgramD3D::GetVertexExecutableTask : public ProgramD3D::GetExecutableTask
 {
   public:
-    GetVertexExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}
+    GetVertexExecutableTask(ProgramD3D *program, const gl::Context *context)
+        : GetExecutableTask(program), mContext(context)
+    {
+    }
     gl::Error run() override
     {
         const auto &defaultInputLayout =
-            GetDefaultInputLayoutFromShader(mProgram->mState.getAttachedVertexShader());
+            GetDefaultInputLayoutFromShader(mContext, mProgram->mState.getAttachedVertexShader());
 
         ANGLE_TRY(
             mProgram->getVertexExecutableForInputLayout(defaultInputLayout, &mResult, &mInfoLog));
 
         return gl::NoError();
     }
+
+  private:
+    const gl::Context *mContext;
 };
 
 class ProgramD3D::GetPixelExecutableTask : public ProgramD3D::GetExecutableTask
@@ -1394,17 +1402,17 @@ gl::Error ProgramD3D::getComputeExecutable(ShaderExecutableD3D **outExecutable)
     return gl::NoError();
 }
 
-LinkResult ProgramD3D::compileProgramExecutables(const gl::ContextState &contextState,
-                                                 gl::InfoLog &infoLog)
+gl::LinkResult ProgramD3D::compileProgramExecutables(const gl::Context *context,
+                                                     gl::InfoLog &infoLog)
 {
     // Ensure the compiler is initialized to avoid race conditions.
     ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized());
 
     WorkerThreadPool *workerPool = mRenderer->getWorkerThreadPool();
 
-    GetVertexExecutableTask vertexTask(this);
+    GetVertexExecutableTask vertexTask(this, context);
     GetPixelExecutableTask pixelTask(this);
-    GetGeometryExecutableTask geometryTask(this, contextState);
+    GetGeometryExecutableTask geometryTask(this, context->getContextState());
 
     std::array<WaitableEvent, 3> waitEvents = {{workerPool->postWorkerTask(&vertexTask),
                                                 workerPool->postWorkerTask(&pixelTask),
@@ -1452,12 +1460,13 @@ LinkResult ProgramD3D::compileProgramExecutables(const gl::ContextState &context
             (!usesGeometryShader(GL_POINTS) || pointGS));
 }
 
-LinkResult ProgramD3D::compileComputeExecutable(gl::InfoLog &infoLog)
+gl::LinkResult ProgramD3D::compileComputeExecutable(const gl::Context *context,
+                                                    gl::InfoLog &infoLog)
 {
     // Ensure the compiler is initialized to avoid race conditions.
     ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized());
 
-    std::string computeShader = mDynamicHLSL->generateComputeShaderLinkHLSL(mState);
+    std::string computeShader = mDynamicHLSL->generateComputeShaderLinkHLSL(context, mState);
 
     ShaderExecutableD3D *computeExecutable = nullptr;
     ANGLE_TRY(mRenderer->compileToExecutable(infoLog, computeShader, SHADER_COMPUTE,
@@ -1479,22 +1488,22 @@ LinkResult ProgramD3D::compileComputeExecutable(gl::InfoLog &infoLog)
     return mComputeExecutable.get() != nullptr;
 }
 
-LinkResult ProgramD3D::link(ContextImpl *contextImpl,
-                            const gl::VaryingPacking &packing,
-                            gl::InfoLog &infoLog)
+gl::LinkResult ProgramD3D::link(const gl::Context *context,
+                                const gl::VaryingPacking &packing,
+                                gl::InfoLog &infoLog)
 {
-    const auto &data = contextImpl->getContextState();
+    const auto &data = context->getContextState();
 
     reset();
 
-    const gl::Shader *computeShader = mState.getAttachedComputeShader();
+    gl::Shader *computeShader = mState.getAttachedComputeShader();
     if (computeShader)
     {
         mSamplersCS.resize(data.getCaps().maxComputeTextureImageUnits);
 
-        defineUniformsAndAssignRegisters();
+        defineUniformsAndAssignRegisters(context);
 
-        LinkResult result = compileComputeExecutable(infoLog);
+        gl::LinkResult result = compileComputeExecutable(context, infoLog);
         if (result.isError())
         {
             infoLog << result.getError().getMessage();
@@ -1506,12 +1515,12 @@ LinkResult ProgramD3D::link(ContextImpl *contextImpl,
             return result;
         }
 
-        initUniformBlockInfo(computeShader);
+        initUniformBlockInfo(context, computeShader);
     }
     else
     {
-        const gl::Shader *vertexShader   = mState.getAttachedVertexShader();
-        const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
+        gl::Shader *vertexShader   = mState.getAttachedVertexShader();
+        gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
 
         const ShaderD3D *vertexShaderD3D   = GetImplAs<ShaderD3D>(vertexShader);
         const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(fragmentShader);
@@ -1544,16 +1553,17 @@ LinkResult ProgramD3D::link(ContextImpl *contextImpl,
         ProgramD3DMetadata metadata(mRenderer, vertexShaderD3D, fragmentShaderD3D);
         BuiltinVaryingsD3D builtins(metadata, packing);
 
-        mDynamicHLSL->generateShaderLinkHLSL(data, mState, metadata, packing, builtins, &mPixelHLSL,
-                                             &mVertexHLSL);
+        mDynamicHLSL->generateShaderLinkHLSL(context, mState, metadata, packing, builtins,
+                                             &mPixelHLSL, &mVertexHLSL);
 
         mUsesPointSize = vertexShaderD3D->usesPointSize();
         mDynamicHLSL->getPixelShaderOutputKey(data, mState, metadata, &mPixelShaderKey);
         mUsesFragDepth = metadata.usesFragDepth();
 
         // Cache if we use flat shading
-        mUsesFlatInterpolation = (FindFlatInterpolationVarying(fragmentShader->getVaryings()) ||
-                                  FindFlatInterpolationVarying(vertexShader->getVaryings()));
+        mUsesFlatInterpolation =
+            (FindFlatInterpolationVarying(fragmentShader->getVaryings(context)) ||
+             FindFlatInterpolationVarying(vertexShader->getVaryings(context)));
 
         if (mRenderer->getMajorShaderModel() >= 4)
         {
@@ -1561,13 +1571,13 @@ LinkResult ProgramD3D::link(ContextImpl *contextImpl,
                 mDynamicHLSL->generateGeometryShaderPreamble(packing, builtins);
         }
 
-        initAttribLocationsToD3DSemantic();
+        initAttribLocationsToD3DSemantic(context);
 
-        defineUniformsAndAssignRegisters();
+        defineUniformsAndAssignRegisters(context);
 
         gatherTransformFeedbackVaryings(packing, builtins[SHADER_VERTEX]);
 
-        LinkResult result = compileProgramExecutables(data, infoLog);
+        gl::LinkResult result = compileProgramExecutables(context, infoLog);
         if (result.isError())
         {
             infoLog << result.getError().getMessage();
@@ -1579,8 +1589,8 @@ LinkResult ProgramD3D::link(ContextImpl *contextImpl,
             return result;
         }
 
-        initUniformBlockInfo(vertexShader);
-        initUniformBlockInfo(fragmentShader);
+        initUniformBlockInfo(context, vertexShader);
+        initUniformBlockInfo(context, fragmentShader);
     }
 
     return true;
@@ -1592,9 +1602,9 @@ GLboolean ProgramD3D::validate(const gl::Caps & /*caps*/, gl::InfoLog * /*infoLo
     return GL_TRUE;
 }
 
-void ProgramD3D::initUniformBlockInfo(const gl::Shader *shader)
+void ProgramD3D::initUniformBlockInfo(const gl::Context *context, gl::Shader *shader)
 {
-    for (const sh::InterfaceBlock &interfaceBlock : shader->getInterfaceBlocks())
+    for (const sh::InterfaceBlock &interfaceBlock : shader->getInterfaceBlocks(context))
     {
         if (!interfaceBlock.staticUse && interfaceBlock.layout == sh::BLOCKLAYOUT_PACKED)
             continue;
@@ -1922,13 +1932,13 @@ void ProgramD3D::setUniformBlockBinding(GLuint /*uniformBlockIndex*/,
 {
 }
 
-void ProgramD3D::defineUniformsAndAssignRegisters()
+void ProgramD3D::defineUniformsAndAssignRegisters(const gl::Context *context)
 {
     D3DUniformMap uniformMap;
-    const gl::Shader *computeShader = mState.getAttachedComputeShader();
+    gl::Shader *computeShader = mState.getAttachedComputeShader();
     if (computeShader)
     {
-        for (const sh::Uniform &computeUniform : computeShader->getUniforms())
+        for (const sh::Uniform &computeUniform : computeShader->getUniforms(context))
         {
             if (computeUniform.staticUse)
             {
@@ -1938,8 +1948,8 @@ void ProgramD3D::defineUniformsAndAssignRegisters()
     }
     else
     {
-        const gl::Shader *vertexShader = mState.getAttachedVertexShader();
-        for (const sh::Uniform &vertexUniform : vertexShader->getUniforms())
+        gl::Shader *vertexShader = mState.getAttachedVertexShader();
+        for (const sh::Uniform &vertexUniform : vertexShader->getUniforms(context))
         {
             if (vertexUniform.staticUse)
             {
@@ -1947,8 +1957,8 @@ void ProgramD3D::defineUniformsAndAssignRegisters()
             }
         }
 
-        const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
-        for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms())
+        gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
+        for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms(context))
         {
             if (fragmentUniform.staticUse)
             {
@@ -2359,20 +2369,22 @@ unsigned int ProgramD3D::issueSerial()
     return mCurrentSerial++;
 }
 
-void ProgramD3D::initAttribLocationsToD3DSemantic()
+void ProgramD3D::initAttribLocationsToD3DSemantic(const gl::Context *context)
 {
-    const gl::Shader *vertexShader = mState.getAttachedVertexShader();
+    gl::Shader *vertexShader = mState.getAttachedVertexShader();
     ASSERT(vertexShader != nullptr);
 
     // Init semantic index
-    for (const sh::Attribute &attribute : mState.getAttributes())
+    int semanticIndex = 0;
+    for (const sh::Attribute &attribute : vertexShader->getActiveAttributes(context))
     {
-        int d3dSemantic = vertexShader->getSemanticIndex(attribute.name);
         int regCount    = gl::VariableRegisterCount(attribute.type);
+        GLuint location = mState.getAttributeLocation(attribute.name);
+        ASSERT(location != std::numeric_limits<GLuint>::max());
 
         for (int reg = 0; reg < regCount; ++reg)
         {
-            mAttribLocationToD3DSemantic[attribute.location + reg] = d3dSemantic + reg;
+            mAttribLocationToD3DSemantic[location + reg] = semanticIndex++;
         }
     }
 }
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.h
index 19b7dbfdd80..7f0a48bf8cb 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/ProgramD3D.h
@@ -158,14 +158,15 @@ class ProgramD3D : public ProgramImpl
     bool usesGeometryShader(GLenum drawMode) const;
     bool usesInstancedPointSpriteEmulation() const;
 
-    LinkResult load(const ContextImpl *contextImpl,
-                    gl::InfoLog &infoLog,
-                    gl::BinaryInputStream *stream) override;
-    gl::Error save(gl::BinaryOutputStream *stream) override;
+    gl::LinkResult load(const gl::Context *context,
+                        gl::InfoLog &infoLog,
+                        gl::BinaryInputStream *stream) override;
+    void save(const gl::Context *context, gl::BinaryOutputStream *stream) override;
     void setBinaryRetrievableHint(bool retrievable) override;
     void setSeparable(bool separable) override;
 
-    gl::Error getPixelExecutableForFramebuffer(const gl::Framebuffer *fbo,
+    gl::Error getPixelExecutableForFramebuffer(const gl::Context *context,
+                                               const gl::Framebuffer *fbo,
                                                ShaderExecutableD3D **outExectuable);
     gl::Error getPixelExecutableForOutputLayout(const std::vector<GLenum> &outputLayout,
                                                 ShaderExecutableD3D **outExectuable,
@@ -178,9 +179,9 @@ class ProgramD3D : public ProgramImpl
                                                     ShaderExecutableD3D **outExecutable,
                                                     gl::InfoLog *infoLog);
     gl::Error getComputeExecutable(ShaderExecutableD3D **outExecutable);
-    LinkResult link(ContextImpl *contextImpl,
-                    const gl::VaryingPacking &packing,
-                    gl::InfoLog &infoLog) override;
+    gl::LinkResult link(const gl::Context *context,
+                        const gl::VaryingPacking &packing,
+                        gl::InfoLog &infoLog) override;
     GLboolean validate(const gl::Caps &caps, gl::InfoLog *infoLog) override;
 
     bool getUniformBlockSize(const std::string &blockName, size_t *sizeOut) const override;
@@ -248,18 +249,9 @@ class ProgramD3D : public ProgramImpl
 
     void setUniformBlockBinding(GLuint uniformBlockIndex, GLuint uniformBlockBinding) override;
 
-    const UniformStorageD3D &getVertexUniformStorage() const
-    {
-        return *mVertexUniformStorage.get();
-    }
-    const UniformStorageD3D &getFragmentUniformStorage() const
-    {
-        return *mFragmentUniformStorage.get();
-    }
-    const UniformStorageD3D &getComputeUniformStorage() const
-    {
-        return *mComputeUniformStorage.get();
-    }
+    UniformStorageD3D &getVertexUniformStorage() const { return *mVertexUniformStorage.get(); }
+    UniformStorageD3D &getFragmentUniformStorage() const { return *mFragmentUniformStorage.get(); }
+    UniformStorageD3D &getComputeUniformStorage() const { return *mComputeUniformStorage.get(); }
 
     unsigned int getSerial() const;
 
@@ -345,7 +337,7 @@ class ProgramD3D : public ProgramImpl
 
     typedef std::map<std::string, D3DUniform *> D3DUniformMap;
 
-    void defineUniformsAndAssignRegisters();
+    void defineUniformsAndAssignRegisters(const gl::Context *context);
     void defineUniformBase(const gl::Shader *shader,
                            const sh::Uniform &uniform,
                            D3DUniformMap *uniformMap);
@@ -373,20 +365,20 @@ class ProgramD3D : public ProgramImpl
                             const GLfloat *value,
                             GLenum targetUniformType);
 
-    LinkResult compileProgramExecutables(const gl::ContextState &data, gl::InfoLog &infoLog);
-    LinkResult compileComputeExecutable(gl::InfoLog &infoLog);
+    gl::LinkResult compileProgramExecutables(const gl::Context *context, gl::InfoLog &infoLog);
+    gl::LinkResult compileComputeExecutable(const gl::Context *context, gl::InfoLog &infoLog);
 
     void gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyings,
                                          const BuiltinInfo &builtins);
     D3DUniform *getD3DUniformByName(const std::string &name);
     D3DUniform *getD3DUniformFromLocation(GLint location);
 
-    void initAttribLocationsToD3DSemantic();
+    void initAttribLocationsToD3DSemantic(const gl::Context *context);
 
     void reset();
     void ensureUniformBlocksInitialized();
 
-    void initUniformBlockInfo(const gl::Shader *shader);
+    void initUniformBlockInfo(const gl::Context *context, gl::Shader *shader);
     size_t getUniformBlockInfo(const sh::InterfaceBlock &interfaceBlock);
 
     RendererD3D *mRenderer;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.cpp
index 2df0f744328..774f3e40b6b 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.cpp
@@ -51,8 +51,9 @@ gl::Error RenderbufferD3D::setStorageMultisample(size_t samples, GLenum internal
     const gl::TextureCaps &formatCaps = mRenderer->getNativeTextureCaps().get(creationFormat);
     if (samples > formatCaps.getMaxSamples())
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Renderbuffer format does not support %u samples, %u is the maximum.",
-                         samples, formatCaps.getMaxSamples());
+        return gl::OutOfMemory() << "Renderbuffer format does not support " << samples
+                                 << " samples, " << formatCaps.getMaxSamples()
+                                 << " is the maximum.";
     }
 
     RenderTargetD3D *newRT = nullptr;
@@ -74,11 +75,12 @@ gl::Error RenderbufferD3D::setStorageEGLImageTarget(egl::Image *image)
     return gl::NoError();
 }
 
-gl::Error RenderbufferD3D::getRenderTarget(RenderTargetD3D **outRenderTarget)
+gl::Error RenderbufferD3D::getRenderTarget(const gl::Context *context,
+                                           RenderTargetD3D **outRenderTarget)
 {
     if (mImage)
     {
-        return mImage->getRenderTarget(outRenderTarget);
+        return mImage->getRenderTarget(context, outRenderTarget);
     }
     else
     {
@@ -87,11 +89,12 @@ gl::Error RenderbufferD3D::getRenderTarget(RenderTargetD3D **outRenderTarget)
     }
 }
 
-gl::Error RenderbufferD3D::getAttachmentRenderTarget(GLenum /*binding*/,
+gl::Error RenderbufferD3D::getAttachmentRenderTarget(const gl::Context *context,
+                                                     GLenum /*binding*/,
                                                      const gl::ImageIndex & /*imageIndex*/,
                                                      FramebufferAttachmentRenderTarget **rtOut)
 {
-    return getRenderTarget(reinterpret_cast<RenderTargetD3D **>(rtOut));
+    return getRenderTarget(context, reinterpret_cast<RenderTargetD3D **>(rtOut));
 }
 
-}
+}  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.h
index 15fd5835935..c28c37e94fc 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RenderbufferD3D.h
@@ -34,8 +34,9 @@ class RenderbufferD3D : public RenderbufferImpl
                                     size_t height) override;
     gl::Error setStorageEGLImageTarget(egl::Image *image) override;
 
-    gl::Error getRenderTarget(RenderTargetD3D **outRenderTarget);
-    gl::Error getAttachmentRenderTarget(GLenum binding,
+    gl::Error getRenderTarget(const gl::Context *context, RenderTargetD3D **outRenderTarget);
+    gl::Error getAttachmentRenderTarget(const gl::Context *context,
+                                        GLenum binding,
                                         const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp
index e0cb86d2876..9f624b63af3 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp
@@ -11,13 +11,16 @@
 #include "common/MemoryBuffer.h"
 #include "common/debug.h"
 #include "common/utilities.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
+#include "libANGLE/ImageIndex.h"
 #include "libANGLE/ResourceManager.h"
 #include "libANGLE/State.h"
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/ContextImpl.h"
 #include "libANGLE/renderer/TextureImpl.h"
 #include "libANGLE/renderer/d3d/BufferD3D.h"
 #include "libANGLE/renderer/d3d/DeviceD3D.h"
@@ -25,6 +28,7 @@
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
 #include "libANGLE/renderer/d3d/SamplerD3D.h"
+#include "libANGLE/renderer/d3d/TextureD3D.h"
 
 namespace rx
 {
@@ -49,60 +53,23 @@ void RendererD3D::cleanup()
 {
     for (auto &incompleteTexture : mIncompleteTextures)
     {
-        incompleteTexture.second.set(nullptr);
+        incompleteTexture.second->onDestroy(mDisplay->getProxyContext());
+        incompleteTexture.second.set(mDisplay->getProxyContext(), nullptr);
     }
     mIncompleteTextures.clear();
 }
 
-unsigned int RendererD3D::GetBlendSampleMask(const gl::ContextState &data, int samples)
-{
-    const auto &glState = data.getState();
-    unsigned int mask   = 0;
-    if (glState.isSampleCoverageEnabled())
-    {
-        GLfloat coverageValue = glState.getSampleCoverageValue();
-        if (coverageValue != 0)
-        {
-            float threshold = 0.5f;
-
-            for (int i = 0; i < samples; ++i)
-            {
-                mask <<= 1;
-
-                if ((i + 1) * coverageValue >= threshold)
-                {
-                    threshold += 1.0f;
-                    mask |= 1;
-                }
-            }
-        }
-
-        bool coverageInvert = glState.getSampleCoverageInvert();
-        if (coverageInvert)
-        {
-            mask = ~mask;
-        }
-    }
-    else
-    {
-        mask = 0xFFFFFFFF;
-    }
-
-    return mask;
-}
-
 // For each Direct3D sampler of either the pixel or vertex stage,
 // looks up the corresponding OpenGL texture image unit and texture type,
 // and sets the texture and its addressing/filtering state (or NULL when inactive).
 // Sampler mapping needs to be up-to-date on the program object before this is called.
-gl::Error RendererD3D::applyTextures(GLImplFactory *implFactory,
-                                     const gl::ContextState &data,
+gl::Error RendererD3D::applyTextures(const gl::Context *context,
                                      gl::SamplerType shaderType,
                                      const FramebufferTextureArray &framebufferTextures,
                                      size_t framebufferTextureCount)
 {
-    const auto &glState    = data.getState();
-    const auto &caps       = data.getCaps();
+    const auto &glState    = context->getGLState();
+    const auto &caps       = context->getCaps();
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
 
     ASSERT(!programD3D->isSamplerMappingDirty());
@@ -125,49 +92,52 @@ gl::Error RendererD3D::applyTextures(GLImplFactory *implFactory,
                 samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState();
 
             // TODO: std::binary_search may become unavailable using older versions of GCC
-            if (texture->getTextureState().isSamplerComplete(samplerState, data) &&
+            if (texture->getTextureState().isSamplerComplete(samplerState,
+                                                             context->getContextState()) &&
                 !std::binary_search(framebufferTextures.begin(),
                                     framebufferTextures.begin() + framebufferTextureCount, texture))
             {
-                ANGLE_TRY(setSamplerState(shaderType, samplerIndex, texture, samplerState));
-                ANGLE_TRY(setTexture(shaderType, samplerIndex, texture));
+                ANGLE_TRY(
+                    setSamplerState(context, shaderType, samplerIndex, texture, samplerState));
+                ANGLE_TRY(setTexture(context, shaderType, samplerIndex, texture));
             }
             else
             {
                 // Texture is not sampler complete or it is in use by the framebuffer.  Bind the
                 // incomplete texture.
-                gl::Texture *incompleteTexture = getIncompleteTexture(implFactory, textureType);
+                gl::Texture *incompleteTexture = getIncompleteTexture(context, textureType);
 
-                ANGLE_TRY(setSamplerState(shaderType, samplerIndex, incompleteTexture,
+                ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, incompleteTexture,
                                           incompleteTexture->getSamplerState()));
-                ANGLE_TRY(setTexture(shaderType, samplerIndex, incompleteTexture));
+                ANGLE_TRY(setTexture(context, shaderType, samplerIndex, incompleteTexture));
             }
         }
         else
         {
             // No texture bound to this slot even though it is used by the shader, bind a NULL
             // texture
-            ANGLE_TRY(setTexture(shaderType, samplerIndex, nullptr));
+            ANGLE_TRY(setTexture(context, shaderType, samplerIndex, nullptr));
         }
     }
 
     // Set all the remaining textures to NULL
     size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? caps.maxTextureImageUnits
                                                             : caps.maxVertexTextureImageUnits;
-    clearTextures(shaderType, samplerRange, samplerCount);
+    clearTextures(context, shaderType, samplerRange, samplerCount);
 
     return gl::NoError();
 }
 
-gl::Error RendererD3D::applyTextures(GLImplFactory *implFactory, const gl::ContextState &data)
+gl::Error RendererD3D::applyTextures(const gl::Context *context)
 {
     FramebufferTextureArray framebufferTextures;
-    size_t framebufferSerialCount = getBoundFramebufferTextures(data, &framebufferTextures);
+    size_t framebufferSerialCount =
+        getBoundFramebufferTextures(context->getContextState(), &framebufferTextures);
 
-    ANGLE_TRY(applyTextures(implFactory, data, gl::SAMPLER_VERTEX, framebufferTextures,
-                            framebufferSerialCount));
-    ANGLE_TRY(applyTextures(implFactory, data, gl::SAMPLER_PIXEL, framebufferTextures,
-                            framebufferSerialCount));
+    ANGLE_TRY(
+        applyTextures(context, gl::SAMPLER_VERTEX, framebufferTextures, framebufferSerialCount));
+    ANGLE_TRY(
+        applyTextures(context, gl::SAMPLER_PIXEL, framebufferTextures, framebufferSerialCount));
     return gl::NoError();
 }
 
@@ -206,7 +176,8 @@ gl::Error RendererD3D::markTransformFeedbackUsage(const gl::ContextState &data)
     const gl::TransformFeedback *transformFeedback = data.getState().getCurrentTransformFeedback();
     for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++)
     {
-        const OffsetBindingPointer<gl::Buffer> &binding = transformFeedback->getIndexedBuffer(i);
+        const gl::OffsetBindingPointer<gl::Buffer> &binding =
+            transformFeedback->getIndexedBuffer(i);
         if (binding.get() != nullptr)
         {
             BufferD3D *bufferD3D = GetImplAs<BufferD3D>(binding.get());
@@ -244,10 +215,11 @@ size_t RendererD3D::getBoundFramebufferTextures(const gl::ContextState &data,
     return textureCount;
 }
 
-gl::Texture *RendererD3D::getIncompleteTexture(GLImplFactory *implFactory, GLenum type)
+gl::Texture *RendererD3D::getIncompleteTexture(const gl::Context *context, GLenum type)
 {
     if (mIncompleteTextures.find(type) == mIncompleteTextures.end())
     {
+        GLImplFactory *implFactory = context->getImplementation();
         const GLubyte color[] = {0, 0, 0, 255};
         const gl::Extents colorSize(1, 1, 1);
         const gl::PixelUnpackState unpack(1, 0);
@@ -259,7 +231,14 @@ gl::Texture *RendererD3D::getIncompleteTexture(GLImplFactory *implFactory, GLenu
         // Skip the API layer to avoid needing to pass the Context and mess with dirty bits.
         gl::Texture *t =
             new gl::Texture(implFactory, std::numeric_limits<GLuint>::max(), createType);
-        t->setStorage(nullptr, createType, 1, GL_RGBA8, colorSize);
+        if (createType == GL_TEXTURE_2D_MULTISAMPLE)
+        {
+            t->setStorageMultisample(nullptr, createType, 1, GL_RGBA8, colorSize, true);
+        }
+        else
+        {
+            t->setStorage(nullptr, createType, 1, GL_RGBA8, colorSize);
+        }
         if (type == GL_TEXTURE_CUBE_MAP)
         {
             for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
@@ -269,12 +248,18 @@ gl::Texture *RendererD3D::getIncompleteTexture(GLImplFactory *implFactory, GLenu
                                                     GL_UNSIGNED_BYTE, unpack, color);
             }
         }
+        else if (type == GL_TEXTURE_2D_MULTISAMPLE)
+        {
+            gl::ColorF clearValue(0, 0, 0, 1);
+            gl::ImageIndex index = gl::ImageIndex::Make2DMultisample();
+            GetImplAs<TextureD3D>(t)->clearLevel(context, index, clearValue);
+        }
         else
         {
             t->getImplementation()->setSubImage(nullptr, createType, 0, area, GL_RGBA8,
                                                 GL_UNSIGNED_BYTE, unpack, color);
         }
-        mIncompleteTextures[type].set(t);
+        mIncompleteTextures[type].set(context, t);
     }
 
     return mIncompleteTextures[type].get();
@@ -380,4 +365,46 @@ angle::WorkerThreadPool *RendererD3D::getWorkerThreadPool()
     return &mWorkerThreadPool;
 }
 
+bool RendererD3D::isRobustResourceInitEnabled() const
+{
+    return mDisplay->isRobustResourceInitEnabled();
+}
+
+unsigned int GetBlendSampleMask(const gl::ContextState &data, int samples)
+{
+    const auto &glState = data.getState();
+    unsigned int mask   = 0;
+    if (glState.isSampleCoverageEnabled())
+    {
+        GLfloat coverageValue = glState.getSampleCoverageValue();
+        if (coverageValue != 0)
+        {
+            float threshold = 0.5f;
+
+            for (int i = 0; i < samples; ++i)
+            {
+                mask <<= 1;
+
+                if ((i + 1) * coverageValue >= threshold)
+                {
+                    threshold += 1.0f;
+                    mask |= 1;
+                }
+            }
+        }
+
+        bool coverageInvert = glState.getSampleCoverageInvert();
+        if (coverageInvert)
+        {
+            mask = ~mask;
+        }
+    }
+    else
+    {
+        mask = 0xFFFFFFFF;
+    }
+
+    return mask;
+}
+
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.h
index 1e65249152a..a4edbdc36a1 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/RendererD3D.h
@@ -11,15 +11,16 @@
 
 #include <array>
 
-#include "common/debug.h"
+#include "common/Color.h"
 #include "common/MemoryBuffer.h"
+#include "common/debug.h"
 #include "libANGLE/ContextState.h"
 #include "libANGLE/Device.h"
+#include "libANGLE/Version.h"
+#include "libANGLE/WorkerThread.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
 #include "libANGLE/renderer/d3d/formatutilsD3D.h"
-#include "libANGLE/Version.h"
-#include "libANGLE/WorkerThread.h"
 #include "platform/WorkaroundsD3D.h"
 
 namespace egl
@@ -146,8 +147,15 @@ class RendererD3D : public BufferFactoryD3D
                                            HANDLE shareHandle,
                                            const egl::AttributeMap &attribs) const = 0;
 
-    virtual gl::Error setSamplerState(gl::SamplerType type, int index, gl::Texture *texture, const gl::SamplerState &sampler) = 0;
-    virtual gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture) = 0;
+    virtual gl::Error setSamplerState(const gl::Context *context,
+                                      gl::SamplerType type,
+                                      int index,
+                                      gl::Texture *texture,
+                                      const gl::SamplerState &sampler) = 0;
+    virtual gl::Error setTexture(const gl::Context *context,
+                                 gl::SamplerType type,
+                                 int index,
+                                 gl::Texture *texture) = 0;
 
     virtual gl::Error setUniformBuffers(const gl::ContextState &data,
                                         const std::vector<GLint> &vertexUniformBuffers,
@@ -165,16 +173,38 @@ class RendererD3D : public BufferFactoryD3D
     const angle::WorkaroundsD3D &getWorkarounds() const;
 
     // Pixel operations
-    virtual gl::Error copyImage2D(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                 const gl::Offset &destOffset, TextureStorage *storage, GLint level) = 0;
-    virtual gl::Error copyImageCube(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                    const gl::Offset &destOffset, TextureStorage *storage, GLenum target, GLint level) = 0;
-    virtual gl::Error copyImage3D(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                  const gl::Offset &destOffset, TextureStorage *storage, GLint level) = 0;
-    virtual gl::Error copyImage2DArray(const gl::Framebuffer *framebuffer, const gl::Rectangle &sourceRect, GLenum destFormat,
-                                       const gl::Offset &destOffset, TextureStorage *storage, GLint level) = 0;
-
-    virtual gl::Error copyTexture(const gl::Texture *source,
+    virtual gl::Error copyImage2D(const gl::Context *context,
+                                  const gl::Framebuffer *framebuffer,
+                                  const gl::Rectangle &sourceRect,
+                                  GLenum destFormat,
+                                  const gl::Offset &destOffset,
+                                  TextureStorage *storage,
+                                  GLint level) = 0;
+    virtual gl::Error copyImageCube(const gl::Context *context,
+                                    const gl::Framebuffer *framebuffer,
+                                    const gl::Rectangle &sourceRect,
+                                    GLenum destFormat,
+                                    const gl::Offset &destOffset,
+                                    TextureStorage *storage,
+                                    GLenum target,
+                                    GLint level) = 0;
+    virtual gl::Error copyImage3D(const gl::Context *context,
+                                  const gl::Framebuffer *framebuffer,
+                                  const gl::Rectangle &sourceRect,
+                                  GLenum destFormat,
+                                  const gl::Offset &destOffset,
+                                  TextureStorage *storage,
+                                  GLint level) = 0;
+    virtual gl::Error copyImage2DArray(const gl::Context *context,
+                                       const gl::Framebuffer *framebuffer,
+                                       const gl::Rectangle &sourceRect,
+                                       GLenum destFormat,
+                                       const gl::Offset &destOffset,
+                                       TextureStorage *storage,
+                                       GLint level) = 0;
+
+    virtual gl::Error copyTexture(const gl::Context *context,
+                                  const gl::Texture *source,
                                   GLint sourceLevel,
                                   const gl::Rectangle &sourceRect,
                                   GLenum destFormat,
@@ -185,7 +215,8 @@ class RendererD3D : public BufferFactoryD3D
                                   bool unpackFlipY,
                                   bool unpackPremultiplyAlpha,
                                   bool unpackUnmultiplyAlpha) = 0;
-    virtual gl::Error copyCompressedTexture(const gl::Texture *source,
+    virtual gl::Error copyCompressedTexture(const gl::Context *context,
+                                            const gl::Texture *source,
                                             GLint sourceLevel,
                                             TextureStorage *storage,
                                             GLint destLevel) = 0;
@@ -195,7 +226,7 @@ class RendererD3D : public BufferFactoryD3D
     virtual gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) = 0;
 
     // Shader operations
-    virtual gl::Error loadExecutable(const void *function,
+    virtual gl::Error loadExecutable(const uint8_t *function,
                                      size_t length,
                                      ShaderType type,
                                      const std::vector<D3DVarying> &streamOutVaryings,
@@ -214,9 +245,20 @@ class RendererD3D : public BufferFactoryD3D
 
     // Image operations
     virtual ImageD3D *createImage() = 0;
-    virtual gl::Error generateMipmap(ImageD3D *dest, ImageD3D *source) = 0;
-    virtual gl::Error generateMipmapUsingD3D(TextureStorage *storage,
+    virtual gl::Error generateMipmap(const gl::Context *context,
+                                     ImageD3D *dest,
+                                     ImageD3D *source) = 0;
+    virtual gl::Error generateMipmapUsingD3D(const gl::Context *context,
+                                             TextureStorage *storage,
                                              const gl::TextureState &textureState) = 0;
+    virtual gl::Error copyImage(const gl::Context *context,
+                                ImageD3D *dest,
+                                ImageD3D *source,
+                                const gl::Rectangle &sourceRect,
+                                const gl::Offset &destOffset,
+                                bool unpackFlipY,
+                                bool unpackPremultiplyAlpha,
+                                bool unpackUnmultiplyAlpha)                 = 0;
     virtual TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain) = 0;
     virtual TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage,
                                                          RenderTargetD3D *renderTargetD3D) = 0;
@@ -227,11 +269,22 @@ class RendererD3D : public BufferFactoryD3D
     virtual TextureStorage *createTextureStorageCube(GLenum internalformat, bool renderTarget, int size, int levels, bool hintLevelZeroOnly) = 0;
     virtual TextureStorage *createTextureStorage3D(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels) = 0;
     virtual TextureStorage *createTextureStorage2DArray(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels) = 0;
+    virtual TextureStorage *createTextureStorage2DMultisample(GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height,
+                                                              int levels,
+                                                              int samples,
+                                                              GLboolean fixedSampleLocations) = 0;
 
     // Buffer-to-texture and Texture-to-buffer copies
     virtual bool supportsFastCopyBufferToTexture(GLenum internalFormat) const = 0;
-    virtual gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
-                                              GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea) = 0;
+    virtual gl::Error fastCopyBufferToTexture(const gl::Context *context,
+                                              const gl::PixelUnpackState &unpack,
+                                              unsigned int offset,
+                                              RenderTargetD3D *destRenderTarget,
+                                              GLenum destinationFormat,
+                                              GLenum sourcePixelsType,
+                                              const gl::Box &destArea) = 0;
 
     // Device lost
     GLenum getResetStatus();
@@ -249,7 +302,13 @@ class RendererD3D : public BufferFactoryD3D
     GLint64 getTimestamp();
 
     // In D3D11, faster than calling setTexture a jillion times
-    virtual gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) = 0;
+    virtual gl::Error clearTextures(const gl::Context *context,
+                                    gl::SamplerType samplerType,
+                                    size_t rangeStart,
+                                    size_t rangeEnd) = 0;
+
+    virtual gl::Error clearRenderTarget(RenderTargetD3D *renderTarget,
+                                        const gl::ColorF &clearValues) = 0;
 
     virtual egl::Error getEGLDevice(DeviceImpl **device) = 0;
 
@@ -275,6 +334,8 @@ class RendererD3D : public BufferFactoryD3D
     virtual gl::Error applyComputeUniforms(const ProgramD3D &programD3D,
                                            const std::vector<D3DUniform *> &uniformArray) = 0;
 
+    bool isRobustResourceInitEnabled() const;
+
   protected:
     virtual bool getLUID(LUID *adapterLuid) const = 0;
     virtual void generateCaps(gl::Caps *outCaps,
@@ -284,10 +345,9 @@ class RendererD3D : public BufferFactoryD3D
 
     void cleanup();
 
-    static unsigned int GetBlendSampleMask(const gl::ContextState &data, int samples);
     // dirtyPointer is a special value that will make the comparison with any valid pointer fail and force the renderer to re-apply the state.
 
-    gl::Error applyTextures(GLImplFactory *implFactory, const gl::ContextState &data);
+    gl::Error applyTextures(const gl::Context *context);
     bool skipDraw(const gl::ContextState &data, GLenum drawMode);
     gl::Error markTransformFeedbackUsage(const gl::ContextState &data);
 
@@ -300,15 +360,14 @@ class RendererD3D : public BufferFactoryD3D
 
     typedef std::array<gl::Texture*, gl::IMPLEMENTATION_MAX_FRAMEBUFFER_ATTACHMENTS> FramebufferTextureArray;
 
-    gl::Error applyTextures(GLImplFactory *implFactory,
-                            const gl::ContextState &data,
+    gl::Error applyTextures(const gl::Context *context,
                             gl::SamplerType shaderType,
                             const FramebufferTextureArray &framebufferTextures,
                             size_t framebufferTextureCount);
 
     size_t getBoundFramebufferTextures(const gl::ContextState &data,
                                        FramebufferTextureArray *outTextureArray);
-    gl::Texture *getIncompleteTexture(GLImplFactory *implFactory, GLenum type);
+    gl::Texture *getIncompleteTexture(const gl::Context *context, GLenum type);
 
     virtual angle::WorkaroundsD3D generateWorkarounds() const = 0;
 
@@ -329,6 +388,8 @@ class RendererD3D : public BufferFactoryD3D
     angle::WorkerThreadPool mWorkerThreadPool;
 };
 
+unsigned int GetBlendSampleMask(const gl::ContextState &data, int samples);
+
 }  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_RENDERERD3D_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.cpp
index 4e3252d86b5..30f40b02f12 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.cpp
@@ -8,10 +8,11 @@
 
 #include "libANGLE/renderer/d3d/SurfaceD3D.h"
 
+#include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
 #include "libANGLE/Surface.h"
-#include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
+#include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/SwapChainD3D.h"
 
 #include <tchar.h>
@@ -81,23 +82,18 @@ void SurfaceD3D::releaseSwapChain()
     SafeDelete(mSwapChain);
 }
 
-egl::Error SurfaceD3D::initialize(const DisplayImpl *displayImpl)
+egl::Error SurfaceD3D::initialize(const egl::Display *display)
 {
     if (mNativeWindow->getNativeWindow())
     {
         if (!mNativeWindow->initialize())
         {
-            return egl::Error(EGL_BAD_SURFACE);
+            return egl::EglBadSurface();
         }
     }
 
-    egl::Error error = resetSwapChain();
-    if (error.isError())
-    {
-        return error;
-    }
-
-    return egl::Error(EGL_SUCCESS);
+    ANGLE_TRY(resetSwapChain(display));
+    return egl::NoError();
 }
 
 FramebufferImpl *SurfaceD3D::createDefaultFramebuffer(const gl::FramebufferState &data)
@@ -107,12 +103,12 @@ FramebufferImpl *SurfaceD3D::createDefaultFramebuffer(const gl::FramebufferState
 
 egl::Error SurfaceD3D::bindTexImage(gl::Texture *, EGLint)
 {
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 egl::Error SurfaceD3D::releaseTexImage(EGLint)
 {
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 egl::Error SurfaceD3D::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc)
@@ -120,7 +116,7 @@ egl::Error SurfaceD3D::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLui
     return mSwapChain->getSyncValues(ust, msc, sbc);
 }
 
-egl::Error SurfaceD3D::resetSwapChain()
+egl::Error SurfaceD3D::resetSwapChain(const egl::Display *display)
 {
     ASSERT(!mSwapChain);
 
@@ -134,7 +130,7 @@ egl::Error SurfaceD3D::resetSwapChain()
         {
             ASSERT(false);
 
-            return egl::Error(EGL_BAD_SURFACE, "Could not retrieve the window dimensions");
+            return egl::EglBadSurface() << "Could not retrieve the window dimensions";
         }
 
         width = windowRect.right - windowRect.left;
@@ -152,25 +148,29 @@ egl::Error SurfaceD3D::resetSwapChain()
                                    mDepthStencilFormat, mOrientation, mState.config->samples);
     if (!mSwapChain)
     {
-        return egl::Error(EGL_BAD_ALLOC);
+        return egl::EglBadAlloc();
     }
 
-    egl::Error error = resetSwapChain(width, height);
+    // This is a bit risky to pass the proxy context here, but it can happen at almost any time.
+    egl::Error error = resetSwapChain(display->getProxyContext(), width, height);
     if (error.isError())
     {
         SafeDelete(mSwapChain);
         return error;
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
-egl::Error SurfaceD3D::resizeSwapChain(int backbufferWidth, int backbufferHeight)
+egl::Error SurfaceD3D::resizeSwapChain(const gl::Context *context,
+                                       int backbufferWidth,
+                                       int backbufferHeight)
 {
     ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0);
     ASSERT(mSwapChain);
 
-    EGLint status = mSwapChain->resize(std::max(1, backbufferWidth), std::max(1, backbufferHeight));
+    EGLint status =
+        mSwapChain->resize(context, std::max(1, backbufferWidth), std::max(1, backbufferHeight));
 
     if (status == EGL_CONTEXT_LOST)
     {
@@ -185,15 +185,18 @@ egl::Error SurfaceD3D::resizeSwapChain(int backbufferWidth, int backbufferHeight
     mWidth = backbufferWidth;
     mHeight = backbufferHeight;
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
-egl::Error SurfaceD3D::resetSwapChain(int backbufferWidth, int backbufferHeight)
+egl::Error SurfaceD3D::resetSwapChain(const gl::Context *context,
+                                      int backbufferWidth,
+                                      int backbufferHeight)
 {
     ASSERT(backbufferWidth >= 0 && backbufferHeight >= 0);
     ASSERT(mSwapChain);
 
-    EGLint status = mSwapChain->reset(std::max(1, backbufferWidth), std::max(1, backbufferHeight), mSwapInterval);
+    EGLint status = mSwapChain->reset(context, std::max(1, backbufferWidth),
+                                      std::max(1, backbufferHeight), mSwapInterval);
 
     if (status == EGL_CONTEXT_LOST)
     {
@@ -209,14 +212,18 @@ egl::Error SurfaceD3D::resetSwapChain(int backbufferWidth, int backbufferHeight)
     mHeight = backbufferHeight;
     mSwapIntervalDirty = false;
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
-egl::Error SurfaceD3D::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+egl::Error SurfaceD3D::swapRect(const gl::Context *context,
+                                EGLint x,
+                                EGLint y,
+                                EGLint width,
+                                EGLint height)
 {
     if (!mSwapChain)
     {
-        return egl::Error(EGL_SUCCESS);
+        return egl::NoError();
     }
 
     if (x + width > mWidth)
@@ -231,7 +238,7 @@ egl::Error SurfaceD3D::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
 
     if (width != 0 && height != 0)
     {
-        EGLint status = mSwapChain->swapRect(x, y, width, height);
+        EGLint status = mSwapChain->swapRect(context, x, y, width, height);
 
         if (status == EGL_CONTEXT_LOST)
         {
@@ -244,12 +251,12 @@ egl::Error SurfaceD3D::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
         }
     }
 
-    checkForOutOfDateSwapChain();
+    checkForOutOfDateSwapChain(context);
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
-bool SurfaceD3D::checkForOutOfDateSwapChain()
+bool SurfaceD3D::checkForOutOfDateSwapChain(const gl::Context *context)
 {
     RECT client;
     int clientWidth = getWidth();
@@ -275,24 +282,28 @@ bool SurfaceD3D::checkForOutOfDateSwapChain()
 
     if (mSwapIntervalDirty)
     {
-        resetSwapChain(clientWidth, clientHeight);
+        resetSwapChain(context, clientWidth, clientHeight);
     }
     else if (sizeDirty)
     {
-        resizeSwapChain(clientWidth, clientHeight);
+        resizeSwapChain(context, clientWidth, clientHeight);
     }
 
     return wasDirty;
 }
 
-egl::Error SurfaceD3D::swap(const DisplayImpl *displayImpl)
+egl::Error SurfaceD3D::swap(const gl::Context *context)
 {
-    return swapRect(0, 0, mWidth, mHeight);
+    return swapRect(context, 0, 0, mWidth, mHeight);
 }
 
-egl::Error SurfaceD3D::postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height)
+egl::Error SurfaceD3D::postSubBuffer(const gl::Context *context,
+                                     EGLint x,
+                                     EGLint y,
+                                     EGLint width,
+                                     EGLint height)
 {
-    return swapRect(x, y, width, height);
+    return swapRect(context, x, y, width, height);
 }
 
 rx::SwapChainD3D *SurfaceD3D::getSwapChain() const
@@ -344,10 +355,11 @@ egl::Error SurfaceD3D::querySurfacePointerANGLE(EGLint attribute, void **value)
     }
     else UNREACHABLE();
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
-gl::Error SurfaceD3D::getAttachmentRenderTarget(GLenum binding,
+gl::Error SurfaceD3D::getAttachmentRenderTarget(const gl::Context *context,
+                                                GLenum binding,
                                                 const gl::ImageIndex &imageIndex,
                                                 FramebufferAttachmentRenderTarget **rtOut)
 {
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.h
index 3be288871c0..5703c2289e9 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/SurfaceD3D.h
@@ -28,11 +28,15 @@ class SurfaceD3D : public SurfaceImpl
     ~SurfaceD3D() override;
     void releaseSwapChain();
 
-    egl::Error initialize(const DisplayImpl *displayImpl) override;
+    egl::Error initialize(const egl::Display *display) override;
     FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override;
 
-    egl::Error swap(const DisplayImpl *displayImpl) override;
-    egl::Error postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height) override;
+    egl::Error swap(const gl::Context *context) override;
+    egl::Error postSubBuffer(const gl::Context *context,
+                             EGLint x,
+                             EGLint y,
+                             EGLint width,
+                             EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
     egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
     egl::Error releaseTexImage(EGLint buffer) override;
@@ -48,12 +52,13 @@ class SurfaceD3D : public SurfaceImpl
     // D3D implementations
     SwapChainD3D *getSwapChain() const;
 
-    egl::Error resetSwapChain();
+    egl::Error resetSwapChain(const egl::Display *display);
 
     // Returns true if swapchain changed due to resize or interval update
-    bool checkForOutOfDateSwapChain();
+    bool checkForOutOfDateSwapChain(const gl::Context *context);
 
-    gl::Error getAttachmentRenderTarget(GLenum binding,
+    gl::Error getAttachmentRenderTarget(const gl::Context *context,
+                                        GLenum binding,
                                         const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
@@ -66,9 +71,17 @@ class SurfaceD3D : public SurfaceImpl
                EGLClientBuffer clientBuffer,
                const egl::AttributeMap &attribs);
 
-    egl::Error swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
-    egl::Error resetSwapChain(int backbufferWidth, int backbufferHeight);
-    egl::Error resizeSwapChain(int backbufferWidth, int backbufferHeight);
+    egl::Error swapRect(const gl::Context *context,
+                        EGLint x,
+                        EGLint y,
+                        EGLint width,
+                        EGLint height);
+    egl::Error resetSwapChain(const gl::Context *context,
+                              int backbufferWidth,
+                              int backbufferHeight);
+    egl::Error resizeSwapChain(const gl::Context *context,
+                               int backbufferWidth,
+                               int backbufferHeight);
 
     RendererD3D *mRenderer;
     egl::Display *mDisplay;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/SwapChainD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/SwapChainD3D.h
index 5472864ef55..81c3d13da43 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/SwapChainD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/SwapChainD3D.h
@@ -22,6 +22,16 @@
 #define ANGLE_FORCE_VSYNC_OFF 0
 #endif
 
+namespace gl
+{
+class Context;
+}  // namespace gl
+
+namespace egl
+{
+class Display;
+}  // namespace egl
+
 namespace rx
 {
 class RenderTargetD3D;
@@ -35,9 +45,18 @@ class SwapChainD3D : angle::NonCopyable
                  GLenum depthBufferFormat);
     virtual ~SwapChainD3D();
 
-    virtual EGLint resize(EGLint backbufferWidth, EGLint backbufferSize) = 0;
-    virtual EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval) = 0;
-    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height) = 0;
+    virtual EGLint resize(const gl::Context *context,
+                          EGLint backbufferWidth,
+                          EGLint backbufferSize) = 0;
+    virtual EGLint reset(const gl::Context *context,
+                         EGLint backbufferWidth,
+                         EGLint backbufferHeight,
+                         EGLint swapInterval) = 0;
+    virtual EGLint swapRect(const gl::Context *context,
+                            EGLint x,
+                            EGLint y,
+                            EGLint width,
+                            EGLint height) = 0;
     virtual void recreate() = 0;
 
     virtual RenderTargetD3D *getColorRenderTarget() = 0;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.cpp
index cdfa552b02f..69dc9de0aa1 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.cpp
@@ -12,6 +12,7 @@
 #include "common/utilities.h"
 #include "libANGLE/Buffer.h"
 #include "libANGLE/Config.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/Image.h"
 #include "libANGLE/Surface.h"
@@ -21,8 +22,8 @@
 #include "libANGLE/renderer/d3d/BufferD3D.h"
 #include "libANGLE/renderer/d3d/EGLImageD3D.h"
 #include "libANGLE/renderer/d3d/ImageD3D.h"
-#include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
+#include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/SurfaceD3D.h"
 #include "libANGLE/renderer/d3d/TextureStorage.h"
 
@@ -82,16 +83,17 @@ TextureD3D::TextureD3D(const gl::TextureState &state, RendererD3D *renderer)
 
 TextureD3D::~TextureD3D()
 {
+    ASSERT(!mTexStorage);
 }
 
-gl::Error TextureD3D::getNativeTexture(TextureStorage **outStorage)
+gl::Error TextureD3D::getNativeTexture(const gl::Context *context, TextureStorage **outStorage)
 {
     // ensure the underlying texture is created
-    ANGLE_TRY(initializeStorage(false));
+    ANGLE_TRY(initializeStorage(context, false));
 
     if (mTexStorage)
     {
-        ANGLE_TRY(updateStorage());
+        ANGLE_TRY(updateStorage(context));
     }
 
     ASSERT(outStorage);
@@ -100,6 +102,19 @@ gl::Error TextureD3D::getNativeTexture(TextureStorage **outStorage)
     return gl::NoError();
 }
 
+gl::Error TextureD3D::getImageAndSyncFromStorage(const gl::Context *context,
+                                                 const gl::ImageIndex &index,
+                                                 ImageD3D **outImage) const
+{
+    ImageD3D *image = getImage(index);
+    if (mTexStorage)
+    {
+        ANGLE_TRY(image->copyFromTexStorage(context, index, mTexStorage));
+    }
+    *outImage = image;
+    return gl::NoError();
+}
+
 GLint TextureD3D::getLevelZeroWidth() const
 {
     ASSERT(gl::CountLeadingZeros(static_cast<uint32_t>(getBaseLevelWidth())) > getBaseLevel());
@@ -135,6 +150,11 @@ GLint TextureD3D::getBaseLevelDepth() const
     return (baseImage ? baseImage->getDepth() : 0);
 }
 
+bool TextureD3D::shouldForceReleaseImagesOnSetImage(const uint8_t *pixels) const
+{
+    return mRenderer->isRobustResourceInitEnabled() && pixels == nullptr;
+}
+
 // Note: "base level image" is loosely defined to be any image from the base level,
 // where in the base of 2D array textures and cube maps there are several. Don't use
 // the base level image for anything except querying texture format and size.
@@ -144,15 +164,25 @@ GLenum TextureD3D::getBaseLevelInternalFormat() const
     return (baseImage ? baseImage->getInternalFormat() : GL_NONE);
 }
 
-gl::Error TextureD3D::setStorageMultisample(ContextImpl *contextImpl,
+gl::Error TextureD3D::setStorage(const gl::Context *context,
+                                 GLenum target,
+                                 size_t levels,
+                                 GLenum internalFormat,
+                                 const gl::Extents &size)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D::setStorageMultisample(const gl::Context *context,
                                             GLenum target,
                                             GLsizei samples,
                                             GLint internalFormat,
                                             const gl::Extents &size,
                                             GLboolean fixedSampleLocations)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError() << "setStorageMultisample is unimplemented.";
+    UNREACHABLE();
+    return gl::InternalError();
 }
 
 bool TextureD3D::shouldUseSetData(const ImageD3D *image) const
@@ -162,6 +192,11 @@ bool TextureD3D::shouldUseSetData(const ImageD3D *image) const
         return false;
     }
 
+    if (image->isDirty())
+    {
+        return false;
+    }
+
     gl::InternalFormat internalFormat = gl::GetSizedInternalFormatInfo(image->getInternalFormat());
 
     // We can only handle full updates for depth-stencil textures, so to avoid complications
@@ -175,7 +210,8 @@ bool TextureD3D::shouldUseSetData(const ImageD3D *image) const
     return (mTexStorage && !internalFormat.compressed);
 }
 
-gl::Error TextureD3D::setImageImpl(const gl::ImageIndex &index,
+gl::Error TextureD3D::setImageImpl(const gl::Context *context,
+                                   const gl::ImageIndex &index,
                                    GLenum type,
                                    const gl::PixelUnpackState &unpack,
                                    const uint8_t *pixels,
@@ -199,12 +235,14 @@ gl::Error TextureD3D::setImageImpl(const gl::ImageIndex &index,
     {
         if (shouldUseSetData(image))
         {
-            ANGLE_TRY(mTexStorage->setData(index, image, nullptr, type, unpack, pixelData));
+            ANGLE_TRY(
+                mTexStorage->setData(context, index, image, nullptr, type, unpack, pixelData));
         }
         else
         {
             gl::Box fullImageArea(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth());
-            ANGLE_TRY(image->loadData(fullImageArea, unpack, type, pixelData, index.is3D()));
+            ANGLE_TRY(
+                image->loadData(context, fullImageArea, unpack, type, pixelData, index.is3D()));
         }
 
         mDirtyImages = true;
@@ -213,8 +251,14 @@ gl::Error TextureD3D::setImageImpl(const gl::ImageIndex &index,
     return gl::NoError();
 }
 
-gl::Error TextureD3D::subImage(const gl::ImageIndex &index, const gl::Box &area, GLenum format, GLenum type,
-                               const gl::PixelUnpackState &unpack, const uint8_t *pixels, ptrdiff_t layerOffset)
+gl::Error TextureD3D::subImage(const gl::Context *context,
+                               const gl::ImageIndex &index,
+                               const gl::Box &area,
+                               GLenum format,
+                               GLenum type,
+                               const gl::PixelUnpackState &unpack,
+                               const uint8_t *pixels,
+                               ptrdiff_t layerOffset)
 {
     // CPU readback & copy where direct GPU copy is not supported
     const uint8_t *pixelData = nullptr;
@@ -227,18 +271,19 @@ gl::Error TextureD3D::subImage(const gl::ImageIndex &index, const gl::Box &area,
 
         if (shouldUseSetData(image))
         {
-            return mTexStorage->setData(index, image, &area, type, unpack, pixelData);
+            return mTexStorage->setData(context, index, image, &area, type, unpack, pixelData);
         }
 
-        ANGLE_TRY(image->loadData(area, unpack, type, pixelData, index.is3D()));
-        ANGLE_TRY(commitRegion(index, area));
+        ANGLE_TRY(image->loadData(context, area, unpack, type, pixelData, index.is3D()));
+        ANGLE_TRY(commitRegion(context, index, area));
         mDirtyImages = true;
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D::setCompressedImageImpl(const gl::ImageIndex &index,
+gl::Error TextureD3D::setCompressedImageImpl(const gl::Context *context,
+                                             const gl::ImageIndex &index,
                                              const gl::PixelUnpackState &unpack,
                                              const uint8_t *pixels,
                                              ptrdiff_t layerOffset)
@@ -259,7 +304,7 @@ gl::Error TextureD3D::setCompressedImageImpl(const gl::ImageIndex &index,
     if (pixelData != nullptr)
     {
         gl::Box fullImageArea(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth());
-        ANGLE_TRY(image->loadCompressedData(fullImageArea, pixelData));
+        ANGLE_TRY(image->loadCompressedData(context, fullImageArea, pixelData));
 
         mDirtyImages = true;
     }
@@ -267,8 +312,12 @@ gl::Error TextureD3D::setCompressedImageImpl(const gl::ImageIndex &index,
     return gl::NoError();
 }
 
-gl::Error TextureD3D::subImageCompressed(const gl::ImageIndex &index, const gl::Box &area, GLenum format,
-                                         const gl::PixelUnpackState &unpack, const uint8_t *pixels,
+gl::Error TextureD3D::subImageCompressed(const gl::Context *context,
+                                         const gl::ImageIndex &index,
+                                         const gl::Box &area,
+                                         GLenum format,
+                                         const gl::PixelUnpackState &unpack,
+                                         const uint8_t *pixels,
                                          ptrdiff_t layerOffset)
 {
     const uint8_t *pixelData = nullptr;
@@ -279,7 +328,7 @@ gl::Error TextureD3D::subImageCompressed(const gl::ImageIndex &index, const gl::
         ImageD3D *image = getImage(index);
         ASSERT(image);
 
-        ANGLE_TRY(image->loadCompressedData(area, pixelData));
+        ANGLE_TRY(image->loadCompressedData(context, area, pixelData));
 
         mDirtyImages = true;
     }
@@ -292,16 +341,20 @@ bool TextureD3D::isFastUnpackable(const gl::PixelUnpackState &unpack, GLenum siz
     return unpack.pixelBuffer.id() != 0 && mRenderer->supportsFastCopyBufferToTexture(sizedInternalFormat);
 }
 
-gl::Error TextureD3D::fastUnpackPixels(const gl::PixelUnpackState &unpack, const uint8_t *pixels, const gl::Box &destArea,
-                                       GLenum sizedInternalFormat, GLenum type, RenderTargetD3D *destRenderTarget)
+gl::Error TextureD3D::fastUnpackPixels(const gl::Context *context,
+                                       const gl::PixelUnpackState &unpack,
+                                       const uint8_t *pixels,
+                                       const gl::Box &destArea,
+                                       GLenum sizedInternalFormat,
+                                       GLenum type,
+                                       RenderTargetD3D *destRenderTarget)
 {
     if (unpack.skipRows != 0 || unpack.skipPixels != 0 || unpack.imageHeight != 0 ||
         unpack.skipImages != 0)
     {
         // TODO(jmadill): additional unpack parameters
         UNIMPLEMENTED();
-        return gl::Error(GL_INVALID_OPERATION,
-                         "Unimplemented pixel store parameters in fastUnpackPixels");
+        return gl::InternalError() << "Unimplemented pixel store parameters in fastUnpackPixels";
     }
 
     // No-op
@@ -316,7 +369,7 @@ gl::Error TextureD3D::fastUnpackPixels(const gl::PixelUnpackState &unpack, const
 
     uintptr_t offset = reinterpret_cast<uintptr_t>(pixels);
 
-    ANGLE_TRY(mRenderer->fastCopyBufferToTexture(unpack, static_cast<unsigned int>(offset),
+    ANGLE_TRY(mRenderer->fastCopyBufferToTexture(context, unpack, static_cast<unsigned int>(offset),
                                                  destRenderTarget, sizedInternalFormat, type,
                                                  destArea));
 
@@ -353,16 +406,17 @@ ImageD3D *TextureD3D::getBaseLevelImage() const
     return getImage(getImageIndex(mBaseLevel, 0));
 }
 
-gl::Error TextureD3D::setImageExternal(GLenum target,
+gl::Error TextureD3D::setImageExternal(const gl::Context *context,
+                                       GLenum target,
                                        egl::Stream *stream,
                                        const egl::Stream::GLTextureDescription &desc)
 {
     // Only external images can accept external textures
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D::generateMipmap(ContextImpl *contextImpl)
+gl::Error TextureD3D::generateMipmap(const gl::Context *context)
 {
     const GLuint baseLevel = mState.getEffectiveBaseLevel();
     const GLuint maxLevel = mState.getMipmapMaxLevel();
@@ -372,30 +426,30 @@ gl::Error TextureD3D::generateMipmap(ContextImpl *contextImpl)
     {
         // Switch to using the mipmapped texture.
         TextureStorage *textureStorage = nullptr;
-        ANGLE_TRY(getNativeTexture(&textureStorage));
+        ANGLE_TRY(getNativeTexture(context, &textureStorage));
         ANGLE_TRY(textureStorage->useLevelZeroWorkaroundTexture(false));
     }
 
     // Set up proper mipmap chain in our Image array.
-    initMipmapImages();
+    ANGLE_TRY(initMipmapImages(context));
 
     if (mTexStorage && mTexStorage->supportsNativeMipmapFunction())
     {
-        ANGLE_TRY(updateStorage());
+        ANGLE_TRY(updateStorage(context));
 
         // Generate the mipmap chain using the ad-hoc DirectX function.
-        ANGLE_TRY(mRenderer->generateMipmapUsingD3D(mTexStorage, mState));
+        ANGLE_TRY(mRenderer->generateMipmapUsingD3D(context, mTexStorage, mState));
     }
     else
     {
         // Generate the mipmap chain, one level at a time.
-        ANGLE_TRY(generateMipmapUsingImages(maxLevel));
+        ANGLE_TRY(generateMipmapUsingImages(context, maxLevel));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D::generateMipmapUsingImages(const GLuint maxLevel)
+gl::Error TextureD3D::generateMipmapUsingImages(const gl::Context *context, const GLuint maxLevel)
 {
     // We know that all layers have the same dimension, for the texture to be complete
     GLint layerCount = static_cast<GLint>(getLayerCount(mBaseLevel));
@@ -413,12 +467,12 @@ gl::Error TextureD3D::generateMipmapUsingImages(const GLuint maxLevel)
                 gl::ImageIndex srcIndex = getImageIndex(mBaseLevel, layer);
 
                 ImageD3D *image = getImage(srcIndex);
-                ANGLE_TRY(image->copyFromTexStorage(srcIndex, mTexStorage));
+                ANGLE_TRY(image->copyFromTexStorage(context, srcIndex, mTexStorage));
             }
         }
         else
         {
-            ANGLE_TRY(updateStorage());
+            ANGLE_TRY(updateStorage(context));
         }
     }
 
@@ -441,19 +495,20 @@ gl::Error TextureD3D::generateMipmapUsingImages(const GLuint maxLevel)
             if (renderableStorage)
             {
                 // GPU-side mipmapping
-                ANGLE_TRY(mTexStorage->generateMipmap(sourceIndex, destIndex));
+                ANGLE_TRY(mTexStorage->generateMipmap(context, sourceIndex, destIndex));
             }
             else
             {
                 // CPU-side mipmapping
-                ANGLE_TRY(mRenderer->generateMipmap(getImage(destIndex), getImage(sourceIndex)));
+                ANGLE_TRY(
+                    mRenderer->generateMipmap(context, getImage(destIndex), getImage(sourceIndex)));
             }
         }
     }
 
     if (mTexStorage)
     {
-        updateStorage();
+        updateStorage(context);
     }
 
     return gl::NoError();
@@ -486,9 +541,9 @@ bool TextureD3D::isBaseImageZeroSize() const
     return false;
 }
 
-gl::Error TextureD3D::ensureRenderTarget()
+gl::Error TextureD3D::ensureRenderTarget(const gl::Context *context)
 {
-    ANGLE_TRY(initializeStorage(true));
+    ANGLE_TRY(initializeStorage(context, true));
 
     // initializeStorage can fail with NoError if the texture is not complete. This is not
     // an error for incomplete sampling, but it is a big problem for rendering.
@@ -503,13 +558,12 @@ gl::Error TextureD3D::ensureRenderTarget()
         ASSERT(mTexStorage);
         if (!mTexStorage->isRenderTarget())
         {
-            TextureStorage *newRenderTargetStorage = nullptr;
+            TexStoragePointer newRenderTargetStorage(context);
             ANGLE_TRY(createCompleteStorage(true, &newRenderTargetStorage));
 
-            std::unique_ptr<TextureStorage> newStorageRef(newRenderTargetStorage);
-            ANGLE_TRY(mTexStorage->copyToStorage(newRenderTargetStorage));
-            ANGLE_TRY(setCompleteTexStorage(newRenderTargetStorage));
-            newStorageRef.release();
+            ANGLE_TRY(mTexStorage->copyToStorage(context, newRenderTargetStorage.get()));
+            ANGLE_TRY(setCompleteTexStorage(context, newRenderTargetStorage.get()));
+            newRenderTargetStorage.release();
         }
     }
 
@@ -523,30 +577,33 @@ bool TextureD3D::canCreateRenderTargetForImage(const gl::ImageIndex &index) cons
     return (image->isRenderableFormat() && levelsComplete);
 }
 
-gl::Error TextureD3D::commitRegion(const gl::ImageIndex &index, const gl::Box &region)
+gl::Error TextureD3D::commitRegion(const gl::Context *context,
+                                   const gl::ImageIndex &index,
+                                   const gl::Box &region)
 {
     if (mTexStorage)
     {
         ASSERT(isValidIndex(index));
         ImageD3D *image = getImage(index);
-        ANGLE_TRY(image->copyToStorage(mTexStorage, index, region));
+        ANGLE_TRY(image->copyToStorage(context, mTexStorage, index, region));
         image->markClean();
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D::getAttachmentRenderTarget(GLenum /*binding*/,
+gl::Error TextureD3D::getAttachmentRenderTarget(const gl::Context *context,
+                                                GLenum /*binding*/,
                                                 const gl::ImageIndex &imageIndex,
                                                 FramebufferAttachmentRenderTarget **rtOut)
 {
     RenderTargetD3D *rtD3D = nullptr;
-    gl::Error error        = getRenderTarget(imageIndex, &rtD3D);
+    gl::Error error        = getRenderTarget(context, imageIndex, &rtD3D);
     *rtOut = static_cast<FramebufferAttachmentRenderTarget *>(rtD3D);
     return error;
 }
 
-void TextureD3D::setBaseLevel(GLuint baseLevel)
+gl::Error TextureD3D::setBaseLevel(const gl::Context *context, GLuint baseLevel)
 {
     const int oldStorageWidth  = std::max(1, getLevelZeroWidth());
     const int oldStorageHeight = std::max(1, getLevelZeroHeight());
@@ -565,8 +622,10 @@ void TextureD3D::setBaseLevel(GLuint baseLevel)
          newStorageDepth != oldStorageDepth || newStorageFormat != oldStorageFormat))
     {
         markAllImagesDirty();
-        SafeDelete(mTexStorage);
+        ANGLE_TRY(releaseTexStorage(context));
     }
+
+    return gl::NoError();
 }
 
 void TextureD3D::syncState(const gl::Texture::DirtyBits &dirtyBits)
@@ -574,231 +633,67 @@ void TextureD3D::syncState(const gl::Texture::DirtyBits &dirtyBits)
     // TODO(geofflang): Use dirty bits
 }
 
-TextureD3D_2D::TextureD3D_2D(const gl::TextureState &state, RendererD3D *renderer)
-    : TextureD3D(state, renderer)
-{
-    mEGLImageTarget = false;
-    for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
-    {
-        mImageArray[i] = renderer->createImage();
-    }
-}
-
-TextureD3D_2DMultisample::TextureD3D_2DMultisample(const gl::TextureState &state,
-                                                   RendererD3D *renderer)
-    : TextureD3D(state, renderer)
-{
-}
-
-TextureD3D_2DMultisample::~TextureD3D_2DMultisample()
-{
-}
-
-ImageD3D *TextureD3D_2DMultisample::getImage(const gl::ImageIndex &index) const
-{
-    UNIMPLEMENTED();
-    return nullptr;
-}
-
-gl::Error TextureD3D_2DMultisample::setImage(ContextImpl *contextImpl,
-                                             GLenum target,
-                                             size_t level,
-                                             GLenum internalFormat,
-                                             const gl::Extents &size,
-                                             GLenum format,
-                                             GLenum type,
-                                             const gl::PixelUnpackState &unpack,
-                                             const uint8_t *pixels)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::setSubImage(ContextImpl *contextImpl,
-                                                GLenum target,
-                                                size_t level,
-                                                const gl::Box &area,
-                                                GLenum format,
-                                                GLenum type,
-                                                const gl::PixelUnpackState &unpack,
-                                                const uint8_t *pixels)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::setCompressedImage(ContextImpl *contextImpl,
-                                                       GLenum target,
-                                                       size_t level,
-                                                       GLenum internalFormat,
-                                                       const gl::Extents &size,
-                                                       const gl::PixelUnpackState &unpack,
-                                                       size_t imageSize,
-                                                       const uint8_t *pixels)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::setCompressedSubImage(ContextImpl *contextImpl,
-                                                          GLenum target,
-                                                          size_t level,
-                                                          const gl::Box &area,
-                                                          GLenum format,
-                                                          const gl::PixelUnpackState &unpack,
-                                                          size_t imageSize,
-                                                          const uint8_t *pixels)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::copyImage(ContextImpl *contextImpl,
-                                              GLenum target,
-                                              size_t level,
-                                              const gl::Rectangle &sourceArea,
-                                              GLenum internalFormat,
-                                              const gl::Framebuffer *source)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::copySubImage(ContextImpl *contextImpl,
-                                                 GLenum target,
-                                                 size_t level,
-                                                 const gl::Offset &destOffset,
-                                                 const gl::Rectangle &sourceArea,
-                                                 const gl::Framebuffer *source)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::setStorage(ContextImpl *contextImpl,
-                                               GLenum target,
-                                               size_t levels,
-                                               GLenum internalFormat,
-                                               const gl::Extents &size)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::setImageExternal(GLenum target,
-                                                     egl::Stream *stream,
-                                                     const egl::Stream::GLTextureDescription &desc)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-void TextureD3D_2DMultisample::bindTexImage(egl::Surface *surface)
-{
-    UNIMPLEMENTED();
-}
-
-void TextureD3D_2DMultisample::releaseTexImage()
-{
-    UNIMPLEMENTED();
-}
-
-gl::Error TextureD3D_2DMultisample::setEGLImageTarget(GLenum target, egl::Image *image)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::Error TextureD3D_2DMultisample::getRenderTarget(const gl::ImageIndex &index,
-                                                    RenderTargetD3D **outRT)
+gl::Error TextureD3D::clearLevel(const gl::Context *context,
+                                 const gl::ImageIndex &index,
+                                 const gl::ColorF &clearValues)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
-
-gl::ImageIndexIterator TextureD3D_2DMultisample::imageIterator() const
-{
-    UNIMPLEMENTED();
-    return gl::ImageIndexIterator::Make2DMultisample();
-}
-
-gl::ImageIndex TextureD3D_2DMultisample::getImageIndex(GLint mip, GLint layer) const
-{
-    UNIMPLEMENTED();
-    return gl::ImageIndex::Make2DMultisample();
-}
-
-bool TextureD3D_2DMultisample::isValidIndex(const gl::ImageIndex &index) const
-{
-    UNIMPLEMENTED();
-    return false;
-}
-
-GLsizei TextureD3D_2DMultisample::getLayerCount(int level) const
-{
-    UNIMPLEMENTED();
-    return GLsizei();
-}
-
-void TextureD3D_2DMultisample::markAllImagesDirty()
-{
-    UNIMPLEMENTED();
-}
+    TextureStorage *storage = nullptr;
+    ANGLE_TRY(getNativeTexture(context, &storage));
+    RenderTargetD3D *renderTargetD3D = nullptr;
+    ANGLE_TRY(storage->getRenderTarget(context, index, &renderTargetD3D));
 
-gl::Error TextureD3D_2DMultisample::initializeStorage(bool renderTarget)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
-}
+    mRenderer->clearRenderTarget(renderTargetD3D, clearValues);
 
-gl::Error TextureD3D_2DMultisample::createCompleteStorage(bool renderTarget,
-                                                          TextureStorage **outTexStorage) const
-{
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    return gl::NoError();
 }
 
-gl::Error TextureD3D_2DMultisample::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
+gl::Error TextureD3D::releaseTexStorage(const gl::Context *context)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    if (!mTexStorage)
+    {
+        return gl::NoError();
+    }
+    ANGLE_TRY(mTexStorage->onDestroy(context));
+    mTexStorage = nullptr;
+    return gl::NoError();
 }
 
-gl::Error TextureD3D_2DMultisample::updateStorage()
+gl::Error TextureD3D::onDestroy(const gl::Context *context)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    return releaseTexStorage(context);
 }
 
-void TextureD3D_2DMultisample::initMipmapImages()
+TextureD3D_2D::TextureD3D_2D(const gl::TextureState &state, RendererD3D *renderer)
+    : TextureD3D(state, renderer)
 {
-    UNIMPLEMENTED();
+    mEGLImageTarget = false;
+    for (auto &image : mImageArray)
+    {
+        image.reset(renderer->createImage());
+    }
 }
 
-bool TextureD3D_2DMultisample::isImageComplete(const gl::ImageIndex &index) const
+gl::Error TextureD3D_2D::onDestroy(const gl::Context *context)
 {
-    UNIMPLEMENTED();
-    return false;
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
+    for (auto &image : mImageArray)
+    {
+        image.reset();
+    }
+    return TextureD3D::onDestroy(context);
 }
 
 TextureD3D_2D::~TextureD3D_2D()
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
-    for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
-    {
-        SafeDelete(mImageArray[i]);
-    }
-
-    SafeDelete(mTexStorage);
 }
 
 ImageD3D *TextureD3D_2D::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(layer == 0);
-    return mImageArray[level];
+    return mImageArray[level].get();
 }
 
 ImageD3D *TextureD3D_2D::getImage(const gl::ImageIndex &index) const
@@ -806,7 +701,7 @@ ImageD3D *TextureD3D_2D::getImage(const gl::ImageIndex &index) const
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(!index.hasLayer());
     ASSERT(index.type == GL_TEXTURE_2D);
-    return mImageArray[index.mipIndex];
+    return mImageArray[index.mipIndex].get();
 }
 
 GLsizei TextureD3D_2D::getLayerCount(int level) const
@@ -844,7 +739,12 @@ bool TextureD3D_2D::isDepth(GLint level) const
     return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).depthBits > 0;
 }
 
-gl::Error TextureD3D_2D::setImage(ContextImpl *contextImpl,
+bool TextureD3D_2D::isSRGB(GLint level) const
+{
+    return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).colorEncoding == GL_SRGB;
+}
+
+gl::Error TextureD3D_2D::setImage(const gl::Context *context,
                                   GLenum target,
                                   size_t imageLevel,
                                   GLenum internalFormat,
@@ -861,7 +761,8 @@ gl::Error TextureD3D_2D::setImage(ContextImpl *contextImpl,
     bool fastUnpacked = false;
     GLint level       = static_cast<GLint>(imageLevel);
 
-    redefineImage(level, internalFormatInfo.sizedInternalFormat, size, false);
+    ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, size,
+                            shouldForceReleaseImagesOnSetImage(pixels)));
 
     gl::ImageIndex index = gl::ImageIndex::Make2D(level);
 
@@ -870,12 +771,12 @@ gl::Error TextureD3D_2D::setImage(ContextImpl *contextImpl,
     {
         // Will try to create RT storage if it does not exist
         RenderTargetD3D *destRenderTarget = nullptr;
-        ANGLE_TRY(getRenderTarget(index, &destRenderTarget));
+        ANGLE_TRY(getRenderTarget(context, index, &destRenderTarget));
 
         gl::Box destArea(0, 0, 0, getWidth(level), getHeight(level), 1);
 
-        ANGLE_TRY(fastUnpackPixels(unpack, pixels, destArea, internalFormatInfo.sizedInternalFormat,
-                                   type, destRenderTarget));
+        ANGLE_TRY(fastUnpackPixels(context, unpack, pixels, destArea,
+                                   internalFormatInfo.sizedInternalFormat, type, destRenderTarget));
 
         // Ensure we don't overwrite our newly initialized data
         mImageArray[level]->markClean();
@@ -885,13 +786,13 @@ gl::Error TextureD3D_2D::setImage(ContextImpl *contextImpl,
 
     if (!fastUnpacked)
     {
-        ANGLE_TRY(setImageImpl(index, type, unpack, pixels, 0));
+        ANGLE_TRY(setImageImpl(context, index, type, unpack, pixels, 0));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::setSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::setSubImage(const gl::Context *context,
                                      GLenum target,
                                      size_t imageLevel,
                                      const gl::Box &area,
@@ -907,18 +808,19 @@ gl::Error TextureD3D_2D::setSubImage(ContextImpl *contextImpl,
     if (isFastUnpackable(unpack, getInternalFormat(level)) && isLevelComplete(level))
     {
         RenderTargetD3D *renderTarget = nullptr;
-        ANGLE_TRY(getRenderTarget(index, &renderTarget));
+        ANGLE_TRY(getRenderTarget(context, index, &renderTarget));
         ASSERT(!mImageArray[level]->isDirty());
 
-        return fastUnpackPixels(unpack, pixels, area, getInternalFormat(level), type, renderTarget);
+        return fastUnpackPixels(context, unpack, pixels, area, getInternalFormat(level), type,
+                                renderTarget);
     }
     else
     {
-        return TextureD3D::subImage(index, area, format, type, unpack, pixels, 0);
+        return TextureD3D::subImage(context, index, area, format, type, unpack, pixels, 0);
     }
 }
 
-gl::Error TextureD3D_2D::setCompressedImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::setCompressedImage(const gl::Context *context,
                                             GLenum target,
                                             size_t imageLevel,
                                             GLenum internalFormat,
@@ -931,12 +833,13 @@ gl::Error TextureD3D_2D::setCompressedImage(ContextImpl *contextImpl,
     GLint level = static_cast<GLint>(imageLevel);
 
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    redefineImage(level, internalFormat, size, false);
+    ANGLE_TRY(redefineImage(context, level, internalFormat, size,
+                            shouldForceReleaseImagesOnSetImage(pixels)));
 
-    return setCompressedImageImpl(gl::ImageIndex::Make2D(level), unpack, pixels, 0);
+    return setCompressedImageImpl(context, gl::ImageIndex::Make2D(level), unpack, pixels, 0);
 }
 
-gl::Error TextureD3D_2D::setCompressedSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::setCompressedSubImage(const gl::Context *context,
                                                GLenum target,
                                                size_t level,
                                                const gl::Box &area,
@@ -948,59 +851,101 @@ gl::Error TextureD3D_2D::setCompressedSubImage(ContextImpl *contextImpl,
     ASSERT(target == GL_TEXTURE_2D && area.depth == 1 && area.z == 0);
 
     gl::ImageIndex index = gl::ImageIndex::Make2D(static_cast<GLint>(level));
-    ANGLE_TRY(TextureD3D::subImageCompressed(index, area, format, unpack, pixels, 0));
+    ANGLE_TRY(TextureD3D::subImageCompressed(context, index, area, format, unpack, pixels, 0));
 
-    return commitRegion(index, area);
+    return commitRegion(context, index, area);
 }
 
-gl::Error TextureD3D_2D::copyImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::copyImage(const gl::Context *context,
                                    GLenum target,
                                    size_t imageLevel,
-                                   const gl::Rectangle &sourceArea,
+                                   const gl::Rectangle &origSourceArea,
                                    GLenum internalFormat,
                                    const gl::Framebuffer *source)
 {
     ASSERT(target == GL_TEXTURE_2D);
 
-    GLint level                = static_cast<GLint>(imageLevel);
+    GLint level = static_cast<GLint>(imageLevel);
     const gl::InternalFormat &internalFormatInfo =
         gl::GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE);
-    redefineImage(level, internalFormatInfo.sizedInternalFormat,
-                  gl::Extents(sourceArea.width, sourceArea.height, 1), false);
+    gl::Extents sourceExtents(origSourceArea.width, origSourceArea.height, 1);
+    ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, sourceExtents,
+                            mRenderer->isRobustResourceInitEnabled()));
+
+    gl::Extents fbSize = source->getReadColorbuffer()->getSize();
+
+    // Does the read area extend beyond the framebuffer?
+    bool outside = origSourceArea.x < 0 || origSourceArea.y < 0 ||
+                   origSourceArea.x + origSourceArea.width > fbSize.width ||
+                   origSourceArea.y + origSourceArea.height > fbSize.height;
+
+    // In WebGL mode we need to zero the texture outside the framebuffer.
+    // If we have robust resource init, it was already zeroed by redefineImage() above, otherwise
+    // zero it explicitly.
+    // TODO(fjhenigman): When robust resource is fully implemented look into making it a
+    // prerequisite for WebGL and deleting this code.
+    if (outside && context->getExtensions().webglCompatibility &&
+        !mRenderer->isRobustResourceInitEnabled())
+    {
+        angle::MemoryBuffer *zero;
+        ANGLE_TRY(context->getZeroFilledBuffer(
+            origSourceArea.width * origSourceArea.height * internalFormatInfo.pixelBytes, &zero));
+        setImage(context, target, imageLevel, internalFormat, sourceExtents,
+                 internalFormatInfo.format, internalFormatInfo.type, gl::PixelUnpackState(1, 0),
+                 zero->data());
+    }
+
+    gl::Rectangle sourceArea;
+    if (!ClipRectangle(origSourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height),
+                       &sourceArea))
+    {
+        // Empty source area, nothing to do.
+        return gl::NoError();
+    }
 
     gl::ImageIndex index = gl::ImageIndex::Make2D(level);
-    gl::Offset destOffset(0, 0, 0);
+    gl::Offset destOffset(sourceArea.x - origSourceArea.x, sourceArea.y - origSourceArea.y, 0);
 
     // If the zero max LOD workaround is active, then we can't sample from individual layers of the framebuffer in shaders,
     // so we should use the non-rendering copy path.
     if (!canCreateRenderTargetForImage(index) || mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
-        ANGLE_TRY(mImageArray[level]->copyFromFramebuffer(destOffset, sourceArea, source));
+        ANGLE_TRY(mImageArray[level]->copyFromFramebuffer(context, destOffset, sourceArea, source));
         mDirtyImages = true;
     }
     else
     {
-        ANGLE_TRY(ensureRenderTarget());
-        mImageArray[level]->markClean();
+        ANGLE_TRY(ensureRenderTarget(context));
 
         if (sourceArea.width != 0 && sourceArea.height != 0 && isValidLevel(level))
         {
-            ANGLE_TRY(mRenderer->copyImage2D(source, sourceArea, internalFormat, destOffset,
-                                             mTexStorage, level));
+            ANGLE_TRY(updateStorageLevel(context, level));
+            ANGLE_TRY(mRenderer->copyImage2D(context, source, sourceArea, internalFormat,
+                                             destOffset, mTexStorage, level));
         }
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::copySubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::copySubImage(const gl::Context *context,
                                       GLenum target,
                                       size_t imageLevel,
-                                      const gl::Offset &destOffset,
-                                      const gl::Rectangle &sourceArea,
+                                      const gl::Offset &origDestOffset,
+                                      const gl::Rectangle &origSourceArea,
                                       const gl::Framebuffer *source)
 {
-    ASSERT(target == GL_TEXTURE_2D && destOffset.z == 0);
+    ASSERT(target == GL_TEXTURE_2D && origDestOffset.z == 0);
+
+    gl::Extents fbSize = source->getReadColorbuffer()->getSize();
+    gl::Rectangle sourceArea;
+    if (!ClipRectangle(origSourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height),
+                       &sourceArea))
+    {
+        return gl::NoError();
+    }
+    const gl::Offset destOffset(origDestOffset.x + sourceArea.x - origSourceArea.x,
+                                origDestOffset.y + sourceArea.y - origSourceArea.y, 0);
 
     // can only make our texture storage to a render target if level 0 is defined (with a width & height) and
     // the current level we're copying to is defined (with appropriate format, width & height)
@@ -1012,17 +957,17 @@ gl::Error TextureD3D_2D::copySubImage(ContextImpl *contextImpl,
     // so we should use the non-rendering copy path.
     if (!canCreateRenderTargetForImage(index) || mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
-        ANGLE_TRY(mImageArray[level]->copyFromFramebuffer(destOffset, sourceArea, source));
+        ANGLE_TRY(mImageArray[level]->copyFromFramebuffer(context, destOffset, sourceArea, source));
         mDirtyImages = true;
     }
     else
     {
-        ANGLE_TRY(ensureRenderTarget());
+        ANGLE_TRY(ensureRenderTarget(context));
 
         if (isValidLevel(level))
         {
-            ANGLE_TRY(updateStorageLevel(level));
-            ANGLE_TRY(mRenderer->copyImage2D(source, sourceArea,
+            ANGLE_TRY(updateStorageLevel(context, level));
+            ANGLE_TRY(mRenderer->copyImage2D(context, source, sourceArea,
                                              gl::GetUnsizedFormat(getBaseLevelInternalFormat()),
                                              destOffset, mTexStorage, level));
         }
@@ -1031,7 +976,7 @@ gl::Error TextureD3D_2D::copySubImage(ContextImpl *contextImpl,
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::copyTexture(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::copyTexture(const gl::Context *context,
                                      GLenum target,
                                      size_t level,
                                      GLenum internalFormat,
@@ -1051,31 +996,42 @@ gl::Error TextureD3D_2D::copyTexture(ContextImpl *contextImpl,
     const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type);
     gl::Extents size(static_cast<int>(source->getWidth(sourceTarget, sourceLevel)),
                      static_cast<int>(source->getHeight(sourceTarget, sourceLevel)), 1);
-    redefineImage(destLevel, internalFormatInfo.sizedInternalFormat, size, false);
+    ANGLE_TRY(
+        redefineImage(context, destLevel, internalFormatInfo.sizedInternalFormat, size, false));
 
-    if (canCreateRenderTargetForImage(gl::ImageIndex::Make2D(destLevel)))
+    gl::Rectangle sourceRect(0, 0, size.width, size.height);
+    gl::Offset destOffset(0, 0, 0);
+
+    if (!isSRGB(destLevel) && canCreateRenderTargetForImage(gl::ImageIndex::Make2D(destLevel)))
     {
-        ANGLE_TRY(ensureRenderTarget());
+        ANGLE_TRY(ensureRenderTarget(context));
         ASSERT(isValidLevel(destLevel));
-        ANGLE_TRY(updateStorageLevel(destLevel));
+        ANGLE_TRY(updateStorageLevel(context, destLevel));
 
-        gl::Rectangle sourceRect(0, 0, size.width, size.height);
-        gl::Offset destOffset(0, 0, 0);
-        ANGLE_TRY(mRenderer->copyTexture(source, static_cast<GLint>(sourceLevel), sourceRect,
-                                         internalFormatInfo.format, destOffset, mTexStorage, target,
-                                         destLevel, unpackFlipY, unpackPremultiplyAlpha,
-                                         unpackUnmultiplyAlpha));
+        ANGLE_TRY(mRenderer->copyTexture(context, source, static_cast<GLint>(sourceLevel),
+                                         sourceRect, internalFormatInfo.format, destOffset,
+                                         mTexStorage, target, destLevel, unpackFlipY,
+                                         unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
     else
     {
-        ASSERT(internalFormat == GL_RGB9_E5);
-        UNIMPLEMENTED();
+        gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(static_cast<GLint>(sourceLevel));
+        TextureD3D *sourceD3D           = GetImplAs<TextureD3D>(source);
+        ImageD3D *sourceImage           = nullptr;
+        ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage));
+
+        gl::ImageIndex destImageIndex = gl::ImageIndex::Make2D(static_cast<GLint>(destLevel));
+        ImageD3D *destImage           = nullptr;
+        ANGLE_TRY(getImageAndSyncFromStorage(context, destImageIndex, &destImage));
+
+        ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceRect, destOffset,
+                                       unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::copySubTexture(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::copySubTexture(const gl::Context *context,
                                         GLenum target,
                                         size_t level,
                                         const gl::Offset &destOffset,
@@ -1090,27 +1046,37 @@ gl::Error TextureD3D_2D::copySubTexture(ContextImpl *contextImpl,
 
     GLint destLevel = static_cast<GLint>(level);
 
-    if (canCreateRenderTargetForImage(gl::ImageIndex::Make2D(destLevel)))
+    if (!isSRGB(destLevel) && canCreateRenderTargetForImage(gl::ImageIndex::Make2D(destLevel)))
     {
-        ANGLE_TRY(ensureRenderTarget());
+        ANGLE_TRY(ensureRenderTarget(context));
         ASSERT(isValidLevel(destLevel));
-        ANGLE_TRY(updateStorageLevel(destLevel));
+        ANGLE_TRY(updateStorageLevel(context, destLevel));
 
-        ANGLE_TRY(mRenderer->copyTexture(source, static_cast<GLint>(sourceLevel), sourceArea,
-                                         gl::GetUnsizedFormat(getInternalFormat(destLevel)),
-                                         destOffset, mTexStorage, target, destLevel, unpackFlipY,
-                                         unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
+        ANGLE_TRY(mRenderer->copyTexture(
+            context, source, static_cast<GLint>(sourceLevel), sourceArea,
+            gl::GetUnsizedFormat(getInternalFormat(destLevel)), destOffset, mTexStorage, target,
+            destLevel, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
     else
     {
-        ASSERT(getInternalFormat(destLevel) == GL_RGB9_E5);
-        UNIMPLEMENTED();
+        gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(static_cast<GLint>(sourceLevel));
+        TextureD3D *sourceD3D           = GetImplAs<TextureD3D>(source);
+        ImageD3D *sourceImage           = nullptr;
+        ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage));
+
+        gl::ImageIndex destImageIndex = gl::ImageIndex::Make2D(static_cast<GLint>(destLevel));
+        ImageD3D *destImage           = nullptr;
+        ANGLE_TRY(getImageAndSyncFromStorage(context, destImageIndex, &destImage));
+
+        ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceArea, destOffset,
+                                       unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::copyCompressedTexture(ContextImpl *contextImpl, const gl::Texture *source)
+gl::Error TextureD3D_2D::copyCompressedTexture(const gl::Context *context,
+                                               const gl::Texture *source)
 {
     GLenum sourceTarget = source->getTarget();
     GLint sourceLevel   = 0;
@@ -1121,17 +1087,18 @@ gl::Error TextureD3D_2D::copyCompressedTexture(ContextImpl *contextImpl, const g
         source->getFormat(sourceTarget, sourceLevel).info->sizedInternalFormat;
     gl::Extents size(static_cast<int>(source->getWidth(sourceTarget, sourceLevel)),
                      static_cast<int>(source->getHeight(sourceTarget, sourceLevel)), 1);
-    redefineImage(destLevel, sizedInternalFormat, size, false);
+    ANGLE_TRY(redefineImage(context, destLevel, sizedInternalFormat, size, false));
 
-    ANGLE_TRY(initializeStorage(false));
+    ANGLE_TRY(initializeStorage(context, false));
     ASSERT(mTexStorage);
 
-    ANGLE_TRY(mRenderer->copyCompressedTexture(source, sourceLevel, mTexStorage, destLevel));
+    ANGLE_TRY(
+        mRenderer->copyCompressedTexture(context, source, sourceLevel, mTexStorage, destLevel));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::setStorage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2D::setStorage(const gl::Context *context,
                                     GLenum target,
                                     size_t levels,
                                     GLenum internalFormat,
@@ -1144,44 +1111,38 @@ gl::Error TextureD3D_2D::setStorage(ContextImpl *contextImpl,
         gl::Extents levelSize(std::max(1, size.width >> level),
                               std::max(1, size.height >> level),
                               1);
-        redefineImage(level, internalFormat, levelSize, true);
+        ANGLE_TRY(redefineImage(context, level, internalFormat, levelSize, true));
     }
 
     for (size_t level = levels; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
     {
-        redefineImage(level, GL_NONE, gl::Extents(0, 0, 1), true);
+        ANGLE_TRY(redefineImage(context, level, GL_NONE, gl::Extents(0, 0, 1), true));
     }
 
     // TODO(geofflang): Verify storage creation had no errors
-    bool renderTarget       = IsRenderTargetUsage(mState.getUsage());
-    TextureStorage *storage = mRenderer->createTextureStorage2D(
-        internalFormat, renderTarget, size.width, size.height, static_cast<int>(levels), false);
+    bool renderTarget = IsRenderTargetUsage(mState.getUsage());
+    TexStoragePointer storage(context);
+    storage.reset(mRenderer->createTextureStorage2D(internalFormat, renderTarget, size.width,
+                                                    size.height, static_cast<int>(levels), false));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     mImmutable = true;
 
     return gl::NoError();
 }
 
-void TextureD3D_2D::bindTexImage(egl::Surface *surface)
+gl::Error TextureD3D_2D::bindTexImage(const gl::Context *context, egl::Surface *surface)
 {
     GLenum internalformat = surface->getConfig()->renderTargetFormat;
 
     gl::Extents size(surface->getWidth(), surface->getHeight(), 1);
-    redefineImage(0, internalformat, size, true);
+    ANGLE_TRY(redefineImage(context, 0, internalformat, size, true));
 
-    if (mTexStorage)
-    {
-        SafeDelete(mTexStorage);
-    }
+    ANGLE_TRY(releaseTexStorage(context));
 
     SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface);
     ASSERT(surfaceD3D);
@@ -1190,42 +1151,47 @@ void TextureD3D_2D::bindTexImage(egl::Surface *surface)
     mEGLImageTarget = false;
 
     mDirtyImages = true;
+    return gl::NoError();
 }
 
-void TextureD3D_2D::releaseTexImage()
+gl::Error TextureD3D_2D::releaseTexImage(const gl::Context *context)
 {
     if (mTexStorage)
     {
-        SafeDelete(mTexStorage);
+        ANGLE_TRY(releaseTexStorage(context));
     }
 
     for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
-        redefineImage(i, GL_NONE, gl::Extents(0, 0, 1), true);
+        ANGLE_TRY(redefineImage(context, i, GL_NONE, gl::Extents(0, 0, 1), true));
     }
+
+    return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::setEGLImageTarget(GLenum target, egl::Image *image)
+gl::Error TextureD3D_2D::setEGLImageTarget(const gl::Context *context,
+                                           GLenum target,
+                                           egl::Image *image)
 {
     EGLImageD3D *eglImaged3d = GetImplAs<EGLImageD3D>(image);
 
     // Set the properties of the base mip level from the EGL image
     const auto &format = image->getFormat();
     gl::Extents size(static_cast<int>(image->getWidth()), static_cast<int>(image->getHeight()), 1);
-    redefineImage(0, format.info->sizedInternalFormat, size, true);
+    ANGLE_TRY(redefineImage(context, 0, format.info->sizedInternalFormat, size, true));
 
     // Clear all other images.
-    for (size_t level = 1; level < ArraySize(mImageArray); level++)
+    for (size_t level = 1; level < mImageArray.size(); level++)
     {
-        redefineImage(level, GL_NONE, gl::Extents(0, 0, 1), true);
+        ANGLE_TRY(redefineImage(context, level, GL_NONE, gl::Extents(0, 0, 1), true));
     }
 
-    SafeDelete(mTexStorage);
+    ANGLE_TRY(releaseTexStorage(context));
     mImageArray[0]->markClean();
 
     // Pass in the RenderTargetD3D here: createTextureStorage can't generate an error.
     RenderTargetD3D *renderTargetD3D = nullptr;
-    ANGLE_TRY(eglImaged3d->getRenderTarget(&renderTargetD3D));
+    ANGLE_TRY(eglImaged3d->getRenderTarget(context, &renderTargetD3D));
 
     mTexStorage     = mRenderer->createTextureStorageEGLImage(eglImaged3d, renderTargetD3D);
     mEGLImageTarget = true;
@@ -1233,7 +1199,7 @@ gl::Error TextureD3D_2D::setEGLImageTarget(GLenum target, egl::Image *image)
     return gl::NoError();
 }
 
-void TextureD3D_2D::initMipmapImages()
+gl::Error TextureD3D_2D::initMipmapImages(const gl::Context *context)
 {
     const GLuint baseLevel = mState.getEffectiveBaseLevel();
     const GLuint maxLevel  = mState.getMipmapMaxLevel();
@@ -1244,19 +1210,22 @@ void TextureD3D_2D::initMipmapImages()
         gl::Extents levelSize(std::max(getLevelZeroWidth() >> level, 1),
                               std::max(getLevelZeroHeight() >> level, 1), 1);
 
-        redefineImage(level, getBaseLevelInternalFormat(), levelSize, false);
+        ANGLE_TRY(redefineImage(context, level, getBaseLevelInternalFormat(), levelSize, false));
     }
+    return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureD3D_2D::getRenderTarget(const gl::Context *context,
+                                         const gl::ImageIndex &index,
+                                         RenderTargetD3D **outRT)
 {
     ASSERT(!index.hasLayer());
 
     // ensure the underlying texture is created
-    ANGLE_TRY(ensureRenderTarget());
-    ANGLE_TRY(updateStorageLevel(index.mipIndex));
+    ANGLE_TRY(ensureRenderTarget(context));
+    ANGLE_TRY(updateStorageLevel(context, index.mipIndex));
 
-    return mTexStorage->getRenderTarget(index, outRT);
+    return mTexStorage->getRenderTarget(context, index, outRT);
 }
 
 bool TextureD3D_2D::isValidLevel(int level) const
@@ -1285,8 +1254,9 @@ bool TextureD3D_2D::isLevelComplete(int level) const
         return true;
     }
 
-    ASSERT(level >= 0 && level <= (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
-    ImageD3D *image = mImageArray[level];
+    ASSERT(level >= 0 && level <= static_cast<int>(mImageArray.size()) &&
+           mImageArray[level] != nullptr);
+    ImageD3D *image = mImageArray[level].get();
 
     if (image->getInternalFormat() != getBaseLevelInternalFormat())
     {
@@ -1312,7 +1282,7 @@ bool TextureD3D_2D::isImageComplete(const gl::ImageIndex &index) const
 }
 
 // Constructs a native texture resource from the texture images
-gl::Error TextureD3D_2D::initializeStorage(bool renderTarget)
+gl::Error TextureD3D_2D::initializeStorage(const gl::Context *context, bool renderTarget)
 {
     // Only initialize the first time this texture is used as a render target or shader resource
     if (mTexStorage)
@@ -1328,25 +1298,22 @@ gl::Error TextureD3D_2D::initializeStorage(bool renderTarget)
 
     bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
 
-    TextureStorage *storage = nullptr;
+    TexStoragePointer storage(context);
     ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
     ASSERT(mTexStorage);
 
     // flush image data to the storage
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::createCompleteStorage(bool renderTarget, TextureStorage **outTexStorage) const
+gl::Error TextureD3D_2D::createCompleteStorage(bool renderTarget,
+                                               TexStoragePointer *outStorage) const
 {
     GLsizei width         = getLevelZeroWidth();
     GLsizei height        = getLevelZeroHeight();
@@ -1370,22 +1337,25 @@ gl::Error TextureD3D_2D::createCompleteStorage(bool renderTarget, TextureStorage
     }
 
     // TODO(geofflang): Determine if the texture creation succeeded
-    *outTexStorage = mRenderer->createTextureStorage2D(internalFormat, renderTarget, width, height, levels, hintLevelZeroOnly);
+    outStorage->reset(mRenderer->createTextureStorage2D(internalFormat, renderTarget, width, height,
+                                                        levels, hintLevelZeroOnly));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
+gl::Error TextureD3D_2D::setCompleteTexStorage(const gl::Context *context,
+                                               TextureStorage *newCompleteTexStorage)
 {
     if (newCompleteTexStorage && newCompleteTexStorage->isManaged())
     {
         for (int level = 0; level < newCompleteTexStorage->getLevelCount(); level++)
         {
-            ANGLE_TRY(mImageArray[level]->setManagedSurface2D(newCompleteTexStorage, level));
+            ANGLE_TRY(
+                mImageArray[level]->setManagedSurface2D(context, newCompleteTexStorage, level));
         }
     }
 
-    SafeDelete(mTexStorage);
+    ANGLE_TRY(releaseTexStorage(context));
     mTexStorage = newCompleteTexStorage;
 
     mDirtyImages = true;
@@ -1393,7 +1363,7 @@ gl::Error TextureD3D_2D::setCompleteTexStorage(TextureStorage *newCompleteTexSto
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::updateStorage()
+gl::Error TextureD3D_2D::updateStorage(const gl::Context *context)
 {
     ASSERT(mTexStorage != nullptr);
     GLint storageLevels = mTexStorage->getLevelCount();
@@ -1401,32 +1371,33 @@ gl::Error TextureD3D_2D::updateStorage()
     {
         if (mImageArray[level]->isDirty() && isLevelComplete(level))
         {
-            ANGLE_TRY(updateStorageLevel(level));
+            ANGLE_TRY(updateStorageLevel(context, level));
         }
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2D::updateStorageLevel(int level)
+gl::Error TextureD3D_2D::updateStorageLevel(const gl::Context *context, int level)
 {
-    ASSERT(level <= (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
+    ASSERT(level <= static_cast<int>(mImageArray.size()) && mImageArray[level] != nullptr);
     ASSERT(isLevelComplete(level));
 
     if (mImageArray[level]->isDirty())
     {
         gl::ImageIndex index = gl::ImageIndex::Make2D(level);
         gl::Box region(0, 0, 0, getWidth(level), getHeight(level), 1);
-        ANGLE_TRY(commitRegion(index, region));
+        ANGLE_TRY(commitRegion(context, index, region));
     }
 
     return gl::NoError();
 }
 
-void TextureD3D_2D::redefineImage(size_t level,
-                                  GLenum internalformat,
-                                  const gl::Extents &size,
-                                  bool forceRelease)
+gl::Error TextureD3D_2D::redefineImage(const gl::Context *context,
+                                       size_t level,
+                                       GLenum internalformat,
+                                       const gl::Extents &size,
+                                       bool forceRelease)
 {
     ASSERT(size.depth == 1);
 
@@ -1436,6 +1407,7 @@ void TextureD3D_2D::redefineImage(size_t level,
     const GLenum storageFormat = getBaseLevelInternalFormat();
 
     mImageArray[level]->redefine(GL_TEXTURE_2D, internalformat, size, forceRelease);
+    mDirtyImages = mDirtyImages || mImageArray[level]->isDirty();
 
     if (mTexStorage)
     {
@@ -1445,22 +1417,23 @@ void TextureD3D_2D::redefineImage(size_t level,
         // while orphaning
         if (level != 0 && mEGLImageTarget)
         {
-            // TODO(jmadill): Don't discard error.
-            mImageArray[0]->copyFromTexStorage(gl::ImageIndex::Make2D(0), mTexStorage);
+            ANGLE_TRY(mImageArray[0]->copyFromTexStorage(context, gl::ImageIndex::Make2D(0),
+                                                         mTexStorage));
         }
 
-        if ((level >= storageLevels && storageLevels != 0) ||
-            size.width != storageWidth ||
+        if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth ||
             size.height != storageHeight ||
-            internalformat != storageFormat)   // Discard mismatched storage
+            internalformat != storageFormat)  // Discard mismatched storage
         {
-            SafeDelete(mTexStorage);
+            ANGLE_TRY(releaseTexStorage(context));
             markAllImagesDirty();
         }
     }
 
     // Can't be an EGL image target after being redefined
     mEGLImageTarget = false;
+
+    return gl::NoError();
 }
 
 gl::ImageIndexIterator TextureD3D_2D::imageIterator() const
@@ -1489,57 +1462,49 @@ void TextureD3D_2D::markAllImagesDirty()
     mDirtyImages = true;
 }
 
-gl::Error TextureD3D_2D::setStorageMultisample(ContextImpl *contextImpl,
-                                               GLenum target,
-                                               GLsizei samples,
-                                               GLint internalFormat,
-                                               const gl::Extents &size,
-                                               GLboolean fixedSampleLocations)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError() << "setStorageMultisample is unimplemented.";
-}
-
 TextureD3D_Cube::TextureD3D_Cube(const gl::TextureState &state, RendererD3D *renderer)
     : TextureD3D(state, renderer)
 {
-    for (int i = 0; i < 6; i++)
+    for (auto &face : mImageArray)
     {
-        for (int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
+        for (auto &image : face)
         {
-            mImageArray[i][j] = renderer->createImage();
+            image.reset(renderer->createImage());
         }
     }
 }
 
-TextureD3D_Cube::~TextureD3D_Cube()
+gl::Error TextureD3D_Cube::onDestroy(const gl::Context *context)
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
-    for (int i = 0; i < 6; i++)
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
+    for (auto &face : mImageArray)
     {
-        for (int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
+        for (auto &image : face)
         {
-            SafeDelete(mImageArray[i][j]);
+            image.reset();
         }
     }
+    return TextureD3D::onDestroy(context);
+}
 
-    SafeDelete(mTexStorage);
+TextureD3D_Cube::~TextureD3D_Cube()
+{
 }
 
 ImageD3D *TextureD3D_Cube::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(layer >= 0 && layer < 6);
-    return mImageArray[layer][level];
+    return mImageArray[layer][level].get();
 }
 
 ImageD3D *TextureD3D_Cube::getImage(const gl::ImageIndex &index) const
 {
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(index.layerIndex >= 0 && index.layerIndex < 6);
-    return mImageArray[index.layerIndex][index.mipIndex];
+    return mImageArray[index.layerIndex][index.mipIndex].get();
 }
 
 GLsizei TextureD3D_Cube::getLayerCount(int level) const
@@ -1561,13 +1526,20 @@ bool TextureD3D_Cube::isDepth(GLint level, GLint layer) const
     return gl::GetSizedInternalFormatInfo(getInternalFormat(level, layer)).depthBits > 0;
 }
 
-gl::Error TextureD3D_Cube::setEGLImageTarget(GLenum target, egl::Image *image)
+bool TextureD3D_Cube::isSRGB(GLint level, GLint layer) const
+{
+    return gl::GetSizedInternalFormatInfo(getInternalFormat(level, layer)).colorEncoding == GL_SRGB;
+}
+
+gl::Error TextureD3D_Cube::setEGLImageTarget(const gl::Context *context,
+                                             GLenum target,
+                                             egl::Image *image)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_Cube::setImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::setImage(const gl::Context *context,
                                     GLenum target,
                                     size_t level,
                                     GLenum internalFormat,
@@ -1582,13 +1554,14 @@ gl::Error TextureD3D_Cube::setImage(ContextImpl *contextImpl,
     const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type);
     gl::ImageIndex index       = gl::ImageIndex::MakeCube(target, static_cast<GLint>(level));
 
-    redefineImage(index.layerIndex, static_cast<GLint>(level),
-                  internalFormatInfo.sizedInternalFormat, size);
+    ANGLE_TRY(redefineImage(context, index.layerIndex, static_cast<GLint>(level),
+                            internalFormatInfo.sizedInternalFormat, size,
+                            shouldForceReleaseImagesOnSetImage(pixels)));
 
-    return setImageImpl(index, type, unpack, pixels, 0);
+    return setImageImpl(context, index, type, unpack, pixels, 0);
 }
 
-gl::Error TextureD3D_Cube::setSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::setSubImage(const gl::Context *context,
                                        GLenum target,
                                        size_t level,
                                        const gl::Box &area,
@@ -1600,10 +1573,10 @@ gl::Error TextureD3D_Cube::setSubImage(ContextImpl *contextImpl,
     ASSERT(area.depth == 1 && area.z == 0);
 
     gl::ImageIndex index = gl::ImageIndex::MakeCube(target, static_cast<GLint>(level));
-    return TextureD3D::subImage(index, area, format, type, unpack, pixels, 0);
+    return TextureD3D::subImage(context, index, area, format, type, unpack, pixels, 0);
 }
 
-gl::Error TextureD3D_Cube::setCompressedImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::setCompressedImage(const gl::Context *context,
                                               GLenum target,
                                               size_t level,
                                               GLenum internalFormat,
@@ -1617,13 +1590,14 @@ gl::Error TextureD3D_Cube::setCompressedImage(ContextImpl *contextImpl,
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
     size_t faceIndex = gl::CubeMapTextureTargetToLayerIndex(target);
 
-    redefineImage(static_cast<int>(faceIndex), static_cast<GLint>(level), internalFormat, size);
+    ANGLE_TRY(redefineImage(context, static_cast<int>(faceIndex), static_cast<GLint>(level),
+                            internalFormat, size, shouldForceReleaseImagesOnSetImage(pixels)));
 
     gl::ImageIndex index = gl::ImageIndex::MakeCube(target, static_cast<GLint>(level));
-    return setCompressedImageImpl(index, unpack, pixels, 0);
+    return setCompressedImageImpl(context, index, unpack, pixels, 0);
 }
 
-gl::Error TextureD3D_Cube::setCompressedSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::setCompressedSubImage(const gl::Context *context,
                                                  GLenum target,
                                                  size_t level,
                                                  const gl::Box &area,
@@ -1636,11 +1610,11 @@ gl::Error TextureD3D_Cube::setCompressedSubImage(ContextImpl *contextImpl,
 
     gl::ImageIndex index = gl::ImageIndex::MakeCube(target, static_cast<GLint>(level));
 
-    ANGLE_TRY(TextureD3D::subImageCompressed(index, area, format, unpack, pixels, 0));
-    return commitRegion(index, area);
+    ANGLE_TRY(TextureD3D::subImageCompressed(context, index, area, format, unpack, pixels, 0));
+    return commitRegion(context, index, area);
 }
 
-gl::Error TextureD3D_Cube::copyImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::copyImage(const gl::Context *context,
                                      GLenum target,
                                      size_t imageLevel,
                                      const gl::Rectangle &sourceArea,
@@ -1654,7 +1628,9 @@ gl::Error TextureD3D_Cube::copyImage(ContextImpl *contextImpl,
     GLint level = static_cast<GLint>(imageLevel);
 
     gl::Extents size(sourceArea.width, sourceArea.height, 1);
-    redefineImage(static_cast<int>(faceIndex), level, internalFormatInfo.sizedInternalFormat, size);
+    ANGLE_TRY(redefineImage(context, static_cast<int>(faceIndex), level,
+                            internalFormatInfo.sizedInternalFormat, size,
+                            mRenderer->isRobustResourceInitEnabled()));
 
     gl::ImageIndex index = gl::ImageIndex::MakeCube(target, level);
     gl::Offset destOffset(0, 0, 0);
@@ -1663,28 +1639,28 @@ gl::Error TextureD3D_Cube::copyImage(ContextImpl *contextImpl,
     // so we should use the non-rendering copy path.
     if (!canCreateRenderTargetForImage(index) || mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
-        ANGLE_TRY(
-            mImageArray[faceIndex][level]->copyFromFramebuffer(destOffset, sourceArea, source));
+        ANGLE_TRY(mImageArray[faceIndex][level]->copyFromFramebuffer(context, destOffset,
+                                                                     sourceArea, source));
         mDirtyImages = true;
     }
     else
     {
-        ANGLE_TRY(ensureRenderTarget());
-        mImageArray[faceIndex][level]->markClean();
+        ANGLE_TRY(ensureRenderTarget(context));
 
         ASSERT(size.width == size.height);
 
         if (size.width > 0 && isValidFaceLevel(faceIndex, level))
         {
-            ANGLE_TRY(mRenderer->copyImageCube(source, sourceArea, internalFormat, destOffset,
-                                               mTexStorage, target, level));
+            ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, level));
+            ANGLE_TRY(mRenderer->copyImageCube(context, source, sourceArea, internalFormat,
+                                               destOffset, mTexStorage, target, level));
         }
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::copySubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::copySubImage(const gl::Context *context,
                                         GLenum target,
                                         size_t imageLevel,
                                         const gl::Offset &destOffset,
@@ -1700,8 +1676,8 @@ gl::Error TextureD3D_Cube::copySubImage(ContextImpl *contextImpl,
     // so we should use the non-rendering copy path.
     if (!canCreateRenderTargetForImage(index) || mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
-        gl::Error error =
-            mImageArray[faceIndex][level]->copyFromFramebuffer(destOffset, sourceArea, source);
+        gl::Error error = mImageArray[faceIndex][level]->copyFromFramebuffer(context, destOffset,
+                                                                             sourceArea, source);
         if (error.isError())
         {
             return error;
@@ -1711,11 +1687,11 @@ gl::Error TextureD3D_Cube::copySubImage(ContextImpl *contextImpl,
     }
     else
     {
-        ANGLE_TRY(ensureRenderTarget());
+        ANGLE_TRY(ensureRenderTarget(context));
         if (isValidFaceLevel(faceIndex, level))
         {
-            ANGLE_TRY(updateStorageFaceLevel(faceIndex, level));
-            ANGLE_TRY(mRenderer->copyImageCube(source, sourceArea,
+            ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, level));
+            ANGLE_TRY(mRenderer->copyImageCube(context, source, sourceArea,
                                                gl::GetUnsizedFormat(getBaseLevelInternalFormat()),
                                                destOffset, mTexStorage, target, level));
         }
@@ -1724,7 +1700,7 @@ gl::Error TextureD3D_Cube::copySubImage(ContextImpl *contextImpl,
     return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::copyTexture(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::copyTexture(const gl::Context *context,
                                        GLenum target,
                                        size_t level,
                                        GLenum internalFormat,
@@ -1745,31 +1721,44 @@ gl::Error TextureD3D_Cube::copyTexture(ContextImpl *contextImpl,
     const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type);
     gl::Extents size(static_cast<int>(source->getWidth(sourceTarget, sourceLevel)),
                      static_cast<int>(source->getHeight(sourceTarget, sourceLevel)), 1);
-    redefineImage(faceIndex, destLevel, internalFormatInfo.sizedInternalFormat, size);
+    ANGLE_TRY(redefineImage(context, faceIndex, destLevel, internalFormatInfo.sizedInternalFormat,
+                            size, false));
+
+    gl::Rectangle sourceRect(0, 0, size.width, size.height);
+    gl::Offset destOffset(0, 0, 0);
 
-    if (canCreateRenderTargetForImage(gl::ImageIndex::MakeCube(target, destLevel)))
+    if (!isSRGB(destLevel, faceIndex) &&
+        canCreateRenderTargetForImage(gl::ImageIndex::MakeCube(target, destLevel)))
     {
-        ANGLE_TRY(ensureRenderTarget());
+        ANGLE_TRY(ensureRenderTarget(context));
         ASSERT(isValidFaceLevel(faceIndex, destLevel));
-        ANGLE_TRY(updateStorageFaceLevel(faceIndex, destLevel));
+        ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, destLevel));
 
-        gl::Rectangle sourceRect(0, 0, size.width, size.height);
-        gl::Offset destOffset(0, 0, 0);
-        ANGLE_TRY(mRenderer->copyTexture(source, static_cast<GLint>(sourceLevel), sourceRect,
-                                         internalFormatInfo.format, destOffset, mTexStorage, target,
-                                         destLevel, unpackFlipY, unpackPremultiplyAlpha,
-                                         unpackUnmultiplyAlpha));
+        ANGLE_TRY(mRenderer->copyTexture(context, source, static_cast<GLint>(sourceLevel),
+                                         sourceRect, internalFormatInfo.format, destOffset,
+                                         mTexStorage, target, destLevel, unpackFlipY,
+                                         unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
     else
     {
-        ASSERT(internalFormat == GL_RGB9_E5);
-        UNIMPLEMENTED();
+        gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(static_cast<GLint>(sourceLevel));
+        TextureD3D *sourceD3D           = GetImplAs<TextureD3D>(source);
+        ImageD3D *sourceImage           = nullptr;
+        ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage));
+
+        gl::ImageIndex destImageIndex =
+            gl::ImageIndex::MakeCube(target, static_cast<GLint>(destLevel));
+        ImageD3D *destImage = nullptr;
+        ANGLE_TRY(getImageAndSyncFromStorage(context, destImageIndex, &destImage));
+
+        ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceRect, destOffset,
+                                       unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::copySubTexture(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::copySubTexture(const gl::Context *context,
                                           GLenum target,
                                           size_t level,
                                           const gl::Offset &destOffset,
@@ -1785,27 +1774,38 @@ gl::Error TextureD3D_Cube::copySubTexture(ContextImpl *contextImpl,
     GLint destLevel = static_cast<GLint>(level);
     int faceIndex   = static_cast<int>(gl::CubeMapTextureTargetToLayerIndex(target));
 
-    if (canCreateRenderTargetForImage(gl::ImageIndex::MakeCube(target, destLevel)))
+    if (!isSRGB(destLevel, faceIndex) &&
+        canCreateRenderTargetForImage(gl::ImageIndex::MakeCube(target, destLevel)))
     {
-        ANGLE_TRY(ensureRenderTarget());
+        ANGLE_TRY(ensureRenderTarget(context));
         ASSERT(isValidFaceLevel(faceIndex, destLevel));
-        ANGLE_TRY(updateStorageFaceLevel(faceIndex, destLevel));
+        ANGLE_TRY(updateStorageFaceLevel(context, faceIndex, destLevel));
 
         ANGLE_TRY(mRenderer->copyTexture(
-            source, static_cast<GLint>(sourceLevel), sourceArea,
+            context, source, static_cast<GLint>(sourceLevel), sourceArea,
             gl::GetUnsizedFormat(getInternalFormat(destLevel, faceIndex)), destOffset, mTexStorage,
             target, destLevel, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
     else
     {
-        ASSERT(getInternalFormat(destLevel, faceIndex) == GL_RGB9_E5);
-        UNIMPLEMENTED();
+        gl::ImageIndex sourceImageIndex = gl::ImageIndex::Make2D(static_cast<GLint>(sourceLevel));
+        TextureD3D *sourceD3D           = GetImplAs<TextureD3D>(source);
+        ImageD3D *sourceImage           = nullptr;
+        ANGLE_TRY(sourceD3D->getImageAndSyncFromStorage(context, sourceImageIndex, &sourceImage));
+
+        gl::ImageIndex destImageIndex =
+            gl::ImageIndex::MakeCube(target, static_cast<GLint>(destLevel));
+        ImageD3D *destImage = nullptr;
+        ANGLE_TRY(getImageAndSyncFromStorage(context, destImageIndex, &destImage));
+
+        ANGLE_TRY(mRenderer->copyImage(context, destImage, sourceImage, sourceArea, destOffset,
+                                       unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::setStorage(ContextImpl *contextImpl,
+gl::Error TextureD3D_Cube::setStorage(const gl::Context *context,
                                       GLenum target,
                                       size_t levels,
                                       GLenum internalFormat,
@@ -1834,17 +1834,14 @@ gl::Error TextureD3D_Cube::setStorage(ContextImpl *contextImpl,
     // TODO(geofflang): Verify storage creation had no errors
     bool renderTarget = IsRenderTargetUsage(mState.getUsage());
 
-    TextureStorage *storage = mRenderer->createTextureStorageCube(
-        internalFormat, renderTarget, size.width, static_cast<int>(levels), false);
+    TexStoragePointer storage(context);
+    storage.reset(mRenderer->createTextureStorageCube(internalFormat, renderTarget, size.width,
+                                                      static_cast<int>(levels), false));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     mImmutable = true;
 
@@ -1878,17 +1875,19 @@ bool TextureD3D_Cube::isCubeComplete() const
     return true;
 }
 
-void TextureD3D_Cube::bindTexImage(egl::Surface *surface)
+gl::Error TextureD3D_Cube::bindTexImage(const gl::Context *context, egl::Surface *surface)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-void TextureD3D_Cube::releaseTexImage()
+gl::Error TextureD3D_Cube::releaseTexImage(const gl::Context *context)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-void TextureD3D_Cube::initMipmapImages()
+gl::Error TextureD3D_Cube::initMipmapImages(const gl::Context *context)
 {
     const GLuint baseLevel = mState.getEffectiveBaseLevel();
     const GLuint maxLevel  = mState.getMipmapMaxLevel();
@@ -1900,24 +1899,28 @@ void TextureD3D_Cube::initMipmapImages()
         {
             int faceLevelSize =
                 (std::max(mImageArray[faceIndex][baseLevel]->getWidth() >> (level - baseLevel), 1));
-            redefineImage(faceIndex, level, mImageArray[faceIndex][baseLevel]->getInternalFormat(),
-                          gl::Extents(faceLevelSize, faceLevelSize, 1));
+            ANGLE_TRY(redefineImage(context, faceIndex, level,
+                                    mImageArray[faceIndex][baseLevel]->getInternalFormat(),
+                                    gl::Extents(faceLevelSize, faceLevelSize, 1), false));
         }
     }
+    return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureD3D_Cube::getRenderTarget(const gl::Context *context,
+                                           const gl::ImageIndex &index,
+                                           RenderTargetD3D **outRT)
 {
     ASSERT(gl::IsCubeMapTextureTarget(index.type));
 
     // ensure the underlying texture is created
-    ANGLE_TRY(ensureRenderTarget());
-    ANGLE_TRY(updateStorageFaceLevel(index.layerIndex, index.mipIndex));
+    ANGLE_TRY(ensureRenderTarget(context));
+    ANGLE_TRY(updateStorageFaceLevel(context, index.layerIndex, index.mipIndex));
 
-    return mTexStorage->getRenderTarget(index, outRT);
+    return mTexStorage->getRenderTarget(context, index, outRT);
 }
 
-gl::Error TextureD3D_Cube::initializeStorage(bool renderTarget)
+gl::Error TextureD3D_Cube::initializeStorage(const gl::Context *context, bool renderTarget)
 {
     // Only initialize the first time this texture is used as a render target or shader resource
     if (mTexStorage)
@@ -1933,25 +1936,22 @@ gl::Error TextureD3D_Cube::initializeStorage(bool renderTarget)
 
     bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
 
-    TextureStorage *storage = nullptr;
+    TexStoragePointer storage(context);
     ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
     ASSERT(mTexStorage);
 
     // flush image data to the storage
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::createCompleteStorage(bool renderTarget, TextureStorage **outTexStorage) const
+gl::Error TextureD3D_Cube::createCompleteStorage(bool renderTarget,
+                                                 TexStoragePointer *outStorage) const
 {
     GLsizei size = getLevelZeroWidth();
 
@@ -1976,12 +1976,14 @@ gl::Error TextureD3D_Cube::createCompleteStorage(bool renderTarget, TextureStora
     }
 
     // TODO (geofflang): detect if storage creation succeeded
-    *outTexStorage = mRenderer->createTextureStorageCube(getBaseLevelInternalFormat(), renderTarget, size, levels, hintLevelZeroOnly);
+    outStorage->reset(mRenderer->createTextureStorageCube(
+        getBaseLevelInternalFormat(), renderTarget, size, levels, hintLevelZeroOnly));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
+gl::Error TextureD3D_Cube::setCompleteTexStorage(const gl::Context *context,
+                                                 TextureStorage *newCompleteTexStorage)
 {
     if (newCompleteTexStorage && newCompleteTexStorage->isManaged())
     {
@@ -1990,19 +1992,19 @@ gl::Error TextureD3D_Cube::setCompleteTexStorage(TextureStorage *newCompleteTexS
             for (int level = 0; level < newCompleteTexStorage->getLevelCount(); level++)
             {
                 ANGLE_TRY(mImageArray[faceIndex][level]->setManagedSurfaceCube(
-                    newCompleteTexStorage, faceIndex, level));
+                    context, newCompleteTexStorage, faceIndex, level));
             }
         }
     }
 
-    SafeDelete(mTexStorage);
+    ANGLE_TRY(releaseTexStorage(context));
     mTexStorage = newCompleteTexStorage;
 
     mDirtyImages = true;
     return gl::NoError();
 }
 
-gl::Error TextureD3D_Cube::updateStorage()
+gl::Error TextureD3D_Cube::updateStorage(const gl::Context *context)
 {
     ASSERT(mTexStorage != nullptr);
     GLint storageLevels = mTexStorage->getLevelCount();
@@ -2012,7 +2014,7 @@ gl::Error TextureD3D_Cube::updateStorage()
         {
             if (mImageArray[face][level]->isDirty() && isFaceLevelComplete(face, level))
             {
-                ANGLE_TRY(updateStorageFaceLevel(face, level));
+                ANGLE_TRY(updateStorageFaceLevel(context, face, level));
             }
         }
     }
@@ -2031,7 +2033,7 @@ bool TextureD3D_Cube::isFaceLevelComplete(int faceIndex, int level) const
     {
         return false;
     }
-    ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) &&
+    ASSERT(level >= 0 && faceIndex < 6 && level < static_cast<int>(mImageArray[faceIndex].size()) &&
            mImageArray[faceIndex][level] != nullptr);
 
     if (isImmutable())
@@ -2055,7 +2057,7 @@ bool TextureD3D_Cube::isFaceLevelComplete(int faceIndex, int level) const
     }
 
     // Check that non-zero levels are consistent with the base level.
-    const ImageD3D *faceLevelImage = mImageArray[faceIndex][level];
+    const ImageD3D *faceLevelImage = mImageArray[faceIndex][level].get();
 
     if (faceLevelImage->getInternalFormat() != getBaseLevelInternalFormat())
     {
@@ -2075,45 +2077,55 @@ bool TextureD3D_Cube::isImageComplete(const gl::ImageIndex &index) const
     return isFaceLevelComplete(index.layerIndex, index.mipIndex);
 }
 
-gl::Error TextureD3D_Cube::updateStorageFaceLevel(int faceIndex, int level)
+gl::Error TextureD3D_Cube::updateStorageFaceLevel(const gl::Context *context,
+                                                  int faceIndex,
+                                                  int level)
 {
-    ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) &&
+    ASSERT(level >= 0 && faceIndex < 6 && level < static_cast<int>(mImageArray[faceIndex].size()) &&
            mImageArray[faceIndex][level] != nullptr);
-    ImageD3D *image = mImageArray[faceIndex][level];
+    ImageD3D *image = mImageArray[faceIndex][level].get();
 
     if (image->isDirty())
     {
         GLenum faceTarget = gl::LayerIndexToCubeMapTextureTarget(faceIndex);
         gl::ImageIndex index = gl::ImageIndex::MakeCube(faceTarget, level);
         gl::Box region(0, 0, 0, image->getWidth(), image->getHeight(), 1);
-        ANGLE_TRY(commitRegion(index, region));
+        ANGLE_TRY(commitRegion(context, index, region));
     }
 
     return gl::NoError();
 }
 
-void TextureD3D_Cube::redefineImage(int faceIndex, GLint level, GLenum internalformat, const gl::Extents &size)
+gl::Error TextureD3D_Cube::redefineImage(const gl::Context *context,
+                                         int faceIndex,
+                                         GLint level,
+                                         GLenum internalformat,
+                                         const gl::Extents &size,
+                                         bool forceRelease)
 {
     // If there currently is a corresponding storage texture image, it has these parameters
     const int storageWidth     = std::max(1, getLevelZeroWidth() >> level);
     const int storageHeight    = std::max(1, getLevelZeroHeight() >> level);
     const GLenum storageFormat = getBaseLevelInternalFormat();
 
-    mImageArray[faceIndex][level]->redefine(GL_TEXTURE_CUBE_MAP, internalformat, size, false);
+    mImageArray[faceIndex][level]->redefine(GL_TEXTURE_CUBE_MAP, internalformat, size,
+                                            forceRelease);
+    mDirtyImages = mDirtyImages || mImageArray[faceIndex][level]->isDirty();
 
     if (mTexStorage)
     {
         const int storageLevels = mTexStorage->getLevelCount();
 
-        if ((level >= storageLevels && storageLevels != 0) ||
-            size.width != storageWidth ||
+        if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth ||
             size.height != storageHeight ||
-            internalformat != storageFormat)   // Discard mismatched storage
+            internalformat != storageFormat)  // Discard mismatched storage
         {
             markAllImagesDirty();
-            SafeDelete(mTexStorage);
+            ANGLE_TRY(releaseTexStorage(context));
         }
     }
+
+    return gl::NoError();
 }
 
 gl::ImageIndexIterator TextureD3D_Cube::imageIterator() const
@@ -2150,28 +2162,31 @@ TextureD3D_3D::TextureD3D_3D(const gl::TextureState &state, RendererD3D *rendere
 {
     for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
     {
-        mImageArray[i] = renderer->createImage();
+        mImageArray[i].reset(renderer->createImage());
     }
 }
 
-TextureD3D_3D::~TextureD3D_3D()
+gl::Error TextureD3D_3D::onDestroy(const gl::Context *context)
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
-    for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
+    for (auto &image : mImageArray)
     {
-        delete mImageArray[i];
+        image.reset();
     }
+    return TextureD3D::onDestroy(context);
+}
 
-    SafeDelete(mTexStorage);
+TextureD3D_3D::~TextureD3D_3D()
+{
 }
 
 ImageD3D *TextureD3D_3D::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(layer == 0);
-    return mImageArray[level];
+    return mImageArray[level].get();
 }
 
 ImageD3D *TextureD3D_3D::getImage(const gl::ImageIndex &index) const
@@ -2179,7 +2194,7 @@ ImageD3D *TextureD3D_3D::getImage(const gl::ImageIndex &index) const
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
     ASSERT(!index.hasLayer());
     ASSERT(index.type == GL_TEXTURE_3D);
-    return mImageArray[index.mipIndex];
+    return mImageArray[index.mipIndex].get();
 }
 
 GLsizei TextureD3D_3D::getLayerCount(int level) const
@@ -2225,13 +2240,15 @@ bool TextureD3D_3D::isDepth(GLint level) const
     return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).depthBits > 0;
 }
 
-gl::Error TextureD3D_3D::setEGLImageTarget(GLenum target, egl::Image *image)
+gl::Error TextureD3D_3D::setEGLImageTarget(const gl::Context *context,
+                                           GLenum target,
+                                           egl::Image *image)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_3D::setImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_3D::setImage(const gl::Context *context,
                                   GLenum target,
                                   size_t imageLevel,
                                   GLenum internalFormat,
@@ -2245,7 +2262,8 @@ gl::Error TextureD3D_3D::setImage(ContextImpl *contextImpl,
     const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type);
 
     GLint level = static_cast<GLint>(imageLevel);
-    redefineImage(level, internalFormatInfo.sizedInternalFormat, size);
+    ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, size,
+                            shouldForceReleaseImagesOnSetImage(pixels)));
 
     bool fastUnpacked = false;
 
@@ -2257,12 +2275,12 @@ gl::Error TextureD3D_3D::setImage(ContextImpl *contextImpl,
     {
         // Will try to create RT storage if it does not exist
         RenderTargetD3D *destRenderTarget = nullptr;
-        ANGLE_TRY(getRenderTarget(index, &destRenderTarget));
+        ANGLE_TRY(getRenderTarget(context, index, &destRenderTarget));
 
         gl::Box destArea(0, 0, 0, getWidth(level), getHeight(level), getDepth(level));
 
-        ANGLE_TRY(fastUnpackPixels(unpack, pixels, destArea, internalFormatInfo.sizedInternalFormat,
-                                   type, destRenderTarget));
+        ANGLE_TRY(fastUnpackPixels(context, unpack, pixels, destArea,
+                                   internalFormatInfo.sizedInternalFormat, type, destRenderTarget));
 
         // Ensure we don't overwrite our newly initialized data
         mImageArray[level]->markClean();
@@ -2272,13 +2290,13 @@ gl::Error TextureD3D_3D::setImage(ContextImpl *contextImpl,
 
     if (!fastUnpacked)
     {
-        ANGLE_TRY(setImageImpl(index, type, unpack, pixels, 0));
+        ANGLE_TRY(setImageImpl(context, index, type, unpack, pixels, 0));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_3D::setSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_3D::setSubImage(const gl::Context *context,
                                      GLenum target,
                                      size_t imageLevel,
                                      const gl::Box &area,
@@ -2296,18 +2314,19 @@ gl::Error TextureD3D_3D::setSubImage(ContextImpl *contextImpl,
     if (isFastUnpackable(unpack, getInternalFormat(level)) && isLevelComplete(level))
     {
         RenderTargetD3D *destRenderTarget = nullptr;
-        ANGLE_TRY(getRenderTarget(index, &destRenderTarget));
+        ANGLE_TRY(getRenderTarget(context, index, &destRenderTarget));
         ASSERT(!mImageArray[level]->isDirty());
 
-        return fastUnpackPixels(unpack, pixels, area, getInternalFormat(level), type, destRenderTarget);
+        return fastUnpackPixels(context, unpack, pixels, area, getInternalFormat(level), type,
+                                destRenderTarget);
     }
     else
     {
-        return TextureD3D::subImage(index, area, format, type, unpack, pixels, 0);
+        return TextureD3D::subImage(context, index, area, format, type, unpack, pixels, 0);
     }
 }
 
-gl::Error TextureD3D_3D::setCompressedImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_3D::setCompressedImage(const gl::Context *context,
                                             GLenum target,
                                             size_t imageLevel,
                                             GLenum internalFormat,
@@ -2320,13 +2339,14 @@ gl::Error TextureD3D_3D::setCompressedImage(ContextImpl *contextImpl,
 
     GLint level = static_cast<GLint>(imageLevel);
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    redefineImage(level, internalFormat, size);
+    ANGLE_TRY(redefineImage(context, level, internalFormat, size,
+                            shouldForceReleaseImagesOnSetImage(pixels)));
 
     gl::ImageIndex index = gl::ImageIndex::Make3D(level);
-    return setCompressedImageImpl(index, unpack, pixels, 0);
+    return setCompressedImageImpl(context, index, unpack, pixels, 0);
 }
 
-gl::Error TextureD3D_3D::setCompressedSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_3D::setCompressedSubImage(const gl::Context *context,
                                                GLenum target,
                                                size_t level,
                                                const gl::Box &area,
@@ -2338,11 +2358,11 @@ gl::Error TextureD3D_3D::setCompressedSubImage(ContextImpl *contextImpl,
     ASSERT(target == GL_TEXTURE_3D);
 
     gl::ImageIndex index = gl::ImageIndex::Make3D(static_cast<GLint>(level));
-    ANGLE_TRY(TextureD3D::subImageCompressed(index, area, format, unpack, pixels, 0));
-    return commitRegion(index, area);
+    ANGLE_TRY(TextureD3D::subImageCompressed(context, index, area, format, unpack, pixels, 0));
+    return commitRegion(context, index, area);
 }
 
-gl::Error TextureD3D_3D::copyImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_3D::copyImage(const gl::Context *context,
                                    GLenum target,
                                    size_t level,
                                    const gl::Rectangle &sourceArea,
@@ -2350,10 +2370,10 @@ gl::Error TextureD3D_3D::copyImage(ContextImpl *contextImpl,
                                    const gl::Framebuffer *source)
 {
     UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION, "Copying 3D textures is unimplemented.");
+    return gl::InternalError() << "Copying 3D textures is unimplemented.";
 }
 
-gl::Error TextureD3D_3D::copySubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_3D::copySubImage(const gl::Context *context,
                                       GLenum target,
                                       size_t imageLevel,
                                       const gl::Offset &destOffset,
@@ -2362,35 +2382,41 @@ gl::Error TextureD3D_3D::copySubImage(ContextImpl *contextImpl,
 {
     ASSERT(target == GL_TEXTURE_3D);
 
-    GLint level          = static_cast<GLint>(imageLevel);
+    GLint level = static_cast<GLint>(imageLevel);
+
+    gl::Extents fbSize = source->getReadColorbuffer()->getSize();
+    gl::Rectangle clippedSourceArea;
+    if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height),
+                       &clippedSourceArea))
+    {
+        return gl::NoError();
+    }
+    const gl::Offset clippedDestOffset(destOffset.x + clippedSourceArea.x - sourceArea.x,
+                                       destOffset.y + clippedSourceArea.y - sourceArea.y,
+                                       destOffset.z);
 
-    // Currently, 3D single-layer blits are broken because we don't know how to make an SRV
-    // for a single layer of a 3D texture.
-    // TODO(jmadill): Investigate 3D blits in D3D11.
-    // gl::ImageIndex index = gl::ImageIndex::Make3D(level);
+    // Currently, copying directly to the storage is not possible because it's not possible to
+    // create an SRV from a single layer of a 3D texture.  Instead, make sure the image is up to
+    // date before the copy and then copy back to the storage afterwards if needed.
+    // TODO: Investigate 3D blits in D3D11.
 
-    // if (!canCreateRenderTargetForImage(index))
+    bool syncTexStorage = mTexStorage && isLevelComplete(level);
+    if (syncTexStorage)
     {
-        ANGLE_TRY(mImageArray[level]->copyFromFramebuffer(destOffset, sourceArea, source));
-        mDirtyImages = true;
+        gl::ImageIndex index = gl::ImageIndex::Make3D(level);
+        mImageArray[level]->copyFromTexStorage(context, index, mTexStorage);
+    }
+    ANGLE_TRY(mImageArray[level]->copyFromFramebuffer(context, clippedDestOffset, clippedSourceArea,
+                                                      source));
+    if (syncTexStorage)
+    {
+        updateStorageLevel(context, level);
     }
-    // else
-    //{
-    //    ANGLE_TRY(ensureRenderTarget());
-    //    if (isValidLevel(level))
-    //    {
-    //        ANGLE_TRY(updateStorageLevel(level));
-    //        ANGLE_TRY(mRenderer->copyImage3D(
-    //            source, sourceArea,
-    //            gl::GetInternalFormatInfo(getBaseLevelInternalFormat()).format,
-    //            destOffset, mTexStorage, level));
-    //    }
-    //}
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_3D::setStorage(ContextImpl *contextImpl,
+gl::Error TextureD3D_3D::setStorage(const gl::Context *context,
                                     GLenum target,
                                     size_t levels,
                                     GLenum internalFormat,
@@ -2413,35 +2439,34 @@ gl::Error TextureD3D_3D::setStorage(ContextImpl *contextImpl,
 
     // TODO(geofflang): Verify storage creation had no errors
     bool renderTarget = IsRenderTargetUsage(mState.getUsage());
-    TextureStorage *storage =
-        mRenderer->createTextureStorage3D(internalFormat, renderTarget, size.width, size.height,
-                                          size.depth, static_cast<int>(levels));
+    TexStoragePointer storage(context);
+    storage.reset(mRenderer->createTextureStorage3D(internalFormat, renderTarget, size.width,
+                                                    size.height, size.depth,
+                                                    static_cast<int>(levels)));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     mImmutable = true;
 
     return gl::NoError();
 }
 
-void TextureD3D_3D::bindTexImage(egl::Surface *surface)
+gl::Error TextureD3D_3D::bindTexImage(const gl::Context *context, egl::Surface *surface)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-void TextureD3D_3D::releaseTexImage()
+gl::Error TextureD3D_3D::releaseTexImage(const gl::Context *context)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-void TextureD3D_3D::initMipmapImages()
+gl::Error TextureD3D_3D::initMipmapImages(const gl::Context *context)
 {
     const GLuint baseLevel = mState.getEffectiveBaseLevel();
     const GLuint maxLevel  = mState.getMipmapMaxLevel();
@@ -2452,28 +2477,32 @@ void TextureD3D_3D::initMipmapImages()
         gl::Extents levelSize(std::max(getLevelZeroWidth() >> level, 1),
                               std::max(getLevelZeroHeight() >> level, 1),
                               std::max(getLevelZeroDepth() >> level, 1));
-        redefineImage(level, getBaseLevelInternalFormat(), levelSize);
+        ANGLE_TRY(redefineImage(context, level, getBaseLevelInternalFormat(), levelSize, false));
     }
+
+    return gl::NoError();
 }
 
-gl::Error TextureD3D_3D::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureD3D_3D::getRenderTarget(const gl::Context *context,
+                                         const gl::ImageIndex &index,
+                                         RenderTargetD3D **outRT)
 {
     // ensure the underlying texture is created
-    ANGLE_TRY(ensureRenderTarget());
+    ANGLE_TRY(ensureRenderTarget(context));
 
     if (index.hasLayer())
     {
-        ANGLE_TRY(updateStorage());
+        ANGLE_TRY(updateStorage(context));
     }
     else
     {
-        ANGLE_TRY(updateStorageLevel(index.mipIndex));
+        ANGLE_TRY(updateStorageLevel(context, index.mipIndex));
     }
 
-    return mTexStorage->getRenderTarget(index, outRT);
+    return mTexStorage->getRenderTarget(context, index, outRT);
 }
 
-gl::Error TextureD3D_3D::initializeStorage(bool renderTarget)
+gl::Error TextureD3D_3D::initializeStorage(const gl::Context *context, bool renderTarget)
 {
     // Only initialize the first time this texture is used as a render target or shader resource
     if (mTexStorage)
@@ -2489,25 +2518,22 @@ gl::Error TextureD3D_3D::initializeStorage(bool renderTarget)
 
     bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
 
-    TextureStorage *storage = nullptr;
+    TexStoragePointer storage(context);
     ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
     ASSERT(mTexStorage);
 
     // flush image data to the storage
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_3D::createCompleteStorage(bool renderTarget, TextureStorage **outStorage) const
+gl::Error TextureD3D_3D::createCompleteStorage(bool renderTarget,
+                                               TexStoragePointer *outStorage) const
 {
     GLsizei width         = getLevelZeroWidth();
     GLsizei height        = getLevelZeroHeight();
@@ -2520,14 +2546,16 @@ gl::Error TextureD3D_3D::createCompleteStorage(bool renderTarget, TextureStorage
     GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, depth));
 
     // TODO: Verify creation of the storage succeeded
-    *outStorage = mRenderer->createTextureStorage3D(internalFormat, renderTarget, width, height, depth, levels);
+    outStorage->reset(mRenderer->createTextureStorage3D(internalFormat, renderTarget, width, height,
+                                                        depth, levels));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_3D::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
+gl::Error TextureD3D_3D::setCompleteTexStorage(const gl::Context *context,
+                                               TextureStorage *newCompleteTexStorage)
 {
-    SafeDelete(mTexStorage);
+    ANGLE_TRY(releaseTexStorage(context));
     mTexStorage = newCompleteTexStorage;
     mDirtyImages = true;
 
@@ -2537,7 +2565,7 @@ gl::Error TextureD3D_3D::setCompleteTexStorage(TextureStorage *newCompleteTexSto
     return gl::NoError();
 }
 
-gl::Error TextureD3D_3D::updateStorage()
+gl::Error TextureD3D_3D::updateStorage(const gl::Context *context)
 {
     ASSERT(mTexStorage != nullptr);
     GLint storageLevels = mTexStorage->getLevelCount();
@@ -2545,7 +2573,7 @@ gl::Error TextureD3D_3D::updateStorage()
     {
         if (mImageArray[level]->isDirty() && isLevelComplete(level))
         {
-            ANGLE_TRY(updateStorageLevel(level));
+            ANGLE_TRY(updateStorageLevel(context, level));
         }
     }
 
@@ -2559,7 +2587,8 @@ bool TextureD3D_3D::isValidLevel(int level) const
 
 bool TextureD3D_3D::isLevelComplete(int level) const
 {
-    ASSERT(level >= 0 && level < (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
+    ASSERT(level >= 0 && level < static_cast<int>(mImageArray.size()) &&
+           mImageArray[level] != nullptr);
 
     if (isImmutable())
     {
@@ -2580,7 +2609,7 @@ bool TextureD3D_3D::isLevelComplete(int level) const
         return true;
     }
 
-    ImageD3D *levelImage = mImageArray[level];
+    ImageD3D *levelImage = mImageArray[level].get();
 
     if (levelImage->getInternalFormat() != getBaseLevelInternalFormat())
     {
@@ -2610,22 +2639,27 @@ bool TextureD3D_3D::isImageComplete(const gl::ImageIndex &index) const
     return isLevelComplete(index.mipIndex);
 }
 
-gl::Error TextureD3D_3D::updateStorageLevel(int level)
+gl::Error TextureD3D_3D::updateStorageLevel(const gl::Context *context, int level)
 {
-    ASSERT(level >= 0 && level < (int)ArraySize(mImageArray) && mImageArray[level] != nullptr);
+    ASSERT(level >= 0 && level < static_cast<int>(mImageArray.size()) &&
+           mImageArray[level] != nullptr);
     ASSERT(isLevelComplete(level));
 
     if (mImageArray[level]->isDirty())
     {
         gl::ImageIndex index = gl::ImageIndex::Make3D(level);
         gl::Box region(0, 0, 0, getWidth(level), getHeight(level), getDepth(level));
-        ANGLE_TRY(commitRegion(index, region));
+        ANGLE_TRY(commitRegion(context, index, region));
     }
 
     return gl::NoError();
 }
 
-void TextureD3D_3D::redefineImage(GLint level, GLenum internalformat, const gl::Extents &size)
+gl::Error TextureD3D_3D::redefineImage(const gl::Context *context,
+                                       GLint level,
+                                       GLenum internalformat,
+                                       const gl::Extents &size,
+                                       bool forceRelease)
 {
     // If there currently is a corresponding storage texture image, it has these parameters
     const int storageWidth  = std::max(1, getLevelZeroWidth() >> level);
@@ -2633,22 +2667,23 @@ void TextureD3D_3D::redefineImage(GLint level, GLenum internalformat, const gl::
     const int storageDepth  = std::max(1, getLevelZeroDepth() >> level);
     const GLenum storageFormat = getBaseLevelInternalFormat();
 
-    mImageArray[level]->redefine(GL_TEXTURE_3D, internalformat, size, false);
+    mImageArray[level]->redefine(GL_TEXTURE_3D, internalformat, size, forceRelease);
+    mDirtyImages = mDirtyImages || mImageArray[level]->isDirty();
 
     if (mTexStorage)
     {
         const int storageLevels = mTexStorage->getLevelCount();
 
-        if ((level >= storageLevels && storageLevels != 0) ||
-            size.width != storageWidth ||
-            size.height != storageHeight ||
-            size.depth != storageDepth ||
-            internalformat != storageFormat)   // Discard mismatched storage
+        if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth ||
+            size.height != storageHeight || size.depth != storageDepth ||
+            internalformat != storageFormat)  // Discard mismatched storage
         {
             markAllImagesDirty();
-            SafeDelete(mTexStorage);
+            ANGLE_TRY(releaseTexStorage(context));
         }
     }
+
+    return gl::NoError();
 }
 
 gl::ImageIndexIterator TextureD3D_3D::imageIterator() const
@@ -2694,13 +2729,17 @@ TextureD3D_2DArray::TextureD3D_2DArray(const gl::TextureState &state, RendererD3
     }
 }
 
-TextureD3D_2DArray::~TextureD3D_2DArray()
+gl::Error TextureD3D_2DArray::onDestroy(const gl::Context *context)
 {
-    // Delete the Images before the TextureStorage.
-    // Images might be relying on the TextureStorage for some of their data.
-    // If TextureStorage is deleted before the Images, then their data will be wastefully copied back from the GPU before we delete the Images.
+    // Delete the Images before the TextureStorage. Images might be relying on the TextureStorage
+    // for some of their data. If TextureStorage is deleted before the Images, then their data will
+    // be wastefully copied back from the GPU before we delete the Images.
     deleteImages();
-    SafeDelete(mTexStorage);
+    return TextureD3D::onDestroy(context);
+}
+
+TextureD3D_2DArray::~TextureD3D_2DArray()
+{
 }
 
 ImageD3D *TextureD3D_2DArray::getImage(int level, int layer) const
@@ -2746,13 +2785,15 @@ bool TextureD3D_2DArray::isDepth(GLint level) const
     return gl::GetSizedInternalFormatInfo(getInternalFormat(level)).depthBits > 0;
 }
 
-gl::Error TextureD3D_2DArray::setEGLImageTarget(GLenum target, egl::Image *image)
+gl::Error TextureD3D_2DArray::setEGLImageTarget(const gl::Context *context,
+                                                GLenum target,
+                                                egl::Image *image)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_2DArray::setImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2DArray::setImage(const gl::Context *context,
                                        GLenum target,
                                        size_t imageLevel,
                                        GLenum internalFormat,
@@ -2767,7 +2808,8 @@ gl::Error TextureD3D_2DArray::setImage(ContextImpl *contextImpl,
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat, type);
 
     GLint level = static_cast<GLint>(imageLevel);
-    redefineImage(level, formatInfo.sizedInternalFormat, size);
+    ANGLE_TRY(redefineImage(context, level, formatInfo.sizedInternalFormat, size,
+                            shouldForceReleaseImagesOnSetImage(pixels)));
 
     GLsizei inputDepthPitch              = 0;
     ANGLE_TRY_RESULT(formatInfo.computeDepthPitch(type, size.width, size.height, unpack.alignment,
@@ -2778,13 +2820,13 @@ gl::Error TextureD3D_2DArray::setImage(ContextImpl *contextImpl,
     {
         const ptrdiff_t layerOffset = (inputDepthPitch * i);
         gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, i);
-        ANGLE_TRY(setImageImpl(index, type, unpack, pixels, layerOffset));
+        ANGLE_TRY(setImageImpl(context, index, type, unpack, pixels, layerOffset));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::setSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2DArray::setSubImage(const gl::Context *context,
                                           GLenum target,
                                           size_t imageLevel,
                                           const gl::Box &area,
@@ -2810,14 +2852,14 @@ gl::Error TextureD3D_2DArray::setSubImage(ContextImpl *contextImpl,
         gl::Box layerArea(area.x, area.y, 0, area.width, area.height, 1);
 
         gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, layer);
-        ANGLE_TRY(
-            TextureD3D::subImage(index, layerArea, format, type, unpack, pixels, layerOffset));
+        ANGLE_TRY(TextureD3D::subImage(context, index, layerArea, format, type, unpack, pixels,
+                                       layerOffset));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::setCompressedImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2DArray::setCompressedImage(const gl::Context *context,
                                                  GLenum target,
                                                  size_t imageLevel,
                                                  GLenum internalFormat,
@@ -2830,7 +2872,8 @@ gl::Error TextureD3D_2DArray::setCompressedImage(ContextImpl *contextImpl,
 
     GLint level = static_cast<GLint>(imageLevel);
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    redefineImage(level, internalFormat, size);
+    ANGLE_TRY(redefineImage(context, level, internalFormat, size,
+                            shouldForceReleaseImagesOnSetImage(pixels)));
 
     const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(internalFormat);
     GLsizei inputDepthPitch              = 0;
@@ -2843,13 +2886,13 @@ gl::Error TextureD3D_2DArray::setCompressedImage(ContextImpl *contextImpl,
         const ptrdiff_t layerOffset = (inputDepthPitch * i);
 
         gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, i);
-        ANGLE_TRY(setCompressedImageImpl(index, unpack, pixels, layerOffset));
+        ANGLE_TRY(setCompressedImageImpl(context, index, unpack, pixels, layerOffset));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::setCompressedSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2DArray::setCompressedSubImage(const gl::Context *context,
                                                     GLenum target,
                                                     size_t level,
                                                     const gl::Box &area,
@@ -2874,15 +2917,15 @@ gl::Error TextureD3D_2DArray::setCompressedSubImage(ContextImpl *contextImpl,
         gl::Box layerArea(area.x, area.y, 0, area.width, area.height, 1);
 
         gl::ImageIndex index = gl::ImageIndex::Make2DArray(static_cast<GLint>(level), layer);
-        ANGLE_TRY(
-            TextureD3D::subImageCompressed(index, layerArea, format, unpack, pixels, layerOffset));
-        ANGLE_TRY(commitRegion(index, layerArea));
+        ANGLE_TRY(TextureD3D::subImageCompressed(context, index, layerArea, format, unpack, pixels,
+                                                 layerOffset));
+        ANGLE_TRY(commitRegion(context, index, layerArea));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::copyImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2DArray::copyImage(const gl::Context *context,
                                         GLenum target,
                                         size_t level,
                                         const gl::Rectangle &sourceArea,
@@ -2890,10 +2933,10 @@ gl::Error TextureD3D_2DArray::copyImage(ContextImpl *contextImpl,
                                         const gl::Framebuffer *source)
 {
     UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION, "Copying 2D array textures is unimplemented.");
+    return gl::InternalError() << "Copying 2D array textures is unimplemented.";
 }
 
-gl::Error TextureD3D_2DArray::copySubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2DArray::copySubImage(const gl::Context *context,
                                            GLenum target,
                                            size_t imageLevel,
                                            const gl::Offset &destOffset,
@@ -2905,29 +2948,41 @@ gl::Error TextureD3D_2DArray::copySubImage(ContextImpl *contextImpl,
     GLint level          = static_cast<GLint>(imageLevel);
     gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, destOffset.z);
 
+    gl::Extents fbSize = source->getReadColorbuffer()->getSize();
+    gl::Rectangle clippedSourceArea;
+    if (!ClipRectangle(sourceArea, gl::Rectangle(0, 0, fbSize.width, fbSize.height),
+                       &clippedSourceArea))
+    {
+        return gl::NoError();
+    }
+    const gl::Offset clippedDestOffset(destOffset.x + clippedSourceArea.x - sourceArea.x,
+                                       destOffset.y + clippedSourceArea.y - sourceArea.y,
+                                       destOffset.z);
+
     if (!canCreateRenderTargetForImage(index))
     {
-        gl::Offset destLayerOffset(destOffset.x, destOffset.y, 0);
-        ANGLE_TRY(mImageArray[level][destOffset.z]->copyFromFramebuffer(destLayerOffset, sourceArea,
-                                                                        source));
+        gl::Offset destLayerOffset(clippedDestOffset.x, clippedDestOffset.y, 0);
+        ANGLE_TRY(mImageArray[level][clippedDestOffset.z]->copyFromFramebuffer(
+            context, destLayerOffset, clippedSourceArea, source));
         mDirtyImages = true;
     }
     else
     {
-        ANGLE_TRY(ensureRenderTarget());
+        ANGLE_TRY(ensureRenderTarget(context));
 
         if (isValidLevel(level))
         {
-            ANGLE_TRY(updateStorageLevel(level));
-            ANGLE_TRY(mRenderer->copyImage2DArray(
-                source, sourceArea, gl::GetUnsizedFormat(getInternalFormat(getBaseLevel())),
-                destOffset, mTexStorage, level));
+            ANGLE_TRY(updateStorageLevel(context, level));
+            ANGLE_TRY(
+                mRenderer->copyImage2DArray(context, source, clippedSourceArea,
+                                            gl::GetUnsizedFormat(getInternalFormat(getBaseLevel())),
+                                            clippedDestOffset, mTexStorage, level));
         }
     }
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::setStorage(ContextImpl *contextImpl,
+gl::Error TextureD3D_2DArray::setStorage(const gl::Context *context,
                                          GLenum target,
                                          size_t levels,
                                          GLenum internalFormat,
@@ -2960,35 +3015,34 @@ gl::Error TextureD3D_2DArray::setStorage(ContextImpl *contextImpl,
 
     // TODO(geofflang): Verify storage creation had no errors
     bool renderTarget = IsRenderTargetUsage(mState.getUsage());
-    TextureStorage *storage =
-        mRenderer->createTextureStorage2DArray(internalFormat, renderTarget, size.width,
-                                               size.height, size.depth, static_cast<int>(levels));
+    TexStoragePointer storage(context);
+    storage.reset(mRenderer->createTextureStorage2DArray(internalFormat, renderTarget, size.width,
+                                                         size.height, size.depth,
+                                                         static_cast<int>(levels)));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     mImmutable = true;
 
     return gl::NoError();
 }
 
-void TextureD3D_2DArray::bindTexImage(egl::Surface *surface)
+gl::Error TextureD3D_2DArray::bindTexImage(const gl::Context *context, egl::Surface *surface)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-void TextureD3D_2DArray::releaseTexImage()
+gl::Error TextureD3D_2DArray::releaseTexImage(const gl::Context *context)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-void TextureD3D_2DArray::initMipmapImages()
+gl::Error TextureD3D_2DArray::initMipmapImages(const gl::Context *context)
 {
     const GLuint baseLevel = mState.getEffectiveBaseLevel();
     const GLuint maxLevel  = mState.getMipmapMaxLevel();
@@ -3005,19 +3059,23 @@ void TextureD3D_2DArray::initMipmapImages()
         gl::Extents levelLayerSize(std::max(baseWidth >> level, 1),
                                    std::max(baseHeight >> level, 1),
                                    baseDepth);
-        redefineImage(level, baseFormat, levelLayerSize);
+        ANGLE_TRY(redefineImage(context, level, baseFormat, levelLayerSize, false));
     }
+
+    return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureD3D_2DArray::getRenderTarget(const gl::Context *context,
+                                              const gl::ImageIndex &index,
+                                              RenderTargetD3D **outRT)
 {
     // ensure the underlying texture is created
-    ANGLE_TRY(ensureRenderTarget());
-    ANGLE_TRY(updateStorageLevel(index.mipIndex));
-    return mTexStorage->getRenderTarget(index, outRT);
+    ANGLE_TRY(ensureRenderTarget(context));
+    ANGLE_TRY(updateStorageLevel(context, index.mipIndex));
+    return mTexStorage->getRenderTarget(context, index, outRT);
 }
 
-gl::Error TextureD3D_2DArray::initializeStorage(bool renderTarget)
+gl::Error TextureD3D_2DArray::initializeStorage(const gl::Context *context, bool renderTarget)
 {
     // Only initialize the first time this texture is used as a render target or shader resource
     if (mTexStorage)
@@ -3033,25 +3091,22 @@ gl::Error TextureD3D_2DArray::initializeStorage(bool renderTarget)
 
     bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
 
-    TextureStorage *storage = nullptr;
+    TexStoragePointer storage(context);
     ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
 
-    gl::Error error = setCompleteTexStorage(storage);
-    if (error.isError())
-    {
-        SafeDelete(storage);
-        return error;
-    }
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
 
     ASSERT(mTexStorage);
 
     // flush image data to the storage
-    ANGLE_TRY(updateStorage());
+    ANGLE_TRY(updateStorage(context));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::createCompleteStorage(bool renderTarget, TextureStorage **outStorage) const
+gl::Error TextureD3D_2DArray::createCompleteStorage(bool renderTarget,
+                                                    TexStoragePointer *outStorage) const
 {
     GLsizei width         = getLevelZeroWidth();
     GLsizei height        = getLevelZeroHeight();
@@ -3064,14 +3119,16 @@ gl::Error TextureD3D_2DArray::createCompleteStorage(bool renderTarget, TextureSt
     GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1));
 
     // TODO(geofflang): Verify storage creation succeeds
-    *outStorage = mRenderer->createTextureStorage2DArray(internalFormat, renderTarget, width, height, depth, levels);
+    outStorage->reset(mRenderer->createTextureStorage2DArray(internalFormat, renderTarget, width,
+                                                             height, depth, levels));
 
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
+gl::Error TextureD3D_2DArray::setCompleteTexStorage(const gl::Context *context,
+                                                    TextureStorage *newCompleteTexStorage)
 {
-    SafeDelete(mTexStorage);
+    ANGLE_TRY(releaseTexStorage(context));
     mTexStorage = newCompleteTexStorage;
     mDirtyImages = true;
 
@@ -3081,7 +3138,7 @@ gl::Error TextureD3D_2DArray::setCompleteTexStorage(TextureStorage *newCompleteT
     return gl::NoError();
 }
 
-gl::Error TextureD3D_2DArray::updateStorage()
+gl::Error TextureD3D_2DArray::updateStorage(const gl::Context *context)
 {
     ASSERT(mTexStorage != nullptr);
     GLint storageLevels = mTexStorage->getLevelCount();
@@ -3089,7 +3146,7 @@ gl::Error TextureD3D_2DArray::updateStorage()
     {
         if (isLevelComplete(level))
         {
-            ANGLE_TRY(updateStorageLevel(level));
+            ANGLE_TRY(updateStorageLevel(context, level));
         }
     }
 
@@ -3160,9 +3217,9 @@ bool TextureD3D_2DArray::isImageComplete(const gl::ImageIndex &index) const
     return isLevelComplete(index.mipIndex);
 }
 
-gl::Error TextureD3D_2DArray::updateStorageLevel(int level)
+gl::Error TextureD3D_2DArray::updateStorageLevel(const gl::Context *context, int level)
 {
-    ASSERT(level >= 0 && level < (int)ArraySize(mLayerCounts));
+    ASSERT(level >= 0 && level < static_cast<int>(ArraySize(mLayerCounts)));
     ASSERT(isLevelComplete(level));
 
     for (int layer = 0; layer < mLayerCounts[level]; layer++)
@@ -3172,7 +3229,7 @@ gl::Error TextureD3D_2DArray::updateStorageLevel(int level)
         {
             gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, layer);
             gl::Box region(0, 0, 0, getWidth(level), getHeight(level), 1);
-            ANGLE_TRY(commitRegion(index, region));
+            ANGLE_TRY(commitRegion(context, index, region));
         }
     }
 
@@ -3193,7 +3250,11 @@ void TextureD3D_2DArray::deleteImages()
     }
 }
 
-void TextureD3D_2DArray::redefineImage(GLint level, GLenum internalformat, const gl::Extents &size)
+gl::Error TextureD3D_2DArray::redefineImage(const gl::Context *context,
+                                            GLint level,
+                                            GLenum internalformat,
+                                            const gl::Extents &size,
+                                            bool forceRelease)
 {
     // If there currently is a corresponding storage texture image, it has these parameters
     const int storageWidth  = std::max(1, getLevelZeroWidth() >> level);
@@ -3230,7 +3291,9 @@ void TextureD3D_2DArray::redefineImage(GLint level, GLenum internalformat, const
         for (int layer = 0; layer < mLayerCounts[level]; layer++)
         {
             mImageArray[level][layer]->redefine(GL_TEXTURE_2D_ARRAY, internalformat,
-                                                gl::Extents(size.width, size.height, 1), false);
+                                                gl::Extents(size.width, size.height, 1),
+                                                forceRelease);
+            mDirtyImages = mDirtyImages || mImageArray[level][layer]->isDirty();
         }
     }
 
@@ -3239,16 +3302,16 @@ void TextureD3D_2DArray::redefineImage(GLint level, GLenum internalformat, const
         const GLenum storageFormat = getBaseLevelInternalFormat();
         const int storageLevels = mTexStorage->getLevelCount();
 
-        if ((level >= storageLevels && storageLevels != 0) ||
-            size.width != storageWidth ||
-            size.height != storageHeight ||
-            size.depth != storageDepth ||
-            internalformat != storageFormat)   // Discard mismatched storage
+        if ((level >= storageLevels && storageLevels != 0) || size.width != storageWidth ||
+            size.height != storageHeight || size.depth != storageDepth ||
+            internalformat != storageFormat)  // Discard mismatched storage
         {
             markAllImagesDirty();
-            SafeDelete(mTexStorage);
+            ANGLE_TRY(releaseTexStorage(context));
         }
     }
+
+    return gl::NoError();
 }
 
 gl::ImageIndexIterator TextureD3D_2DArray::imageIterator() const
@@ -3298,7 +3361,6 @@ TextureD3D_External::TextureD3D_External(const gl::TextureState &state, Renderer
 
 TextureD3D_External::~TextureD3D_External()
 {
-    SafeDelete(mTexStorage);
 }
 
 ImageD3D *TextureD3D_External::getImage(const gl::ImageIndex &index) const
@@ -3312,7 +3374,7 @@ GLsizei TextureD3D_External::getLayerCount(int level) const
     return 1;
 }
 
-gl::Error TextureD3D_External::setImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_External::setImage(const gl::Context *context,
                                         GLenum target,
                                         size_t imageLevel,
                                         GLenum internalFormat,
@@ -3324,10 +3386,10 @@ gl::Error TextureD3D_External::setImage(ContextImpl *contextImpl,
 {
     // Image setting is not supported for external images
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::setSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_External::setSubImage(const gl::Context *context,
                                            GLenum target,
                                            size_t imageLevel,
                                            const gl::Box &area,
@@ -3337,10 +3399,10 @@ gl::Error TextureD3D_External::setSubImage(ContextImpl *contextImpl,
                                            const uint8_t *pixels)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::setCompressedImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_External::setCompressedImage(const gl::Context *context,
                                                   GLenum target,
                                                   size_t imageLevel,
                                                   GLenum internalFormat,
@@ -3350,10 +3412,10 @@ gl::Error TextureD3D_External::setCompressedImage(ContextImpl *contextImpl,
                                                   const uint8_t *pixels)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::setCompressedSubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_External::setCompressedSubImage(const gl::Context *context,
                                                      GLenum target,
                                                      size_t level,
                                                      const gl::Box &area,
@@ -3363,10 +3425,10 @@ gl::Error TextureD3D_External::setCompressedSubImage(ContextImpl *contextImpl,
                                                      const uint8_t *pixels)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::copyImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_External::copyImage(const gl::Context *context,
                                          GLenum target,
                                          size_t imageLevel,
                                          const gl::Rectangle &sourceArea,
@@ -3374,10 +3436,10 @@ gl::Error TextureD3D_External::copyImage(ContextImpl *contextImpl,
                                          const gl::Framebuffer *source)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::copySubImage(ContextImpl *contextImpl,
+gl::Error TextureD3D_External::copySubImage(const gl::Context *context,
                                             GLenum target,
                                             size_t imageLevel,
                                             const gl::Offset &destOffset,
@@ -3385,26 +3447,27 @@ gl::Error TextureD3D_External::copySubImage(ContextImpl *contextImpl,
                                             const gl::Framebuffer *source)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::setStorage(ContextImpl *contextImpl,
+gl::Error TextureD3D_External::setStorage(const gl::Context *context,
                                           GLenum target,
                                           size_t levels,
                                           GLenum internalFormat,
                                           const gl::Extents &size)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::setImageExternal(GLenum target,
+gl::Error TextureD3D_External::setImageExternal(const gl::Context *context,
+                                                GLenum target,
                                                 egl::Stream *stream,
                                                 const egl::Stream::GLTextureDescription &desc)
 {
     ASSERT(target == GL_TEXTURE_EXTERNAL_OES);
 
-    SafeDelete(mTexStorage);
+    ANGLE_TRY(releaseTexStorage(context));
 
     // If the stream is null, the external image is unbound and we release the storage
     if (stream != nullptr)
@@ -3415,39 +3478,46 @@ gl::Error TextureD3D_External::setImageExternal(GLenum target,
     return gl::NoError();
 }
 
-void TextureD3D_External::bindTexImage(egl::Surface *surface)
+gl::Error TextureD3D_External::bindTexImage(const gl::Context *context, egl::Surface *surface)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-void TextureD3D_External::releaseTexImage()
+gl::Error TextureD3D_External::releaseTexImage(const gl::Context *context)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::setEGLImageTarget(GLenum target, egl::Image *image)
+gl::Error TextureD3D_External::setEGLImageTarget(const gl::Context *context,
+                                                 GLenum target,
+                                                 egl::Image *image)
 {
     EGLImageD3D *eglImaged3d = GetImplAs<EGLImageD3D>(image);
 
     // Pass in the RenderTargetD3D here: createTextureStorage can't generate an error.
     RenderTargetD3D *renderTargetD3D = nullptr;
-    ANGLE_TRY(eglImaged3d->getRenderTarget(&renderTargetD3D));
+    ANGLE_TRY(eglImaged3d->getRenderTarget(context, &renderTargetD3D));
 
-    SafeDelete(mTexStorage);
+    ANGLE_TRY(releaseTexStorage(context));
     mTexStorage = mRenderer->createTextureStorageEGLImage(eglImaged3d, renderTargetD3D);
 
     return gl::NoError();
 }
 
-void TextureD3D_External::initMipmapImages()
+gl::Error TextureD3D_External::initMipmapImages(const gl::Context *context)
 {
     UNREACHABLE();
+    return gl::InternalError();
 }
 
-gl::Error TextureD3D_External::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureD3D_External::getRenderTarget(const gl::Context *context,
+                                               const gl::ImageIndex &index,
+                                               RenderTargetD3D **outRT)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
 bool TextureD3D_External::isImageComplete(const gl::ImageIndex &index) const
@@ -3455,7 +3525,7 @@ bool TextureD3D_External::isImageComplete(const gl::ImageIndex &index) const
     return (index.mipIndex == 0) ? (mTexStorage != nullptr) : false;
 }
 
-gl::Error TextureD3D_External::initializeStorage(bool renderTarget)
+gl::Error TextureD3D_External::initializeStorage(const gl::Context *context, bool renderTarget)
 {
     // Texture storage is created when an external image is bound
     ASSERT(mTexStorage);
@@ -3463,19 +3533,20 @@ gl::Error TextureD3D_External::initializeStorage(bool renderTarget)
 }
 
 gl::Error TextureD3D_External::createCompleteStorage(bool renderTarget,
-                                                     TextureStorage **outTexStorage) const
+                                                     TexStoragePointer *outStorage) const
 {
     UNREACHABLE();
     return gl::NoError();
 }
 
-gl::Error TextureD3D_External::setCompleteTexStorage(TextureStorage *newCompleteTexStorage)
+gl::Error TextureD3D_External::setCompleteTexStorage(const gl::Context *context,
+                                                     TextureStorage *newCompleteTexStorage)
 {
     UNREACHABLE();
     return gl::NoError();
 }
 
-gl::Error TextureD3D_External::updateStorage()
+gl::Error TextureD3D_External::updateStorage(const gl::Context *context)
 {
     // Texture storage does not need to be updated since it is already loaded with the latest
     // external image
@@ -3503,4 +3574,233 @@ void TextureD3D_External::markAllImagesDirty()
 {
     UNREACHABLE();
 }
+
+TextureD3D_2DMultisample::TextureD3D_2DMultisample(const gl::TextureState &state,
+                                                   RendererD3D *renderer)
+    : TextureD3D(state, renderer)
+{
+}
+
+TextureD3D_2DMultisample::~TextureD3D_2DMultisample()
+{
+}
+
+ImageD3D *TextureD3D_2DMultisample::getImage(const gl::ImageIndex &index) const
+{
+    return nullptr;
+}
+
+gl::Error TextureD3D_2DMultisample::setImage(const gl::Context *context,
+                                             GLenum target,
+                                             size_t level,
+                                             GLenum internalFormat,
+                                             const gl::Extents &size,
+                                             GLenum format,
+                                             GLenum type,
+                                             const gl::PixelUnpackState &unpack,
+                                             const uint8_t *pixels)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D_2DMultisample::setSubImage(const gl::Context *context,
+                                                GLenum target,
+                                                size_t level,
+                                                const gl::Box &area,
+                                                GLenum format,
+                                                GLenum type,
+                                                const gl::PixelUnpackState &unpack,
+                                                const uint8_t *pixels)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D_2DMultisample::setCompressedImage(const gl::Context *context,
+                                                       GLenum target,
+                                                       size_t level,
+                                                       GLenum internalFormat,
+                                                       const gl::Extents &size,
+                                                       const gl::PixelUnpackState &unpack,
+                                                       size_t imageSize,
+                                                       const uint8_t *pixels)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D_2DMultisample::setCompressedSubImage(const gl::Context *context,
+                                                          GLenum target,
+                                                          size_t level,
+                                                          const gl::Box &area,
+                                                          GLenum format,
+                                                          const gl::PixelUnpackState &unpack,
+                                                          size_t imageSize,
+                                                          const uint8_t *pixels)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D_2DMultisample::copyImage(const gl::Context *context,
+                                              GLenum target,
+                                              size_t level,
+                                              const gl::Rectangle &sourceArea,
+                                              GLenum internalFormat,
+                                              const gl::Framebuffer *source)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D_2DMultisample::copySubImage(const gl::Context *context,
+                                                 GLenum target,
+                                                 size_t level,
+                                                 const gl::Offset &destOffset,
+                                                 const gl::Rectangle &sourceArea,
+                                                 const gl::Framebuffer *source)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D_2DMultisample::setStorageMultisample(const gl::Context *context,
+                                                          GLenum target,
+                                                          GLsizei samples,
+                                                          GLint internalFormat,
+                                                          const gl::Extents &size,
+                                                          GLboolean fixedSampleLocations)
+{
+    ASSERT(target == GL_TEXTURE_2D_MULTISAMPLE && size.depth == 1);
+
+    TexStoragePointer storage(context);
+    storage.reset(mRenderer->createTextureStorage2DMultisample(internalFormat, size.width,
+                                                               size.height, static_cast<int>(0),
+                                                               samples, fixedSampleLocations));
+
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
+
+    ANGLE_TRY(updateStorage(context));
+
+    mImmutable = false;
+
+    return gl::NoError();
+}
+
+gl::Error TextureD3D_2DMultisample::bindTexImage(const gl::Context *context, egl::Surface *surface)
+{
+    UNREACHABLE();
+    return gl::NoError();
+}
+
+gl::Error TextureD3D_2DMultisample::releaseTexImage(const gl::Context *context)
+{
+    UNREACHABLE();
+    return gl::NoError();
+}
+
+gl::Error TextureD3D_2DMultisample::setEGLImageTarget(const gl::Context *context,
+                                                      GLenum target,
+                                                      egl::Image *image)
+{
+    UNREACHABLE();
+    return gl::InternalError();
+}
+
+gl::Error TextureD3D_2DMultisample::getRenderTarget(const gl::Context *context,
+                                                    const gl::ImageIndex &index,
+                                                    RenderTargetD3D **outRT)
+{
+    ASSERT(!index.hasLayer());
+
+    // ensure the underlying texture is created
+    ANGLE_TRY(ensureRenderTarget(context));
+
+    return mTexStorage->getRenderTarget(context, index, outRT);
+}
+
+gl::ImageIndexIterator TextureD3D_2DMultisample::imageIterator() const
+{
+    return gl::ImageIndexIterator::Make2DMultisample();
+}
+
+gl::ImageIndex TextureD3D_2DMultisample::getImageIndex(GLint mip, GLint layer) const
+{
+    return gl::ImageIndex::Make2DMultisample();
+}
+
+bool TextureD3D_2DMultisample::isValidIndex(const gl::ImageIndex &index) const
+{
+    return (mTexStorage && index.type == GL_TEXTURE_2D_MULTISAMPLE && index.mipIndex == 0);
+}
+
+GLsizei TextureD3D_2DMultisample::getLayerCount(int level) const
+{
+    UNIMPLEMENTED();
+    return GLsizei();
+}
+
+void TextureD3D_2DMultisample::markAllImagesDirty()
+{
+}
+
+gl::Error TextureD3D_2DMultisample::initializeStorage(const gl::Context *context, bool renderTarget)
+{
+    // Only initialize the first time this texture is used as a render target or shader resource
+    if (mTexStorage)
+    {
+        return gl::NoError();
+    }
+
+    bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mState.getUsage()));
+
+    TexStoragePointer storage(context);
+    ANGLE_TRY(createCompleteStorage(createRenderTarget, &storage));
+
+    ANGLE_TRY(setCompleteTexStorage(context, storage.get()));
+    storage.release();
+
+    ASSERT(mTexStorage);
+
+    // flush image data to the storage
+    ANGLE_TRY(updateStorage(context));
+
+    return gl::NoError();
+}
+
+gl::Error TextureD3D_2DMultisample::createCompleteStorage(bool renderTarget,
+                                                          TexStoragePointer *outStorage) const
+{
+    outStorage->reset(mTexStorage);
+
+    return gl::NoError();
+}
+
+gl::Error TextureD3D_2DMultisample::setCompleteTexStorage(const gl::Context *context,
+                                                          TextureStorage *newCompleteTexStorage)
+{
+    ANGLE_TRY(releaseTexStorage(context));
+    mTexStorage = newCompleteTexStorage;
+
+    return gl::NoError();
+}
+
+gl::Error TextureD3D_2DMultisample::updateStorage(const gl::Context *context)
+{
+    return gl::NoError();
+}
+
+gl::Error TextureD3D_2DMultisample::initMipmapImages(const gl::Context *context)
+{
+    UNIMPLEMENTED();
+    return gl::NoError();
+}
+
+bool TextureD3D_2DMultisample::isImageComplete(const gl::ImageIndex &index) const
+{
+    return true;
+}
+
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.h
index dbe43a449f0..e72c670c343 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureD3D.h
@@ -9,10 +9,12 @@
 #ifndef LIBANGLE_RENDERER_D3D_TEXTURED3D_H_
 #define LIBANGLE_RENDERER_D3D_TEXTURED3D_H_
 
-#include "libANGLE/renderer/TextureImpl.h"
-#include "libANGLE/angletypes.h"
+#include "common/Color.h"
 #include "libANGLE/Constants.h"
 #include "libANGLE/Stream.h"
+#include "libANGLE/angletypes.h"
+#include "libANGLE/renderer/TextureImpl.h"
+#include "libANGLE/renderer/d3d/TextureStorage.h"
 
 namespace gl
 {
@@ -27,13 +29,18 @@ class RendererD3D;
 class RenderTargetD3D;
 class TextureStorage;
 
+template <typename T>
+using TexLevelsArray = std::array<T, gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS>;
+
 class TextureD3D : public TextureImpl
 {
   public:
     TextureD3D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D();
 
-    gl::Error getNativeTexture(TextureStorage **outStorage);
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    gl::Error getNativeTexture(const gl::Context *context, TextureStorage **outStorage);
 
     bool hasDirtyImages() const { return mDirtyImages; }
     void resetDirty() { mDirtyImages = false; }
@@ -41,11 +48,21 @@ class TextureD3D : public TextureImpl
     virtual ImageD3D *getImage(const gl::ImageIndex &index) const = 0;
     virtual GLsizei getLayerCount(int level) const = 0;
 
+    gl::Error getImageAndSyncFromStorage(const gl::Context *context,
+                                         const gl::ImageIndex &index,
+                                         ImageD3D **outImage) const;
+
     GLint getBaseLevelWidth() const;
     GLint getBaseLevelHeight() const;
     GLenum getBaseLevelInternalFormat() const;
 
-    gl::Error setStorageMultisample(ContextImpl *contextImpl,
+    gl::Error setStorage(const gl::Context *context,
+                         GLenum target,
+                         size_t levels,
+                         GLenum internalFormat,
+                         const gl::Extents &size);
+
+    gl::Error setStorageMultisample(const gl::Context *context,
                                     GLenum target,
                                     GLsizei samples,
                                     GLint internalFormat,
@@ -54,7 +71,9 @@ class TextureD3D : public TextureImpl
 
     bool isImmutable() const { return mImmutable; }
 
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) = 0;
+    virtual gl::Error getRenderTarget(const gl::Context *context,
+                                      const gl::ImageIndex &index,
+                                      RenderTargetD3D **outRT) = 0;
 
     // Returns an iterator over all "Images" for this particular Texture.
     virtual gl::ImageIndexIterator imageIterator() const = 0;
@@ -64,54 +83,84 @@ class TextureD3D : public TextureImpl
     virtual gl::ImageIndex getImageIndex(GLint mip, GLint layer) const = 0;
     virtual bool isValidIndex(const gl::ImageIndex &index) const = 0;
 
-    virtual gl::Error setImageExternal(GLenum target,
-                                       egl::Stream *stream,
-                                       const egl::Stream::GLTextureDescription &desc) override;
-    gl::Error generateMipmap(ContextImpl *contextImpl) override;
+    gl::Error setImageExternal(const gl::Context *context,
+                               GLenum target,
+                               egl::Stream *stream,
+                               const egl::Stream::GLTextureDescription &desc) override;
+    gl::Error generateMipmap(const gl::Context *context) override;
     TextureStorage *getStorage();
     ImageD3D *getBaseLevelImage() const;
 
-    gl::Error getAttachmentRenderTarget(GLenum binding,
+    gl::Error getAttachmentRenderTarget(const gl::Context *context,
+                                        GLenum binding,
                                         const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
-    void setBaseLevel(GLuint baseLevel) override;
+    gl::Error setBaseLevel(const gl::Context *context, GLuint baseLevel) override;
 
     void syncState(const gl::Texture::DirtyBits &dirtyBits) override;
 
+    gl::Error clearLevel(const gl::Context *context,
+                         const gl::ImageIndex &index,
+                         const gl::ColorF &clearValues);
+
   protected:
-    gl::Error setImageImpl(const gl::ImageIndex &index,
+    gl::Error setImageImpl(const gl::Context *context,
+                           const gl::ImageIndex &index,
                            GLenum type,
                            const gl::PixelUnpackState &unpack,
                            const uint8_t *pixels,
                            ptrdiff_t layerOffset);
-    gl::Error subImage(const gl::ImageIndex &index, const gl::Box &area, GLenum format, GLenum type,
-                       const gl::PixelUnpackState &unpack, const uint8_t *pixels, ptrdiff_t layerOffset);
-    gl::Error setCompressedImageImpl(const gl::ImageIndex &index,
+    gl::Error subImage(const gl::Context *context,
+                       const gl::ImageIndex &index,
+                       const gl::Box &area,
+                       GLenum format,
+                       GLenum type,
+                       const gl::PixelUnpackState &unpack,
+                       const uint8_t *pixels,
+                       ptrdiff_t layerOffset);
+    gl::Error setCompressedImageImpl(const gl::Context *context,
+                                     const gl::ImageIndex &index,
                                      const gl::PixelUnpackState &unpack,
                                      const uint8_t *pixels,
                                      ptrdiff_t layerOffset);
-    gl::Error subImageCompressed(const gl::ImageIndex &index, const gl::Box &area, GLenum format,
-                                 const gl::PixelUnpackState &unpack, const uint8_t *pixels, ptrdiff_t layerOffset);
+    gl::Error subImageCompressed(const gl::Context *context,
+                                 const gl::ImageIndex &index,
+                                 const gl::Box &area,
+                                 GLenum format,
+                                 const gl::PixelUnpackState &unpack,
+                                 const uint8_t *pixels,
+                                 ptrdiff_t layerOffset);
     bool isFastUnpackable(const gl::PixelUnpackState &unpack, GLenum sizedInternalFormat);
-    gl::Error fastUnpackPixels(const gl::PixelUnpackState &unpack, const uint8_t *pixels, const gl::Box &destArea,
-                               GLenum sizedInternalFormat, GLenum type, RenderTargetD3D *destRenderTarget);
+    gl::Error fastUnpackPixels(const gl::Context *context,
+                               const gl::PixelUnpackState &unpack,
+                               const uint8_t *pixels,
+                               const gl::Box &destArea,
+                               GLenum sizedInternalFormat,
+                               GLenum type,
+                               RenderTargetD3D *destRenderTarget);
 
     GLint getLevelZeroWidth() const;
     GLint getLevelZeroHeight() const;
     virtual GLint getLevelZeroDepth() const;
 
     GLint creationLevels(GLsizei width, GLsizei height, GLsizei depth) const;
-    virtual void initMipmapImages() = 0;
+    virtual gl::Error initMipmapImages(const gl::Context *context) = 0;
     bool isBaseImageZeroSize() const;
     virtual bool isImageComplete(const gl::ImageIndex &index) const = 0;
 
     bool canCreateRenderTargetForImage(const gl::ImageIndex &index) const;
-    virtual gl::Error ensureRenderTarget();
+    gl::Error ensureRenderTarget(const gl::Context *context);
+
+    virtual gl::Error createCompleteStorage(bool renderTarget,
+                                            TexStoragePointer *outTexStorage) const = 0;
+    virtual gl::Error setCompleteTexStorage(const gl::Context *context,
+                                            TextureStorage *newCompleteTexStorage) = 0;
+    gl::Error commitRegion(const gl::Context *context,
+                           const gl::ImageIndex &index,
+                           const gl::Box &region);
 
-    virtual gl::Error createCompleteStorage(bool renderTarget, TextureStorage **outTexStorage) const = 0;
-    virtual gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage) = 0;
-    gl::Error commitRegion(const gl::ImageIndex &index, const gl::Box &region);
+    gl::Error releaseTexStorage(const gl::Context *context);
 
     GLuint getBaseLevel() const { return mBaseLevel; };
 
@@ -119,6 +168,8 @@ class TextureD3D : public TextureImpl
 
     GLint getBaseLevelDepth() const;
 
+    bool shouldForceReleaseImagesOnSetImage(const uint8_t *pixels) const;
+
     RendererD3D *mRenderer;
 
     bool mDirtyImages;
@@ -127,13 +178,13 @@ class TextureD3D : public TextureImpl
     TextureStorage *mTexStorage;
 
   private:
-    virtual gl::Error initializeStorage(bool renderTarget) = 0;
+    virtual gl::Error initializeStorage(const gl::Context *context, bool renderTarget) = 0;
 
-    virtual gl::Error updateStorage() = 0;
+    virtual gl::Error updateStorage(const gl::Context *context) = 0;
 
     bool shouldUseSetData(const ImageD3D *image) const;
 
-    gl::Error generateMipmapUsingImages(const GLuint maxLevel);
+    gl::Error generateMipmapUsingImages(const gl::Context *context, const GLuint maxLevel);
 
     GLuint mBaseLevel;
 };
@@ -144,16 +195,19 @@ class TextureD3D_2D : public TextureD3D
     TextureD3D_2D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_2D();
 
-    virtual ImageD3D *getImage(int level, int layer) const;
-    virtual ImageD3D *getImage(const gl::ImageIndex &index) const;
-    virtual GLsizei getLayerCount(int level) const;
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    ImageD3D *getImage(int level, int layer) const;
+    ImageD3D *getImage(const gl::ImageIndex &index) const override;
+    GLsizei getLayerCount(int level) const override;
 
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
     GLenum getInternalFormat(GLint level) const;
     bool isDepth(GLint level) const;
+    bool isSRGB(GLint level) const;
 
-    gl::Error setImage(ContextImpl *contextImpl,
+    gl::Error setImage(const gl::Context *context,
                        GLenum target,
                        size_t level,
                        GLenum internalFormat,
@@ -162,7 +216,7 @@ class TextureD3D_2D : public TextureD3D
                        GLenum type,
                        const gl::PixelUnpackState &unpack,
                        const uint8_t *pixels) override;
-    gl::Error setSubImage(ContextImpl *contextImpl,
+    gl::Error setSubImage(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           const gl::Box &area,
@@ -171,7 +225,7 @@ class TextureD3D_2D : public TextureD3D
                           const gl::PixelUnpackState &unpack,
                           const uint8_t *pixels) override;
 
-    gl::Error setCompressedImage(ContextImpl *contextImpl,
+    gl::Error setCompressedImage(const gl::Context *context,
                                  GLenum target,
                                  size_t level,
                                  GLenum internalFormat,
@@ -179,7 +233,7 @@ class TextureD3D_2D : public TextureD3D
                                  const gl::PixelUnpackState &unpack,
                                  size_t imageSize,
                                  const uint8_t *pixels) override;
-    gl::Error setCompressedSubImage(ContextImpl *contextImpl,
+    gl::Error setCompressedSubImage(const gl::Context *context,
                                     GLenum target,
                                     size_t level,
                                     const gl::Box &area,
@@ -188,20 +242,20 @@ class TextureD3D_2D : public TextureD3D
                                     size_t imageSize,
                                     const uint8_t *pixels) override;
 
-    gl::Error copyImage(ContextImpl *contextImpl,
+    gl::Error copyImage(const gl::Context *context,
                         GLenum target,
                         size_t level,
                         const gl::Rectangle &sourceArea,
                         GLenum internalFormat,
                         const gl::Framebuffer *source) override;
-    gl::Error copySubImage(ContextImpl *contextImpl,
+    gl::Error copySubImage(const gl::Context *context,
                            GLenum target,
                            size_t level,
                            const gl::Offset &destOffset,
                            const gl::Rectangle &sourceArea,
                            const gl::Framebuffer *source) override;
 
-    gl::Error copyTexture(ContextImpl *contextImpl,
+    gl::Error copyTexture(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           GLenum internalFormat,
@@ -211,7 +265,7 @@ class TextureD3D_2D : public TextureD3D
                           bool unpackPremultiplyAlpha,
                           bool unpackUnmultiplyAlpha,
                           const gl::Texture *source) override;
-    gl::Error copySubTexture(ContextImpl *contextImpl,
+    gl::Error copySubTexture(const gl::Context *context,
                              GLenum target,
                              size_t level,
                              const gl::Offset &destOffset,
@@ -221,56 +275,56 @@ class TextureD3D_2D : public TextureD3D
                              bool unpackPremultiplyAlpha,
                              bool unpackUnmultiplyAlpha,
                              const gl::Texture *source) override;
-    gl::Error copyCompressedTexture(ContextImpl *contextImpl, const gl::Texture *source) override;
+    gl::Error copyCompressedTexture(const gl::Context *context, const gl::Texture *source) override;
 
-    gl::Error setStorage(ContextImpl *contextImpl,
+    gl::Error setStorage(const gl::Context *context,
                          GLenum target,
                          size_t levels,
                          GLenum internalFormat,
                          const gl::Extents &size) override;
 
-    virtual void bindTexImage(egl::Surface *surface);
-    virtual void releaseTexImage();
+    gl::Error bindTexImage(const gl::Context *context, egl::Surface *surface) override;
+    gl::Error releaseTexImage(const gl::Context *context) override;
 
-    gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
+    gl::Error setEGLImageTarget(const gl::Context *context,
+                                GLenum target,
+                                egl::Image *image) override;
 
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT);
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
-    virtual gl::ImageIndexIterator imageIterator() const;
-    virtual gl::ImageIndex getImageIndex(GLint mip, GLint layer) const;
-    virtual bool isValidIndex(const gl::ImageIndex &index) const;
-
-    gl::Error setStorageMultisample(ContextImpl *contextImpl,
-                                    GLenum target,
-                                    GLsizei samples,
-                                    GLint internalFormat,
-                                    const gl::Extents &size,
-                                    GLboolean fixedSampleLocations) override;
+    gl::ImageIndexIterator imageIterator() const override;
+    gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
+    bool isValidIndex(const gl::ImageIndex &index) const override;
 
   protected:
     void markAllImagesDirty() override;
 
   private:
-    virtual gl::Error initializeStorage(bool renderTarget);
-    virtual gl::Error createCompleteStorage(bool renderTarget, TextureStorage **outTexStorage) const;
-    virtual gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
+    gl::Error initializeStorage(const gl::Context *context, bool renderTarget) override;
+    gl::Error createCompleteStorage(bool renderTarget,
+                                    TexStoragePointer *outTexStorage) const override;
+    gl::Error setCompleteTexStorage(const gl::Context *context,
+                                    TextureStorage *newCompleteTexStorage) override;
 
-    virtual gl::Error updateStorage();
-    virtual void initMipmapImages();
+    gl::Error updateStorage(const gl::Context *context) override;
+    gl::Error initMipmapImages(const gl::Context *context) override;
 
     bool isValidLevel(int level) const;
     bool isLevelComplete(int level) const;
     virtual bool isImageComplete(const gl::ImageIndex &index) const;
 
-    gl::Error updateStorageLevel(int level);
+    gl::Error updateStorageLevel(const gl::Context *context, int level);
 
-    void redefineImage(size_t level,
-                       GLenum internalformat,
-                       const gl::Extents &size,
-                       bool forceRelease);
+    gl::Error redefineImage(const gl::Context *context,
+                            size_t level,
+                            GLenum internalformat,
+                            const gl::Extents &size,
+                            bool forceRelease);
 
     bool mEGLImageTarget;
-    ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+    TexLevelsArray<std::unique_ptr<ImageD3D>> mImageArray;
 };
 
 class TextureD3D_Cube : public TextureD3D
@@ -279,17 +333,17 @@ class TextureD3D_Cube : public TextureD3D
     TextureD3D_Cube(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_Cube();
 
-    virtual ImageD3D *getImage(int level, int layer) const;
-    virtual ImageD3D *getImage(const gl::ImageIndex &index) const;
-    virtual GLsizei getLayerCount(int level) const;
+    gl::Error onDestroy(const gl::Context *context) override;
 
-    virtual bool hasDirtyImages() const { return mDirtyImages; }
-    virtual void resetDirty() { mDirtyImages = false; }
+    ImageD3D *getImage(int level, int layer) const;
+    ImageD3D *getImage(const gl::ImageIndex &index) const override;
+    GLsizei getLayerCount(int level) const override;
 
     GLenum getInternalFormat(GLint level, GLint layer) const;
     bool isDepth(GLint level, GLint layer) const;
+    bool isSRGB(GLint level, GLint layer) const;
 
-    gl::Error setImage(ContextImpl *contextImpl,
+    gl::Error setImage(const gl::Context *context,
                        GLenum target,
                        size_t level,
                        GLenum internalFormat,
@@ -298,7 +352,7 @@ class TextureD3D_Cube : public TextureD3D
                        GLenum type,
                        const gl::PixelUnpackState &unpack,
                        const uint8_t *pixels) override;
-    gl::Error setSubImage(ContextImpl *contextImpl,
+    gl::Error setSubImage(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           const gl::Box &area,
@@ -307,7 +361,7 @@ class TextureD3D_Cube : public TextureD3D
                           const gl::PixelUnpackState &unpack,
                           const uint8_t *pixels) override;
 
-    gl::Error setCompressedImage(ContextImpl *contextImpl,
+    gl::Error setCompressedImage(const gl::Context *context,
                                  GLenum target,
                                  size_t level,
                                  GLenum internalFormat,
@@ -315,7 +369,7 @@ class TextureD3D_Cube : public TextureD3D
                                  const gl::PixelUnpackState &unpack,
                                  size_t imageSize,
                                  const uint8_t *pixels) override;
-    gl::Error setCompressedSubImage(ContextImpl *contextImpl,
+    gl::Error setCompressedSubImage(const gl::Context *context,
                                     GLenum target,
                                     size_t level,
                                     const gl::Box &area,
@@ -324,20 +378,20 @@ class TextureD3D_Cube : public TextureD3D
                                     size_t imageSize,
                                     const uint8_t *pixels) override;
 
-    gl::Error copyImage(ContextImpl *contextImpl,
+    gl::Error copyImage(const gl::Context *context,
                         GLenum target,
                         size_t level,
                         const gl::Rectangle &sourceArea,
                         GLenum internalFormat,
                         const gl::Framebuffer *source) override;
-    gl::Error copySubImage(ContextImpl *contextImpl,
+    gl::Error copySubImage(const gl::Context *context,
                            GLenum target,
                            size_t level,
                            const gl::Offset &destOffset,
                            const gl::Rectangle &sourceArea,
                            const gl::Framebuffer *source) override;
 
-    gl::Error copyTexture(ContextImpl *contextImpl,
+    gl::Error copyTexture(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           GLenum internalFormat,
@@ -347,7 +401,7 @@ class TextureD3D_Cube : public TextureD3D
                           bool unpackPremultiplyAlpha,
                           bool unpackUnmultiplyAlpha,
                           const gl::Texture *source) override;
-    gl::Error copySubTexture(ContextImpl *contextImpl,
+    gl::Error copySubTexture(const gl::Context *context,
                              GLenum target,
                              size_t level,
                              const gl::Offset &destOffset,
@@ -358,43 +412,54 @@ class TextureD3D_Cube : public TextureD3D
                              bool unpackUnmultiplyAlpha,
                              const gl::Texture *source) override;
 
-    gl::Error setStorage(ContextImpl *contextImpl,
+    gl::Error setStorage(const gl::Context *context,
                          GLenum target,
                          size_t levels,
                          GLenum internalFormat,
                          const gl::Extents &size) override;
 
-    virtual void bindTexImage(egl::Surface *surface);
-    virtual void releaseTexImage();
+    gl::Error bindTexImage(const gl::Context *context, egl::Surface *surface) override;
+    gl::Error releaseTexImage(const gl::Context *context) override;
 
-    gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
+    gl::Error setEGLImageTarget(const gl::Context *context,
+                                GLenum target,
+                                egl::Image *image) override;
 
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT);
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
-    virtual gl::ImageIndexIterator imageIterator() const;
-    virtual gl::ImageIndex getImageIndex(GLint mip, GLint layer) const;
-    virtual bool isValidIndex(const gl::ImageIndex &index) const;
+    gl::ImageIndexIterator imageIterator() const override;
+    gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
+    bool isValidIndex(const gl::ImageIndex &index) const override;
 
   protected:
     void markAllImagesDirty() override;
 
   private:
-    virtual gl::Error initializeStorage(bool renderTarget);
-    virtual gl::Error createCompleteStorage(bool renderTarget, TextureStorage **outTexStorage) const;
-    virtual gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
+    gl::Error initializeStorage(const gl::Context *context, bool renderTarget) override;
+    gl::Error createCompleteStorage(bool renderTarget,
+                                    TexStoragePointer *outTexStorage) const override;
+    gl::Error setCompleteTexStorage(const gl::Context *context,
+                                    TextureStorage *newCompleteTexStorage) override;
 
-    virtual gl::Error updateStorage();
-    void initMipmapImages() override;
+    gl::Error updateStorage(const gl::Context *context) override;
+    gl::Error initMipmapImages(const gl::Context *context) override;
 
     bool isValidFaceLevel(int faceIndex, int level) const;
     bool isFaceLevelComplete(int faceIndex, int level) const;
     bool isCubeComplete() const;
     virtual bool isImageComplete(const gl::ImageIndex &index) const;
-    gl::Error updateStorageFaceLevel(int faceIndex, int level);
+    gl::Error updateStorageFaceLevel(const gl::Context *context, int faceIndex, int level);
 
-    void redefineImage(int faceIndex, GLint level, GLenum internalformat, const gl::Extents &size);
+    gl::Error redefineImage(const gl::Context *context,
+                            int faceIndex,
+                            GLint level,
+                            GLenum internalformat,
+                            const gl::Extents &size,
+                            bool forceRelease);
 
-    ImageD3D *mImageArray[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+    std::array<TexLevelsArray<std::unique_ptr<ImageD3D>>, 6> mImageArray;
 };
 
 class TextureD3D_3D : public TextureD3D
@@ -403,9 +468,11 @@ class TextureD3D_3D : public TextureD3D
     TextureD3D_3D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_3D();
 
-    virtual ImageD3D *getImage(int level, int layer) const;
-    virtual ImageD3D *getImage(const gl::ImageIndex &index) const;
-    virtual GLsizei getLayerCount(int level) const;
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    ImageD3D *getImage(int level, int layer) const;
+    ImageD3D *getImage(const gl::ImageIndex &index) const override;
+    GLsizei getLayerCount(int level) const override;
 
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
@@ -413,7 +480,7 @@ class TextureD3D_3D : public TextureD3D
     GLenum getInternalFormat(GLint level) const;
     bool isDepth(GLint level) const;
 
-    gl::Error setImage(ContextImpl *contextImpl,
+    gl::Error setImage(const gl::Context *context,
                        GLenum target,
                        size_t level,
                        GLenum internalFormat,
@@ -422,7 +489,7 @@ class TextureD3D_3D : public TextureD3D
                        GLenum type,
                        const gl::PixelUnpackState &unpack,
                        const uint8_t *pixels) override;
-    gl::Error setSubImage(ContextImpl *contextImpl,
+    gl::Error setSubImage(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           const gl::Box &area,
@@ -431,7 +498,7 @@ class TextureD3D_3D : public TextureD3D
                           const gl::PixelUnpackState &unpack,
                           const uint8_t *pixels) override;
 
-    gl::Error setCompressedImage(ContextImpl *contextImpl,
+    gl::Error setCompressedImage(const gl::Context *context,
                                  GLenum target,
                                  size_t level,
                                  GLenum internalFormat,
@@ -439,7 +506,7 @@ class TextureD3D_3D : public TextureD3D
                                  const gl::PixelUnpackState &unpack,
                                  size_t imageSize,
                                  const uint8_t *pixels) override;
-    gl::Error setCompressedSubImage(ContextImpl *contextImpl,
+    gl::Error setCompressedSubImage(const gl::Context *context,
                                     GLenum target,
                                     size_t level,
                                     const gl::Box &area,
@@ -448,56 +515,66 @@ class TextureD3D_3D : public TextureD3D
                                     size_t imageSize,
                                     const uint8_t *pixels) override;
 
-    gl::Error copyImage(ContextImpl *contextImpl,
+    gl::Error copyImage(const gl::Context *context,
                         GLenum target,
                         size_t level,
                         const gl::Rectangle &sourceArea,
                         GLenum internalFormat,
                         const gl::Framebuffer *source) override;
-    gl::Error copySubImage(ContextImpl *contextImpl,
+    gl::Error copySubImage(const gl::Context *context,
                            GLenum target,
                            size_t level,
                            const gl::Offset &destOffset,
                            const gl::Rectangle &sourceArea,
                            const gl::Framebuffer *source) override;
 
-    gl::Error setStorage(ContextImpl *contextImpl,
+    gl::Error setStorage(const gl::Context *context,
                          GLenum target,
                          size_t levels,
                          GLenum internalFormat,
                          const gl::Extents &size) override;
 
-    virtual void bindTexImage(egl::Surface *surface);
-    virtual void releaseTexImage();
+    gl::Error bindTexImage(const gl::Context *context, egl::Surface *surface) override;
+    gl::Error releaseTexImage(const gl::Context *context) override;
 
-    gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
+    gl::Error setEGLImageTarget(const gl::Context *context,
+                                GLenum target,
+                                egl::Image *image) override;
 
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT);
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
-    virtual gl::ImageIndexIterator imageIterator() const;
-    virtual gl::ImageIndex getImageIndex(GLint mip, GLint layer) const;
-    virtual bool isValidIndex(const gl::ImageIndex &index) const;
+    gl::ImageIndexIterator imageIterator() const override;
+    gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
+    bool isValidIndex(const gl::ImageIndex &index) const override;
 
   protected:
     void markAllImagesDirty() override;
     GLint getLevelZeroDepth() const override;
 
   private:
-    virtual gl::Error initializeStorage(bool renderTarget);
-    virtual gl::Error createCompleteStorage(bool renderTarget, TextureStorage **outStorage) const;
-    virtual gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
+    gl::Error initializeStorage(const gl::Context *context, bool renderTarget) override;
+    gl::Error createCompleteStorage(bool renderTarget,
+                                    TexStoragePointer *outStorage) const override;
+    gl::Error setCompleteTexStorage(const gl::Context *context,
+                                    TextureStorage *newCompleteTexStorage) override;
 
-    virtual gl::Error updateStorage();
-    void initMipmapImages() override;
+    gl::Error updateStorage(const gl::Context *context) override;
+    gl::Error initMipmapImages(const gl::Context *context) override;
 
     bool isValidLevel(int level) const;
     bool isLevelComplete(int level) const;
     virtual bool isImageComplete(const gl::ImageIndex &index) const;
-    gl::Error updateStorageLevel(int level);
+    gl::Error updateStorageLevel(const gl::Context *context, int level);
 
-    void redefineImage(GLint level, GLenum internalformat, const gl::Extents &size);
+    gl::Error redefineImage(const gl::Context *context,
+                            GLint level,
+                            GLenum internalformat,
+                            const gl::Extents &size,
+                            bool forceRelease);
 
-    ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+    TexLevelsArray<std::unique_ptr<ImageD3D>> mImageArray;
 };
 
 class TextureD3D_2DArray : public TextureD3D
@@ -506,6 +583,8 @@ class TextureD3D_2DArray : public TextureD3D
     TextureD3D_2DArray(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_2DArray();
 
+    gl::Error onDestroy(const gl::Context *context) override;
+
     virtual ImageD3D *getImage(int level, int layer) const;
     virtual ImageD3D *getImage(const gl::ImageIndex &index) const;
     virtual GLsizei getLayerCount(int level) const;
@@ -515,7 +594,7 @@ class TextureD3D_2DArray : public TextureD3D
     GLenum getInternalFormat(GLint level) const;
     bool isDepth(GLint level) const;
 
-    gl::Error setImage(ContextImpl *contextImpl,
+    gl::Error setImage(const gl::Context *context,
                        GLenum target,
                        size_t level,
                        GLenum internalFormat,
@@ -524,7 +603,7 @@ class TextureD3D_2DArray : public TextureD3D
                        GLenum type,
                        const gl::PixelUnpackState &unpack,
                        const uint8_t *pixels) override;
-    gl::Error setSubImage(ContextImpl *contextImpl,
+    gl::Error setSubImage(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           const gl::Box &area,
@@ -533,7 +612,7 @@ class TextureD3D_2DArray : public TextureD3D
                           const gl::PixelUnpackState &unpack,
                           const uint8_t *pixels) override;
 
-    gl::Error setCompressedImage(ContextImpl *contextImpl,
+    gl::Error setCompressedImage(const gl::Context *context,
                                  GLenum target,
                                  size_t level,
                                  GLenum internalFormat,
@@ -541,7 +620,7 @@ class TextureD3D_2DArray : public TextureD3D
                                  const gl::PixelUnpackState &unpack,
                                  size_t imageSize,
                                  const uint8_t *pixels) override;
-    gl::Error setCompressedSubImage(ContextImpl *contextImpl,
+    gl::Error setCompressedSubImage(const gl::Context *context,
                                     GLenum target,
                                     size_t level,
                                     const gl::Box &area,
@@ -550,54 +629,64 @@ class TextureD3D_2DArray : public TextureD3D
                                     size_t imageSize,
                                     const uint8_t *pixels) override;
 
-    gl::Error copyImage(ContextImpl *contextImpl,
+    gl::Error copyImage(const gl::Context *context,
                         GLenum target,
                         size_t level,
                         const gl::Rectangle &sourceArea,
                         GLenum internalFormat,
                         const gl::Framebuffer *source) override;
-    gl::Error copySubImage(ContextImpl *contextImpl,
+    gl::Error copySubImage(const gl::Context *context,
                            GLenum target,
                            size_t level,
                            const gl::Offset &destOffset,
                            const gl::Rectangle &sourceArea,
                            const gl::Framebuffer *source) override;
 
-    gl::Error setStorage(ContextImpl *contextImpl,
+    gl::Error setStorage(const gl::Context *context,
                          GLenum target,
                          size_t levels,
                          GLenum internalFormat,
                          const gl::Extents &size) override;
 
-    virtual void bindTexImage(egl::Surface *surface);
-    virtual void releaseTexImage();
+    gl::Error bindTexImage(const gl::Context *context, egl::Surface *surface) override;
+    gl::Error releaseTexImage(const gl::Context *context) override;
 
-    gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
+    gl::Error setEGLImageTarget(const gl::Context *context,
+                                GLenum target,
+                                egl::Image *image) override;
 
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT);
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
-    virtual gl::ImageIndexIterator imageIterator() const;
-    virtual gl::ImageIndex getImageIndex(GLint mip, GLint layer) const;
-    virtual bool isValidIndex(const gl::ImageIndex &index) const;
+    gl::ImageIndexIterator imageIterator() const override;
+    gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
+    bool isValidIndex(const gl::ImageIndex &index) const override;
 
   protected:
     void markAllImagesDirty() override;
 
   private:
-    virtual gl::Error initializeStorage(bool renderTarget);
-    virtual gl::Error createCompleteStorage(bool renderTarget, TextureStorage **outStorage) const;
-    virtual gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage);
+    gl::Error initializeStorage(const gl::Context *context, bool renderTarget) override;
+    gl::Error createCompleteStorage(bool renderTarget,
+                                    TexStoragePointer *outStorage) const override;
+    gl::Error setCompleteTexStorage(const gl::Context *context,
+                                    TextureStorage *newCompleteTexStorage) override;
 
-    virtual gl::Error updateStorage();
-    void initMipmapImages() override;
+    gl::Error updateStorage(const gl::Context *context) override;
+    gl::Error initMipmapImages(const gl::Context *context) override;
 
     bool isValidLevel(int level) const;
     bool isLevelComplete(int level) const;
     virtual bool isImageComplete(const gl::ImageIndex &index) const;
-    gl::Error updateStorageLevel(int level);
+    gl::Error updateStorageLevel(const gl::Context *context, int level);
 
     void deleteImages();
-    void redefineImage(GLint level, GLenum internalformat, const gl::Extents &size);
+    gl::Error redefineImage(const gl::Context *context,
+                            GLint level,
+                            GLenum internalformat,
+                            const gl::Extents &size,
+                            bool forceRelease);
 
     // Storing images as an array of single depth textures since D3D11 treats each array level of a
     // Texture2D object as a separate subresource.  Each layer would have to be looped over
@@ -616,7 +705,7 @@ class TextureD3D_External : public TextureD3D
     ImageD3D *getImage(const gl::ImageIndex &index) const override;
     GLsizei getLayerCount(int level) const override;
 
-    gl::Error setImage(ContextImpl *contextImpl,
+    gl::Error setImage(const gl::Context *context,
                        GLenum target,
                        size_t level,
                        GLenum internalFormat,
@@ -625,7 +714,7 @@ class TextureD3D_External : public TextureD3D
                        GLenum type,
                        const gl::PixelUnpackState &unpack,
                        const uint8_t *pixels) override;
-    gl::Error setSubImage(ContextImpl *contextImpl,
+    gl::Error setSubImage(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           const gl::Box &area,
@@ -634,7 +723,7 @@ class TextureD3D_External : public TextureD3D
                           const gl::PixelUnpackState &unpack,
                           const uint8_t *pixels) override;
 
-    gl::Error setCompressedImage(ContextImpl *contextImpl,
+    gl::Error setCompressedImage(const gl::Context *context,
                                  GLenum target,
                                  size_t level,
                                  GLenum internalFormat,
@@ -642,7 +731,7 @@ class TextureD3D_External : public TextureD3D
                                  const gl::PixelUnpackState &unpack,
                                  size_t imageSize,
                                  const uint8_t *pixels) override;
-    gl::Error setCompressedSubImage(ContextImpl *contextImpl,
+    gl::Error setCompressedSubImage(const gl::Context *context,
                                     GLenum target,
                                     size_t level,
                                     const gl::Box &area,
@@ -651,35 +740,40 @@ class TextureD3D_External : public TextureD3D
                                     size_t imageSize,
                                     const uint8_t *pixels) override;
 
-    gl::Error copyImage(ContextImpl *contextImpl,
+    gl::Error copyImage(const gl::Context *context,
                         GLenum target,
                         size_t level,
                         const gl::Rectangle &sourceArea,
                         GLenum internalFormat,
                         const gl::Framebuffer *source) override;
-    gl::Error copySubImage(ContextImpl *contextImpl,
+    gl::Error copySubImage(const gl::Context *context,
                            GLenum target,
                            size_t level,
                            const gl::Offset &destOffset,
                            const gl::Rectangle &sourceArea,
                            const gl::Framebuffer *source) override;
 
-    gl::Error setStorage(ContextImpl *contextImpl,
+    gl::Error setStorage(const gl::Context *context,
                          GLenum target,
                          size_t levels,
                          GLenum internalFormat,
                          const gl::Extents &size) override;
 
-    gl::Error setImageExternal(GLenum target,
+    gl::Error setImageExternal(const gl::Context *context,
+                               GLenum target,
                                egl::Stream *stream,
                                const egl::Stream::GLTextureDescription &desc) override;
 
-    void bindTexImage(egl::Surface *surface) override;
-    void releaseTexImage() override;
+    gl::Error bindTexImage(const gl::Context *context, egl::Surface *surface) override;
+    gl::Error releaseTexImage(const gl::Context *context) override;
 
-    gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
+    gl::Error setEGLImageTarget(const gl::Context *context,
+                                GLenum target,
+                                egl::Image *image) override;
 
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
     gl::ImageIndexIterator imageIterator() const override;
     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
@@ -689,13 +783,14 @@ class TextureD3D_External : public TextureD3D
     void markAllImagesDirty() override;
 
   private:
-    gl::Error initializeStorage(bool renderTarget) override;
+    gl::Error initializeStorage(const gl::Context *context, bool renderTarget) override;
     gl::Error createCompleteStorage(bool renderTarget,
-                                    TextureStorage **outTexStorage) const override;
-    gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage) override;
+                                    TexStoragePointer *outTexStorage) const override;
+    gl::Error setCompleteTexStorage(const gl::Context *context,
+                                    TextureStorage *newCompleteTexStorage) override;
 
-    gl::Error updateStorage() override;
-    void initMipmapImages() override;
+    gl::Error updateStorage(const gl::Context *context) override;
+    gl::Error initMipmapImages(const gl::Context *context) override;
 
     bool isImageComplete(const gl::ImageIndex &index) const override;
 };
@@ -707,7 +802,7 @@ class TextureD3D_2DMultisample : public TextureD3D
     ~TextureD3D_2DMultisample() override;
 
     ImageD3D *getImage(const gl::ImageIndex &index) const override;
-    gl::Error setImage(ContextImpl *contextImpl,
+    gl::Error setImage(const gl::Context *context,
                        GLenum target,
                        size_t level,
                        GLenum internalFormat,
@@ -716,7 +811,7 @@ class TextureD3D_2DMultisample : public TextureD3D
                        GLenum type,
                        const gl::PixelUnpackState &unpack,
                        const uint8_t *pixels) override;
-    gl::Error setSubImage(ContextImpl *contextImpl,
+    gl::Error setSubImage(const gl::Context *context,
                           GLenum target,
                           size_t level,
                           const gl::Box &area,
@@ -725,7 +820,7 @@ class TextureD3D_2DMultisample : public TextureD3D
                           const gl::PixelUnpackState &unpack,
                           const uint8_t *pixels) override;
 
-    gl::Error setCompressedImage(ContextImpl *contextImpl,
+    gl::Error setCompressedImage(const gl::Context *context,
                                  GLenum target,
                                  size_t level,
                                  GLenum internalFormat,
@@ -733,7 +828,7 @@ class TextureD3D_2DMultisample : public TextureD3D
                                  const gl::PixelUnpackState &unpack,
                                  size_t imageSize,
                                  const uint8_t *pixels) override;
-    gl::Error setCompressedSubImage(ContextImpl *contextImpl,
+    gl::Error setCompressedSubImage(const gl::Context *context,
                                     GLenum target,
                                     size_t level,
                                     const gl::Box &area,
@@ -742,35 +837,36 @@ class TextureD3D_2DMultisample : public TextureD3D
                                     size_t imageSize,
                                     const uint8_t *pixels) override;
 
-    gl::Error copyImage(ContextImpl *contextImpl,
+    gl::Error copyImage(const gl::Context *context,
                         GLenum target,
                         size_t level,
                         const gl::Rectangle &sourceArea,
                         GLenum internalFormat,
                         const gl::Framebuffer *source) override;
-    gl::Error copySubImage(ContextImpl *contextImpl,
+    gl::Error copySubImage(const gl::Context *context,
                            GLenum target,
                            size_t level,
                            const gl::Offset &destOffset,
                            const gl::Rectangle &sourceArea,
                            const gl::Framebuffer *source) override;
 
-    gl::Error setStorage(ContextImpl *contextImpl,
-                         GLenum target,
-                         size_t levels,
-                         GLenum internalFormat,
-                         const gl::Extents &size) override;
-
-    gl::Error setImageExternal(GLenum target,
-                               egl::Stream *stream,
-                               const egl::Stream::GLTextureDescription &desc) override;
+    gl::Error setStorageMultisample(const gl::Context *context,
+                                    GLenum target,
+                                    GLsizei samples,
+                                    GLint internalFormat,
+                                    const gl::Extents &size,
+                                    GLboolean fixedSampleLocations) override;
 
-    void bindTexImage(egl::Surface *surface) override;
-    void releaseTexImage() override;
+    gl::Error bindTexImage(const gl::Context *context, egl::Surface *surface) override;
+    gl::Error releaseTexImage(const gl::Context *context) override;
 
-    gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
+    gl::Error setEGLImageTarget(const gl::Context *context,
+                                GLenum target,
+                                egl::Image *image) override;
 
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
     gl::ImageIndexIterator imageIterator() const override;
     gl::ImageIndex getImageIndex(GLint mip, GLint layer) const override;
@@ -782,13 +878,14 @@ class TextureD3D_2DMultisample : public TextureD3D
     void markAllImagesDirty() override;
 
   private:
-    gl::Error initializeStorage(bool renderTarget) override;
+    gl::Error initializeStorage(const gl::Context *context, bool renderTarget) override;
     gl::Error createCompleteStorage(bool renderTarget,
-                                    TextureStorage **outTexStorage) const override;
-    gl::Error setCompleteTexStorage(TextureStorage *newCompleteTexStorage) override;
+                                    TexStoragePointer *outTexStorage) const override;
+    gl::Error setCompleteTexStorage(const gl::Context *context,
+                                    TextureStorage *newCompleteTexStorage) override;
 
-    gl::Error updateStorage() override;
-    void initMipmapImages() override;
+    gl::Error updateStorage(const gl::Context *context) override;
+    gl::Error initMipmapImages(const gl::Context *context) override;
 
     bool isImageComplete(const gl::ImageIndex &index) const override;
 };
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureStorage.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureStorage.h
index c29e20f0d3c..239ac54a3be 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureStorage.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/TextureStorage.h
@@ -19,10 +19,11 @@
 
 namespace gl
 {
+class Context;
 struct ImageIndex;
 struct Box;
 struct PixelUnpackState;
-}
+}  // namespace gl
 
 namespace rx
 {
@@ -34,7 +35,12 @@ class TextureStorage : angle::NonCopyable
 {
   public:
     TextureStorage() {}
-    virtual ~TextureStorage() {}
+
+    virtual gl::Error onDestroy(const gl::Context *context)
+    {
+        delete this;
+        return gl::NoError();
+    }
 
     virtual int getTopLevel() const = 0;
     virtual bool isRenderTarget() const = 0;
@@ -42,20 +48,34 @@ class TextureStorage : angle::NonCopyable
     virtual bool supportsNativeMipmapFunction() const = 0;
     virtual int getLevelCount() const = 0;
 
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) = 0;
-    virtual gl::Error generateMipmap(const gl::ImageIndex &sourceIndex, const gl::ImageIndex &destIndex) = 0;
+    virtual gl::Error getRenderTarget(const gl::Context *context,
+                                      const gl::ImageIndex &index,
+                                      RenderTargetD3D **outRT) = 0;
+    virtual gl::Error generateMipmap(const gl::Context *context,
+                                     const gl::ImageIndex &sourceIndex,
+                                     const gl::ImageIndex &destIndex) = 0;
 
-    virtual gl::Error copyToStorage(TextureStorage *destStorage) = 0;
-    virtual gl::Error setData(const gl::ImageIndex &index, ImageD3D *image, const gl::Box *destBox, GLenum type,
-                              const gl::PixelUnpackState &unpack, const uint8_t *pixelData) = 0;
+    virtual gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) = 0;
+    virtual gl::Error setData(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              ImageD3D *image,
+                              const gl::Box *destBox,
+                              GLenum type,
+                              const gl::PixelUnpackState &unpack,
+                              const uint8_t *pixelData) = 0;
 
     // This is a no-op for most implementations of TextureStorage. Some (e.g. TextureStorage11_2D) might override it.
     virtual gl::Error useLevelZeroWorkaroundTexture(bool useLevelZeroTexture)
     {
         return gl::NoError();
     }
+
+  protected:
+    virtual ~TextureStorage() {}
 };
 
-}
+using TexStoragePointer = angle::UniqueObjectPointer<TextureStorage, gl::Context>;
+
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.cpp
index 30d65be0113..0503ca37808 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.cpp
@@ -104,8 +104,8 @@ gl::ErrorOrResult<unsigned int> VertexBufferInterface::getSpaceRequired(
 
     if (alignedSpaceRequired < spaceRequired)
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Vertex buffer overflow in VertexBufferInterface::getSpaceRequired.");
+        return gl::OutOfMemory()
+               << "Vertex buffer overflow in VertexBufferInterface::getSpaceRequired.";
     }
 
     return alignedSpaceRequired;
@@ -167,7 +167,8 @@ gl::Error StreamingVertexBufferInterface::storeDynamicAttribute(const gl::Vertex
     checkedPosition += spaceRequired;
     if (!checkedPosition.IsValid())
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal error, new vertex buffer write position would overflow.");
+        return gl::OutOfMemory()
+               << "Internal error, new vertex buffer write position would overflow.";
     }
 
     ANGLE_TRY(reserveSpace(mReservedSpace));
@@ -202,10 +203,9 @@ gl::Error StreamingVertexBufferInterface::reserveVertexSpace(const gl::VertexAtt
     // Protect against integer overflow
     if (!alignedRequiredSpace.IsValid())
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Unable to reserve %u extra bytes in internal vertex buffer, "
-                         "it would result in an overflow.",
-                         requiredSpace);
+        return gl::OutOfMemory()
+               << "Unable to reserve " << requiredSpace
+               << " extra bytes in internal vertex buffer, it would result in an overflow.";
     }
 
     mReservedSpace = alignedRequiredSpace.ValueOrDie();
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.h
index bb749c1bf83..36297d9d5d5 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexBuffer.h
@@ -22,7 +22,7 @@
 namespace gl
 {
 struct VertexAttribute;
-struct VertexBinding;
+class VertexBinding;
 struct VertexAttribCurrentValueData;
 }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.cpp
index ed59c0e3fbc..46592e5478a 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.cpp
@@ -63,7 +63,7 @@ bool DirectStoragePossible(const gl::VertexAttribute &attrib, const gl::VertexBi
         return false;
     }
 
-    gl::Buffer *buffer = binding.buffer.get();
+    gl::Buffer *buffer = binding.getBuffer().get();
     if (!buffer)
     {
         return false;
@@ -149,7 +149,7 @@ VertexStorageType ClassifyAttributeStorage(const gl::VertexAttribute &attrib,
     }
 
     // If specified with immediate data, we must use dynamic storage.
-    auto *buffer = binding.buffer.get();
+    auto *buffer = binding.getBuffer().get();
     if (!buffer)
     {
         return VertexStorageType::DYNAMIC;
@@ -248,7 +248,7 @@ gl::Error VertexDataManager::prepareVertexData(const gl::State &state,
         translated->attribute        = &attrib;
         translated->binding          = &binding;
         translated->currentValueType = currentValueData.Type;
-        translated->divisor          = binding.divisor;
+        translated->divisor          = binding.getDivisor();
 
         switch (ClassifyAttributeStorage(attrib, binding))
         {
@@ -297,7 +297,7 @@ void VertexDataManager::StoreDirectAttrib(TranslatedAttribute *directAttrib)
     const auto &attrib  = *directAttrib->attribute;
     const auto &binding = *directAttrib->binding;
 
-    gl::Buffer *buffer   = binding.buffer.get();
+    gl::Buffer *buffer   = binding.getBuffer().get();
     BufferD3D *bufferD3D = buffer ? GetImplAs<BufferD3D>(buffer) : nullptr;
 
     ASSERT(DirectStoragePossible(attrib, binding));
@@ -309,7 +309,7 @@ void VertexDataManager::StoreDirectAttrib(TranslatedAttribute *directAttrib)
         static_cast<unsigned int>(ComputeVertexAttributeOffset(attrib, binding));
 
     // Instanced vertices do not apply the 'start' offset
-    directAttrib->usesFirstVertexOffset = (binding.divisor == 0);
+    directAttrib->usesFirstVertexOffset = (binding.getDivisor() == 0);
 }
 
 // static
@@ -319,7 +319,7 @@ gl::Error VertexDataManager::StoreStaticAttrib(TranslatedAttribute *translated)
     const auto &attrib  = *translated->attribute;
     const auto &binding = *translated->binding;
 
-    gl::Buffer *buffer = binding.buffer.get();
+    gl::Buffer *buffer = binding.getBuffer().get();
     ASSERT(buffer && attrib.enabled && !DirectStoragePossible(attrib, binding));
     BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer);
 
@@ -362,8 +362,7 @@ gl::Error VertexDataManager::StoreStaticAttrib(TranslatedAttribute *translated)
 
     if (!checkedOffset.IsValid())
     {
-        return gl::Error(GL_INVALID_OPERATION,
-                         "Integer overflow in VertexDataManager::StoreStaticAttrib");
+        return gl::InternalError() << "Integer overflow in VertexDataManager::StoreStaticAttrib";
     }
 
     translated->vertexBuffer.set(vertexBuffer);
@@ -371,7 +370,7 @@ gl::Error VertexDataManager::StoreStaticAttrib(TranslatedAttribute *translated)
     translated->baseOffset = streamOffset + firstElementOffset;
 
     // Instanced vertices do not apply the 'start' offset
-    translated->usesFirstVertexOffset = (binding.divisor == 0);
+    translated->usesFirstVertexOffset = (binding.getDivisor() == 0);
 
     return gl::NoError();
 }
@@ -429,7 +428,7 @@ void VertexDataManager::PromoteDynamicAttribs(
         ASSERT(dynamicAttrib.attribute && dynamicAttrib.binding);
         const auto &binding       = *dynamicAttrib.binding;
 
-        gl::Buffer *buffer        = binding.buffer.get();
+        gl::Buffer *buffer = binding.getBuffer().get();
         if (buffer)
         {
             BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer);
@@ -449,7 +448,7 @@ gl::Error VertexDataManager::reserveSpaceForAttrib(const TranslatedAttribute &tr
 
     ASSERT(!DirectStoragePossible(attrib, binding));
 
-    gl::Buffer *buffer   = binding.buffer.get();
+    gl::Buffer *buffer   = binding.getBuffer().get();
     BufferD3D *bufferD3D = buffer ? GetImplAs<BufferD3D>(buffer) : nullptr;
     ASSERT(!bufferD3D || bufferD3D->getStaticVertexBuffer(attrib, binding) == nullptr);
 
@@ -471,14 +470,14 @@ gl::Error VertexDataManager::storeDynamicAttrib(TranslatedAttribute *translated,
     const auto &attrib  = *translated->attribute;
     const auto &binding = *translated->binding;
 
-    gl::Buffer *buffer = binding.buffer.get();
+    gl::Buffer *buffer = binding.getBuffer().get();
     ASSERT(buffer || attrib.pointer);
     ASSERT(attrib.enabled);
 
     BufferD3D *storage = buffer ? GetImplAs<BufferD3D>(buffer) : nullptr;
 
     // Instanced vertices do not apply the 'start' offset
-    GLint firstVertexIndex = (binding.divisor > 0 ? 0 : start);
+    GLint firstVertexIndex = (binding.getDivisor() > 0 ? 0 : start);
 
     // Compute source data pointer
     const uint8_t *sourceData = nullptr;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.h
index c9cb5dfb449..e411c6c921b 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/VertexDataManager.h
@@ -19,7 +19,7 @@ namespace gl
 {
 class State;
 struct VertexAttribute;
-struct VertexBinding;
+class VertexBinding;
 struct VertexAttribCurrentValueData;
 }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp
index a9ee18e6694..66efc58b7e1 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp
@@ -43,8 +43,12 @@ namespace
 #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h"
 #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h"
 
+#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_ps.h"
+#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_ps.h"
 #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgb_ps.h"
 #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_rgba_ps.h"
+#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_ps.h"
+#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_ps.h"
 #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgb_ps.h"
 #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_rgba_ps.h"
 #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftou_pm_rgb_ps.h"
@@ -556,12 +560,12 @@ DXGI_FORMAT GetStencilSRVFormat(const d3d11::Format &formatSet)
 Blit11::Blit11(Renderer11 *renderer)
     : mRenderer(renderer),
       mResourcesInitialized(false),
-      mVertexBuffer(nullptr),
-      mPointSampler(nullptr),
-      mLinearSampler(nullptr),
-      mScissorEnabledRasterizerState(nullptr),
-      mScissorDisabledRasterizerState(nullptr),
-      mDepthStencilState(nullptr),
+      mVertexBuffer(),
+      mPointSampler(),
+      mLinearSampler(),
+      mScissorEnabledRasterizerState(),
+      mScissorDisabledRasterizerState(),
+      mDepthStencilState(),
       mQuad2DIL(quad2DLayout,
                 ArraySize(quad2DLayout),
                 g_VS_Passthrough2D,
@@ -579,7 +583,7 @@ Blit11::Blit11(Renderer11 *renderer)
       mQuad3DVS(g_VS_Passthrough3D, ArraySize(g_VS_Passthrough3D), "Blit11 3D vertex shader"),
       mQuad3DGS(g_GS_Passthrough3D, ArraySize(g_GS_Passthrough3D), "Blit11 3D geometry shader"),
       mAlphaMaskBlendState(GetAlphaMaskBlendStateDesc(), "Blit11 Alpha Mask Blend"),
-      mSwizzleCB(nullptr),
+      mSwizzleCB(),
       mResolveDepthStencilVS(g_VS_ResolveDepthStencil,
                              ArraySize(g_VS_ResolveDepthStencil),
                              "Blit11::mResolveDepthStencilVS"),
@@ -597,16 +601,6 @@ Blit11::Blit11(Renderer11 *renderer)
 
 Blit11::~Blit11()
 {
-    mQuad2DIL.release();
-    mQuad2DVS.release();
-    mDepthPS.release();
-
-    mQuad3DIL.release();
-    mQuad3DVS.release();
-    mQuad3DGS.release();
-
-    clearShaderMap();
-    releaseResolveDepthStencilResources();
 }
 
 gl::Error Blit11::initResources()
@@ -618,9 +612,6 @@ gl::Error Blit11::initResources()
 
     TRACE_EVENT0("gpu.angle", "Blit11::initResources");
 
-    HRESULT result;
-    ID3D11Device *device = mRenderer->getDevice();
-
     D3D11_BUFFER_DESC vbDesc;
     vbDesc.ByteWidth =
         static_cast<unsigned int>(std::max(sizeof(d3d11::PositionLayerTexCoord3DVertex),
@@ -632,13 +623,8 @@ gl::Error Blit11::initResources()
     vbDesc.MiscFlags           = 0;
     vbDesc.StructureByteStride = 0;
 
-    result = device->CreateBuffer(&vbDesc, nullptr, mVertexBuffer.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create blit vertex buffer, " << result;
-    }
-    d3d11::SetDebugName(mVertexBuffer, "Blit11 vertex buffer");
+    ANGLE_TRY(mRenderer->allocateResource(vbDesc, &mVertexBuffer));
+    mVertexBuffer.setDebugName("Blit11 vertex buffer");
 
     D3D11_SAMPLER_DESC pointSamplerDesc;
     pointSamplerDesc.Filter         = D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR;
@@ -655,13 +641,8 @@ gl::Error Blit11::initResources()
     pointSamplerDesc.MinLOD         = 0.0f;
     pointSamplerDesc.MaxLOD         = FLT_MAX;
 
-    result = device->CreateSamplerState(&pointSamplerDesc, mPointSampler.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create blit point sampler state, " << result;
-    }
-    d3d11::SetDebugName(mPointSampler, "Blit11 point sampler");
+    ANGLE_TRY(mRenderer->allocateResource(pointSamplerDesc, &mPointSampler));
+    mPointSampler.setDebugName("Blit11 point sampler");
 
     D3D11_SAMPLER_DESC linearSamplerDesc;
     linearSamplerDesc.Filter         = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
@@ -678,13 +659,8 @@ gl::Error Blit11::initResources()
     linearSamplerDesc.MinLOD         = 0.0f;
     linearSamplerDesc.MaxLOD         = FLT_MAX;
 
-    result = device->CreateSamplerState(&linearSamplerDesc, mLinearSampler.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create blit linear sampler state, " << result;
-    }
-    d3d11::SetDebugName(mLinearSampler, "Blit11 linear sampler");
+    ANGLE_TRY(mRenderer->allocateResource(linearSamplerDesc, &mLinearSampler));
+    mLinearSampler.setDebugName("Blit11 linear sampler");
 
     // Use a rasterizer state that will not cull so that inverted quads will not be culled
     D3D11_RASTERIZER_DESC rasterDesc;
@@ -699,25 +675,12 @@ gl::Error Blit11::initResources()
     rasterDesc.AntialiasedLineEnable = FALSE;
 
     rasterDesc.ScissorEnable = TRUE;
-    result =
-        device->CreateRasterizerState(&rasterDesc, mScissorEnabledRasterizerState.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create blit scissoring rasterizer state, " << result;
-    }
-    d3d11::SetDebugName(mScissorEnabledRasterizerState, "Blit11 scissoring rasterizer state");
+    ANGLE_TRY(mRenderer->allocateResource(rasterDesc, &mScissorEnabledRasterizerState));
+    mScissorEnabledRasterizerState.setDebugName("Blit11 scissoring rasterizer state");
 
     rasterDesc.ScissorEnable = FALSE;
-    result =
-        device->CreateRasterizerState(&rasterDesc, mScissorDisabledRasterizerState.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create blit no scissoring rasterizer state, "
-                                 << result;
-    }
-    d3d11::SetDebugName(mScissorDisabledRasterizerState, "Blit11 no scissoring rasterizer state");
+    ANGLE_TRY(mRenderer->allocateResource(rasterDesc, &mScissorDisabledRasterizerState));
+    mScissorDisabledRasterizerState.setDebugName("Blit11 no scissoring rasterizer state");
 
     D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
     depthStencilDesc.DepthEnable                  = TRUE;
@@ -735,13 +698,8 @@ gl::Error Blit11::initResources()
     depthStencilDesc.BackFace.StencilPassOp       = D3D11_STENCIL_OP_KEEP;
     depthStencilDesc.BackFace.StencilFunc         = D3D11_COMPARISON_ALWAYS;
 
-    result = device->CreateDepthStencilState(&depthStencilDesc, mDepthStencilState.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create blit depth stencil state, " << result;
-    }
-    d3d11::SetDebugName(mDepthStencilState, "Blit11 depth stencil state");
+    ANGLE_TRY(mRenderer->allocateResource(depthStencilDesc, &mDepthStencilState));
+    mDepthStencilState.setDebugName("Blit11 depth stencil state");
 
     D3D11_BUFFER_DESC swizzleBufferDesc;
     swizzleBufferDesc.ByteWidth           = sizeof(unsigned int) * 4;
@@ -751,13 +709,8 @@ gl::Error Blit11::initResources()
     swizzleBufferDesc.MiscFlags           = 0;
     swizzleBufferDesc.StructureByteStride = 0;
 
-    result = device->CreateBuffer(&swizzleBufferDesc, nullptr, mSwizzleCB.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::OutOfMemory() << "Failed to create blit swizzle buffer, " << result;
-    }
-    d3d11::SetDebugName(mSwizzleCB, "Blit11 swizzle constant buffer");
+    ANGLE_TRY(mRenderer->allocateResource(swizzleBufferDesc, &mSwizzleCB));
+    mSwizzleCB.setDebugName("Blit11 swizzle constant buffer");
 
     mResourcesInitialized = true;
 
@@ -890,7 +843,17 @@ Blit11::BlitShaderType Blit11::GetBlitShaderType(GLenum destinationFormat,
                         return unpackPremultiplyAlpha ? BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY
                                                       : BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY;
                     }
-
+                case GL_LUMINANCE:
+                    ASSERT(!floatToIntBlit);
+                    return unpackPremultiplyAlpha ? BLITSHADER_2D_LUMAF_PREMULTIPLY
+                                                  : BLITSHADER_2D_LUMAF_UNMULTIPLY;
+                case GL_LUMINANCE_ALPHA:
+                    ASSERT(!floatToIntBlit);
+                    return unpackPremultiplyAlpha ? BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY
+                                                  : BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY;
+                case GL_ALPHA:
+                    ASSERT(!floatToIntBlit);
+                    return BLITSHADER_2D_ALPHA;
                 default:
                     UNREACHABLE();
                     return BLITSHADER_INVALID;
@@ -996,31 +959,34 @@ Blit11::SwizzleShaderType Blit11::GetSwizzleShaderType(GLenum type,
     }
 }
 
-Blit11::ShaderSupport Blit11::getShaderSupport(const Shader &shader)
+gl::Error Blit11::getShaderSupport(const Shader &shader, Blit11::ShaderSupport *supportOut)
 {
-    ID3D11Device *device = mRenderer->getDevice();
-    ShaderSupport support;
-
     if (shader.dimension == SHADER_2D)
     {
-        support.inputLayout         = mQuad2DIL.resolve(device);
-        support.vertexShader        = mQuad2DVS.resolve(device);
-        support.geometryShader      = nullptr;
-        support.vertexWriteFunction = Write2DVertices;
+        ANGLE_TRY(mQuad2DIL.resolve(mRenderer));
+        ANGLE_TRY(mQuad2DVS.resolve(mRenderer));
+        supportOut->inputLayout         = &mQuad2DIL.getObj();
+        supportOut->vertexShader        = &mQuad2DVS.getObj();
+        supportOut->geometryShader      = nullptr;
+        supportOut->vertexWriteFunction = Write2DVertices;
     }
     else
     {
         ASSERT(shader.dimension == SHADER_3D);
-        support.inputLayout         = mQuad3DIL.resolve(device);
-        support.vertexShader        = mQuad3DVS.resolve(device);
-        support.geometryShader      = mQuad3DGS.resolve(device);
-        support.vertexWriteFunction = Write3DVertices;
+        ANGLE_TRY(mQuad3DIL.resolve(mRenderer));
+        ANGLE_TRY(mQuad3DVS.resolve(mRenderer));
+        ANGLE_TRY(mQuad3DGS.resolve(mRenderer));
+        supportOut->inputLayout         = &mQuad2DIL.getObj();
+        supportOut->vertexShader        = &mQuad3DVS.getObj();
+        supportOut->geometryShader      = &mQuad3DGS.getObj();
+        supportOut->vertexWriteFunction = Write3DVertices;
     }
 
-    return support;
+    return gl::NoError();
 }
 
-gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
+gl::Error Blit11::swizzleTexture(const gl::Context *context,
+                                 const d3d11::SharedSRV &source,
                                  const d3d11::RenderTargetView &dest,
                                  const gl::Extents &size,
                                  const gl::SwizzleState &swizzleTarget)
@@ -1076,16 +1042,17 @@ gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
     // Set vertices
     D3D11_MAPPED_SUBRESOURCE mappedResource;
     result =
-        deviceContext->Map(mVertexBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+        deviceContext->Map(mVertexBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
-        return gl::OutOfMemory() << "Failed to map internal vertex buffer for swizzle, " << result;
+        return gl::OutOfMemory() << "Failed to map internal vertex buffer for swizzle, "
+                                 << gl::FmtHR(result);
     }
 
-    const ShaderSupport &support = getShaderSupport(*shader);
+    ShaderSupport support;
+    ANGLE_TRY(getShaderSupport(*shader, &support));
 
     UINT stride    = 0;
-    UINT startIdx  = 0;
     UINT drawCount = 0;
     D3D11_PRIMITIVE_TOPOLOGY topology;
 
@@ -1093,14 +1060,14 @@ gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
     support.vertexWriteFunction(area, size, area, size, mappedResource.pData, &stride, &drawCount,
                                 &topology);
 
-    deviceContext->Unmap(mVertexBuffer.Get(), 0);
+    deviceContext->Unmap(mVertexBuffer.get(), 0);
 
     // Set constant buffer
-    result = deviceContext->Map(mSwizzleCB.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    result = deviceContext->Map(mSwizzleCB.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
         return gl::OutOfMemory() << "Failed to map internal constant buffer for swizzle, "
-                                 << result;
+                                 << gl::FmtHR(result);
     }
 
     unsigned int *swizzleIndices = reinterpret_cast<unsigned int *>(mappedResource.pData);
@@ -1109,33 +1076,34 @@ gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
     swizzleIndices[2]            = GetSwizzleIndex(swizzleTarget.swizzleBlue);
     swizzleIndices[3]            = GetSwizzleIndex(swizzleTarget.swizzleAlpha);
 
-    deviceContext->Unmap(mSwizzleCB.Get(), 0);
+    deviceContext->Unmap(mSwizzleCB.get(), 0);
+
+    auto stateManager = mRenderer->getStateManager();
 
     // Apply vertex buffer
-    deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &startIdx);
+    stateManager->setSingleVertexBuffer(&mVertexBuffer, stride, 0);
 
     // Apply constant buffer
-    deviceContext->PSSetConstantBuffers(0, 1, mSwizzleCB.GetAddressOf());
+    ID3D11Buffer *constantBuffer = mSwizzleCB.get();
+    deviceContext->PSSetConstantBuffers(0, 1, &constantBuffer);
 
     // Apply state
     deviceContext->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);
     deviceContext->OMSetDepthStencilState(nullptr, 0xFFFFFFFF);
-    deviceContext->RSSetState(mScissorDisabledRasterizerState.Get());
+    deviceContext->RSSetState(mScissorDisabledRasterizerState.get());
 
     // Apply shaders
-    deviceContext->IASetInputLayout(support.inputLayout);
-    deviceContext->IASetPrimitiveTopology(topology);
-    deviceContext->VSSetShader(support.vertexShader, nullptr, 0);
+    stateManager->setInputLayout(support.inputLayout);
+    stateManager->setPrimitiveTopology(topology);
 
-    deviceContext->PSSetShader(shader->pixelShader, nullptr, 0);
-    deviceContext->GSSetShader(support.geometryShader, nullptr, 0);
+    stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
+                                 &shader->pixelShader);
 
     // Unset the currently bound shader resource to avoid conflicts
-    auto stateManager = mRenderer->getStateManager();
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
 
     // Apply render target
-    stateManager->setOneTimeRenderTarget(dest.get(), nullptr);
+    stateManager->setOneTimeRenderTarget(context, dest.get(), nullptr);
 
     // Set the viewport
     D3D11_VIEWPORT viewport;
@@ -1151,24 +1119,21 @@ gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, source.get());
 
     // Apply samplers
-    deviceContext->PSSetSamplers(0, 1, mPointSampler.GetAddressOf());
+    ID3D11SamplerState *samplerState = mPointSampler.get();
+    deviceContext->PSSetSamplers(0, 1, &samplerState);
 
     // Draw the quad
     deviceContext->Draw(drawCount, 0);
 
-    // Unbind textures and render targets and vertex buffer
+    // Unbind shader resources and dirty state.
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
-
-    UINT zero                      = 0;
-    ID3D11Buffer *const nullBuffer = nullptr;
-    deviceContext->IASetVertexBuffers(0, 1, &nullBuffer, &zero, &zero);
-
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
 
     return gl::NoError();
 }
 
-gl::Error Blit11::copyTexture(const d3d11::SharedSRV &source,
+gl::Error Blit11::copyTexture(const gl::Context *context,
+                              const d3d11::SharedSRV &source,
                               const gl::Box &sourceArea,
                               const gl::Extents &sourceSize,
                               GLenum sourceFormat,
@@ -1205,36 +1170,38 @@ gl::Error Blit11::copyTexture(const d3d11::SharedSRV &source,
     ANGLE_TRY(getBlitShader(destFormat, sourceFormat, isSigned, unpackPremultiplyAlpha,
                             unpackUnmultiplyAlpha, dimension, &shader));
 
-    const ShaderSupport &support = getShaderSupport(*shader);
+    ShaderSupport support;
+    ANGLE_TRY(getShaderSupport(*shader, &support));
 
     // Set vertices
     D3D11_MAPPED_SUBRESOURCE mappedResource;
     result =
-        deviceContext->Map(mVertexBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+        deviceContext->Map(mVertexBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
         return gl::OutOfMemory() << "Failed to map internal vertex buffer for texture copy, "
-                                 << result;
+                                 << gl::FmtHR(result);
     }
 
     UINT stride    = 0;
-    UINT startIdx  = 0;
     UINT drawCount = 0;
     D3D11_PRIMITIVE_TOPOLOGY topology;
 
     support.vertexWriteFunction(sourceArea, sourceSize, destArea, destSize, mappedResource.pData,
                                 &stride, &drawCount, &topology);
 
-    deviceContext->Unmap(mVertexBuffer.Get(), 0);
+    deviceContext->Unmap(mVertexBuffer.get(), 0);
+
+    auto stateManager = mRenderer->getStateManager();
 
     // Apply vertex buffer
-    deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &startIdx);
+    stateManager->setSingleVertexBuffer(&mVertexBuffer, stride, 0);
 
     // Apply state
     if (maskOffAlpha)
     {
-        ID3D11BlendState *blendState = mAlphaMaskBlendState.resolve(mRenderer->getDevice());
-        ASSERT(blendState);
+        ANGLE_TRY(mAlphaMaskBlendState.resolve(mRenderer));
+        ID3D11BlendState *blendState = mAlphaMaskBlendState.get();
         deviceContext->OMSetBlendState(blendState, nullptr, 0xFFFFFFF);
     }
     else
@@ -1252,27 +1219,25 @@ gl::Error Blit11::copyTexture(const d3d11::SharedSRV &source,
         scissorRect.bottom = scissor->y + scissor->height;
 
         deviceContext->RSSetScissorRects(1, &scissorRect);
-        deviceContext->RSSetState(mScissorEnabledRasterizerState.Get());
+        deviceContext->RSSetState(mScissorEnabledRasterizerState.get());
     }
     else
     {
-        deviceContext->RSSetState(mScissorDisabledRasterizerState.Get());
+        deviceContext->RSSetState(mScissorDisabledRasterizerState.get());
     }
 
     // Apply shaders
-    deviceContext->IASetInputLayout(support.inputLayout);
-    deviceContext->IASetPrimitiveTopology(topology);
-    deviceContext->VSSetShader(support.vertexShader, nullptr, 0);
+    stateManager->setInputLayout(support.inputLayout);
+    stateManager->setPrimitiveTopology(topology);
 
-    deviceContext->PSSetShader(shader->pixelShader, nullptr, 0);
-    deviceContext->GSSetShader(support.geometryShader, nullptr, 0);
+    stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
+                                 &shader->pixelShader);
 
     // Unset the currently bound shader resource to avoid conflicts
-    auto stateManager = mRenderer->getStateManager();
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
 
     // Apply render target
-    stateManager->setOneTimeRenderTarget(dest.get(), nullptr);
+    stateManager->setOneTimeRenderTarget(context, dest.get(), nullptr);
 
     // Set the viewport
     D3D11_VIEWPORT viewport;
@@ -1292,10 +1257,10 @@ gl::Error Blit11::copyTexture(const d3d11::SharedSRV &source,
     switch (filter)
     {
         case GL_NEAREST:
-            sampler = mPointSampler.Get();
+            sampler = mPointSampler.get();
             break;
         case GL_LINEAR:
-            sampler = mLinearSampler.Get();
+            sampler = mLinearSampler.get();
             break;
 
         default:
@@ -1307,19 +1272,16 @@ gl::Error Blit11::copyTexture(const d3d11::SharedSRV &source,
     // Draw the quad
     deviceContext->Draw(drawCount, 0);
 
-    // Unbind textures and render targets and vertex buffer
+    // Unbind shader resource and invalidate state.
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
 
-    UINT zero                      = 0;
-    ID3D11Buffer *const nullBuffer = nullptr;
-    deviceContext->IASetVertexBuffers(0, 1, &nullBuffer, &zero, &zero);
-
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
 
     return gl::NoError();
 }
 
-gl::Error Blit11::copyStencil(const TextureHelper11 &source,
+gl::Error Blit11::copyStencil(const gl::Context *context,
+                              const TextureHelper11 &source,
                               unsigned int sourceSubresource,
                               const gl::Box &sourceArea,
                               const gl::Extents &sourceSize,
@@ -1333,7 +1295,8 @@ gl::Error Blit11::copyStencil(const TextureHelper11 &source,
                                 destSubresource, destArea, destSize, scissor, true);
 }
 
-gl::Error Blit11::copyDepth(const d3d11::SharedSRV &source,
+gl::Error Blit11::copyDepth(const gl::Context *context,
+                            const d3d11::SharedSRV &source,
                             const gl::Box &sourceArea,
                             const gl::Extents &sourceSize,
                             const d3d11::DepthStencilView &dest,
@@ -1349,29 +1312,30 @@ gl::Error Blit11::copyDepth(const d3d11::SharedSRV &source,
     // Set vertices
     D3D11_MAPPED_SUBRESOURCE mappedResource;
     result =
-        deviceContext->Map(mVertexBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+        deviceContext->Map(mVertexBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
         return gl::OutOfMemory() << "Failed to map internal vertex buffer for texture copy, "
-                                 << result;
+                                 << gl::FmtHR(result);
     }
 
     UINT stride    = 0;
-    UINT startIdx  = 0;
     UINT drawCount = 0;
     D3D11_PRIMITIVE_TOPOLOGY topology;
 
     Write2DVertices(sourceArea, sourceSize, destArea, destSize, mappedResource.pData, &stride,
                     &drawCount, &topology);
 
-    deviceContext->Unmap(mVertexBuffer.Get(), 0);
+    deviceContext->Unmap(mVertexBuffer.get(), 0);
+
+    auto stateManager = mRenderer->getStateManager();
 
     // Apply vertex buffer
-    deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &startIdx);
+    stateManager->setSingleVertexBuffer(&mVertexBuffer, stride, 0);
 
     // Apply state
     deviceContext->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);
-    deviceContext->OMSetDepthStencilState(mDepthStencilState.Get(), 0xFFFFFFFF);
+    deviceContext->OMSetDepthStencilState(mDepthStencilState.get(), 0xFFFFFFFF);
 
     if (scissor)
     {
@@ -1382,34 +1346,28 @@ gl::Error Blit11::copyDepth(const d3d11::SharedSRV &source,
         scissorRect.bottom = scissor->y + scissor->height;
 
         deviceContext->RSSetScissorRects(1, &scissorRect);
-        deviceContext->RSSetState(mScissorEnabledRasterizerState.Get());
+        deviceContext->RSSetState(mScissorEnabledRasterizerState.get());
     }
     else
     {
-        deviceContext->RSSetState(mScissorDisabledRasterizerState.Get());
+        deviceContext->RSSetState(mScissorDisabledRasterizerState.get());
     }
 
-    ID3D11Device *device         = mRenderer->getDevice();
-    ID3D11VertexShader *quad2DVS = mQuad2DVS.resolve(device);
-    if (quad2DVS == nullptr)
-    {
-        return gl::InternalError() << "Error compiling internal 2D blit vertex shader";
-    }
+    ANGLE_TRY(mQuad2DIL.resolve(mRenderer));
+    ANGLE_TRY(mQuad2DVS.resolve(mRenderer));
+    ANGLE_TRY(mDepthPS.resolve(mRenderer));
 
     // Apply shaders
-    deviceContext->IASetInputLayout(mQuad2DIL.resolve(device));
-    deviceContext->IASetPrimitiveTopology(topology);
-    deviceContext->VSSetShader(quad2DVS, nullptr, 0);
+    stateManager->setInputLayout(&mQuad2DIL.getObj());
+    stateManager->setPrimitiveTopology(topology);
 
-    deviceContext->PSSetShader(mDepthPS.resolve(device), nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
+    stateManager->setDrawShaders(&mQuad2DVS.getObj(), nullptr, &mDepthPS.getObj());
 
     // Unset the currently bound shader resource to avoid conflicts
-    auto stateManager = mRenderer->getStateManager();
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
 
     // Apply render target
-    stateManager->setOneTimeRenderTarget(nullptr, dest.get());
+    stateManager->setOneTimeRenderTarget(context, nullptr, dest.get());
 
     // Set the viewport
     D3D11_VIEWPORT viewport;
@@ -1425,19 +1383,16 @@ gl::Error Blit11::copyDepth(const d3d11::SharedSRV &source,
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, source.get());
 
     // Apply samplers
-    deviceContext->PSSetSamplers(0, 1, mPointSampler.GetAddressOf());
+    ID3D11SamplerState *samplerState = mPointSampler.get();
+    deviceContext->PSSetSamplers(0, 1, &samplerState);
 
     // Draw the quad
     deviceContext->Draw(drawCount, 0);
 
-    // Unbind textures and render targets and vertex buffer
+    // Unbind shader resources and invalidate all state.
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
 
-    UINT zero                      = 0;
-    ID3D11Buffer *const nullBuffer = nullptr;
-    deviceContext->IASetVertexBuffers(0, 1, &nullBuffer, &zero, &zero);
-
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
 
     return gl::NoError();
 }
@@ -1536,31 +1491,30 @@ gl::Error Blit11::copyAndConvertImpl(const TextureHelper11 &source,
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
     TextureHelper11 sourceStaging;
-    ANGLE_TRY_RESULT(mRenderer->createStagingTexture(GL_TEXTURE_2D, source.getFormatSet(),
+    ANGLE_TRY_RESULT(mRenderer->createStagingTexture(ResourceType::Texture2D, source.getFormatSet(),
                                                      sourceSize, StagingAccess::READ),
                      sourceStaging);
 
-    deviceContext->CopySubresourceRegion(sourceStaging.getResource(), 0, 0, 0, 0,
-                                         source.getResource(), sourceSubresource, nullptr);
+    deviceContext->CopySubresourceRegion(sourceStaging.get(), 0, 0, 0, 0, source.get(),
+                                         sourceSubresource, nullptr);
 
     D3D11_MAPPED_SUBRESOURCE sourceMapping;
-    HRESULT result =
-        deviceContext->Map(sourceStaging.getResource(), 0, D3D11_MAP_READ, 0, &sourceMapping);
+    HRESULT result = deviceContext->Map(sourceStaging.get(), 0, D3D11_MAP_READ, 0, &sourceMapping);
     if (FAILED(result))
     {
         return gl::OutOfMemory()
                << "Failed to map internal source staging texture for depth stencil blit, "
-               << result;
+               << gl::FmtHR(result);
     }
 
     D3D11_MAPPED_SUBRESOURCE destMapping;
-    result = deviceContext->Map(destStaging.getResource(), 0, D3D11_MAP_WRITE, 0, &destMapping);
+    result = deviceContext->Map(destStaging.get(), 0, D3D11_MAP_WRITE, 0, &destMapping);
     if (FAILED(result))
     {
-        deviceContext->Unmap(sourceStaging.getResource(), 0);
+        deviceContext->Unmap(sourceStaging.get(), 0);
         return gl::OutOfMemory()
                << "Failed to map internal destination staging texture for depth stencil blit, "
-               << result;
+               << gl::FmtHR(result);
     }
 
     // Clip dest area to the destination size
@@ -1577,8 +1531,8 @@ gl::Error Blit11::copyAndConvertImpl(const TextureHelper11 &source,
                     destPixelStride, static_cast<const uint8_t *>(sourceMapping.pData),
                     static_cast<uint8_t *>(destMapping.pData));
 
-    deviceContext->Unmap(sourceStaging.getResource(), 0);
-    deviceContext->Unmap(destStaging.getResource(), 0);
+    deviceContext->Unmap(sourceStaging.get(), 0);
+    deviceContext->Unmap(destStaging.get(), 0);
 
     return gl::NoError();
 }
@@ -1607,12 +1561,12 @@ gl::Error Blit11::copyAndConvert(const TextureHelper11 &source,
     // ID3D11DevicContext::UpdateSubresource can be called
     //       using it's mapped data as a source
     TextureHelper11 destStaging;
-    ANGLE_TRY_RESULT(mRenderer->createStagingTexture(GL_TEXTURE_2D, dest.getFormatSet(), destSize,
-                                                     StagingAccess::READ_WRITE),
+    ANGLE_TRY_RESULT(mRenderer->createStagingTexture(ResourceType::Texture2D, dest.getFormatSet(),
+                                                     destSize, StagingAccess::READ_WRITE),
                      destStaging);
 
-    deviceContext->CopySubresourceRegion(destStaging.getResource(), 0, 0, 0, 0, dest.getResource(),
-                                         destSubresource, nullptr);
+    deviceContext->CopySubresourceRegion(destStaging.get(), 0, 0, 0, 0, dest.get(), destSubresource,
+                                         nullptr);
 
     copyAndConvertImpl(source, sourceSubresource, sourceArea, sourceSize, destStaging, destArea,
                        destSize, scissor, readOffset, writeOffset, copySize, srcPixelStride,
@@ -1622,60 +1576,61 @@ gl::Error Blit11::copyAndConvert(const TextureHelper11 &source,
     if (mRenderer->getWorkarounds().depthStencilBlitExtraCopy)
     {
         D3D11_MAPPED_SUBRESOURCE mapped;
-        deviceContext->Map(destStaging.getResource(), 0, D3D11_MAP_READ, 0, &mapped);
-        deviceContext->UpdateSubresource(dest.getResource(), destSubresource, nullptr, mapped.pData,
+        deviceContext->Map(destStaging.get(), 0, D3D11_MAP_READ, 0, &mapped);
+        deviceContext->UpdateSubresource(dest.get(), destSubresource, nullptr, mapped.pData,
                                          mapped.RowPitch, mapped.DepthPitch);
-        deviceContext->Unmap(destStaging.getResource(), 0);
+        deviceContext->Unmap(destStaging.get(), 0);
     }
     else
     {
-        deviceContext->CopySubresourceRegion(dest.getResource(), destSubresource, 0, 0, 0,
-                                             destStaging.getResource(), 0, nullptr);
+        deviceContext->CopySubresourceRegion(dest.get(), destSubresource, 0, 0, 0,
+                                             destStaging.get(), 0, nullptr);
     }
 
     return gl::NoError();
 }
 
-void Blit11::addBlitShaderToMap(BlitShaderType blitShaderType,
-                                ShaderDimension dimension,
-                                ID3D11PixelShader *ps)
+gl::Error Blit11::addBlitShaderToMap(BlitShaderType blitShaderType,
+                                     ShaderDimension dimension,
+                                     const ShaderData &shaderData,
+                                     const char *name)
 {
     ASSERT(mBlitShaderMap.find(blitShaderType) == mBlitShaderMap.end());
-    ASSERT(ps);
+
+    d3d11::PixelShader ps;
+    ANGLE_TRY(mRenderer->allocateResource(shaderData, &ps));
+    ps.setDebugName(name);
 
     Shader shader;
     shader.dimension   = dimension;
-    shader.pixelShader = ps;
+    shader.pixelShader = std::move(ps);
 
-    mBlitShaderMap[blitShaderType] = shader;
+    mBlitShaderMap[blitShaderType] = std::move(shader);
+    return gl::NoError();
 }
 
-void Blit11::addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
-                                   ShaderDimension dimension,
-                                   ID3D11PixelShader *ps)
+gl::Error Blit11::addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
+                                        ShaderDimension dimension,
+                                        const ShaderData &shaderData,
+                                        const char *name)
 {
     ASSERT(mSwizzleShaderMap.find(swizzleShaderType) == mSwizzleShaderMap.end());
-    ASSERT(ps);
+
+    d3d11::PixelShader ps;
+    ANGLE_TRY(mRenderer->allocateResource(shaderData, &ps));
+    ps.setDebugName(name);
 
     Shader shader;
     shader.dimension   = dimension;
-    shader.pixelShader = ps;
+    shader.pixelShader = std::move(ps);
 
-    mSwizzleShaderMap[swizzleShaderType] = shader;
+    mSwizzleShaderMap[swizzleShaderType] = std::move(shader);
+    return gl::NoError();
 }
 
 void Blit11::clearShaderMap()
 {
-    for (auto &blitShader : mBlitShaderMap)
-    {
-        SafeRelease(blitShader.second.pixelShader);
-    }
     mBlitShaderMap.clear();
-
-    for (auto &swizzleShader : mSwizzleShaderMap)
-    {
-        SafeRelease(swizzleShader.second.pixelShader);
-    }
     mSwizzleShaderMap.clear();
 }
 
@@ -1705,229 +1660,233 @@ gl::Error Blit11::getBlitShader(GLenum destFormat,
 
     ASSERT(dimension == SHADER_2D || mRenderer->isES3Capable());
 
-    ID3D11Device *device = mRenderer->getDevice();
-
     switch (blitShaderType)
     {
         case BLITSHADER_2D_RGBAF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA2D, "Blit11 2D RGBA pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGBA2D),
+                                         "Blit11 2D RGBA pixel shader"));
             break;
         case BLITSHADER_2D_BGRAF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA2D, "Blit11 2D BGRA pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGBA2D),
+                                         "Blit11 2D BGRA pixel shader"));
             break;
         case BLITSHADER_2D_RGBF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGB2D, "Blit11 2D RGB pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGB2D),
+                                         "Blit11 2D RGB pixel shader"));
             break;
         case BLITSHADER_2D_RGF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRG2D, "Blit11 2D RG pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRG2D),
+                                         "Blit11 2D RG pixel shader"));
             break;
         case BLITSHADER_2D_RF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughR2D, "Blit11 2D R pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_PassthroughR2D),
+                                         "Blit11 2D R pixel shader"));
             break;
         case BLITSHADER_2D_ALPHA:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA2D, "Blit11 2D alpha pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGBA2D),
+                                         "Blit11 2D alpha pixel shader"));
             break;
         case BLITSHADER_2D_LUMA:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughLum2D, "Blit11 2D lum pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughLum2D),
+                                         "Blit11 2D lum pixel shader"));
             break;
         case BLITSHADER_2D_LUMAALPHA:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_PassthroughLumAlpha2D,
-                                                "Blit11 2D luminance alpha pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughLumAlpha2D),
+                                         "Blit11 2D luminance alpha pixel shader"));
             break;
         case BLITSHADER_2D_RGBAUI:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_PassthroughRGBA2DUI,
-                                                "Blit11 2D RGBA UI pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGBA2DUI),
+                                         "Blit11 2D RGBA UI pixel shader"));
             break;
         case BLITSHADER_2D_RGBAI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA2DI, "Blit11 2D RGBA I pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGBA2DI),
+                                         "Blit11 2D RGBA I pixel shader"));
             break;
         case BLITSHADER_2D_RGBUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGB2DUI, "Blit11 2D RGB UI pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGB2DUI),
+                                         "Blit11 2D RGB UI pixel shader"));
             break;
         case BLITSHADER_2D_RGBI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGB2DI, "Blit11 2D RGB I pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRGB2DI),
+                                         "Blit11 2D RGB I pixel shader"));
             break;
         case BLITSHADER_2D_RGUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRG2DUI, "Blit11 2D RG UI pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRG2DUI),
+                                         "Blit11 2D RG UI pixel shader"));
             break;
         case BLITSHADER_2D_RGI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughRG2DI, "Blit11 2D RG I pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughRG2DI),
+                                         "Blit11 2D RG I pixel shader"));
             break;
         case BLITSHADER_2D_RUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughR2DUI, "Blit11 2D R UI pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughR2DUI),
+                                         "Blit11 2D R UI pixel shader"));
             break;
         case BLITSHADER_2D_RI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_PassthroughR2DI, "Blit11 2D R I pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_PassthroughR2DI),
+                                         "Blit11 2D R I pixel shader"));
             break;
         case BLITSHADER_3D_RGBAF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA3D, "Blit11 3D RGBA pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGBA3D),
+                                         "Blit11 3D RGBA pixel shader"));
             break;
         case BLITSHADER_3D_RGBAUI:
-            addBlitShaderToMap(blitShaderType, SHADER_3D,
-                               d3d11::CompilePS(device, g_PS_PassthroughRGBA3DUI,
-                                                "Blit11 3D UI RGBA pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGBA3DUI),
+                                         "Blit11 3D UI RGBA pixel shader"));
             break;
         case BLITSHADER_3D_RGBAI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA3DI, "Blit11 3D I RGBA pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGBA3DI),
+                                         "Blit11 3D I RGBA pixel shader"));
             break;
         case BLITSHADER_3D_BGRAF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA3D, "Blit11 3D BGRA pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGBA3D),
+                                         "Blit11 3D BGRA pixel shader"));
             break;
         case BLITSHADER_3D_RGBF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGB3D, "Blit11 3D RGB pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGB3D),
+                                         "Blit11 3D RGB pixel shader"));
             break;
         case BLITSHADER_3D_RGBUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGB3DUI, "Blit11 3D RGB UI pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGB3DUI),
+                                         "Blit11 3D RGB UI pixel shader"));
             break;
         case BLITSHADER_3D_RGBI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGB3DI, "Blit11 3D RGB I pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGB3DI),
+                                         "Blit11 3D RGB I pixel shader"));
             break;
         case BLITSHADER_3D_RGF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRG3D, "Blit11 3D RG pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRG3D),
+                                         "Blit11 3D RG pixel shader"));
             break;
         case BLITSHADER_3D_RGUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRG3DUI, "Blit11 3D RG UI pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRG3DUI),
+                                         "Blit11 3D RG UI pixel shader"));
             break;
         case BLITSHADER_3D_RGI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRG3DI, "Blit11 3D RG I pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRG3DI),
+                                         "Blit11 3D RG I pixel shader"));
             break;
         case BLITSHADER_3D_RF:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughR3D, "Blit11 3D R pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D, ShaderData(g_PS_PassthroughR3D),
+                                         "Blit11 3D R pixel shader"));
             break;
         case BLITSHADER_3D_RUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughR3DUI, "Blit11 3D R UI pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughR3DUI),
+                                         "Blit11 3D R UI pixel shader"));
             break;
         case BLITSHADER_3D_RI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughR3DI, "Blit11 3D R I pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughR3DI),
+                                         "Blit11 3D R I pixel shader"));
             break;
         case BLITSHADER_3D_ALPHA:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_PassthroughRGBA3D, "Blit11 3D alpha pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughRGBA3D),
+                                         "Blit11 3D alpha pixel shader"));
             break;
         case BLITSHADER_3D_LUMA:
-            addBlitShaderToMap(blitShaderType, SHADER_3D,
-                               d3d11::CompilePS(device, g_PS_PassthroughLum3D,
-                                                "Blit11 3D luminance pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughLum3D),
+                                         "Blit11 3D luminance pixel shader"));
             break;
         case BLITSHADER_3D_LUMAALPHA:
-            addBlitShaderToMap(blitShaderType, SHADER_3D,
-                               d3d11::CompilePS(device, g_PS_PassthroughLumAlpha3D,
-                                                "Blit11 3D luminance alpha pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_3D,
+                                         ShaderData(g_PS_PassthroughLumAlpha3D),
+                                         "Blit11 3D luminance alpha pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBAF_PREMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoF_PM_RGBA,
-                                                "Blit11 2D RGBA premultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoF_PM_RGBA),
+                                         "Blit11 2D RGBA premultiply pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBAF_UNMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoF_UM_RGBA,
-                                                "Blit11 2D RGBA unmultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoF_UM_RGBA),
+                                         "Blit11 2D RGBA unmultiply pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBF_PREMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoF_PM_RGB,
-                                                "Blit11 2D RGB premultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoF_PM_RGB),
+                                         "Blit11 2D RGB premultiply pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBF_UNMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoF_UM_RGB,
-                                                "Blit11 2D RGB unmultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoF_UM_RGB),
+                                         "Blit11 2D RGB unmultiply pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBAF_TOUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_FtoU_PT_RGBA, "Blit11 2D RGBA to uint pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoU_PT_RGBA),
+                                         "Blit11 2D RGBA to uint pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBAF_TOUI_PREMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoU_PM_RGBA,
-                                                "Blit11 2D RGBA to uint premultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoU_PM_RGBA),
+                                         "Blit11 2D RGBA to uint premultiply pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBAF_TOUI_UNMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoU_UM_RGBA,
-                                                "Blit11 2D RGBA to uint unmultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoU_UM_RGBA),
+                                         "Blit11 2D RGBA to uint unmultiply pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBF_TOUI:
-            addBlitShaderToMap(
-                blitShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_FtoU_PT_RGB, "Blit11 2D RGB to uint pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoU_PT_RGB),
+                                         "Blit11 2D RGB to uint pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoU_PM_RGB,
-                                                "Blit11 2D RGB to uint premultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoU_PM_RGB),
+                                         "Blit11 2D RGB to uint premultiply pixel shader"));
             break;
 
         case BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY:
-            addBlitShaderToMap(blitShaderType, SHADER_2D,
-                               d3d11::CompilePS(device, g_PS_FtoU_UM_RGB,
-                                                "Blit11 2D RGB to uint unmultiply pixel shader"));
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoU_UM_RGB),
+                                         "Blit11 2D RGB to uint unmultiply pixel shader"));
+            break;
+        case BLITSHADER_2D_LUMAF_PREMULTIPLY:
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoF_PM_LUMA),
+                                         "Blit11 2D LUMA premultiply pixel shader"));
+            break;
+        case BLITSHADER_2D_LUMAF_UNMULTIPLY:
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D, ShaderData(g_PS_FtoF_UM_LUMA),
+                                         "Blit11 2D LUMA unmultiply pixel shader"));
+            break;
+        case BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY:
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_FtoF_PM_LUMAALPHA),
+                                         "Blit11 2D LUMAALPHA premultiply pixel shader"));
+            break;
+        case BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY:
+            ANGLE_TRY(addBlitShaderToMap(blitShaderType, SHADER_2D,
+                                         ShaderData(g_PS_FtoF_UM_LUMAALPHA),
+                                         "Blit11 2D LUMAALPHA unmultiply pixel shader"));
             break;
 
         default:
@@ -1962,69 +1921,67 @@ gl::Error Blit11::getSwizzleShader(GLenum type,
     // Swizzling shaders (OpenGL ES 3+)
     ASSERT(mRenderer->isES3Capable());
 
-    ID3D11Device *device = mRenderer->getDevice();
-
     switch (swizzleShaderType)
     {
         case SWIZZLESHADER_2D_FLOAT:
-            addSwizzleShaderToMap(
-                swizzleShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_SwizzleF2D, "Blit11 2D F swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_2D,
+                                            ShaderData(g_PS_SwizzleF2D),
+                                            "Blit11 2D F swizzle pixel shader"));
             break;
         case SWIZZLESHADER_2D_UINT:
-            addSwizzleShaderToMap(
-                swizzleShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_SwizzleUI2D, "Blit11 2D UI swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_2D,
+                                            ShaderData(g_PS_SwizzleUI2D),
+                                            "Blit11 2D UI swizzle pixel shader"));
             break;
         case SWIZZLESHADER_2D_INT:
-            addSwizzleShaderToMap(
-                swizzleShaderType, SHADER_2D,
-                d3d11::CompilePS(device, g_PS_SwizzleI2D, "Blit11 2D I swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_2D,
+                                            ShaderData(g_PS_SwizzleI2D),
+                                            "Blit11 2D I swizzle pixel shader"));
             break;
         case SWIZZLESHADER_CUBE_FLOAT:
-            addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
-                                  d3d11::CompilePS(device, g_PS_SwizzleF2DArray,
-                                                   "Blit11 2D Cube F swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleF2DArray),
+                                            "Blit11 2D Cube F swizzle pixel shader"));
             break;
         case SWIZZLESHADER_CUBE_UINT:
-            addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
-                                  d3d11::CompilePS(device, g_PS_SwizzleUI2DArray,
-                                                   "Blit11 2D Cube UI swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleUI2DArray),
+                                            "Blit11 2D Cube UI swizzle pixel shader"));
             break;
         case SWIZZLESHADER_CUBE_INT:
-            addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
-                                  d3d11::CompilePS(device, g_PS_SwizzleI2DArray,
-                                                   "Blit11 2D Cube I swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleI2DArray),
+                                            "Blit11 2D Cube I swizzle pixel shader"));
             break;
         case SWIZZLESHADER_3D_FLOAT:
-            addSwizzleShaderToMap(
-                swizzleShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_SwizzleF3D, "Blit11 3D F swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleF3D),
+                                            "Blit11 3D F swizzle pixel shader"));
             break;
         case SWIZZLESHADER_3D_UINT:
-            addSwizzleShaderToMap(
-                swizzleShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_SwizzleUI3D, "Blit11 3D UI swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleUI3D),
+                                            "Blit11 3D UI swizzle pixel shader"));
             break;
         case SWIZZLESHADER_3D_INT:
-            addSwizzleShaderToMap(
-                swizzleShaderType, SHADER_3D,
-                d3d11::CompilePS(device, g_PS_SwizzleI3D, "Blit11 3D I swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleI3D),
+                                            "Blit11 3D I swizzle pixel shader"));
             break;
         case SWIZZLESHADER_ARRAY_FLOAT:
-            addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
-                                  d3d11::CompilePS(device, g_PS_SwizzleF2DArray,
-                                                   "Blit11 2D Array F swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleF2DArray),
+                                            "Blit11 2D Array F swizzle pixel shader"));
             break;
         case SWIZZLESHADER_ARRAY_UINT:
-            addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
-                                  d3d11::CompilePS(device, g_PS_SwizzleUI2DArray,
-                                                   "Blit11 2D Array UI swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleUI2DArray),
+                                            "Blit11 2D Array UI swizzle pixel shader"));
             break;
         case SWIZZLESHADER_ARRAY_INT:
-            addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
-                                  d3d11::CompilePS(device, g_PS_SwizzleI2DArray,
-                                                   "Blit11 2D Array I swizzle pixel shader"));
+            ANGLE_TRY(addSwizzleShaderToMap(swizzleShaderType, SHADER_3D,
+                                            ShaderData(g_PS_SwizzleI2DArray),
+                                            "Blit11 2D Array I swizzle pixel shader"));
             break;
         default:
             UNREACHABLE();
@@ -2037,29 +1994,35 @@ gl::Error Blit11::getSwizzleShader(GLenum type,
     return gl::NoError();
 }
 
-gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(RenderTarget11 *depth)
+gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(const gl::Context *context,
+                                                        RenderTarget11 *depth)
 {
+    ANGLE_TRY(initResources());
+
     // Multisampled depth stencil SRVs are not available in feature level 10.0
     ASSERT(mRenderer->getRenderer11DeviceCaps().featureLevel > D3D_FEATURE_LEVEL_10_0);
 
     const auto &extents          = depth->getExtents();
-    ID3D11Device *device         = mRenderer->getDevice();
-    ID3D11DeviceContext *context = mRenderer->getDeviceContext();
+    auto *deviceContext          = mRenderer->getDeviceContext();
+    auto *stateManager           = mRenderer->getStateManager();
 
     ANGLE_TRY(initResolveDepthOnly(depth->getFormatSet(), extents));
 
     // Notify the Renderer that all state should be invalidated.
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
+
+    ANGLE_TRY(mResolveDepthStencilVS.resolve(mRenderer));
+    ANGLE_TRY(mResolveDepthPS.resolve(mRenderer));
 
     // Apply the necessary state changes to the D3D11 immediate device context.
-    context->IASetInputLayout(nullptr);
-    context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
-    context->VSSetShader(mResolveDepthStencilVS.resolve(device), nullptr, 0);
-    context->GSSetShader(nullptr, nullptr, 0);
-    context->RSSetState(nullptr);
-    context->OMSetDepthStencilState(mDepthStencilState.Get(), 0xFFFFFFFF);
-    context->OMSetRenderTargets(0, nullptr, mResolvedDepthDSView.get());
-    context->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);
+    stateManager->setInputLayout(nullptr);
+    stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+    stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr,
+                                 &mResolveDepthPS.getObj());
+    deviceContext->RSSetState(nullptr);
+    deviceContext->OMSetDepthStencilState(mDepthStencilState.get(), 0xFFFFFFFF);
+    deviceContext->OMSetRenderTargets(0, nullptr, mResolvedDepthDSView.get());
+    deviceContext->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);
 
     // Set the viewport
     D3D11_VIEWPORT viewport;
@@ -2069,19 +2032,16 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(RenderTarget11 *depth)
     viewport.Height   = static_cast<FLOAT>(extents.height);
     viewport.MinDepth = 0.0f;
     viewport.MaxDepth = 1.0f;
-    context->RSSetViewports(1, &viewport);
+    deviceContext->RSSetViewports(1, &viewport);
 
     ID3D11ShaderResourceView *pixelViews[] = {depth->getShaderResourceView().get()};
 
-    context->PSSetShaderResources(0, 1, pixelViews);
-
-    context->PSSetShader(mResolveDepthPS.resolve(device), nullptr, 0);
+    deviceContext->PSSetShaderResources(0, 1, pixelViews);
 
     // Trigger the blit on the GPU.
-    context->Draw(6, 0);
+    deviceContext->Draw(6, 0);
 
-    return TextureHelper11::MakeAndReference(mResolvedDepth.getResource(),
-                                             mResolvedDepth.getFormatSet());
+    return mResolvedDepth;
 }
 
 gl::Error Blit11::initResolveDepthOnly(const d3d11::Format &format, const gl::Extents &extents)
@@ -2092,8 +2052,6 @@ gl::Error Blit11::initResolveDepthOnly(const d3d11::Format &format, const gl::Ex
         return gl::NoError();
     }
 
-    ID3D11Device *device = mRenderer->getDevice();
-
     D3D11_TEXTURE2D_DESC textureDesc;
     textureDesc.Width              = extents.width;
     textureDesc.Height             = extents.height;
@@ -2107,15 +2065,8 @@ gl::Error Blit11::initResolveDepthOnly(const d3d11::Format &format, const gl::Ex
     textureDesc.CPUAccessFlags     = 0;
     textureDesc.MiscFlags          = 0;
 
-    ID3D11Texture2D *resolvedDepth = nullptr;
-    HRESULT hr                     = device->CreateTexture2D(&textureDesc, nullptr, &resolvedDepth);
-    if (FAILED(hr))
-    {
-        return gl::OutOfMemory() << "Failed to allocate resolved depth texture, " << hr;
-    }
-    d3d11::SetDebugName(resolvedDepth, "Blit11::mResolvedDepth");
-
-    mResolvedDepth = TextureHelper11::MakeAndPossess2D(resolvedDepth, format);
+    ANGLE_TRY(mRenderer->allocateTexture(textureDesc, format, &mResolvedDepth));
+    mResolvedDepth.setDebugName("Blit11::mResolvedDepth");
 
     D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
     dsvDesc.Flags              = 0;
@@ -2123,8 +2074,7 @@ gl::Error Blit11::initResolveDepthOnly(const d3d11::Format &format, const gl::Ex
     dsvDesc.Texture2D.MipSlice = 0;
     dsvDesc.ViewDimension      = D3D11_DSV_DIMENSION_TEXTURE2D;
 
-    ANGLE_TRY(
-        mRenderer->allocateResource(dsvDesc, mResolvedDepth.getResource(), &mResolvedDepthDSView));
+    ANGLE_TRY(mRenderer->allocateResource(dsvDesc, mResolvedDepth.get(), &mResolvedDepthDSView));
     mResolvedDepthDSView.setDebugName("Blit11::mResolvedDepthDSView");
 
     // Possibly D3D11 bug or undefined behaviour: Clear the DSV so that our first render
@@ -2164,28 +2114,22 @@ gl::Error Blit11::initResolveDepthStencil(const gl::Extents &extents)
     textureDesc.CPUAccessFlags     = 0;
     textureDesc.MiscFlags          = 0;
 
-    ID3D11Device *device = mRenderer->getDevice();
+    ANGLE_TRY(mRenderer->allocateTexture(textureDesc, formatSet, &mResolvedDepthStencil));
+    mResolvedDepthStencil.setDebugName("Blit11::mResolvedDepthStencil");
 
-    ID3D11Texture2D *resolvedDepthStencil = nullptr;
-    HRESULT hr = device->CreateTexture2D(&textureDesc, nullptr, &resolvedDepthStencil);
-    if (FAILED(hr))
-    {
-        return gl::OutOfMemory() << "Failed to allocate resolved depth stencil texture, " << hr;
-    }
-    d3d11::SetDebugName(resolvedDepthStencil, "Blit11::mResolvedDepthStencil");
-
-    ANGLE_TRY(
-        mRenderer->allocateResourceNoDesc(resolvedDepthStencil, &mResolvedDepthStencilRTView));
+    ANGLE_TRY(mRenderer->allocateResourceNoDesc(mResolvedDepthStencil.get(),
+                                                &mResolvedDepthStencilRTView));
     mResolvedDepthStencilRTView.setDebugName("Blit11::mResolvedDepthStencilRTView");
 
-    mResolvedDepthStencil = TextureHelper11::MakeAndPossess2D(resolvedDepthStencil, formatSet);
-
     return gl::NoError();
 }
 
-gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(RenderTarget11 *depthStencil,
+gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(const gl::Context *context,
+                                                          RenderTarget11 *depthStencil,
                                                           bool alsoDepth)
 {
+    ANGLE_TRY(initResources());
+
     // Multisampled depth stencil SRVs are not available in feature level 10.0
     ASSERT(mRenderer->getRenderer11DeviceCaps().featureLevel > D3D_FEATURE_LEVEL_10_0);
 
@@ -2193,10 +2137,9 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(RenderTarget11 *depthS
 
     ANGLE_TRY(initResolveDepthStencil(extents));
 
-    ID3D11Device *device         = mRenderer->getDevice();
-    ID3D11DeviceContext *context = mRenderer->getDeviceContext();
-
-    ID3D11Resource *stencilResource = depthStencil->getTexture();
+    ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
+    auto *stateManager              = mRenderer->getStateManager();
+    ID3D11Resource *stencilResource = depthStencil->getTexture().get();
 
     // Check if we need to re-create the stencil SRV.
     if (mStencilSRV.valid())
@@ -2223,19 +2166,35 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(RenderTarget11 *depthS
     }
 
     // Notify the Renderer that all state should be invalidated.
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
 
     ID3D11RenderTargetView *rtvs[] = {mResolvedDepthStencilRTView.get()};
 
+    ANGLE_TRY(mResolveDepthStencilVS.resolve(mRenderer));
+
+    // Resolving the depth buffer works by sampling the depth in the shader using a SRV, then
+    // writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil
+    // because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3.
+    const d3d11::PixelShader *pixelShader = nullptr;
+    if (alsoDepth)
+    {
+        ANGLE_TRY(mResolveDepthStencilPS.resolve(mRenderer));
+        pixelShader = &mResolveDepthStencilPS.getObj();
+    }
+    else
+    {
+        ANGLE_TRY(mResolveStencilPS.resolve(mRenderer));
+        pixelShader = &mResolveStencilPS.getObj();
+    }
+
     // Apply the necessary state changes to the D3D11 immediate device context.
-    context->IASetInputLayout(nullptr);
-    context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
-    context->VSSetShader(mResolveDepthStencilVS.resolve(device), nullptr, 0);
-    context->GSSetShader(nullptr, nullptr, 0);
-    context->RSSetState(nullptr);
-    context->OMSetDepthStencilState(nullptr, 0xFFFFFFFF);
-    context->OMSetRenderTargets(1, rtvs, nullptr);
-    context->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);
+    stateManager->setInputLayout(nullptr);
+    stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+    stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr, pixelShader);
+    deviceContext->RSSetState(nullptr);
+    deviceContext->OMSetDepthStencilState(nullptr, 0xFFFFFFFF);
+    deviceContext->OMSetRenderTargets(1, rtvs, nullptr);
+    deviceContext->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);
 
     // Set the viewport
     D3D11_VIEWPORT viewport;
@@ -2245,35 +2204,24 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(RenderTarget11 *depthS
     viewport.Height   = static_cast<FLOAT>(extents.height);
     viewport.MinDepth = 0.0f;
     viewport.MaxDepth = 1.0f;
-    context->RSSetViewports(1, &viewport);
+    deviceContext->RSSetViewports(1, &viewport);
 
     ID3D11ShaderResourceView *pixelViews[] = {
         depthStencil->getShaderResourceView().get(), mStencilSRV.get(),
     };
 
-    context->PSSetShaderResources(0, 2, pixelViews);
-
-    // Resolving the depth buffer works by sampling the depth in the shader using a SRV, then
-    // writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil
-    // because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3.
-    if (alsoDepth)
-    {
-        context->PSSetShader(mResolveDepthStencilPS.resolve(device), nullptr, 0);
-    }
-    else
-    {
-        context->PSSetShader(mResolveStencilPS.resolve(device), nullptr, 0);
-    }
+    deviceContext->PSSetShaderResources(0, 2, pixelViews);
 
     // Trigger the blit on the GPU.
-    context->Draw(6, 0);
+    deviceContext->Draw(6, 0);
 
     gl::Box copyBox(0, 0, 0, extents.width, extents.height, 1);
 
     TextureHelper11 dest;
-    ANGLE_TRY_RESULT(mRenderer->createStagingTexture(GL_TEXTURE_2D, depthStencil->getFormatSet(),
-                                                     extents, StagingAccess::READ_WRITE),
-                     dest);
+    ANGLE_TRY_RESULT(
+        mRenderer->createStagingTexture(ResourceType::Texture2D, depthStencil->getFormatSet(),
+                                        extents, StagingAccess::READ_WRITE),
+        dest);
 
     const auto &copyFunction = GetCopyDepthStencilFunction(depthStencil->getInternalFormat());
     const auto &dsFormatSet  = depthStencil->getFormatSet();
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h
index f26056e4364..5dce0532882 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h
@@ -27,12 +27,14 @@ class Blit11 : angle::NonCopyable
     explicit Blit11(Renderer11 *renderer);
     ~Blit11();
 
-    gl::Error swizzleTexture(const d3d11::SharedSRV &source,
+    gl::Error swizzleTexture(const gl::Context *context,
+                             const d3d11::SharedSRV &source,
                              const d3d11::RenderTargetView &dest,
                              const gl::Extents &size,
                              const gl::SwizzleState &swizzleTarget);
 
-    gl::Error copyTexture(const d3d11::SharedSRV &source,
+    gl::Error copyTexture(const gl::Context *context,
+                          const d3d11::SharedSRV &source,
                           const gl::Box &sourceArea,
                           const gl::Extents &sourceSize,
                           GLenum sourceFormat,
@@ -46,7 +48,8 @@ class Blit11 : angle::NonCopyable
                           bool unpackPremultiplyAlpha,
                           bool unpackUnmultiplyAlpha);
 
-    gl::Error copyStencil(const TextureHelper11 &source,
+    gl::Error copyStencil(const gl::Context *context,
+                          const TextureHelper11 &source,
                           unsigned int sourceSubresource,
                           const gl::Box &sourceArea,
                           const gl::Extents &sourceSize,
@@ -56,7 +59,8 @@ class Blit11 : angle::NonCopyable
                           const gl::Extents &destSize,
                           const gl::Rectangle *scissor);
 
-    gl::Error copyDepth(const d3d11::SharedSRV &source,
+    gl::Error copyDepth(const gl::Context *context,
+                        const d3d11::SharedSRV &source,
                         const gl::Box &sourceArea,
                         const gl::Extents &sourceSize,
                         const d3d11::DepthStencilView &dest,
@@ -74,9 +78,12 @@ class Blit11 : angle::NonCopyable
                                const gl::Extents &destSize,
                                const gl::Rectangle *scissor);
 
-    gl::ErrorOrResult<TextureHelper11> resolveDepth(RenderTarget11 *depth);
+    gl::ErrorOrResult<TextureHelper11> resolveDepth(const gl::Context *context,
+                                                    RenderTarget11 *depth);
 
-    gl::ErrorOrResult<TextureHelper11> resolveStencil(RenderTarget11 *depthStencil, bool alsoDepth);
+    gl::ErrorOrResult<TextureHelper11> resolveStencil(const gl::Context *context,
+                                                      RenderTarget11 *depthStencil,
+                                                      bool alsoDepth);
 
     using BlitConvertFunction = void(const gl::Box &sourceArea,
                                      const gl::Box &destArea,
@@ -145,6 +152,12 @@ class Blit11 : angle::NonCopyable
         BLITSHADER_2D_RGBF_TOUI,
         BLITSHADER_2D_RGBF_TOUI_PREMULTIPLY,
         BLITSHADER_2D_RGBF_TOUI_UNMULTIPLY,
+
+        BLITSHADER_2D_LUMAF_PREMULTIPLY,
+        BLITSHADER_2D_LUMAF_UNMULTIPLY,
+
+        BLITSHADER_2D_LUMAALPHAF_PREMULTIPLY,
+        BLITSHADER_2D_LUMAALPHAF_UNMULTIPLY
     };
 
     enum SwizzleShaderType
@@ -182,20 +195,20 @@ class Blit11 : angle::NonCopyable
     struct Shader
     {
         ShaderDimension dimension;
-        ID3D11PixelShader *pixelShader;
+        d3d11::PixelShader pixelShader;
     };
 
     struct ShaderSupport
     {
-        ID3D11InputLayout *inputLayout;
-        ID3D11VertexShader *vertexShader;
-        ID3D11GeometryShader *geometryShader;
+        const d3d11::InputLayout *inputLayout;
+        const d3d11::VertexShader *vertexShader;
+        const d3d11::GeometryShader *geometryShader;
         WriteVertexFunction vertexWriteFunction;
     };
 
     gl::Error initResources();
 
-    ShaderSupport getShaderSupport(const Shader &shader);
+    gl::Error getShaderSupport(const Shader &shader, ShaderSupport *supportOut);
 
     static BlitShaderType GetBlitShaderType(GLenum destinationFormat,
                                             GLenum sourceFormat,
@@ -247,9 +260,10 @@ class Blit11 : angle::NonCopyable
                              size_t destPixelStride,
                              BlitConvertFunction *convertFunction);
 
-    void addBlitShaderToMap(BlitShaderType blitShaderType,
-                            ShaderDimension dimension,
-                            ID3D11PixelShader *ps);
+    gl::Error addBlitShaderToMap(BlitShaderType blitShaderType,
+                                 ShaderDimension dimension,
+                                 const ShaderData &shaderData,
+                                 const char *name);
 
     gl::Error getBlitShader(GLenum destFormat,
                             GLenum sourceFormat,
@@ -262,9 +276,10 @@ class Blit11 : angle::NonCopyable
                                D3D11_SRV_DIMENSION viewDimension,
                                const Shader **shaderOut);
 
-    void addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
-                               ShaderDimension dimension,
-                               ID3D11PixelShader *ps);
+    gl::Error addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
+                                    ShaderDimension dimension,
+                                    const ShaderData &shaderData,
+                                    const char *name);
 
     void clearShaderMap();
     void releaseResolveDepthStencilResources();
@@ -277,12 +292,12 @@ class Blit11 : angle::NonCopyable
     std::map<SwizzleShaderType, Shader> mSwizzleShaderMap;
 
     bool mResourcesInitialized;
-    angle::ComPtr<ID3D11Buffer> mVertexBuffer;
-    angle::ComPtr<ID3D11SamplerState> mPointSampler;
-    angle::ComPtr<ID3D11SamplerState> mLinearSampler;
-    angle::ComPtr<ID3D11RasterizerState> mScissorEnabledRasterizerState;
-    angle::ComPtr<ID3D11RasterizerState> mScissorDisabledRasterizerState;
-    angle::ComPtr<ID3D11DepthStencilState> mDepthStencilState;
+    d3d11::Buffer mVertexBuffer;
+    d3d11::SamplerState mPointSampler;
+    d3d11::SamplerState mLinearSampler;
+    d3d11::RasterizerState mScissorEnabledRasterizerState;
+    d3d11::RasterizerState mScissorDisabledRasterizerState;
+    d3d11::DepthStencilState mDepthStencilState;
 
     d3d11::LazyInputLayout mQuad2DIL;
     d3d11::LazyShader<ID3D11VertexShader> mQuad2DVS;
@@ -294,7 +309,7 @@ class Blit11 : angle::NonCopyable
 
     d3d11::LazyBlendState mAlphaMaskBlendState;
 
-    angle::ComPtr<ID3D11Buffer> mSwizzleCB;
+    d3d11::Buffer mSwizzleCB;
 
     d3d11::LazyShader<ID3D11VertexShader> mResolveDepthStencilVS;
     d3d11::LazyShader<ID3D11PixelShader> mResolveDepthPS;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp
index aea9c5fe27a..310ca19b115 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp
@@ -111,7 +111,9 @@ class Buffer11::BufferStorage : angle::NonCopyable
     size_t getSize() const { return mBufferSize; }
     void setDataRevision(DataRevision rev) { mRevision = rev; }
 
-    virtual bool isMappable(GLbitfield access) const = 0;
+    virtual bool isCPUAccessible(GLbitfield access) const = 0;
+
+    virtual bool isGPUAccessible() const = 0;
 
     virtual gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
                                                           size_t sourceOffset,
@@ -146,9 +148,11 @@ class Buffer11::NativeStorage : public Buffer11::BufferStorage
                   const OnBufferDataDirtyChannel *onStorageChanged);
     ~NativeStorage() override;
 
-    bool isMappable(GLbitfield access) const override;
+    bool isCPUAccessible(GLbitfield access) const override;
+
+    bool isGPUAccessible() const override { return true; }
 
-    ID3D11Buffer *getNativeStorage() const { return mNativeStorage; }
+    const d3d11::Buffer &getBuffer() const { return mBuffer; }
     gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
                                                   size_t sourceOffset,
                                                   size_t size,
@@ -170,7 +174,7 @@ class Buffer11::NativeStorage : public Buffer11::BufferStorage
                                unsigned int bufferSize);
     void clearSRVs();
 
-    ID3D11Buffer *mNativeStorage;
+    d3d11::Buffer mBuffer;
     const OnBufferDataDirtyChannel *mOnStorageChanged;
     std::map<DXGI_FORMAT, d3d11::ShaderResourceView> mBufferResourceViews;
 };
@@ -184,9 +188,11 @@ class Buffer11::EmulatedIndexedStorage : public Buffer11::BufferStorage
     EmulatedIndexedStorage(Renderer11 *renderer);
     ~EmulatedIndexedStorage() override;
 
-    bool isMappable(GLbitfield access) const override { return true; }
+    bool isCPUAccessible(GLbitfield access) const override { return true; }
 
-    gl::ErrorOrResult<ID3D11Buffer *> getNativeStorage(SourceIndexData *indexInfo,
+    bool isGPUAccessible() const override { return false; }
+
+    gl::ErrorOrResult<const d3d11::Buffer *> getBuffer(SourceIndexData *indexInfo,
                                                        const TranslatedAttribute &attribute,
                                                        GLint startVertex);
 
@@ -204,7 +210,7 @@ class Buffer11::EmulatedIndexedStorage : public Buffer11::BufferStorage
     void unmap() override;
 
   private:
-    ID3D11Buffer *mNativeStorage;              // contains expanded data for use by D3D
+    d3d11::Buffer mBuffer;                     // contains expanded data for use by D3D
     angle::MemoryBuffer mMemoryBuffer;         // original data (not expanded)
     angle::MemoryBuffer mIndicesMemoryBuffer;  // indices data
 };
@@ -217,7 +223,10 @@ class Buffer11::PackStorage : public Buffer11::BufferStorage
     explicit PackStorage(Renderer11 *renderer);
     ~PackStorage() override;
 
-    bool isMappable(GLbitfield access) const override { return true; }
+    bool isCPUAccessible(GLbitfield access) const override { return true; }
+
+    bool isGPUAccessible() const override { return false; }
+
     gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
                                                   size_t sourceOffset,
                                                   size_t size,
@@ -230,7 +239,8 @@ class Buffer11::PackStorage : public Buffer11::BufferStorage
                   uint8_t **mapPointerOut) override;
     void unmap() override;
 
-    gl::Error packPixels(const gl::FramebufferAttachment &readAttachment,
+    gl::Error packPixels(const gl::Context *context,
+                         const gl::FramebufferAttachment &readAttachment,
                          const PackPixelsParams &params);
 
   private:
@@ -252,7 +262,10 @@ class Buffer11::SystemMemoryStorage : public Buffer11::BufferStorage
     explicit SystemMemoryStorage(Renderer11 *renderer);
     ~SystemMemoryStorage() override {}
 
-    bool isMappable(GLbitfield access) const override { return true; }
+    bool isCPUAccessible(GLbitfield access) const override { return true; }
+
+    bool isGPUAccessible() const override { return false; }
+
     gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source,
                                                   size_t sourceOffset,
                                                   size_t size,
@@ -299,7 +312,7 @@ Buffer11::~Buffer11()
     mRenderer->onBufferDelete(this);
 }
 
-gl::Error Buffer11::setData(ContextImpl *context,
+gl::Error Buffer11::setData(const gl::Context *context,
                             GLenum target,
                             const void *data,
                             size_t size,
@@ -328,7 +341,7 @@ gl::ErrorOrResult<Buffer11::SystemMemoryStorage *> Buffer11::getSystemMemoryStor
     return GetAs<SystemMemoryStorage>(storage);
 }
 
-gl::Error Buffer11::setSubData(ContextImpl * /*context*/,
+gl::Error Buffer11::setSubData(const gl::Context * /*context*/,
                                GLenum target,
                                const void *data,
                                size_t size,
@@ -388,7 +401,7 @@ gl::Error Buffer11::setSubData(ContextImpl * /*context*/,
     return gl::NoError();
 }
 
-gl::Error Buffer11::copySubData(ContextImpl *context,
+gl::Error Buffer11::copySubData(const gl::Context *context,
                                 BufferImpl *source,
                                 GLintptr sourceOffset,
                                 GLintptr destOffset,
@@ -410,17 +423,15 @@ gl::Error Buffer11::copySubData(ContextImpl *context,
 
     if (!copySource || !copyDest)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal staging buffer.");
+        return gl::OutOfMemory() << "Failed to allocate internal staging buffer.";
     }
 
-    // If copying to/from a pixel pack buffer, we must have a staging or
-    // pack buffer partner, because other native buffers can't be mapped
-    if (copyDest->getUsage() == BUFFER_USAGE_PIXEL_PACK && !copySource->isMappable(GL_MAP_READ_BIT))
+    // A staging buffer is needed if there is no cpu-cpu or gpu-gpu copy path avaiable.
+    if (!copyDest->isGPUAccessible() && !copySource->isCPUAccessible(GL_MAP_READ_BIT))
     {
         ANGLE_TRY_RESULT(sourceBuffer->getStagingStorage(), copySource);
     }
-    else if (copySource->getUsage() == BUFFER_USAGE_PIXEL_PACK &&
-             !copyDest->isMappable(GL_MAP_WRITE_BIT))
+    else if (!copySource->isGPUAccessible() && !copyDest->isCPUAccessible(GL_MAP_WRITE_BIT))
     {
         ANGLE_TRY_RESULT(getStagingStorage(), copyDest);
     }
@@ -452,7 +463,7 @@ gl::Error Buffer11::copySubData(ContextImpl *context,
     return gl::NoError();
 }
 
-gl::Error Buffer11::map(ContextImpl *context, GLenum access, void **mapPtr)
+gl::Error Buffer11::map(const gl::Context *context, GLenum access, void **mapPtr)
 {
     // GL_OES_mapbuffer uses an enum instead of a bitfield for it's access, convert to a bitfield
     // and call mapRange.
@@ -460,7 +471,7 @@ gl::Error Buffer11::map(ContextImpl *context, GLenum access, void **mapPtr)
     return mapRange(context, 0, mSize, GL_MAP_WRITE_BIT, mapPtr);
 }
 
-gl::Error Buffer11::mapRange(ContextImpl *context,
+gl::Error Buffer11::mapRange(const gl::Context *context,
                              size_t offset,
                              size_t length,
                              GLbitfield access,
@@ -486,7 +497,7 @@ gl::Error Buffer11::mapRange(ContextImpl *context,
 
     if (!mMappedStorage)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate mappable internal buffer.");
+        return gl::OutOfMemory() << "Failed to allocate mappable internal buffer.";
     }
 
     if ((access & GL_MAP_WRITE_BIT) > 0)
@@ -504,7 +515,7 @@ gl::Error Buffer11::mapRange(ContextImpl *context,
     return gl::NoError();
 }
 
-gl::Error Buffer11::unmap(ContextImpl *context, GLboolean *result)
+gl::Error Buffer11::unmap(const gl::Context *context, GLboolean *result)
 {
     ASSERT(mMappedStorage);
     mMappedStorage->unmap();
@@ -608,7 +619,7 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getBuffer(BufferUsage usage)
 {
     BufferStorage *storage = nullptr;
     ANGLE_TRY_RESULT(getBufferStorage(usage), storage);
-    return GetAs<NativeStorage>(storage)->getNativeStorage();
+    return GetAs<NativeStorage>(storage)->getBuffer().get();
 }
 
 gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getEmulatedIndexedBuffer(
@@ -623,11 +634,10 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getEmulatedIndexedBuffer(
 
     EmulatedIndexedStorage *emulatedStorage = GetAs<EmulatedIndexedStorage>(untypedStorage);
 
-    ID3D11Buffer *nativeStorage = nullptr;
-    ANGLE_TRY_RESULT(emulatedStorage->getNativeStorage(indexInfo, attribute, startVertex),
-                     nativeStorage);
+    const d3d11::Buffer *nativeStorage = nullptr;
+    ANGLE_TRY_RESULT(emulatedStorage->getBuffer(indexInfo, attribute, startVertex), nativeStorage);
 
-    return nativeStorage;
+    return nativeStorage->get();
 }
 
 gl::Error Buffer11::getConstantBufferRange(GLintptr offset,
@@ -650,7 +660,7 @@ gl::Error Buffer11::getConstantBufferRange(GLintptr offset,
         *numConstantsOut  = 0;
     }
 
-    *bufferOut = GetAs<NativeStorage>(bufferStorage)->getNativeStorage();
+    *bufferOut = GetAs<NativeStorage>(bufferStorage)->getBuffer().get();
 
     return gl::NoError();
 }
@@ -663,7 +673,8 @@ gl::ErrorOrResult<ID3D11ShaderResourceView *> Buffer11::getSRV(DXGI_FORMAT srvFo
     return nativeStorage->getSRVForFormat(srvFormat);
 }
 
-gl::Error Buffer11::packPixels(const gl::FramebufferAttachment &readAttachment,
+gl::Error Buffer11::packPixels(const gl::Context *context,
+                               const gl::FramebufferAttachment &readAttachment,
                                const PackPixelsParams &params)
 {
     PackStorage *packStorage = nullptr;
@@ -673,7 +684,7 @@ gl::Error Buffer11::packPixels(const gl::FramebufferAttachment &readAttachment,
     ANGLE_TRY_RESULT(getLatestBufferStorage(), latestStorage);
 
     ASSERT(packStorage);
-    ANGLE_TRY(packStorage->packPixels(readAttachment, params));
+    ANGLE_TRY(packStorage->packPixels(context, readAttachment, params));
     packStorage->setDataRevision(latestStorage ? latestStorage->getDataRevision() + 1 : 1);
 
     return gl::NoError();
@@ -812,7 +823,8 @@ gl::Error Buffer11::updateBufferStorage(BufferStorage *storage,
         // data directly. If we're already using a staging buffer we're fine.
         if (latestBuffer->getUsage() != BUFFER_USAGE_STAGING &&
             storage->getUsage() != BUFFER_USAGE_STAGING &&
-            (!latestBuffer->isMappable(GL_MAP_READ_BIT) || !storage->isMappable(GL_MAP_WRITE_BIT)))
+            (!latestBuffer->isCPUAccessible(GL_MAP_READ_BIT) ||
+             !storage->isCPUAccessible(GL_MAP_WRITE_BIT)))
         {
             NativeStorage *stagingBuffer = nullptr;
             ANGLE_TRY_RESULT(getStagingStorage(), stagingBuffer);
@@ -920,7 +932,7 @@ Buffer11::BufferStorage::BufferStorage(Renderer11 *renderer, BufferUsage usage)
 
 gl::Error Buffer11::BufferStorage::setData(const uint8_t *data, size_t offset, size_t size)
 {
-    ASSERT(isMappable(GL_MAP_WRITE_BIT));
+    ASSERT(isCPUAccessible(GL_MAP_WRITE_BIT));
 
     // Uniform storage can have a different internal size than the buffer size. Ensure we don't
     // overflow.
@@ -941,17 +953,16 @@ gl::Error Buffer11::BufferStorage::setData(const uint8_t *data, size_t offset, s
 Buffer11::NativeStorage::NativeStorage(Renderer11 *renderer,
                                        BufferUsage usage,
                                        const OnBufferDataDirtyChannel *onStorageChanged)
-    : BufferStorage(renderer, usage), mNativeStorage(nullptr), mOnStorageChanged(onStorageChanged)
+    : BufferStorage(renderer, usage), mBuffer(), mOnStorageChanged(onStorageChanged)
 {
 }
 
 Buffer11::NativeStorage::~NativeStorage()
 {
-    SafeRelease(mNativeStorage);
     clearSRVs();
 }
 
-bool Buffer11::NativeStorage::isMappable(GLbitfield access) const
+bool Buffer11::NativeStorage::isCPUAccessible(GLbitfield access) const
 {
     if ((access & GL_MAP_READ_BIT) != 0)
     {
@@ -971,7 +982,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto
     ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
     size_t requiredSize = destOffset + size;
-    bool createBuffer   = !mNativeStorage || mBufferSize < requiredSize;
+    bool createBuffer   = !mBuffer.valid() || mBufferSize < requiredSize;
 
     // (Re)initialize D3D buffer if needed
     bool preserveData = (destOffset > 0);
@@ -989,7 +1000,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto
     if (source->getUsage() == BUFFER_USAGE_PIXEL_PACK ||
         source->getUsage() == BUFFER_USAGE_SYSTEM_MEMORY)
     {
-        ASSERT(source->isMappable(GL_MAP_READ_BIT) && isMappable(GL_MAP_WRITE_BIT));
+        ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT) && isCPUAccessible(GL_MAP_WRITE_BIT));
 
         // Uniform buffers must be mapped with write/discard.
         ASSERT(!(preserveData && mUsage == BUFFER_USAGE_UNIFORM));
@@ -1011,10 +1022,10 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto
         srcBox.front  = 0;
         srcBox.back   = 1;
 
-        ID3D11Buffer *sourceBuffer = GetAs<NativeStorage>(source)->getNativeStorage();
+        const d3d11::Buffer *sourceBuffer = &GetAs<NativeStorage>(source)->getBuffer();
 
-        context->CopySubresourceRegion(mNativeStorage, 0, static_cast<unsigned int>(destOffset), 0,
-                                       0, sourceBuffer, 0, &srcBox);
+        context->CopySubresourceRegion(mBuffer.get(), 0, static_cast<unsigned int>(destOffset), 0,
+                                       0, sourceBuffer->get(), 0, &srcBox);
     }
 
     return createBuffer ? CopyResult::RECREATED : CopyResult::NOT_RECREATED;
@@ -1022,24 +1033,16 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto
 
 gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData)
 {
-    ID3D11Device *device         = mRenderer->getDevice();
     ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
     D3D11_BUFFER_DESC bufferDesc;
     FillBufferDesc(&bufferDesc, mRenderer, mUsage, static_cast<unsigned int>(size));
 
-    ID3D11Buffer *newBuffer;
-    HRESULT result = device->CreateBuffer(&bufferDesc, nullptr, &newBuffer);
-
-    if (FAILED(result))
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer, result: 0x%X.",
-                         result);
-    }
-
-    d3d11::SetDebugName(newBuffer, "Buffer11::NativeStorage");
+    d3d11::Buffer newBuffer;
+    ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &newBuffer));
+    newBuffer.setDebugName("Buffer11::NativeStorage");
 
-    if (mNativeStorage && preserveData)
+    if (mBuffer.valid() && preserveData)
     {
         // We don't call resize if the buffer is big enough already.
         ASSERT(mBufferSize <= size);
@@ -1052,12 +1055,11 @@ gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData)
         srcBox.front  = 0;
         srcBox.back   = 1;
 
-        context->CopySubresourceRegion(newBuffer, 0, 0, 0, 0, mNativeStorage, 0, &srcBox);
+        context->CopySubresourceRegion(newBuffer.get(), 0, 0, 0, 0, mBuffer.get(), 0, &srcBox);
     }
 
     // No longer need the old buffer
-    SafeRelease(mNativeStorage);
-    mNativeStorage = newBuffer;
+    mBuffer = std::move(newBuffer);
 
     mBufferSize = bufferDesc.ByteWidth;
 
@@ -1148,19 +1150,18 @@ gl::Error Buffer11::NativeStorage::map(size_t offset,
                                        GLbitfield access,
                                        uint8_t **mapPointerOut)
 {
-    ASSERT(isMappable(access));
+    ASSERT(isCPUAccessible(access));
 
     D3D11_MAPPED_SUBRESOURCE mappedResource;
     ID3D11DeviceContext *context = mRenderer->getDeviceContext();
     D3D11_MAP d3dMapType         = gl_d3d11::GetD3DMapTypeFromBits(mUsage, access);
     UINT d3dMapFlag = ((access & GL_MAP_UNSYNCHRONIZED_BIT) != 0 ? D3D11_MAP_FLAG_DO_NOT_WAIT : 0);
 
-    HRESULT result = context->Map(mNativeStorage, 0, d3dMapType, d3dMapFlag, &mappedResource);
+    HRESULT result = context->Map(mBuffer.get(), 0, d3dMapType, d3dMapFlag, &mappedResource);
     ASSERT(SUCCEEDED(result));
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to map native storage in Buffer11::NativeStorage::map");
+        return gl::OutOfMemory() << "Failed to map native storage in Buffer11::NativeStorage::map";
     }
     ASSERT(mappedResource.pData);
     *mapPointerOut = static_cast<uint8_t *>(mappedResource.pData) + offset;
@@ -1169,9 +1170,9 @@ gl::Error Buffer11::NativeStorage::map(size_t offset,
 
 void Buffer11::NativeStorage::unmap()
 {
-    ASSERT(isMappable(GL_MAP_WRITE_BIT) || isMappable(GL_MAP_READ_BIT));
+    ASSERT(isCPUAccessible(GL_MAP_WRITE_BIT) || isCPUAccessible(GL_MAP_READ_BIT));
     ID3D11DeviceContext *context = mRenderer->getDeviceContext();
-    context->Unmap(mNativeStorage, 0);
+    context->Unmap(mBuffer.get(), 0);
 }
 
 gl::ErrorOrResult<ID3D11ShaderResourceView *> Buffer11::NativeStorage::getSRVForFormat(
@@ -1192,7 +1193,7 @@ gl::ErrorOrResult<ID3D11ShaderResourceView *> Buffer11::NativeStorage::getSRVFor
     bufferSRVDesc.ViewDimension        = D3D11_SRV_DIMENSION_BUFFER;
     bufferSRVDesc.Format               = srvFormat;
 
-    ANGLE_TRY(mRenderer->allocateResource(bufferSRVDesc, mNativeStorage,
+    ANGLE_TRY(mRenderer->allocateResource(bufferSRVDesc, mBuffer.get(),
                                           &mBufferResourceViews[srvFormat]));
 
     return mBufferResourceViews[srvFormat].get();
@@ -1206,16 +1207,15 @@ void Buffer11::NativeStorage::clearSRVs()
 // Buffer11::EmulatedIndexStorage implementation
 
 Buffer11::EmulatedIndexedStorage::EmulatedIndexedStorage(Renderer11 *renderer)
-    : BufferStorage(renderer, BUFFER_USAGE_EMULATED_INDEXED_VERTEX), mNativeStorage(nullptr)
+    : BufferStorage(renderer, BUFFER_USAGE_EMULATED_INDEXED_VERTEX), mBuffer()
 {
 }
 
 Buffer11::EmulatedIndexedStorage::~EmulatedIndexedStorage()
 {
-    SafeRelease(mNativeStorage);
 }
 
-gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeStorage(
+gl::ErrorOrResult<const d3d11::Buffer *> Buffer11::EmulatedIndexedStorage::getBuffer(
     SourceIndexData *indexInfo,
     const TranslatedAttribute &attribute,
     GLint startVertex)
@@ -1223,9 +1223,9 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
     // If a change in the indices applied from the last draw call is detected, then the emulated
     // indexed buffer needs to be invalidated.  After invalidation, the change detected flag should
     // be cleared to avoid unnecessary recreation of the buffer.
-    if (mNativeStorage == nullptr || indexInfo->srcIndicesChanged)
+    if (!mBuffer.valid() || indexInfo->srcIndicesChanged)
     {
-        SafeRelease(mNativeStorage);
+        mBuffer.reset();
 
         // Copy the source index data. This ensures that the lifetime of the indices pointer
         // stays with this storage until the next time we invalidate.
@@ -1248,9 +1248,8 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
 
         if (!mIndicesMemoryBuffer.resize(indicesDataSize))
         {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Error resizing index memory buffer in "
-                             "Buffer11::EmulatedIndexedStorage::getNativeStorage");
+            return gl::OutOfMemory() << "Error resizing index memory buffer in "
+                                        "Buffer11::EmulatedIndexedStorage::getBuffer";
         }
 
         memcpy(mIndicesMemoryBuffer.data(), indexInfo->srcIndices, indicesDataSize);
@@ -1258,7 +1257,7 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
         indexInfo->srcIndicesChanged = false;
     }
 
-    if (!mNativeStorage)
+    if (!mBuffer.valid())
     {
         unsigned int offset = 0;
         ANGLE_TRY_RESULT(attribute.computeOffset(startVertex), offset);
@@ -1269,9 +1268,8 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
         angle::MemoryBuffer expandedData;
         if (!expandedData.resize(expandedDataSize))
         {
-            return gl::Error(
-                GL_OUT_OF_MEMORY,
-                "Error resizing buffer in Buffer11::EmulatedIndexedStorage::getNativeStorage");
+            return gl::OutOfMemory()
+                   << "Error resizing buffer in Buffer11::EmulatedIndexedStorage::getBuffer";
         }
 
         // Clear the contents of the allocated buffer
@@ -1309,8 +1307,6 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
 
         // Finally, initialize the emulated indexed native storage object with the newly copied data
         // and free the temporary buffers used.
-        ID3D11Device *device = mRenderer->getDevice();
-
         D3D11_BUFFER_DESC bufferDesc;
         bufferDesc.ByteWidth           = expandedDataSize;
         bufferDesc.MiscFlags           = 0;
@@ -1321,16 +1317,11 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::EmulatedIndexedStorage::getNativeSto
 
         D3D11_SUBRESOURCE_DATA subResourceData = {expandedData.data(), 0, 0};
 
-        HRESULT result = device->CreateBuffer(&bufferDesc, &subResourceData, &mNativeStorage);
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Could not create emulated index data buffer: %08lX",
-                             result);
-        }
-        d3d11::SetDebugName(mNativeStorage, "Buffer11::EmulatedIndexedStorage");
+        ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &subResourceData, &mBuffer));
+        mBuffer.setDebugName("Buffer11::EmulatedIndexedStorage");
     }
 
-    return mNativeStorage;
+    return &mBuffer;
 }
 
 gl::ErrorOrResult<CopyResult> Buffer11::EmulatedIndexedStorage::copyFromStorage(
@@ -1339,7 +1330,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::EmulatedIndexedStorage::copyFromStorage(
     size_t size,
     size_t destOffset)
 {
-    ASSERT(source->isMappable(GL_MAP_READ_BIT));
+    ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT));
     uint8_t *sourceData = nullptr;
     ANGLE_TRY(source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData));
     ASSERT(destOffset + size <= mMemoryBuffer.size());
@@ -1354,7 +1345,7 @@ gl::Error Buffer11::EmulatedIndexedStorage::resize(size_t size, bool preserveDat
     {
         if (!mMemoryBuffer.resize(size))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to resize EmulatedIndexedStorage");
+            return gl::OutOfMemory() << "Failed to resize EmulatedIndexedStorage";
         }
         mBufferSize = size;
     }
@@ -1396,7 +1387,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::PackStorage::copyFromStorage(BufferStora
     ANGLE_TRY(flushQueuedPackCommand());
 
     // For all use cases of pack buffers, we must copy through a readable buffer.
-    ASSERT(source->isMappable(GL_MAP_READ_BIT));
+    ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT));
     uint8_t *sourceData = nullptr;
     ANGLE_TRY(source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData));
     ASSERT(destOffset + size <= mMemoryBuffer.size());
@@ -1411,7 +1402,7 @@ gl::Error Buffer11::PackStorage::resize(size_t size, bool preserveData)
     {
         if (!mMemoryBuffer.resize(size))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to resize internal buffer storage.");
+            return gl::OutOfMemory() << "Failed to resize internal buffer storage.";
         }
         mBufferSize = size;
     }
@@ -1443,25 +1434,23 @@ void Buffer11::PackStorage::unmap()
     // No-op
 }
 
-gl::Error Buffer11::PackStorage::packPixels(const gl::FramebufferAttachment &readAttachment,
+gl::Error Buffer11::PackStorage::packPixels(const gl::Context *context,
+                                            const gl::FramebufferAttachment &readAttachment,
                                             const PackPixelsParams &params)
 {
     ANGLE_TRY(flushQueuedPackCommand());
 
     RenderTarget11 *renderTarget = nullptr;
-    ANGLE_TRY(readAttachment.getRenderTarget(&renderTarget));
-
-    ID3D11Resource *renderTargetResource = renderTarget->getTexture();
-    ASSERT(renderTargetResource);
+    ANGLE_TRY(readAttachment.getRenderTarget(context, &renderTarget));
 
+    const TextureHelper11 &srcTexture = renderTarget->getTexture();
+    ASSERT(srcTexture.valid());
     unsigned int srcSubresource = renderTarget->getSubresourceIndex();
-    TextureHelper11 srcTexture =
-        TextureHelper11::MakeAndReference(renderTargetResource, renderTarget->getFormatSet());
 
-    mQueuedPackCommand.reset(new PackPixelsParams(params));
+    mQueuedPackCommand.reset(new PackPixelsParams(context, params));
 
     gl::Extents srcTextureSize(params.area.width, params.area.height, 1);
-    if (!mStagingTexture.getResource() || mStagingTexture.getFormat() != srcTexture.getFormat() ||
+    if (!mStagingTexture.get() || mStagingTexture.getFormat() != srcTexture.getFormat() ||
         mStagingTexture.getExtents() != srcTextureSize)
     {
         ANGLE_TRY_RESULT(
@@ -1482,15 +1471,15 @@ gl::Error Buffer11::PackStorage::packPixels(const gl::FramebufferAttachment &rea
 
     // Select the correct layer from a 3D attachment
     srcBox.front = 0;
-    if (mStagingTexture.getTextureType() == GL_TEXTURE_3D)
+    if (mStagingTexture.is3D())
     {
         srcBox.front = static_cast<UINT>(readAttachment.layer());
     }
     srcBox.back = srcBox.front + 1;
 
     // Asynchronous copy
-    immediateContext->CopySubresourceRegion(mStagingTexture.getResource(), 0, 0, 0, 0,
-                                            srcTexture.getResource(), srcSubresource, &srcBox);
+    immediateContext->CopySubresourceRegion(mStagingTexture.get(), 0, 0, 0, 0, srcTexture.get(),
+                                            srcSubresource, &srcBox);
 
     return gl::NoError();
 }
@@ -1521,7 +1510,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::SystemMemoryStorage::copyFromStorage(Buf
                                                                              size_t size,
                                                                              size_t destOffset)
 {
-    ASSERT(source->isMappable(GL_MAP_READ_BIT));
+    ASSERT(source->isCPUAccessible(GL_MAP_READ_BIT));
     uint8_t *sourceData = nullptr;
     ANGLE_TRY(source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData));
     ASSERT(destOffset + size <= mSystemCopy.size());
@@ -1536,7 +1525,7 @@ gl::Error Buffer11::SystemMemoryStorage::resize(size_t size, bool preserveData)
     {
         if (!mSystemCopy.resize(size))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to resize SystemMemoryStorage");
+            return gl::OutOfMemory() << "Failed to resize SystemMemoryStorage";
         }
         mBufferSize = size;
     }
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h
index a198f457293..65fded27ef2 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h
@@ -64,7 +64,8 @@ class Buffer11 : public BufferD3D
                                      UINT *numConstantsOut);
     gl::ErrorOrResult<ID3D11ShaderResourceView *> getSRV(DXGI_FORMAT srvFormat);
     bool isMapped() const { return mMappedStorage != nullptr; }
-    gl::Error packPixels(const gl::FramebufferAttachment &readAttachment,
+    gl::Error packPixels(const gl::Context *context,
+                         const gl::FramebufferAttachment &readAttachment,
                          const PackPixelsParams &params);
     size_t getTotalCPUBufferMemoryBytes() const;
 
@@ -76,28 +77,28 @@ class Buffer11 : public BufferD3D
     void invalidateStaticData() override;
 
     // BufferImpl implementation
-    gl::Error setData(ContextImpl *context,
+    gl::Error setData(const gl::Context *context,
                       GLenum target,
                       const void *data,
                       size_t size,
                       GLenum usage) override;
-    gl::Error setSubData(ContextImpl *context,
+    gl::Error setSubData(const gl::Context *context,
                          GLenum target,
                          const void *data,
                          size_t size,
                          size_t offset) override;
-    gl::Error copySubData(ContextImpl *contextImpl,
+    gl::Error copySubData(const gl::Context *context,
                           BufferImpl *source,
                           GLintptr sourceOffset,
                           GLintptr destOffset,
                           GLsizeiptr size) override;
-    gl::Error map(ContextImpl *contextImpl, GLenum access, void **mapPtr) override;
-    gl::Error mapRange(ContextImpl *contextImpl,
+    gl::Error map(const gl::Context *context, GLenum access, void **mapPtr) override;
+    gl::Error mapRange(const gl::Context *context,
                        size_t offset,
                        size_t length,
                        GLbitfield access,
                        void **mapPtr) override;
-    gl::Error unmap(ContextImpl *contextImpl, GLboolean *result) override;
+    gl::Error unmap(const gl::Context *context, GLboolean *result) override;
     gl::Error markTransformFeedbackUsage() override;
 
     // We use two set of dirty events. Static buffers are marked dirty whenever
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
index 4755132deaf..a5b3641f54e 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
@@ -82,7 +82,7 @@ bool UpdateDataCache(RtvDsvClearInfo<T> *dataCache,
 }  // anonymous namespace
 
 Clear11::ShaderManager::ShaderManager()
-    : mIl9(nullptr),
+    : mIl9(),
       mVs9(g_VS_Clear_FL9, ArraySize(g_VS_Clear_FL9), "Clear11 VS FL9"),
       mPsFloat9(g_PS_ClearFloat_FL9, ArraySize(g_PS_ClearFloat_FL9), "Clear11 PS FloatFL9"),
       mVs(g_VS_Clear, ArraySize(g_VS_Clear), "Clear11 VS"),
@@ -94,74 +94,88 @@ Clear11::ShaderManager::ShaderManager()
 
 Clear11::ShaderManager::~ShaderManager()
 {
-    mVs9.release();
-    mPsFloat9.release();
-    mVs.release();
-    mPsFloat.release();
-    mPsUInt.release();
-    mPsSInt.release();
 }
 
-void Clear11::ShaderManager::getShadersAndLayout(ID3D11Device *device,
-                                                 D3D_FEATURE_LEVEL featureLevel,
-                                                 const INT clearType,
-                                                 ID3D11InputLayout **il,
-                                                 ID3D11VertexShader **vs,
-                                                 ID3D11PixelShader **ps)
+gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
+                                                      const INT clearType,
+                                                      const d3d11::InputLayout **il,
+                                                      const d3d11::VertexShader **vs,
+                                                      const d3d11::PixelShader **ps)
 {
-    if (featureLevel <= D3D_FEATURE_LEVEL_9_3)
+    if (renderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
         ASSERT(clearType == GL_FLOAT);
 
-        *vs = mVs9.resolve(device);
+        ANGLE_TRY(mVs9.resolve(renderer));
+        ANGLE_TRY(mPsFloat9.resolve(renderer));
 
-        if (mIl9.Get() == nullptr)
+        if (!mIl9.valid())
         {
-            const D3D11_INPUT_ELEMENT_DESC ilDesc = {
-                "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0};
+            const D3D11_INPUT_ELEMENT_DESC ilDesc[] = {
+                {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}};
 
-            device->CreateInputLayout(&ilDesc, 1, g_VS_Clear_FL9, ArraySize(g_PS_ClearFloat_FL9),
-                                      mIl9.GetAddressOf());
+            InputElementArray ilDescArray(ilDesc);
+            ShaderData vertexShader(g_VS_Clear_FL9);
+
+            ANGLE_TRY(renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
         }
 
-        *il = mIl9.Get();
-        *ps = mPsFloat9.resolve(device);
-        return;
+        *vs = &mVs9.getObj();
+        *il = &mIl9;
+        *ps = &mPsFloat9.getObj();
+        return gl::NoError();
     }
 
-    *vs = mVs.resolve(device);
+    ANGLE_TRY(mVs.resolve(renderer));
+    *vs = &mVs.getObj();
     *il = nullptr;
 
     switch (clearType)
     {
         case GL_FLOAT:
-            *ps = mPsFloat.resolve(device);
+            ANGLE_TRY(mPsFloat.resolve(renderer));
+            *ps = &mPsFloat.getObj();
             break;
         case GL_UNSIGNED_INT:
-            *ps = mPsUInt.resolve(device);
+            ANGLE_TRY(mPsUInt.resolve(renderer));
+            *ps = &mPsUInt.getObj();
             break;
         case GL_INT:
-            *ps = mPsSInt.resolve(device);
+            ANGLE_TRY(mPsSInt.resolve(renderer));
+            *ps = &mPsSInt.getObj();
             break;
         default:
             UNREACHABLE();
             break;
     }
+
+    return gl::NoError();
 }
 
 Clear11::Clear11(Renderer11 *renderer)
     : mRenderer(renderer),
-      mScissorEnabledRasterizerState(nullptr),
-      mScissorDisabledRasterizerState(nullptr),
+      mResourcesInitialized(false),
+      mScissorEnabledRasterizerState(),
+      mScissorDisabledRasterizerState(),
       mShaderManager(),
-      mConstantBuffer(nullptr),
-      mVertexBuffer(nullptr),
+      mConstantBuffer(),
+      mVertexBuffer(),
       mShaderData({})
 {
-    TRACE_EVENT0("gpu.angle", "Clear11::Clear11");
+}
 
-    HRESULT result;
-    ID3D11Device *device = renderer->getDevice();
+Clear11::~Clear11()
+{
+}
+
+gl::Error Clear11::ensureResourcesInitialized()
+{
+    if (mResourcesInitialized)
+    {
+        return gl::NoError();
+    }
+
+    TRACE_EVENT0("gpu.angle", "Clear11::ensureResourcesInitialized");
 
     static_assert((sizeof(RtvDsvClearInfo<float>) == sizeof(RtvDsvClearInfo<int>)),
                   "Size of rx::RtvDsvClearInfo<float> is not equal to rx::RtvDsvClearInfo<int>");
@@ -173,55 +187,6 @@ Clear11::Clear11(Renderer11 *renderer)
     static_assert((sizeof(RtvDsvClearInfo<float>) % 16 == 0),
                   "The size of RtvDsvClearInfo<float> should be a multiple of 16bytes.");
 
-    // Create constant buffer for color & depth data
-
-    D3D11_BUFFER_DESC bufferDesc;
-    bufferDesc.ByteWidth           = g_ConstantBufferSize;
-    bufferDesc.Usage               = D3D11_USAGE_DYNAMIC;
-    bufferDesc.BindFlags           = D3D11_BIND_CONSTANT_BUFFER;
-    bufferDesc.CPUAccessFlags      = D3D11_CPU_ACCESS_WRITE;
-    bufferDesc.MiscFlags           = 0;
-    bufferDesc.StructureByteStride = 0;
-
-    D3D11_SUBRESOURCE_DATA initialData;
-    initialData.pSysMem          = &mShaderData;
-    initialData.SysMemPitch      = g_ConstantBufferSize;
-    initialData.SysMemSlicePitch = g_ConstantBufferSize;
-
-    result = device->CreateBuffer(&bufferDesc, &initialData, mConstantBuffer.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mConstantBuffer, "Clear11 Constant Buffer");
-
-    const D3D_FEATURE_LEVEL featureLevel = mRenderer->getRenderer11DeviceCaps().featureLevel;
-
-    if (featureLevel <= D3D_FEATURE_LEVEL_9_3)
-    {
-        // Create vertex buffer with vertices for a quad covering the entire surface
-
-        static_assert((sizeof(d3d11::PositionVertex) % 16) == 0,
-                      "d3d11::PositionVertex should be a multiple of 16 bytes");
-        const d3d11::PositionVertex vbData[6] = {
-            {-1.0f, 1.0f, 0.0f, 1.0f}, {1.0f, -1.0f, 0.0f, 1.0f}, {-1.0f, -1.0f, 0.0f, 1.0f},
-            {-1.0f, 1.0f, 0.0f, 1.0f}, {1.0f, 1.0f, 0.0f, 1.0f},  {1.0f, -1.0f, 0.0f, 1.0f}};
-
-        const UINT vbSize = sizeof(vbData);
-
-        bufferDesc.ByteWidth           = vbSize;
-        bufferDesc.Usage               = D3D11_USAGE_IMMUTABLE;
-        bufferDesc.BindFlags           = D3D11_BIND_VERTEX_BUFFER;
-        bufferDesc.CPUAccessFlags      = 0;
-        bufferDesc.MiscFlags           = 0;
-        bufferDesc.StructureByteStride = 0;
-
-        initialData.pSysMem          = vbData;
-        initialData.SysMemPitch      = vbSize;
-        initialData.SysMemSlicePitch = initialData.SysMemPitch;
-
-        result = device->CreateBuffer(&bufferDesc, &initialData, mVertexBuffer.GetAddressOf());
-        ASSERT(SUCCEEDED(result));
-        d3d11::SetDebugName(mVertexBuffer, "Clear11 Vertex Buffer");
-    }
-
     // Create Rasterizer States
     D3D11_RASTERIZER_DESC rsDesc;
     rsDesc.FillMode              = D3D11_FILL_SOLID;
@@ -235,16 +200,12 @@ Clear11::Clear11(Renderer11 *renderer)
     rsDesc.MultisampleEnable     = FALSE;
     rsDesc.AntialiasedLineEnable = FALSE;
 
-    result = device->CreateRasterizerState(&rsDesc, mScissorDisabledRasterizerState.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mScissorDisabledRasterizerState,
-                        "Clear11 Rasterizer State with scissor disabled");
+    ANGLE_TRY(mRenderer->allocateResource(rsDesc, &mScissorDisabledRasterizerState));
+    mScissorDisabledRasterizerState.setDebugName("Clear11 Rasterizer State with scissor disabled");
 
     rsDesc.ScissorEnable = TRUE;
-    result = device->CreateRasterizerState(&rsDesc, mScissorEnabledRasterizerState.GetAddressOf());
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mScissorEnabledRasterizerState,
-                        "Clear11 Rasterizer State with scissor enabled");
+    ANGLE_TRY(mRenderer->allocateResource(rsDesc, &mScissorEnabledRasterizerState));
+    mScissorEnabledRasterizerState.setDebugName("Clear11 Rasterizer State with scissor enabled");
 
     // Initialize Depthstencil state with defaults
     mDepthStencilStateKey.depthTest                = false;
@@ -276,15 +237,86 @@ Clear11::Clear11(Renderer11 *renderer)
     mBlendStateKey.blendState.dither                = true;
     mBlendStateKey.mrt                              = false;
     memset(mBlendStateKey.rtvMasks, 0, sizeof(mBlendStateKey.rtvMasks));
+
+    mResourcesInitialized = true;
+    return gl::NoError();
 }
 
-Clear11::~Clear11()
+bool Clear11::useVertexBuffer() const
+{
+    return (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3);
+}
+
+gl::Error Clear11::ensureConstantBufferCreated()
+{
+    if (mConstantBuffer.valid())
+    {
+        return gl::NoError();
+    }
+
+    // Create constant buffer for color & depth data
+
+    D3D11_BUFFER_DESC bufferDesc;
+    bufferDesc.ByteWidth           = g_ConstantBufferSize;
+    bufferDesc.Usage               = D3D11_USAGE_DYNAMIC;
+    bufferDesc.BindFlags           = D3D11_BIND_CONSTANT_BUFFER;
+    bufferDesc.CPUAccessFlags      = D3D11_CPU_ACCESS_WRITE;
+    bufferDesc.MiscFlags           = 0;
+    bufferDesc.StructureByteStride = 0;
+
+    D3D11_SUBRESOURCE_DATA initialData;
+    initialData.pSysMem          = &mShaderData;
+    initialData.SysMemPitch      = g_ConstantBufferSize;
+    initialData.SysMemSlicePitch = g_ConstantBufferSize;
+
+    ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &initialData, &mConstantBuffer));
+    mConstantBuffer.setDebugName("Clear11 Constant Buffer");
+    return gl::NoError();
+}
+
+gl::Error Clear11::ensureVertexBufferCreated()
 {
+    ASSERT(useVertexBuffer());
+
+    if (mVertexBuffer.valid())
+    {
+        return gl::NoError();
+    }
+
+    // Create vertex buffer with vertices for a quad covering the entire surface
+
+    static_assert((sizeof(d3d11::PositionVertex) % 16) == 0,
+                  "d3d11::PositionVertex should be a multiple of 16 bytes");
+    const d3d11::PositionVertex vbData[6] = {{-1.0f, 1.0f, 0.0f, 1.0f},  {1.0f, -1.0f, 0.0f, 1.0f},
+                                             {-1.0f, -1.0f, 0.0f, 1.0f}, {-1.0f, 1.0f, 0.0f, 1.0f},
+                                             {1.0f, 1.0f, 0.0f, 1.0f},   {1.0f, -1.0f, 0.0f, 1.0f}};
+
+    const UINT vbSize = sizeof(vbData);
+
+    D3D11_BUFFER_DESC bufferDesc;
+    bufferDesc.ByteWidth           = vbSize;
+    bufferDesc.Usage               = D3D11_USAGE_IMMUTABLE;
+    bufferDesc.BindFlags           = D3D11_BIND_VERTEX_BUFFER;
+    bufferDesc.CPUAccessFlags      = 0;
+    bufferDesc.MiscFlags           = 0;
+    bufferDesc.StructureByteStride = 0;
+
+    D3D11_SUBRESOURCE_DATA initialData;
+    initialData.pSysMem          = vbData;
+    initialData.SysMemPitch      = vbSize;
+    initialData.SysMemSlicePitch = initialData.SysMemPitch;
+
+    ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &initialData, &mVertexBuffer));
+    mVertexBuffer.setDebugName("Clear11 Vertex Buffer");
+    return gl::NoError();
 }
 
-gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
+gl::Error Clear11::clearFramebuffer(const gl::Context *context,
+                                    const ClearParameters &clearParams,
                                     const gl::FramebufferState &fboData)
 {
+    ANGLE_TRY(ensureResourcesInitialized());
+
     // Iterate over the color buffers which require clearing and determine if they can be
     // cleared with ID3D11DeviceContext::ClearRenderTargetView or ID3D11DeviceContext1::ClearView.
     // This requires:
@@ -364,20 +396,17 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
                                    clearParams.colorMaskBlue, clearParams.colorMaskAlpha);
 
     const auto &colorAttachments = fboData.getColorAttachments();
-    const auto &drawBufferStates = fboData.getDrawBufferStates();
-    for (size_t colorAttachmentIndex = 0; colorAttachmentIndex < colorAttachments.size();
-        colorAttachmentIndex++)
+    for (auto colorAttachmentIndex : fboData.getEnabledDrawBuffers())
     {
         const gl::FramebufferAttachment &attachment = colorAttachments[colorAttachmentIndex];
 
-        if (!clearParams.clearColor[colorAttachmentIndex] || !attachment.isAttached() ||
-            drawBufferStates[colorAttachmentIndex] == GL_NONE)
+        if (!clearParams.clearColor[colorAttachmentIndex])
         {
             continue;
         }
 
         RenderTarget11 *renderTarget = nullptr;
-        ANGLE_TRY(attachment.getRenderTarget(&renderTarget));
+        ANGLE_TRY(attachment.getRenderTarget(context, &renderTarget));
 
         const gl::InternalFormat &formatInfo = *attachment.getFormat().info;
 
@@ -487,7 +516,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
         RenderTarget11 *depthStencilRenderTarget = nullptr;
 
         ASSERT(depthStencilAttachment != nullptr);
-        ANGLE_TRY(depthStencilAttachment->getRenderTarget(&depthStencilRenderTarget));
+        ANGLE_TRY(depthStencilAttachment->getRenderTarget(context, &depthStencilRenderTarget));
 
         dsv = depthStencilRenderTarget->getDepthStencilView().get();
         ASSERT(dsv != nullptr);
@@ -562,7 +591,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
 
     // Get BlendState
     ID3D11BlendState *blendState = nullptr;
-    ANGLE_TRY(mRenderer->getStateCache().getBlendState(mBlendStateKey, &blendState));
+    ANGLE_TRY(mRenderer->getBlendState(mBlendStateKey, &blendState));
 
     ID3D11DepthStencilState *dsState = nullptr;
     const float *zValue              = nullptr;
@@ -576,7 +605,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
         mDepthStencilStateKey.stencilTest      = clearParams.clearStencil;
 
         // Get DepthStencilState
-        ANGLE_TRY(mRenderer->getStateCache().getDepthStencilState(mDepthStencilStateKey, &dsState));
+        ANGLE_TRY(mRenderer->getDepthStencilState(mDepthStencilStateKey, &dsState));
         zValue = clearParams.clearDepth ? &clearParams.depthValue : nullptr;
     }
 
@@ -602,20 +631,22 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
             break;
     }
 
+    ANGLE_TRY(ensureConstantBufferCreated());
+
     if (dirtyCb)
     {
         // Update the constant buffer with the updated cache contents
         // TODO(Shahmeer): Consider using UpdateSubresource1 D3D11_COPY_DISCARD where possible.
         D3D11_MAPPED_SUBRESOURCE mappedResource;
-        HRESULT result = deviceContext->Map(mConstantBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0,
+        HRESULT result = deviceContext->Map(mConstantBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0,
                                             &mappedResource);
         if (FAILED(result))
         {
-            return gl::OutOfMemory() << "Clear11: Failed to map CB, " << result;
+            return gl::OutOfMemory() << "Clear11: Failed to map CB, " << gl::FmtHR(result);
         }
 
         memcpy(mappedResource.pData, &mShaderData, g_ConstantBufferSize);
-        deviceContext->Unmap(mConstantBuffer.Get(), 0);
+        deviceContext->Unmap(mConstantBuffer.get(), 0);
     }
 
     // Set the viewport to be the same size as the framebuffer
@@ -639,54 +670,52 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
         const D3D11_RECT scissorRect = {clearParams.scissor.x, clearParams.scissor.y,
                                         clearParams.scissor.x1(), clearParams.scissor.y1()};
         deviceContext->RSSetScissorRects(1, &scissorRect);
-        deviceContext->RSSetState(mScissorEnabledRasterizerState.Get());
+        deviceContext->RSSetState(mScissorEnabledRasterizerState.get());
     }
     else
     {
-        deviceContext->RSSetState(mScissorDisabledRasterizerState.Get());
+        deviceContext->RSSetState(mScissorDisabledRasterizerState.get());
     }
 
+    auto *stateManager = mRenderer->getStateManager();
+
     // Get Shaders
-    const D3D_FEATURE_LEVEL fl = mRenderer->getRenderer11DeviceCaps().featureLevel;
-    ID3D11Device *device = mRenderer->getDevice();
-    ID3D11VertexShader *vs;
-    ID3D11InputLayout *il;
-    ID3D11PixelShader *ps;
+    const d3d11::VertexShader *vs = nullptr;
+    const d3d11::InputLayout *il  = nullptr;
+    const d3d11::PixelShader *ps  = nullptr;
 
-    mShaderManager.getShadersAndLayout(device, fl, clearParams.colorType, &il, &vs, &ps);
+    ANGLE_TRY(mShaderManager.getShadersAndLayout(mRenderer, clearParams.colorType, &il, &vs, &ps));
 
     // Apply Shaders
-    deviceContext->VSSetShader(vs, nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
-    deviceContext->PSSetShader(ps, nullptr, 0);
-    deviceContext->PSSetConstantBuffers(0, 1, mConstantBuffer.GetAddressOf());
+    stateManager->setDrawShaders(vs, nullptr, ps);
+    ID3D11Buffer *constantBuffer = mConstantBuffer.get();
+    deviceContext->PSSetConstantBuffers(0, 1, &constantBuffer);
 
     // Bind IL & VB if needed
     deviceContext->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0);
-    deviceContext->IASetInputLayout(il);
+    stateManager->setInputLayout(il);
 
-    if (mVertexBuffer.Get())
+    if (useVertexBuffer())
     {
-        const UINT offset = 0;
-        deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &g_VertexSize,
-                                          &offset);
+        ANGLE_TRY(ensureVertexBufferCreated());
+        stateManager->setSingleVertexBuffer(&mVertexBuffer, g_VertexSize, 0);
     }
     else
     {
-        deviceContext->IASetVertexBuffers(0, 0, nullptr, nullptr, nullptr);
+        stateManager->setSingleVertexBuffer(nullptr, 0, 0);
     }
 
-    deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+    stateManager->setPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 
     // Apply render targets
-    mRenderer->getStateManager()->setOneTimeRenderTargets(&rtvs[0], numRtvs, dsv);
+    stateManager->setOneTimeRenderTargets(context, &rtvs[0], numRtvs, dsv);
 
     // Draw the fullscreen quad
     deviceContext->Draw(6, 0);
 
     // Clean up
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
 
     return gl::NoError();
 }
-}
+}  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.h
index c623a8a2456..00990951c2e 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.h
@@ -38,7 +38,8 @@ class Clear11 : angle::NonCopyable
     ~Clear11();
 
     // Clears the framebuffer with the supplied clear parameters, assumes that the framebuffer is currently applied.
-    gl::Error clearFramebuffer(const ClearParameters &clearParams,
+    gl::Error clearFramebuffer(const gl::Context *context,
+                               const ClearParameters &clearParams,
                                const gl::FramebufferState &fboData);
 
   private:
@@ -47,15 +48,14 @@ class Clear11 : angle::NonCopyable
       public:
         ShaderManager();
         ~ShaderManager();
-        void getShadersAndLayout(ID3D11Device *device,
-                                 D3D_FEATURE_LEVEL featureLevel,
-                                 const INT clearType,
-                                 ID3D11InputLayout **il,
-                                 ID3D11VertexShader **vs,
-                                 ID3D11PixelShader **ps);
+        gl::Error getShadersAndLayout(Renderer11 *renderer,
+                                      const INT clearType,
+                                      const d3d11::InputLayout **il,
+                                      const d3d11::VertexShader **vs,
+                                      const d3d11::PixelShader **ps);
 
       private:
-        angle::ComPtr<ID3D11InputLayout> mIl9;
+        d3d11::InputLayout mIl9;
         d3d11::LazyShader<ID3D11VertexShader> mVs9;
         d3d11::LazyShader<ID3D11PixelShader> mPsFloat9;
         d3d11::LazyShader<ID3D11VertexShader> mVs;
@@ -64,23 +64,29 @@ class Clear11 : angle::NonCopyable
         d3d11::LazyShader<ID3D11PixelShader> mPsSInt;
     };
 
+    bool useVertexBuffer() const;
+    gl::Error ensureConstantBufferCreated();
+    gl::Error ensureVertexBufferCreated();
+    gl::Error ensureResourcesInitialized();
+
     Renderer11 *mRenderer;
+    bool mResourcesInitialized;
 
     // States
-    angle::ComPtr<ID3D11RasterizerState> mScissorEnabledRasterizerState;
-    angle::ComPtr<ID3D11RasterizerState> mScissorDisabledRasterizerState;
+    d3d11::RasterizerState mScissorEnabledRasterizerState;
+    d3d11::RasterizerState mScissorDisabledRasterizerState;
     gl::DepthStencilState mDepthStencilStateKey;
     d3d11::BlendStateKey mBlendStateKey;
 
     // Shaders and shader resources
     ShaderManager mShaderManager;
-    angle::ComPtr<ID3D11Buffer> mConstantBuffer;
-    angle::ComPtr<ID3D11Buffer> mVertexBuffer;
+    d3d11::Buffer mConstantBuffer;
+    d3d11::Buffer mVertexBuffer;
 
     // Buffer data and draw parameters
     RtvDsvClearInfo<float> mShaderData;
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_CLEAR11_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp
index 5a960fe9628..91a3622a5b4 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp
@@ -149,39 +149,44 @@ gl::Error Context11::finish()
     return mRenderer->finish();
 }
 
-gl::Error Context11::drawArrays(GLenum mode, GLint first, GLsizei count)
+gl::Error Context11::drawArrays(const gl::Context *context, GLenum mode, GLint first, GLsizei count)
 {
-    return mRenderer->genericDrawArrays(this, mode, first, count, 0);
+    return mRenderer->genericDrawArrays(context, mode, first, count, 0);
 }
 
-gl::Error Context11::drawArraysInstanced(GLenum mode,
+gl::Error Context11::drawArraysInstanced(const gl::Context *context,
+                                         GLenum mode,
                                          GLint first,
                                          GLsizei count,
                                          GLsizei instanceCount)
 {
-    return mRenderer->genericDrawArrays(this, mode, first, count, instanceCount);
+    return mRenderer->genericDrawArrays(context, mode, first, count, instanceCount);
 }
 
-gl::Error Context11::drawElements(GLenum mode,
+gl::Error Context11::drawElements(const gl::Context *context,
+                                  GLenum mode,
                                   GLsizei count,
                                   GLenum type,
                                   const void *indices,
                                   const gl::IndexRange &indexRange)
 {
-    return mRenderer->genericDrawElements(this, mode, count, type, indices, 0, indexRange);
+    return mRenderer->genericDrawElements(context, mode, count, type, indices, 0, indexRange);
 }
 
-gl::Error Context11::drawElementsInstanced(GLenum mode,
+gl::Error Context11::drawElementsInstanced(const gl::Context *context,
+                                           GLenum mode,
                                            GLsizei count,
                                            GLenum type,
                                            const void *indices,
                                            GLsizei instances,
                                            const gl::IndexRange &indexRange)
 {
-    return mRenderer->genericDrawElements(this, mode, count, type, indices, instances, indexRange);
+    return mRenderer->genericDrawElements(context, mode, count, type, indices, instances,
+                                          indexRange);
 }
 
-gl::Error Context11::drawRangeElements(GLenum mode,
+gl::Error Context11::drawRangeElements(const gl::Context *context,
+                                       GLenum mode,
                                        GLuint start,
                                        GLuint end,
                                        GLsizei count,
@@ -189,17 +194,22 @@ gl::Error Context11::drawRangeElements(GLenum mode,
                                        const void *indices,
                                        const gl::IndexRange &indexRange)
 {
-    return mRenderer->genericDrawElements(this, mode, count, type, indices, 0, indexRange);
+    return mRenderer->genericDrawElements(context, mode, count, type, indices, 0, indexRange);
 }
 
-gl::Error Context11::drawArraysIndirect(GLenum mode, const void *indirect)
+gl::Error Context11::drawArraysIndirect(const gl::Context *context,
+                                        GLenum mode,
+                                        const void *indirect)
 {
-    return mRenderer->genericDrawIndirect(this, mode, GL_NONE, indirect);
+    return mRenderer->genericDrawIndirect(context, mode, GL_NONE, indirect);
 }
 
-gl::Error Context11::drawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
+gl::Error Context11::drawElementsIndirect(const gl::Context *context,
+                                          GLenum mode,
+                                          GLenum type,
+                                          const void *indirect)
 {
-    return mRenderer->genericDrawIndirect(this, mode, type, indirect);
+    return mRenderer->genericDrawIndirect(context, mode, type, indirect);
 }
 
 GLenum Context11::getResetStatus()
@@ -240,9 +250,9 @@ void Context11::popGroupMarker()
     mRenderer->getAnnotator()->endEvent();
 }
 
-void Context11::syncState(const gl::State::DirtyBits &dirtyBits)
+void Context11::syncState(const gl::Context *context, const gl::State::DirtyBits &dirtyBits)
 {
-    mRenderer->getStateManager()->syncState(mState.getState(), dirtyBits);
+    mRenderer->getStateManager()->syncState(context, dirtyBits);
 }
 
 GLint Context11::getGPUDisjoint()
@@ -255,9 +265,9 @@ GLint64 Context11::getTimestamp()
     return mRenderer->getTimestamp();
 }
 
-void Context11::onMakeCurrent(const gl::ContextState &data)
+void Context11::onMakeCurrent(const gl::Context *context)
 {
-    mRenderer->getStateManager()->onMakeCurrent(data);
+    mRenderer->getStateManager()->onMakeCurrent(context);
 }
 
 const gl::Caps &Context11::getNativeCaps() const
@@ -280,9 +290,12 @@ const gl::Limitations &Context11::getNativeLimitations() const
     return mRenderer->getNativeLimitations();
 }
 
-gl::Error Context11::dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ)
+gl::Error Context11::dispatchCompute(const gl::Context *context,
+                                     GLuint numGroupsX,
+                                     GLuint numGroupsY,
+                                     GLuint numGroupsZ)
 {
-    return mRenderer->dispatchCompute(this, numGroupsX, numGroupsY, numGroupsZ);
+    return mRenderer->dispatchCompute(context, numGroupsX, numGroupsY, numGroupsZ);
 }
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h
index 69478775219..f11c533f4e2 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h
@@ -64,32 +64,44 @@ class Context11 : public ContextImpl
     gl::Error finish() override;
 
     // Drawing methods.
-    gl::Error drawArrays(GLenum mode, GLint first, GLsizei count) override;
-    gl::Error drawArraysInstanced(GLenum mode,
+    gl::Error drawArrays(const gl::Context *context,
+                         GLenum mode,
+                         GLint first,
+                         GLsizei count) override;
+    gl::Error drawArraysInstanced(const gl::Context *context,
+                                  GLenum mode,
                                   GLint first,
                                   GLsizei count,
                                   GLsizei instanceCount) override;
 
-    gl::Error drawElements(GLenum mode,
+    gl::Error drawElements(const gl::Context *context,
+                           GLenum mode,
                            GLsizei count,
                            GLenum type,
                            const void *indices,
                            const gl::IndexRange &indexRange) override;
-    gl::Error drawElementsInstanced(GLenum mode,
+    gl::Error drawElementsInstanced(const gl::Context *context,
+                                    GLenum mode,
                                     GLsizei count,
                                     GLenum type,
                                     const void *indices,
                                     GLsizei instances,
                                     const gl::IndexRange &indexRange) override;
-    gl::Error drawRangeElements(GLenum mode,
+    gl::Error drawRangeElements(const gl::Context *context,
+                                GLenum mode,
                                 GLuint start,
                                 GLuint end,
                                 GLsizei count,
                                 GLenum type,
                                 const void *indices,
                                 const gl::IndexRange &indexRange) override;
-    gl::Error drawArraysIndirect(GLenum mode, const void *indirect) override;
-    gl::Error drawElementsIndirect(GLenum mode, GLenum type, const void *indirect) override;
+    gl::Error drawArraysIndirect(const gl::Context *context,
+                                 GLenum mode,
+                                 const void *indirect) override;
+    gl::Error drawElementsIndirect(const gl::Context *context,
+                                   GLenum mode,
+                                   GLenum type,
+                                   const void *indirect) override;
 
     // Device loss
     GLenum getResetStatus() override;
@@ -104,14 +116,14 @@ class Context11 : public ContextImpl
     void popGroupMarker() override;
 
     // State sync with dirty bits.
-    void syncState(const gl::State::DirtyBits &dirtyBits) override;
+    void syncState(const gl::Context *context, const gl::State::DirtyBits &dirtyBits) override;
 
     // Disjoint timer queries
     GLint getGPUDisjoint() override;
     GLint64 getTimestamp() override;
 
     // Context switching
-    void onMakeCurrent(const gl::ContextState &data) override;
+    void onMakeCurrent(const gl::Context *context) override;
 
     // Caps queries
     const gl::Caps &getNativeCaps() const override;
@@ -121,7 +133,10 @@ class Context11 : public ContextImpl
 
     Renderer11 *getRenderer() const { return mRenderer; }
 
-    gl::Error dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ) override;
+    gl::Error dispatchCompute(const gl::Context *context,
+                              GLuint numGroupsX,
+                              GLuint numGroupsY,
+                              GLuint numGroupsZ) override;
 
   private:
     Renderer11 *mRenderer;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp
index bf980edc9f6..51449f68372 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp
@@ -33,8 +33,7 @@ gl::Error FenceSetHelper(FenceClass *fence)
         HRESULT result = fence->mRenderer->getDevice()->CreateQuery(&queryDesc, &fence->mQuery);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create event query, result: 0x%X.",
-                             result);
+            return gl::OutOfMemory() << "Failed to create event query, " << gl::FmtHR(result);
         }
     }
 
@@ -53,7 +52,7 @@ gl::Error FenceTestHelper(FenceClass *fence, bool flushCommandBuffer, GLboolean
 
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to get query data, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to get query data, " << gl::FmtHR(result);
     }
 
     ASSERT(result == S_OK || result == S_FALSE);
@@ -96,8 +95,7 @@ gl::Error FenceNV11::finish()
 
         if (loopCount % kDeviceLostCheckPeriod == 0 && mRenderer->testDeviceLost())
         {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Device was lost while querying result of an event query.");
+            return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
         }
 
         ScheduleYield();
@@ -193,8 +191,7 @@ gl::Error FenceSync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *ou
         if ((loopCount % kDeviceLostCheckPeriod) == 0 && mRenderer->testDeviceLost())
         {
             *outResult = GL_WAIT_FAILED;
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Device was lost while querying result of an event query.");
+            return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
         }
     }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp
index 4cbabbc2a86..edafee91bf6 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp
@@ -29,7 +29,8 @@ namespace rx
 
 namespace
 {
-gl::Error MarkAttachmentsDirty(const gl::FramebufferAttachment *attachment)
+gl::Error MarkAttachmentsDirty(const gl::Context *context,
+                               const gl::FramebufferAttachment *attachment)
 {
     if (attachment && attachment->type() == GL_TEXTURE)
     {
@@ -38,7 +39,7 @@ gl::Error MarkAttachmentsDirty(const gl::FramebufferAttachment *attachment)
         TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
 
         TextureStorage *texStorage = nullptr;
-        ANGLE_TRY(textureD3D->getNativeTexture(&texStorage));
+        ANGLE_TRY(textureD3D->getNativeTexture(context, &texStorage));
 
         if (texStorage)
         {
@@ -52,14 +53,20 @@ gl::Error MarkAttachmentsDirty(const gl::FramebufferAttachment *attachment)
     return gl::NoError();
 }
 
-void UpdateCachedRenderTarget(const gl::FramebufferAttachment *attachment,
+void UpdateCachedRenderTarget(const gl::Context *context,
+                              const gl::FramebufferAttachment *attachment,
                               RenderTarget11 *&cachedRenderTarget,
                               OnRenderTargetDirtyBinding *channelBinding)
 {
     RenderTarget11 *newRenderTarget = nullptr;
     if (attachment)
     {
-        attachment->getRenderTarget(&newRenderTarget);
+        // TODO(jmadill): Don't swallow this error.
+        gl::Error error = attachment->getRenderTarget(context, &newRenderTarget);
+        if (error.isError())
+        {
+            ERR() << "Internal rendertarget error: " << error;
+        }
     }
     if (newRenderTarget != cachedRenderTarget)
     {
@@ -88,23 +95,23 @@ Framebuffer11::~Framebuffer11()
 {
 }
 
-gl::Error Framebuffer11::markAttachmentsDirty() const
+gl::Error Framebuffer11::markAttachmentsDirty(const gl::Context *context) const
 {
     for (const auto &colorAttachment : mState.getColorAttachments())
     {
         if (colorAttachment.isAttached())
         {
-            ANGLE_TRY(MarkAttachmentsDirty(&colorAttachment));
+            ANGLE_TRY(MarkAttachmentsDirty(context, &colorAttachment));
         }
     }
 
-    ANGLE_TRY(MarkAttachmentsDirty(mState.getDepthAttachment()));
-    ANGLE_TRY(MarkAttachmentsDirty(mState.getStencilAttachment()));
+    ANGLE_TRY(MarkAttachmentsDirty(context, mState.getDepthAttachment()));
+    ANGLE_TRY(MarkAttachmentsDirty(context, mState.getStencilAttachment()));
 
     return gl::NoError();
 }
 
-gl::Error Framebuffer11::clearImpl(ContextImpl *context, const ClearParameters &clearParams)
+gl::Error Framebuffer11::clearImpl(const gl::Context *context, const ClearParameters &clearParams)
 {
     Clear11 *clearer = mRenderer->getClearer();
 
@@ -120,29 +127,36 @@ gl::Error Framebuffer11::clearImpl(ContextImpl *context, const ClearParameters &
         presentPathFastClearParams.scissor.y       = framebufferSize.height -
                                                presentPathFastClearParams.scissor.y -
                                                presentPathFastClearParams.scissor.height;
-        ANGLE_TRY(clearer->clearFramebuffer(presentPathFastClearParams, mState));
+        ANGLE_TRY(clearer->clearFramebuffer(context, presentPathFastClearParams, mState));
     }
     else
     {
-        ANGLE_TRY(clearer->clearFramebuffer(clearParams, mState));
+        ANGLE_TRY(clearer->clearFramebuffer(context, clearParams, mState));
     }
 
-    ANGLE_TRY(markAttachmentsDirty());
+    ANGLE_TRY(markAttachmentsDirty(context));
 
     return gl::NoError();
 }
 
-gl::Error Framebuffer11::invalidate(size_t count, const GLenum *attachments)
+gl::Error Framebuffer11::invalidate(const gl::Context *context,
+                                    size_t count,
+                                    const GLenum *attachments)
 {
-    return invalidateBase(count, attachments, false);
+    return invalidateBase(context, count, attachments, false);
 }
 
-gl::Error Framebuffer11::discard(size_t count, const GLenum *attachments)
+gl::Error Framebuffer11::discard(const gl::Context *context,
+                                 size_t count,
+                                 const GLenum *attachments)
 {
-    return invalidateBase(count, attachments, true);
+    return invalidateBase(context, count, attachments, true);
 }
 
-gl::Error Framebuffer11::invalidateBase(size_t count, const GLenum *attachments, bool useEXTBehavior) const
+gl::Error Framebuffer11::invalidateBase(const gl::Context *context,
+                                        size_t count,
+                                        const GLenum *attachments,
+                                        bool useEXTBehavior) const
 {
     ID3D11DeviceContext1 *deviceContext1 = mRenderer->getDeviceContext1IfSupported();
 
@@ -183,7 +197,7 @@ gl::Error Framebuffer11::invalidateBase(size_t count, const GLenum *attachments,
                 auto colorAttachment = mState.getColorAttachment(colorIndex);
                 if (colorAttachment)
                 {
-                    ANGLE_TRY(invalidateAttachment(colorAttachment));
+                    ANGLE_TRY(invalidateAttachment(context, colorAttachment));
                 }
                 break;
             }
@@ -216,31 +230,35 @@ gl::Error Framebuffer11::invalidateBase(size_t count, const GLenum *attachments,
 
     if (discardDepth && mState.getDepthAttachment())
     {
-        ANGLE_TRY(invalidateAttachment(mState.getDepthAttachment()));
+        ANGLE_TRY(invalidateAttachment(context, mState.getDepthAttachment()));
     }
 
     if (discardStencil && mState.getStencilAttachment())
     {
-        ANGLE_TRY(invalidateAttachment(mState.getStencilAttachment()));
+        ANGLE_TRY(invalidateAttachment(context, mState.getStencilAttachment()));
     }
 
     return gl::NoError();
 }
 
-gl::Error Framebuffer11::invalidateSub(size_t, const GLenum *, const gl::Rectangle &)
+gl::Error Framebuffer11::invalidateSub(const gl::Context *context,
+                                       size_t,
+                                       const GLenum *,
+                                       const gl::Rectangle &)
 {
     // A no-op implementation conforms to the spec, so don't call UNIMPLEMENTED()
     return gl::NoError();
 }
 
-gl::Error Framebuffer11::invalidateAttachment(const gl::FramebufferAttachment *attachment) const
+gl::Error Framebuffer11::invalidateAttachment(const gl::Context *context,
+                                              const gl::FramebufferAttachment *attachment) const
 {
     ID3D11DeviceContext1 *deviceContext1 = mRenderer->getDeviceContext1IfSupported();
     ASSERT(deviceContext1);
     ASSERT(attachment && attachment->isAttached());
 
     RenderTarget11 *renderTarget = nullptr;
-    ANGLE_TRY(attachment->getRenderTarget(&renderTarget));
+    ANGLE_TRY(attachment->getRenderTarget(context, &renderTarget));
     const auto &rtv = renderTarget->getRenderTargetView();
 
     if (rtv.valid())
@@ -251,7 +269,8 @@ gl::Error Framebuffer11::invalidateAttachment(const gl::FramebufferAttachment *a
     return gl::NoError();
 }
 
-gl::Error Framebuffer11::readPixelsImpl(const gl::Rectangle &area,
+gl::Error Framebuffer11::readPixelsImpl(const gl::Context *context,
+                                        const gl::Rectangle &area,
                                         GLenum format,
                                         GLenum type,
                                         size_t outputPitch,
@@ -268,14 +287,15 @@ gl::Error Framebuffer11::readPixelsImpl(const gl::Rectangle &area,
         PackPixelsParams packParams(area, format, type, static_cast<GLuint>(outputPitch), pack,
                                     reinterpret_cast<ptrdiff_t>(pixels));
 
-        return packBufferStorage->packPixels(*readAttachment, packParams);
+        return packBufferStorage->packPixels(context, *readAttachment, packParams);
     }
 
-    return mRenderer->readFromAttachment(*readAttachment, area, format, type,
+    return mRenderer->readFromAttachment(context, *readAttachment, area, format, type,
                                          static_cast<GLuint>(outputPitch), pack, pixels);
 }
 
-gl::Error Framebuffer11::blitImpl(const gl::Rectangle &sourceArea,
+gl::Error Framebuffer11::blitImpl(const gl::Context *context,
+                                  const gl::Rectangle &sourceArea,
                                   const gl::Rectangle &destArea,
                                   const gl::Rectangle *scissor,
                                   bool blitRenderTarget,
@@ -290,7 +310,7 @@ gl::Error Framebuffer11::blitImpl(const gl::Rectangle &sourceArea,
         ASSERT(readBuffer);
 
         RenderTargetD3D *readRenderTarget = nullptr;
-        ANGLE_TRY(readBuffer->getRenderTarget(&readRenderTarget));
+        ANGLE_TRY(readBuffer->getRenderTarget(context, &readRenderTarget));
         ASSERT(readRenderTarget);
 
         const auto &colorAttachments = mState.getColorAttachments();
@@ -304,7 +324,7 @@ gl::Error Framebuffer11::blitImpl(const gl::Rectangle &sourceArea,
                 drawBufferStates[colorAttachment] != GL_NONE)
             {
                 RenderTargetD3D *drawRenderTarget = nullptr;
-                ANGLE_TRY(drawBuffer.getRenderTarget(&drawRenderTarget));
+                ANGLE_TRY(drawBuffer.getRenderTarget(context, &drawRenderTarget));
                 ASSERT(drawRenderTarget);
 
                 const bool invertColorSource   = UsePresentPathFast(mRenderer, readBuffer);
@@ -326,8 +346,8 @@ gl::Error Framebuffer11::blitImpl(const gl::Rectangle &sourceArea,
                 }
 
                 ANGLE_TRY(mRenderer->blitRenderbufferRect(
-                    actualSourceArea, actualDestArea, readRenderTarget, drawRenderTarget, filter,
-                    scissor, blitRenderTarget, false, false));
+                    context, actualSourceArea, actualDestArea, readRenderTarget, drawRenderTarget,
+                    filter, scissor, blitRenderTarget, false, false));
             }
         }
     }
@@ -338,22 +358,22 @@ gl::Error Framebuffer11::blitImpl(const gl::Rectangle &sourceArea,
         ASSERT(readBuffer);
 
         RenderTargetD3D *readRenderTarget = nullptr;
-        ANGLE_TRY(readBuffer->getRenderTarget(&readRenderTarget));
+        ANGLE_TRY(readBuffer->getRenderTarget(context, &readRenderTarget));
         ASSERT(readRenderTarget);
 
         const gl::FramebufferAttachment *drawBuffer = mState.getDepthOrStencilAttachment();
         ASSERT(drawBuffer);
 
         RenderTargetD3D *drawRenderTarget = nullptr;
-        ANGLE_TRY(drawBuffer->getRenderTarget(&drawRenderTarget));
+        ANGLE_TRY(drawBuffer->getRenderTarget(context, &drawRenderTarget));
         ASSERT(drawRenderTarget);
 
-        ANGLE_TRY(mRenderer->blitRenderbufferRect(sourceArea, destArea, readRenderTarget,
+        ANGLE_TRY(mRenderer->blitRenderbufferRect(context, sourceArea, destArea, readRenderTarget,
                                                   drawRenderTarget, filter, scissor, false,
                                                   blitDepth, blitStencil));
     }
 
-    ANGLE_TRY(markAttachmentsDirty());
+    ANGLE_TRY(markAttachmentsDirty(context));
     return gl::NoError();
 }
 
@@ -363,23 +383,22 @@ GLenum Framebuffer11::getRenderTargetImplementationFormat(RenderTargetD3D *rende
     return renderTarget11->getFormatSet().format().fboImplementationInternalFormat;
 }
 
-void Framebuffer11::updateColorRenderTarget(size_t colorIndex)
+void Framebuffer11::updateColorRenderTarget(const gl::Context *context, size_t colorIndex)
 {
-    UpdateCachedRenderTarget(mState.getColorAttachment(colorIndex),
+    UpdateCachedRenderTarget(context, mState.getColorAttachment(colorIndex),
                              mCachedColorRenderTargets[colorIndex],
                              &mColorRenderTargetsDirty[colorIndex]);
 }
 
-void Framebuffer11::updateDepthStencilRenderTarget()
+void Framebuffer11::updateDepthStencilRenderTarget(const gl::Context *context)
 {
-    UpdateCachedRenderTarget(mState.getDepthOrStencilAttachment(), mCachedDepthStencilRenderTarget,
-                             &mDepthStencilRenderTargetDirty);
+    UpdateCachedRenderTarget(context, mState.getDepthOrStencilAttachment(),
+                             mCachedDepthStencilRenderTarget, &mDepthStencilRenderTargetDirty);
 }
 
-void Framebuffer11::syncState(ContextImpl *contextImpl, const gl::Framebuffer::DirtyBits &dirtyBits)
+void Framebuffer11::syncState(const gl::Context *context,
+                              const gl::Framebuffer::DirtyBits &dirtyBits)
 {
-    mRenderer->getStateManager()->invalidateRenderTarget();
-
     const auto &mergedDirtyBits = dirtyBits | mInternalDirtyBits;
     mInternalDirtyBits.reset();
 
@@ -389,7 +408,7 @@ void Framebuffer11::syncState(ContextImpl *contextImpl, const gl::Framebuffer::D
         {
             case gl::Framebuffer::DIRTY_BIT_DEPTH_ATTACHMENT:
             case gl::Framebuffer::DIRTY_BIT_STENCIL_ATTACHMENT:
-                updateDepthStencilRenderTarget();
+                updateDepthStencilRenderTarget(context);
                 break;
             case gl::Framebuffer::DIRTY_BIT_DRAW_BUFFERS:
             case gl::Framebuffer::DIRTY_BIT_READ_BUFFER:
@@ -400,7 +419,7 @@ void Framebuffer11::syncState(ContextImpl *contextImpl, const gl::Framebuffer::D
                        dirtyBit < gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_MAX);
                 size_t colorIndex =
                     static_cast<size_t>(dirtyBit - gl::Framebuffer::DIRTY_BIT_COLOR_ATTACHMENT_0);
-                updateColorRenderTarget(colorIndex);
+                updateColorRenderTarget(context, colorIndex);
                 break;
             }
         }
@@ -409,7 +428,10 @@ void Framebuffer11::syncState(ContextImpl *contextImpl, const gl::Framebuffer::D
     // We should not have dirtied any additional state during our sync.
     ASSERT(!mInternalDirtyBits.any());
 
-    FramebufferD3D::syncState(contextImpl, dirtyBits);
+    FramebufferD3D::syncState(context, dirtyBits);
+
+    // Call this last to allow the state manager to take advantage of the cached render targets.
+    mRenderer->getStateManager()->invalidateRenderTarget(context);
 }
 
 void Framebuffer11::signal(size_t channelID)
@@ -438,9 +460,23 @@ bool Framebuffer11::hasAnyInternalDirtyBit() const
     return mInternalDirtyBits.any();
 }
 
-void Framebuffer11::syncInternalState(ContextImpl *contextImpl)
+void Framebuffer11::syncInternalState(const gl::Context *context)
+{
+    syncState(context, gl::Framebuffer::DirtyBits());
+}
+
+RenderTarget11 *Framebuffer11::getFirstRenderTarget() const
 {
-    syncState(contextImpl, gl::Framebuffer::DirtyBits());
+    ASSERT(mInternalDirtyBits.none());
+    for (auto *renderTarget : mCachedColorRenderTargets)
+    {
+        if (renderTarget)
+        {
+            return renderTarget;
+        }
+    }
+
+    return mCachedDepthStencilRenderTarget;
 }
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h
index 383caf60d7c..6af6daa600f 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h
@@ -23,14 +23,20 @@ class Framebuffer11 : public FramebufferD3D, public OnRenderTargetDirtyReceiver
     Framebuffer11(const gl::FramebufferState &data, Renderer11 *renderer);
     virtual ~Framebuffer11();
 
-    gl::Error discard(size_t count, const GLenum *attachments) override;
-    gl::Error invalidate(size_t count, const GLenum *attachments) override;
-    gl::Error invalidateSub(size_t count, const GLenum *attachments, const gl::Rectangle &area) override;
+    gl::Error discard(const gl::Context *context, size_t count, const GLenum *attachments) override;
+    gl::Error invalidate(const gl::Context *context,
+                         size_t count,
+                         const GLenum *attachments) override;
+    gl::Error invalidateSub(const gl::Context *context,
+                            size_t count,
+                            const GLenum *attachments,
+                            const gl::Rectangle &area) override;
 
     // Invalidate the cached swizzles of all bound texture attachments.
-    gl::Error markAttachmentsDirty() const;
+    gl::Error markAttachmentsDirty(const gl::Context *context) const;
 
-    void syncState(ContextImpl *contextImpl, const gl::Framebuffer::DirtyBits &dirtyBits) override;
+    void syncState(const gl::Context *context,
+                   const gl::Framebuffer::DirtyBits &dirtyBits) override;
 
     const RenderTargetArray &getCachedColorRenderTargets() const
     {
@@ -41,24 +47,28 @@ class Framebuffer11 : public FramebufferD3D, public OnRenderTargetDirtyReceiver
         return mCachedDepthStencilRenderTarget;
     }
 
+    RenderTarget11 *getFirstRenderTarget() const;
+
     bool hasAnyInternalDirtyBit() const;
-    void syncInternalState(ContextImpl *contextImpl);
+    void syncInternalState(const gl::Context *context);
 
     void signal(size_t channelID) override;
 
     gl::Error getSamplePosition(size_t index, GLfloat *xy) const override;
 
   private:
-    gl::Error clearImpl(ContextImpl *context, const ClearParameters &clearParams) override;
+    gl::Error clearImpl(const gl::Context *context, const ClearParameters &clearParams) override;
 
-    gl::Error readPixelsImpl(const gl::Rectangle &area,
+    gl::Error readPixelsImpl(const gl::Context *context,
+                             const gl::Rectangle &area,
                              GLenum format,
                              GLenum type,
                              size_t outputPitch,
                              const gl::PixelPackState &pack,
                              uint8_t *pixels) const override;
 
-    gl::Error blitImpl(const gl::Rectangle &sourceArea,
+    gl::Error blitImpl(const gl::Context *context,
+                       const gl::Rectangle &sourceArea,
                        const gl::Rectangle &destArea,
                        const gl::Rectangle *scissor,
                        bool blitRenderTarget,
@@ -67,13 +77,17 @@ class Framebuffer11 : public FramebufferD3D, public OnRenderTargetDirtyReceiver
                        GLenum filter,
                        const gl::Framebuffer *sourceFramebuffer) override;
 
-    gl::Error invalidateBase(size_t count, const GLenum *attachments, bool useEXTBehavior) const;
-    gl::Error invalidateAttachment(const gl::FramebufferAttachment *attachment) const;
+    gl::Error invalidateBase(const gl::Context *context,
+                             size_t count,
+                             const GLenum *attachments,
+                             bool useEXTBehavior) const;
+    gl::Error invalidateAttachment(const gl::Context *context,
+                                   const gl::FramebufferAttachment *attachment) const;
 
     GLenum getRenderTargetImplementationFormat(RenderTargetD3D *renderTarget) const override;
 
-    void updateColorRenderTarget(size_t colorIndex);
-    void updateDepthStencilRenderTarget();
+    void updateColorRenderTarget(const gl::Context *context, size_t colorIndex);
+    void updateDepthStencilRenderTarget(const gl::Context *context);
 
     Renderer11 *const mRenderer;
     RenderTargetArray mCachedColorRenderTargets;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp
index 6b9998c52ef..780587f1506 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp
@@ -23,10 +23,88 @@
 namespace rx
 {
 
+namespace
+{
+void CopyColor(gl::ColorF *color)
+{
+    // No-op
+}
+
+void PremultiplyAlpha(gl::ColorF *color)
+{
+    color->red *= color->alpha;
+    color->green *= color->alpha;
+    color->blue *= color->alpha;
+}
+
+void UnmultiplyAlpha(gl::ColorF *color)
+{
+    if (color->alpha != 0.0f)
+    {
+        float invAlpha = 1.0f / color->alpha;
+        color->red *= invAlpha;
+        color->green *= invAlpha;
+        color->blue *= invAlpha;
+    }
+}
+
+void ClipChannelsR(gl::ColorF *color)
+{
+    color->green = 0.0f;
+    color->blue  = 0.0f;
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsRG(gl::ColorF *color)
+{
+    color->blue  = 0.0f;
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsRGB(gl::ColorF *color)
+{
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsLuminance(gl::ColorF *color)
+{
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsAlpha(gl::ColorF *color)
+{
+    color->red   = 0.0f;
+    color->green = 0.0f;
+    color->blue  = 0.0f;
+}
+
+void ClipChannelsNoOp(gl::ColorF *color)
+{
+}
+
+void WriteUintColor(const gl::ColorF &color,
+                    ColorWriteFunction colorWriteFunction,
+                    uint8_t *destPixelData)
+{
+    gl::ColorUI destColor(
+        static_cast<unsigned int>(color.red * 255), static_cast<unsigned int>(color.green * 255),
+        static_cast<unsigned int>(color.red * 255), static_cast<unsigned int>(color.alpha * 255));
+    colorWriteFunction(reinterpret_cast<const uint8_t *>(&destColor), destPixelData);
+}
+
+void WriteFloatColor(const gl::ColorF &color,
+                     ColorWriteFunction colorWriteFunction,
+                     uint8_t *destPixelData)
+{
+    colorWriteFunction(reinterpret_cast<const uint8_t *>(&color), destPixelData);
+}
+
+}  // anonymous namespace
+
 Image11::Image11(Renderer11 *renderer)
     : mRenderer(renderer),
       mDXGIFormat(DXGI_FORMAT_UNKNOWN),
-      mStagingTexture(nullptr),
+      mStagingTexture(),
       mStagingSubresource(0),
       mRecoverFromStorage(false),
       mAssociatedStorage(nullptr),
@@ -41,7 +119,9 @@ Image11::~Image11()
     releaseStagingTexture();
 }
 
-gl::Error Image11::generateMipmap(Image11 *dest,
+// static
+gl::Error Image11::GenerateMipmap(const gl::Context *context,
+                                  Image11 *dest,
                                   Image11 *src,
                                   const Renderer11DeviceCaps &rendererCaps)
 {
@@ -50,10 +130,10 @@ gl::Error Image11::generateMipmap(Image11 *dest,
     ASSERT(src->getHeight() == 1 || src->getHeight() / 2 == dest->getHeight());
 
     D3D11_MAPPED_SUBRESOURCE destMapped;
-    ANGLE_TRY(dest->map(D3D11_MAP_WRITE, &destMapped));
+    ANGLE_TRY(dest->map(context, D3D11_MAP_WRITE, &destMapped));
 
     D3D11_MAPPED_SUBRESOURCE srcMapped;
-    gl::Error error = src->map(D3D11_MAP_READ, &srcMapped);
+    gl::Error error = src->map(context, D3D11_MAP_READ, &srcMapped);
     if (error.isError())
     {
         dest->unmap();
@@ -77,12 +157,129 @@ gl::Error Image11::generateMipmap(Image11 *dest,
     return gl::NoError();
 }
 
+// static
+gl::Error Image11::CopyImage(const gl::Context *context,
+                             Image11 *dest,
+                             Image11 *source,
+                             const gl::Rectangle &sourceRect,
+                             const gl::Offset &destOffset,
+                             bool unpackFlipY,
+                             bool unpackPremultiplyAlpha,
+                             bool unpackUnmultiplyAlpha,
+                             const Renderer11DeviceCaps &rendererCaps)
+{
+    D3D11_MAPPED_SUBRESOURCE destMapped;
+    ANGLE_TRY(dest->map(context, D3D11_MAP_WRITE, &destMapped));
+
+    D3D11_MAPPED_SUBRESOURCE srcMapped;
+    gl::Error error = source->map(context, D3D11_MAP_READ, &srcMapped);
+    if (error.isError())
+    {
+        dest->unmap();
+        return error;
+    }
+
+    const auto &sourceFormat =
+        d3d11::Format::Get(source->getInternalFormat(), rendererCaps).format();
+    GLuint sourcePixelBytes =
+        gl::GetSizedInternalFormatInfo(sourceFormat.fboImplementationInternalFormat).pixelBytes;
+
+    GLenum destUnsizedFormat = gl::GetUnsizedFormat(dest->getInternalFormat());
+    const auto &destFormat = d3d11::Format::Get(dest->getInternalFormat(), rendererCaps).format();
+    const auto &destFormatInfo =
+        gl::GetSizedInternalFormatInfo(destFormat.fboImplementationInternalFormat);
+    GLuint destPixelBytes = destFormatInfo.pixelBytes;
+
+    const uint8_t *sourceData = reinterpret_cast<const uint8_t *>(srcMapped.pData);
+    uint8_t *destData         = reinterpret_cast<uint8_t *>(destMapped.pData);
+
+    using ConversionFunction              = void (*)(gl::ColorF *);
+    ConversionFunction conversionFunction = CopyColor;
+    if (unpackPremultiplyAlpha != unpackUnmultiplyAlpha)
+    {
+        if (unpackPremultiplyAlpha)
+        {
+            conversionFunction = PremultiplyAlpha;
+        }
+        else
+        {
+            conversionFunction = UnmultiplyAlpha;
+        }
+    }
+
+    auto clipChannelsFunction = ClipChannelsNoOp;
+    switch (destUnsizedFormat)
+    {
+        case GL_RED:
+            clipChannelsFunction = ClipChannelsR;
+            break;
+        case GL_RG:
+            clipChannelsFunction = ClipChannelsRG;
+            break;
+        case GL_RGB:
+            clipChannelsFunction = ClipChannelsRGB;
+            break;
+        case GL_LUMINANCE:
+            clipChannelsFunction = ClipChannelsLuminance;
+            break;
+        case GL_ALPHA:
+            clipChannelsFunction = ClipChannelsAlpha;
+            break;
+    }
+
+    auto writeFunction =
+        (destFormatInfo.componentType == GL_UNSIGNED_INT) ? WriteUintColor : WriteFloatColor;
+
+    for (int y = 0; y < sourceRect.height; y++)
+    {
+        for (int x = 0; x < sourceRect.width; x++)
+        {
+            int sourceX = sourceRect.x + x;
+            int sourceY = sourceRect.y + y;
+            const uint8_t *sourcePixelData =
+                sourceData + sourceY * srcMapped.RowPitch + sourceX * sourcePixelBytes;
+
+            gl::ColorF sourceColor;
+            sourceFormat.colorReadFunction(sourcePixelData,
+                                           reinterpret_cast<uint8_t *>(&sourceColor));
+
+            conversionFunction(&sourceColor);
+            clipChannelsFunction(&sourceColor);
+
+            int destX = destOffset.x + x;
+            int destY = destOffset.y;
+            if (unpackFlipY)
+            {
+                destY += (sourceRect.height - 1);
+                destY -= y;
+            }
+            else
+            {
+                destY += y;
+            }
+
+            uint8_t *destPixelData =
+                destData + destY * destMapped.RowPitch + destX * destPixelBytes;
+            writeFunction(sourceColor, destFormat.colorWriteFunction, destPixelData);
+        }
+    }
+
+    dest->unmap();
+    source->unmap();
+
+    dest->markDirty();
+
+    return gl::NoError();
+}
+
 bool Image11::isDirty() const
 {
     // If mDirty is true AND mStagingTexture doesn't exist AND mStagingTexture doesn't need to be
     // recovered from TextureStorage AND the texture doesn't require init data (i.e. a blank new
-    // texture will suffice) then isDirty should still return false.
-    if (mDirty && !mStagingTexture && !mRecoverFromStorage)
+    // texture will suffice) AND robust resource initialization is not enabled then isDirty should
+    // still return false.
+    if (mDirty && !mStagingTexture.valid() && !mRecoverFromStorage &&
+        !mRenderer->isRobustResourceInitEnabled())
     {
         const Renderer11DeviceCaps &deviceCaps = mRenderer->getRenderer11DeviceCaps();
         const auto &formatInfo                 = d3d11::Format::Get(mInternalFormat, deviceCaps);
@@ -95,7 +292,8 @@ bool Image11::isDirty() const
     return mDirty;
 }
 
-gl::Error Image11::copyToStorage(TextureStorage *storage,
+gl::Error Image11::copyToStorage(const gl::Context *context,
+                                 TextureStorage *storage,
                                  const gl::ImageIndex &index,
                                  const gl::Box &region)
 {
@@ -111,14 +309,14 @@ gl::Error Image11::copyToStorage(TextureStorage *storage,
     {
         // If another image is relying on this Storage for its data, then we must let it recover its
         // data before we overwrite it.
-        ANGLE_TRY(storage11->releaseAssociatedImage(index, this));
+        ANGLE_TRY(storage11->releaseAssociatedImage(context, index, this));
     }
 
-    ID3D11Resource *stagingTexture       = nullptr;
+    const TextureHelper11 *stagingTexture = nullptr;
     unsigned int stagingSubresourceIndex = 0;
     ANGLE_TRY(getStagingTexture(&stagingTexture, &stagingSubresourceIndex));
-    ANGLE_TRY(
-        storage11->updateSubresourceLevel(stagingTexture, stagingSubresourceIndex, index, region));
+    ANGLE_TRY(storage11->updateSubresourceLevel(context, *stagingTexture, stagingSubresourceIndex,
+                                                index, region));
 
     // Once the image data has been copied into the Storage, we can release it locally.
     if (attemptToReleaseStagingTexture)
@@ -138,7 +336,7 @@ void Image11::verifyAssociatedStorageValid(TextureStorage11 *textureStorage) con
     ASSERT(mAssociatedStorage == textureStorage);
 }
 
-gl::Error Image11::recoverFromAssociatedStorage()
+gl::Error Image11::recoverFromAssociatedStorage(const gl::Context *context)
 {
     if (mRecoverFromStorage)
     {
@@ -148,8 +346,8 @@ gl::Error Image11::recoverFromAssociatedStorage()
 
         // CopySubResource from the Storage to the Staging texture
         gl::Box region(0, 0, 0, mWidth, mHeight, mDepth);
-        ANGLE_TRY(mAssociatedStorage->copySubresourceLevel(mStagingTexture, mStagingSubresource,
-                                                           mAssociatedImageIndex, region));
+        ANGLE_TRY(mAssociatedStorage->copySubresourceLevel(
+            context, mStagingTexture, mStagingSubresource, mAssociatedImageIndex, region));
         mRecoveredFromStorageCount += 1;
 
         // Reset all the recovery parameters, even if the texture storage association is broken.
@@ -198,7 +396,8 @@ bool Image11::redefine(GLenum target,
         mRenderable = (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN);
 
         releaseStagingTexture();
-        mDirty = (formatInfo.dataInitializerFunction != nullptr);
+        mDirty = (formatInfo.dataInitializerFunction != nullptr) ||
+                 mRenderer->isRobustResourceInitEnabled();
 
         return true;
     }
@@ -218,7 +417,8 @@ DXGI_FORMAT Image11::getDXGIFormat() const
 // Store the pixel rectangle designated by xoffset,yoffset,width,height with pixels stored as
 // format/type at input
 // into the target pixel rectangle.
-gl::Error Image11::loadData(const gl::Box &area,
+gl::Error Image11::loadData(const gl::Context *context,
+                            const gl::Box &area,
                             const gl::PixelUnpackState &unpack,
                             GLenum type,
                             const void *input,
@@ -245,7 +445,7 @@ gl::Error Image11::loadData(const gl::Box &area,
     LoadImageFunction loadFunction = d3dFormatInfo.getLoadFunctions()(type).loadFunction;
 
     D3D11_MAPPED_SUBRESOURCE mappedImage;
-    ANGLE_TRY(map(D3D11_MAP_WRITE, &mappedImage));
+    ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage));
 
     uint8_t *offsetMappedData = (reinterpret_cast<uint8_t *>(mappedImage.pData) +
                                  (area.y * mappedImage.RowPitch + area.x * outputPixelSize +
@@ -259,7 +459,9 @@ gl::Error Image11::loadData(const gl::Box &area,
     return gl::NoError();
 }
 
-gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input)
+gl::Error Image11::loadCompressedData(const gl::Context *context,
+                                      const gl::Box &area,
+                                      const void *input)
 {
     const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(mInternalFormat);
     GLsizei inputRowPitch                = 0;
@@ -281,7 +483,7 @@ gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input)
         d3dFormatInfo.getLoadFunctions()(GL_UNSIGNED_BYTE).loadFunction;
 
     D3D11_MAPPED_SUBRESOURCE mappedImage;
-    ANGLE_TRY(map(D3D11_MAP_WRITE, &mappedImage));
+    ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage));
 
     uint8_t *offsetMappedData =
         reinterpret_cast<uint8_t *>(mappedImage.pData) +
@@ -297,22 +499,23 @@ gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input)
     return gl::NoError();
 }
 
-gl::Error Image11::copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureStorage *source)
+gl::Error Image11::copyFromTexStorage(const gl::Context *context,
+                                      const gl::ImageIndex &imageIndex,
+                                      TextureStorage *source)
 {
     TextureStorage11 *storage11 = GetAs<TextureStorage11>(source);
 
-    ID3D11Resource *resource = nullptr;
-    ANGLE_TRY(storage11->getResource(&resource));
+    const TextureHelper11 *textureHelper = nullptr;
+    ANGLE_TRY(storage11->getResource(context, &textureHelper));
 
     UINT subresourceIndex = storage11->getSubresourceIndex(imageIndex);
-    TextureHelper11 textureHelper =
-        TextureHelper11::MakeAndReference(resource, storage11->getFormatSet());
 
     gl::Box sourceBox(0, 0, 0, mWidth, mHeight, mDepth);
-    return copyWithoutConversion(gl::Offset(), sourceBox, textureHelper, subresourceIndex);
+    return copyWithoutConversion(gl::Offset(), sourceBox, *textureHelper, subresourceIndex);
 }
 
-gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
+gl::Error Image11::copyFromFramebuffer(const gl::Context *context,
+                                       const gl::Offset &destOffset,
                                        const gl::Rectangle &sourceArea,
                                        const gl::Framebuffer *sourceFBO)
 {
@@ -325,14 +528,11 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
 
     if (d3d11Format.texFormat == mDXGIFormat && sourceInternalFormat == mInternalFormat)
     {
-        RenderTargetD3D *renderTarget = nullptr;
-        ANGLE_TRY(srcAttachment->getRenderTarget(&renderTarget));
+        RenderTarget11 *rt11 = nullptr;
+        ANGLE_TRY(srcAttachment->getRenderTarget(context, &rt11));
+        ASSERT(rt11->getTexture().get());
 
-        RenderTarget11 *rt11 = GetAs<RenderTarget11>(renderTarget);
-        ASSERT(rt11->getTexture());
-
-        TextureHelper11 textureHelper =
-            TextureHelper11::MakeAndReference(rt11->getTexture(), rt11->getFormatSet());
+        TextureHelper11 textureHelper  = rt11->getTexture();
         unsigned int sourceSubResource = rt11->getSubresourceIndex();
 
         gl::Box sourceBox(sourceArea.x, sourceArea.y, 0, sourceArea.width, sourceArea.height, 1);
@@ -342,7 +542,7 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
     // This format requires conversion, so we must copy the texture to staging and manually convert
     // via readPixels
     D3D11_MAPPED_SUBRESOURCE mappedImage;
-    ANGLE_TRY(map(D3D11_MAP_WRITE, &mappedImage));
+    ANGLE_TRY(map(context, D3D11_MAP_WRITE, &mappedImage));
 
     // determine the offset coordinate into the destination buffer
     const auto &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat);
@@ -365,9 +565,9 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
         mRenderer->getScratchMemoryBuffer(bufferSize, &memoryBuffer);
         GLuint memoryBufferRowPitch = destFormatInfo.pixelBytes * sourceArea.width;
 
-        error = mRenderer->readFromAttachment(*srcAttachment, sourceArea, destFormatInfo.format,
-                                              destFormatInfo.type, memoryBufferRowPitch,
-                                              gl::PixelPackState(), memoryBuffer->data());
+        error = mRenderer->readFromAttachment(
+            context, *srcAttachment, sourceArea, destFormatInfo.format, destFormatInfo.type,
+            memoryBufferRowPitch, gl::PixelPackState(), memoryBuffer->data());
 
         loadFunction.loadFunction(sourceArea.width, sourceArea.height, 1, memoryBuffer->data(),
                                   memoryBufferRowPitch, 0, dataOffset, mappedImage.RowPitch,
@@ -375,9 +575,9 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset,
     }
     else
     {
-        error = mRenderer->readFromAttachment(*srcAttachment, sourceArea, destFormatInfo.format,
-                                              destFormatInfo.type, mappedImage.RowPitch,
-                                              gl::PixelPackState(), dataOffset);
+        error = mRenderer->readFromAttachment(
+            context, *srcAttachment, sourceArea, destFormatInfo.format, destFormatInfo.type,
+            mappedImage.RowPitch, gl::PixelPackState(), dataOffset);
     }
 
     unmap();
@@ -392,22 +592,23 @@ gl::Error Image11::copyWithoutConversion(const gl::Offset &destOffset,
                                          UINT sourceSubResource)
 {
     // No conversion needed-- use copyback fastpath
-    ID3D11Resource *stagingTexture       = nullptr;
+    const TextureHelper11 *stagingTexture = nullptr;
     unsigned int stagingSubresourceIndex = 0;
     ANGLE_TRY(getStagingTexture(&stagingTexture, &stagingSubresourceIndex));
 
-    ID3D11Device *device               = mRenderer->getDevice();
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
-    UINT subresourceAfterResolve = sourceSubResource;
-
-    ID3D11Resource *srcTex     = nullptr;
     const gl::Extents &extents = textureHelper.getExtents();
 
-    bool needResolve =
-        (textureHelper.getTextureType() == GL_TEXTURE_2D && textureHelper.getSampleCount() > 1);
+    D3D11_BOX srcBox;
+    srcBox.left   = sourceArea.x;
+    srcBox.right  = sourceArea.x + sourceArea.width;
+    srcBox.top    = sourceArea.y;
+    srcBox.bottom = sourceArea.y + sourceArea.height;
+    srcBox.front  = sourceArea.z;
+    srcBox.back   = sourceArea.z + sourceArea.depth;
 
-    if (needResolve)
+    if (textureHelper.is2D() && textureHelper.getSampleCount() > 1)
     {
         D3D11_TEXTURE2D_DESC resolveDesc;
         resolveDesc.Width              = extents.width;
@@ -422,64 +623,45 @@ gl::Error Image11::copyWithoutConversion(const gl::Offset &destOffset,
         resolveDesc.CPUAccessFlags     = 0;
         resolveDesc.MiscFlags          = 0;
 
-        ID3D11Texture2D *srcTex2D = nullptr;
-        HRESULT result            = device->CreateTexture2D(&resolveDesc, nullptr, &srcTex2D);
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create resolve texture for Image11::copy, HRESULT: 0x%X.",
-                             result);
-        }
-        srcTex = srcTex2D;
+        d3d11::Texture2D resolveTex;
+        ANGLE_TRY(mRenderer->allocateResource(resolveDesc, &resolveTex));
 
-        deviceContext->ResolveSubresource(srcTex, 0, textureHelper.getTexture2D(),
+        deviceContext->ResolveSubresource(resolveTex.get(), 0, textureHelper.get(),
                                           sourceSubResource, textureHelper.getFormat());
-        subresourceAfterResolve = 0;
+
+        deviceContext->CopySubresourceRegion(stagingTexture->get(), stagingSubresourceIndex,
+                                             destOffset.x, destOffset.y, destOffset.z,
+                                             resolveTex.get(), 0, &srcBox);
     }
     else
     {
-        srcTex = textureHelper.getResource();
-    }
-
-    D3D11_BOX srcBox;
-    srcBox.left   = sourceArea.x;
-    srcBox.right  = sourceArea.x + sourceArea.width;
-    srcBox.top    = sourceArea.y;
-    srcBox.bottom = sourceArea.y + sourceArea.height;
-    srcBox.front  = sourceArea.z;
-    srcBox.back   = sourceArea.z + sourceArea.depth;
-
-    deviceContext->CopySubresourceRegion(stagingTexture, stagingSubresourceIndex, destOffset.x,
-                                         destOffset.y, destOffset.z, srcTex,
-                                         subresourceAfterResolve, &srcBox);
-
-    if (needResolve)
-    {
-        SafeRelease(srcTex);
+        deviceContext->CopySubresourceRegion(stagingTexture->get(), stagingSubresourceIndex,
+                                             destOffset.x, destOffset.y, destOffset.z,
+                                             textureHelper.get(), sourceSubResource, &srcBox);
     }
 
     mDirty = true;
     return gl::NoError();
 }
 
-gl::Error Image11::getStagingTexture(ID3D11Resource **outStagingTexture,
+gl::Error Image11::getStagingTexture(const TextureHelper11 **outStagingTexture,
                                      unsigned int *outSubresourceIndex)
 {
     ANGLE_TRY(createStagingTexture());
 
-    *outStagingTexture   = mStagingTexture;
+    *outStagingTexture   = &mStagingTexture;
     *outSubresourceIndex = mStagingSubresource;
     return gl::NoError();
 }
 
 void Image11::releaseStagingTexture()
 {
-    SafeRelease(mStagingTexture);
+    mStagingTexture.reset();
 }
 
 gl::Error Image11::createStagingTexture()
 {
-    if (mStagingTexture)
+    if (mStagingTexture.valid())
     {
         return gl::NoError();
     }
@@ -487,9 +669,8 @@ gl::Error Image11::createStagingTexture()
     ASSERT(mWidth > 0 && mHeight > 0 && mDepth > 0);
 
     const DXGI_FORMAT dxgiFormat = getDXGIFormat();
-
-    ID3D11Device *device = mRenderer->getDevice();
-    HRESULT result;
+    const auto &formatInfo =
+        d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps());
 
     int lodOffset  = 1;
     GLsizei width  = mWidth;
@@ -500,8 +681,6 @@ gl::Error Image11::createStagingTexture()
 
     if (mTarget == GL_TEXTURE_3D)
     {
-        ID3D11Texture3D *newTexture = nullptr;
-
         D3D11_TEXTURE3D_DESC desc;
         desc.Width          = width;
         desc.Height         = height;
@@ -513,8 +692,7 @@ gl::Error Image11::createStagingTexture()
         desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
         desc.MiscFlags      = 0;
 
-        if (d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps())
-                .dataInitializerFunction != nullptr)
+        if (formatInfo.dataInitializerFunction != nullptr)
         {
             std::vector<D3D11_SUBRESOURCE_DATA> initialData;
             std::vector<std::vector<BYTE>> textureData;
@@ -522,28 +700,19 @@ gl::Error Image11::createStagingTexture()
                                               width, height, mDepth, lodOffset + 1, &initialData,
                                               &textureData);
 
-            result = device->CreateTexture3D(&desc, initialData.data(), &newTexture);
+            ANGLE_TRY(
+                mRenderer->allocateTexture(desc, formatInfo, initialData.data(), &mStagingTexture));
         }
         else
         {
-            result = device->CreateTexture3D(&desc, nullptr, &newTexture);
+            ANGLE_TRY(mRenderer->allocateTexture(desc, formatInfo, &mStagingTexture));
         }
 
-        if (FAILED(result))
-        {
-            ASSERT(result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create staging texture, result: 0x%X.",
-                             result);
-        }
-
-        mStagingTexture     = newTexture;
         mStagingSubresource = D3D11CalcSubresource(lodOffset, 0, lodOffset + 1);
     }
     else if (mTarget == GL_TEXTURE_2D || mTarget == GL_TEXTURE_2D_ARRAY ||
              mTarget == GL_TEXTURE_CUBE_MAP)
     {
-        ID3D11Texture2D *newTexture = nullptr;
-
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = width;
         desc.Height             = height;
@@ -557,8 +726,7 @@ gl::Error Image11::createStagingTexture()
         desc.CPUAccessFlags     = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
         desc.MiscFlags          = 0;
 
-        if (d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps())
-                .dataInitializerFunction != nullptr)
+        if (formatInfo.dataInitializerFunction != nullptr)
         {
             std::vector<D3D11_SUBRESOURCE_DATA> initialData;
             std::vector<std::vector<BYTE>> textureData;
@@ -566,21 +734,14 @@ gl::Error Image11::createStagingTexture()
                                               width, height, 1, lodOffset + 1, &initialData,
                                               &textureData);
 
-            result = device->CreateTexture2D(&desc, initialData.data(), &newTexture);
+            ANGLE_TRY(
+                mRenderer->allocateTexture(desc, formatInfo, initialData.data(), &mStagingTexture));
         }
         else
         {
-            result = device->CreateTexture2D(&desc, nullptr, &newTexture);
-        }
-
-        if (FAILED(result))
-        {
-            ASSERT(result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create staging texture, result: 0x%X.",
-                             result);
+            ANGLE_TRY(mRenderer->allocateTexture(desc, formatInfo, &mStagingTexture));
         }
 
-        mStagingTexture     = newTexture;
         mStagingSubresource = D3D11CalcSubresource(lodOffset, 0, lodOffset + 1);
     }
     else
@@ -592,19 +753,19 @@ gl::Error Image11::createStagingTexture()
     return gl::NoError();
 }
 
-gl::Error Image11::map(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map)
+gl::Error Image11::map(const gl::Context *context, D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map)
 {
     // We must recover from the TextureStorage if necessary, even for D3D11_MAP_WRITE.
-    ANGLE_TRY(recoverFromAssociatedStorage());
+    ANGLE_TRY(recoverFromAssociatedStorage(context));
 
-    ID3D11Resource *stagingTexture = nullptr;
+    const TextureHelper11 *stagingTexture = nullptr;
     unsigned int subresourceIndex  = 0;
     ANGLE_TRY(getStagingTexture(&stagingTexture, &subresourceIndex));
 
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
-    ASSERT(mStagingTexture);
-    HRESULT result = deviceContext->Map(stagingTexture, subresourceIndex, mapType, 0, map);
+    ASSERT(stagingTexture && stagingTexture->valid());
+    HRESULT result = deviceContext->Map(stagingTexture->get(), subresourceIndex, mapType, 0, map);
 
     if (FAILED(result))
     {
@@ -613,7 +774,7 @@ gl::Error Image11::map(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map)
         {
             mRenderer->notifyDeviceLost();
         }
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to map staging texture, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to map staging texture, " << gl::FmtHR(result);
     }
 
     mDirty = true;
@@ -623,10 +784,10 @@ gl::Error Image11::map(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map)
 
 void Image11::unmap()
 {
-    if (mStagingTexture)
+    if (mStagingTexture.valid())
     {
         ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
-        deviceContext->Unmap(mStagingTexture, mStagingSubresource);
+        deviceContext->Unmap(mStagingTexture.get(), mStagingSubresource);
     }
 }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.h
index 0373043dc0e..1adcf688b75 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.h
@@ -10,10 +10,10 @@
 #ifndef LIBANGLE_RENDERER_D3D_D3D11_IMAGE11_H_
 #define LIBANGLE_RENDERER_D3D_D3D11_IMAGE11_H_
 
-#include "libANGLE/renderer/d3d/ImageD3D.h"
-#include "libANGLE/ImageIndex.h"
-
 #include "common/debug.h"
+#include "libANGLE/ImageIndex.h"
+#include "libANGLE/renderer/d3d/ImageD3D.h"
+#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
 
 namespace gl
 {
@@ -33,36 +33,55 @@ class Image11 : public ImageD3D
     Image11(Renderer11 *renderer);
     virtual ~Image11();
 
-    static gl::Error generateMipmap(Image11 *dest,
+    static gl::Error GenerateMipmap(const gl::Context *context,
+                                    Image11 *dest,
                                     Image11 *src,
                                     const Renderer11DeviceCaps &rendererCaps);
+    static gl::Error CopyImage(const gl::Context *context,
+                               Image11 *dest,
+                               Image11 *source,
+                               const gl::Rectangle &sourceRect,
+                               const gl::Offset &destOffset,
+                               bool unpackFlipY,
+                               bool unpackPremultiplyAlpha,
+                               bool unpackUnmultiplyAlpha,
+                               const Renderer11DeviceCaps &rendererCaps);
 
     virtual bool isDirty() const;
 
-    virtual gl::Error copyToStorage(TextureStorage *storage, const gl::ImageIndex &index, const gl::Box &region);
+    gl::Error copyToStorage(const gl::Context *context,
+                            TextureStorage *storage,
+                            const gl::ImageIndex &index,
+                            const gl::Box &region) override;
 
     bool redefine(GLenum target, GLenum internalformat, const gl::Extents &size, bool forceRelease) override;
 
     DXGI_FORMAT getDXGIFormat() const;
 
-    gl::Error loadData(const gl::Box &area,
+    gl::Error loadData(const gl::Context *context,
+                       const gl::Box &area,
                        const gl::PixelUnpackState &unpack,
                        GLenum type,
                        const void *input,
                        bool applySkipImages) override;
-    gl::Error loadCompressedData(const gl::Box &area, const void *input) override;
-
-    gl::Error copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureStorage *source) override;
-    gl::Error copyFromFramebuffer(const gl::Offset &destOffset,
+    gl::Error loadCompressedData(const gl::Context *context,
+                                 const gl::Box &area,
+                                 const void *input) override;
+
+    gl::Error copyFromTexStorage(const gl::Context *context,
+                                 const gl::ImageIndex &imageIndex,
+                                 TextureStorage *source) override;
+    gl::Error copyFromFramebuffer(const gl::Context *context,
+                                  const gl::Offset &destOffset,
                                   const gl::Rectangle &sourceArea,
                                   const gl::Framebuffer *source) override;
 
-    gl::Error recoverFromAssociatedStorage();
+    gl::Error recoverFromAssociatedStorage(const gl::Context *context);
     void verifyAssociatedStorageValid(TextureStorage11 *textureStorage) const;
     void disassociateStorage();
 
   protected:
-    gl::Error map(D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map);
+    gl::Error map(const gl::Context *context, D3D11_MAP mapType, D3D11_MAPPED_SUBRESOURCE *map);
     void unmap();
 
   private:
@@ -71,14 +90,15 @@ class Image11 : public ImageD3D
                                     const TextureHelper11 &textureHelper,
                                     UINT sourceSubResource);
 
-    gl::Error getStagingTexture(ID3D11Resource **outStagingTexture, unsigned int *outSubresourceIndex);
+    gl::Error getStagingTexture(const TextureHelper11 **outStagingTexture,
+                                unsigned int *outSubresourceIndex);
     gl::Error createStagingTexture();
     void releaseStagingTexture();
 
     Renderer11 *mRenderer;
 
     DXGI_FORMAT mDXGIFormat;
-    ID3D11Resource *mStagingTexture;
+    TextureHelper11 mStagingTexture;
     unsigned int mStagingSubresource;
 
     bool mRecoverFromStorage;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp
index 3238c962ac3..a79fb71f710 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp
@@ -14,28 +14,23 @@
 namespace rx
 {
 
-IndexBuffer11::IndexBuffer11(Renderer11 *const renderer) : mRenderer(renderer)
+IndexBuffer11::IndexBuffer11(Renderer11 *const renderer)
+    : mRenderer(renderer), mBuffer(), mBufferSize(0), mIndexType(GL_NONE), mDynamicUsage(false)
 {
-    mBuffer       = nullptr;
-    mBufferSize = 0;
-    mDynamicUsage = false;
 }
 
 IndexBuffer11::~IndexBuffer11()
 {
-    SafeRelease(mBuffer);
 }
 
 gl::Error IndexBuffer11::initialize(unsigned int bufferSize, GLenum indexType, bool dynamic)
 {
-    SafeRelease(mBuffer);
+    mBuffer.reset();
 
     updateSerial();
 
     if (bufferSize > 0)
     {
-        ID3D11Device* dxDevice = mRenderer->getDevice();
-
         D3D11_BUFFER_DESC bufferDesc;
         bufferDesc.ByteWidth = bufferSize;
         bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
@@ -44,19 +39,15 @@ gl::Error IndexBuffer11::initialize(unsigned int bufferSize, GLenum indexType, b
         bufferDesc.MiscFlags = 0;
         bufferDesc.StructureByteStride = 0;
 
-        HRESULT result = dxDevice->CreateBuffer(&bufferDesc, nullptr, &mBuffer);
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal index buffer of size, %lu.", bufferSize);
-        }
+        ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &mBuffer));
 
         if (dynamic)
         {
-            d3d11::SetDebugName(mBuffer, "IndexBuffer11 (dynamic)");
+            mBuffer.setDebugName("IndexBuffer11 (dynamic)");
         }
         else
         {
-            d3d11::SetDebugName(mBuffer, "IndexBuffer11 (static)");
+            mBuffer.setDebugName("IndexBuffer11 (static)");
         }
     }
 
@@ -69,24 +60,25 @@ gl::Error IndexBuffer11::initialize(unsigned int bufferSize, GLenum indexType, b
 
 gl::Error IndexBuffer11::mapBuffer(unsigned int offset, unsigned int size, void** outMappedMemory)
 {
-    if (!mBuffer)
+    if (!mBuffer.valid())
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal index buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal index buffer is not initialized.";
     }
 
     // Check for integer overflows and out-out-bounds map requests
     if (offset + size < offset || offset + size > mBufferSize)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Index buffer map range is not inside the buffer.");
+        return gl::OutOfMemory() << "Index buffer map range is not inside the buffer.";
     }
 
     ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
 
     D3D11_MAPPED_SUBRESOURCE mappedResource;
-    HRESULT result = dxContext->Map(mBuffer, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mappedResource);
+    HRESULT result =
+        dxContext->Map(mBuffer.get(), 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mappedResource);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal index buffer, HRESULT: 0x%08x.", result);
+        return gl::OutOfMemory() << "Failed to map internal index buffer, " << gl::FmtHR(result);
     }
 
     *outMappedMemory = reinterpret_cast<char*>(mappedResource.pData) + offset;
@@ -95,13 +87,13 @@ gl::Error IndexBuffer11::mapBuffer(unsigned int offset, unsigned int size, void*
 
 gl::Error IndexBuffer11::unmapBuffer()
 {
-    if (!mBuffer)
+    if (!mBuffer.valid())
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal index buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal index buffer is not initialized.";
     }
 
     ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
-    dxContext->Unmap(mBuffer, 0);
+    dxContext->Unmap(mBuffer.get(), 0);
     return gl::NoError();
 }
 
@@ -129,21 +121,21 @@ gl::Error IndexBuffer11::setSize(unsigned int bufferSize, GLenum indexType)
 
 gl::Error IndexBuffer11::discard()
 {
-    if (!mBuffer)
+    if (!mBuffer.valid())
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal index buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal index buffer is not initialized.";
     }
 
     ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
 
     D3D11_MAPPED_SUBRESOURCE mappedResource;
-    HRESULT result = dxContext->Map(mBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    HRESULT result = dxContext->Map(mBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal index buffer, HRESULT: 0x%08x.", result);
+        return gl::OutOfMemory() << "Failed to map internal index buffer, " << gl::FmtHR(result);
     }
 
-    dxContext->Unmap(mBuffer, 0);
+    dxContext->Unmap(mBuffer.get(), 0);
 
     return gl::NoError();
 }
@@ -159,9 +151,9 @@ DXGI_FORMAT IndexBuffer11::getIndexFormat() const
     }
 }
 
-ID3D11Buffer *IndexBuffer11::getBuffer() const
+const d3d11::Buffer &IndexBuffer11::getBuffer() const
 {
     return mBuffer;
 }
 
-}
+}  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.h
index e730377e00c..6c7260f2690 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.h
@@ -10,6 +10,7 @@
 #define LIBANGLE_RENDERER_D3D_D3D11_INDEXBUFFER11_H_
 
 #include "libANGLE/renderer/d3d/IndexBuffer.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
 
 namespace rx
 {
@@ -33,17 +34,17 @@ class IndexBuffer11 : public IndexBuffer
     virtual gl::Error discard();
 
     DXGI_FORMAT getIndexFormat() const;
-    ID3D11Buffer *getBuffer() const;
+    const d3d11::Buffer &getBuffer() const;
 
   private:
     Renderer11 *const mRenderer;
 
-    ID3D11Buffer *mBuffer;
+    d3d11::Buffer mBuffer;
     unsigned int mBufferSize;
     GLenum mIndexType;
     bool mDynamicUsage;
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_INDEXBUFFER11_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp
index c5a39907584..1064f865300 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp
@@ -10,6 +10,7 @@
 #include "libANGLE/renderer/d3d/d3d11/InputLayoutCache.h"
 
 #include "common/bitset_utils.h"
+#include "common/third_party/murmurhash/MurmurHash3.h"
 #include "common/utilities.h"
 #include "libANGLE/Program.h"
 #include "libANGLE/VertexArray.h"
@@ -22,7 +23,6 @@
 #include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h"
 #include "libANGLE/renderer/d3d/d3d11/VertexBuffer11.h"
 #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
-#include "third_party/murmurhash/MurmurHash3.h"
 
 namespace rx
 {
@@ -72,8 +72,6 @@ GLenum GetGLSLAttributeType(const std::vector<sh::Attribute> &shaderAttributes,
     return GL_NONE;
 }
 
-const unsigned int kDefaultCacheSize = 1024;
-
 struct PackedAttribute
 {
     uint8_t attribType;
@@ -132,11 +130,14 @@ void SortAttributesByLayout(const gl::Program *program,
 
 } // anonymous namespace
 
-void InputLayoutCache::PackedAttributeLayout::addAttributeData(
-    GLenum glType,
-    UINT semanticIndex,
-    gl::VertexFormatType vertexFormatType,
-    unsigned int divisor)
+PackedAttributeLayout::PackedAttributeLayout() : numAttributes(0), flags(0), attributeData({})
+{
+}
+
+void PackedAttributeLayout::addAttributeData(GLenum glType,
+                                             UINT semanticIndex,
+                                             gl::VertexFormatType vertexFormatType,
+                                             unsigned int divisor)
 {
     gl::AttributeType attribType = gl::GetAttributeType(glType);
 
@@ -156,64 +157,27 @@ void InputLayoutCache::PackedAttributeLayout::addAttributeData(
     attributeData[numAttributes++] = gl::bitCast<uint32_t>(packedAttrib);
 }
 
-bool InputLayoutCache::PackedAttributeLayout::operator<(const PackedAttributeLayout &other) const
+bool PackedAttributeLayout::operator==(const PackedAttributeLayout &other) const
 {
-    if (numAttributes != other.numAttributes)
-    {
-        return numAttributes < other.numAttributes;
-    }
-
-    if (flags != other.flags)
-    {
-        return flags < other.flags;
-    }
-
-    return memcmp(attributeData, other.attributeData, sizeof(uint32_t) * numAttributes) < 0;
+    return (numAttributes == other.numAttributes) && (flags == other.flags) &&
+           (attributeData == other.attributeData);
 }
 
 InputLayoutCache::InputLayoutCache()
-    : mCurrentIL(angle::DirtyPointer),
-      mPointSpriteVertexBuffer(nullptr),
-      mPointSpriteIndexBuffer(nullptr),
-      mCacheSize(kDefaultCacheSize)
+    : mLayoutCache(kDefaultCacheSize * 2), mPointSpriteVertexBuffer(), mPointSpriteIndexBuffer()
 {
-    mCurrentBuffers.fill(nullptr);
-    mCurrentVertexStrides.fill(std::numeric_limits<UINT>::max());
-    mCurrentVertexOffsets.fill(std::numeric_limits<UINT>::max());
     mCurrentAttributes.reserve(gl::MAX_VERTEX_ATTRIBS);
 }
 
 InputLayoutCache::~InputLayoutCache()
 {
-    clear();
-}
-
-void InputLayoutCache::initialize()
-{
-    clear();
 }
 
 void InputLayoutCache::clear()
 {
-    for (auto &layout : mLayoutMap)
-    {
-        SafeRelease(layout.second);
-    }
-    mLayoutMap.clear();
-    SafeRelease(mPointSpriteVertexBuffer);
-    SafeRelease(mPointSpriteIndexBuffer);
-    markDirty();
-}
-
-void InputLayoutCache::markDirty()
-{
-    mCurrentIL = angle::DirtyPointer;
-    for (unsigned int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
-    {
-        mCurrentBuffers[i]       = nullptr;
-        mCurrentVertexStrides[i] = static_cast<UINT>(-1);
-        mCurrentVertexOffsets[i] = static_cast<UINT>(-1);
-    }
+    mLayoutCache.Clear();
+    mPointSpriteVertexBuffer.reset();
+    mPointSpriteIndexBuffer.reset();
 }
 
 gl::Error InputLayoutCache::applyVertexBuffers(
@@ -227,7 +191,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(
     GLsizei numIndicesPerInstance)
 {
     ID3D11DeviceContext *deviceContext = renderer->getDeviceContext();
-    ID3D11Device *device               = renderer->getDevice();
+    auto *stateManager                 = renderer->getStateManager();
 
     gl::Program *program   = state.getProgram();
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
@@ -259,10 +223,6 @@ gl::Error InputLayoutCache::applyVertexBuffers(
     ANGLE_TRY(
         updateInputLayout(renderer, state, mode, sortedSemanticIndices, numIndicesPerInstance));
 
-    bool dirtyBuffers = false;
-    size_t minDiff    = gl::MAX_VERTEX_ATTRIBS;
-    size_t maxDiff    = 0;
-
     // Note that if we use instance emulation, we reserve the first buffer slot.
     size_t reservedBuffers = GetReservedBufferCount(programUsesInstancedPointSprites);
 
@@ -285,7 +245,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(
             if (bufferStorage == nullptr)
             {
                 ASSERT(attrib.vertexBuffer.get());
-                buffer = GetAs<VertexBuffer11>(attrib.vertexBuffer.get())->getBuffer();
+                buffer = GetAs<VertexBuffer11>(attrib.vertexBuffer.get())->getBuffer().get();
             }
             else if (instancedPointSpritesActive && (indexInfo != nullptr))
             {
@@ -317,18 +277,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(
 
         size_t bufferIndex = reservedBuffers + attribIndex;
 
-        if (buffer != mCurrentBuffers[bufferIndex] ||
-            vertexStride != mCurrentVertexStrides[bufferIndex] ||
-            vertexOffset != mCurrentVertexOffsets[bufferIndex])
-        {
-            dirtyBuffers = true;
-            minDiff      = std::min(minDiff, bufferIndex);
-            maxDiff      = std::max(maxDiff, bufferIndex);
-
-            mCurrentBuffers[bufferIndex]       = buffer;
-            mCurrentVertexStrides[bufferIndex] = vertexStride;
-            mCurrentVertexOffsets[bufferIndex] = vertexOffset;
-        }
+        stateManager->queueVertexBufferChange(bufferIndex, buffer, vertexStride, vertexOffset);
     }
 
     // Instanced PointSprite emulation requires two additional ID3D11Buffers. A vertex buffer needs
@@ -342,7 +291,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(
     {
         const UINT pointSpriteVertexStride = sizeof(float) * 5;
 
-        if (!mPointSpriteVertexBuffer)
+        if (!mPointSpriteVertexBuffer.valid())
         {
             static const float pointSpriteVertices[] =
             {
@@ -364,26 +313,16 @@ gl::Error InputLayoutCache::applyVertexBuffers(
             vertexBufferDesc.MiscFlags = 0;
             vertexBufferDesc.StructureByteStride = 0;
 
-            HRESULT result = device->CreateBuffer(&vertexBufferDesc, &vertexBufferData,
-                                                  &mPointSpriteVertexBuffer);
-            if (FAILED(result))
-            {
-                return gl::Error(GL_OUT_OF_MEMORY, "Failed to create instanced pointsprite emulation vertex buffer, HRESULT: 0x%08x", result);
-            }
+            ANGLE_TRY(renderer->allocateResource(vertexBufferDesc, &vertexBufferData,
+                                                 &mPointSpriteVertexBuffer));
         }
 
-        mCurrentBuffers[0] = mPointSpriteVertexBuffer;
         // Set the stride to 0 if GL_POINTS mode is not being used to instruct the driver to avoid
         // indexing into the vertex buffer.
-        mCurrentVertexStrides[0] = instancedPointSpritesActive ? pointSpriteVertexStride : 0;
-        mCurrentVertexOffsets[0] = 0;
-
-        // Update maxDiff to include the additional point sprite vertex buffer
-        // to ensure that IASetVertexBuffers uses the correct buffer count.
-        minDiff = 0;
-        maxDiff = std::max(maxDiff, static_cast<size_t>(0));
+        UINT stride = instancedPointSpritesActive ? pointSpriteVertexStride : 0;
+        stateManager->queueVertexBufferChange(0, mPointSpriteVertexBuffer.get(), stride, 0);
 
-        if (!mPointSpriteIndexBuffer)
+        if (!mPointSpriteIndexBuffer.valid())
         {
             // Create an index buffer and set it for pointsprite rendering
             static const unsigned short pointSpriteIndices[] =
@@ -400,13 +339,8 @@ gl::Error InputLayoutCache::applyVertexBuffers(
             indexBufferDesc.MiscFlags = 0;
             indexBufferDesc.StructureByteStride = 0;
 
-            HRESULT result =
-                device->CreateBuffer(&indexBufferDesc, &indexBufferData, &mPointSpriteIndexBuffer);
-            if (FAILED(result))
-            {
-                SafeRelease(mPointSpriteVertexBuffer);
-                return gl::Error(GL_OUT_OF_MEMORY, "Failed to create instanced pointsprite emulation index buffer, HRESULT: 0x%08x", result);
-            }
+            ANGLE_TRY(renderer->allocateResource(indexBufferDesc, &indexBufferData,
+                                                 &mPointSpriteIndexBuffer));
         }
 
         if (instancedPointSpritesActive)
@@ -415,19 +349,11 @@ gl::Error InputLayoutCache::applyVertexBuffers(
             // non-indexed rendering path in ANGLE (DrawArrays). This means that applyIndexBuffer()
             // on the renderer will not be called and setting this buffer here ensures that the
             // rendering path will contain the correct index buffers.
-            deviceContext->IASetIndexBuffer(mPointSpriteIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
+            deviceContext->IASetIndexBuffer(mPointSpriteIndexBuffer.get(), DXGI_FORMAT_R16_UINT, 0);
         }
     }
 
-    if (dirtyBuffers)
-    {
-        ASSERT(minDiff <= maxDiff && maxDiff < gl::MAX_VERTEX_ATTRIBS);
-        deviceContext->IASetVertexBuffers(
-            static_cast<UINT>(minDiff), static_cast<UINT>(maxDiff - minDiff + 1),
-            &mCurrentBuffers[minDiff], &mCurrentVertexStrides[minDiff],
-            &mCurrentVertexOffsets[minDiff]);
-    }
-
+    stateManager->applyVertexBufferChanges();
     return gl::NoError();
 }
 
@@ -435,6 +361,8 @@ gl::Error InputLayoutCache::updateVertexOffsetsForPointSpritesEmulation(Renderer
                                                                         GLint startVertex,
                                                                         GLsizei emulatedInstanceId)
 {
+    auto *stateManager = renderer->getStateManager();
+
     size_t reservedBuffers = GetReservedBufferCount(true);
     for (size_t attribIndex = 0; attribIndex < mCurrentAttributes.size(); ++attribIndex)
     {
@@ -445,15 +373,12 @@ gl::Error InputLayoutCache::updateVertexOffsetsForPointSpritesEmulation(Renderer
         {
             unsigned int offset = 0;
             ANGLE_TRY_RESULT(attrib.computeOffset(startVertex), offset);
-            mCurrentVertexOffsets[bufferIndex] =
-                offset + (attrib.stride * (emulatedInstanceId / attrib.divisor));
+            offset += (attrib.stride * (emulatedInstanceId / attrib.divisor));
+            stateManager->queueVertexOffsetChange(bufferIndex, offset);
         }
     }
 
-    ID3D11DeviceContext *deviceContext = renderer->getDeviceContext();
-    deviceContext->IASetVertexBuffers(0, gl::MAX_VERTEX_ATTRIBS, mCurrentBuffers.data(),
-                                      mCurrentVertexStrides.data(), mCurrentVertexOffsets.data());
-
+    stateManager->applyVertexBufferChanges();
     return gl::NoError();
 }
 
@@ -505,51 +430,32 @@ gl::Error InputLayoutCache::updateInputLayout(Renderer11 *renderer,
             state.getVertexAttribCurrentValue(static_cast<unsigned int>(attribIndex));
         gl::VertexFormatType vertexFormatType = gl::GetVertexFormatType(attrib, currentValue.Type);
 
-        layout.addAttributeData(glslElementType, d3dSemantic, vertexFormatType, binding.divisor);
+        layout.addAttributeData(glslElementType, d3dSemantic, vertexFormatType,
+                                binding.getDivisor());
     }
 
-    ID3D11InputLayout *inputLayout = nullptr;
+    const d3d11::InputLayout *inputLayout = nullptr;
     if (layout.numAttributes > 0 || layout.flags != 0)
     {
-        auto layoutMapIt = mLayoutMap.find(layout);
-        if (layoutMapIt != mLayoutMap.end())
+        auto it = mLayoutCache.Get(layout);
+        if (it != mLayoutCache.end())
         {
-            inputLayout = layoutMapIt->second;
+            inputLayout = &it->second;
         }
         else
         {
-            ANGLE_TRY(createInputLayout(renderer, sortedSemanticIndices, mode, program,
-                                        numIndicesPerInstance, &inputLayout));
-            if (mLayoutMap.size() >= mCacheSize)
-            {
-                WARN() << "Overflowed the limit of " << mCacheSize
-                       << " input layouts, purging half the cache.";
+            angle::TrimCache(mLayoutCache.max_size() / 2, kGCLimit, "input layout", &mLayoutCache);
 
-                // Randomly release every second element
-                auto it = mLayoutMap.begin();
-                while (it != mLayoutMap.end())
-                {
-                    it++;
-                    if (it != mLayoutMap.end())
-                    {
-                        // c++11 erase allows us to easily delete the current iterator.
-                        SafeRelease(it->second);
-                        it = mLayoutMap.erase(it);
-                    }
-                }
-            }
+            d3d11::InputLayout newInputLayout;
+            ANGLE_TRY(createInputLayout(renderer, sortedSemanticIndices, mode, program,
+                                        numIndicesPerInstance, &newInputLayout));
 
-            mLayoutMap[layout] = inputLayout;
+            auto insertIt = mLayoutCache.Put(layout, std::move(newInputLayout));
+            inputLayout   = &insertIt->second;
         }
     }
 
-    if (reinterpret_cast<uintptr_t>(inputLayout) != mCurrentIL)
-    {
-        ID3D11DeviceContext *deviceContext = renderer->getDeviceContext();
-        deviceContext->IASetInputLayout(inputLayout);
-        mCurrentIL = reinterpret_cast<uintptr_t>(inputLayout);
-    }
-
+    renderer->getStateManager()->setInputLayout(inputLayout);
     return gl::NoError();
 }
 
@@ -558,7 +464,7 @@ gl::Error InputLayoutCache::createInputLayout(Renderer11 *renderer,
                                               GLenum mode,
                                               gl::Program *program,
                                               GLsizei numIndicesPerInstance,
-                                              ID3D11InputLayout **inputLayoutOut)
+                                              d3d11::InputLayout *inputLayoutOut)
 {
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
     auto featureLevel      = renderer->getRenderer11DeviceCaps().featureLevel;
@@ -648,16 +554,18 @@ gl::Error InputLayoutCache::createInputLayout(Renderer11 *renderer,
 
     ShaderExecutableD3D *shader11 = GetAs<ShaderExecutable11>(shader);
 
-    ID3D11Device *device = renderer->getDevice();
-    HRESULT result =
-        device->CreateInputLayout(inputElements.data(), inputElementCount, shader11->getFunction(),
-                                  shader11->getLength(), inputLayoutOut);
-    if (FAILED(result))
-    {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to create internal input layout, HRESULT: 0x%08x", result);
-    }
+    InputElementArray inputElementArray(inputElements.data(), inputElementCount);
+    ShaderData vertexShaderData(shader11->getFunction(), shader11->getLength());
+
+    ANGLE_TRY(renderer->allocateResource(inputElementArray, &vertexShaderData, inputLayoutOut));
     return gl::NoError();
 }
 
+void InputLayoutCache::setCacheSize(size_t newCacheSize)
+{
+    // Forces a reset of the cache.
+    LayoutCache newCache(newCacheSize);
+    mLayoutCache.Swap(newCache);
+}
+
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h
index dfce3e3d305..b8b29ebcac7 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h
@@ -20,13 +20,32 @@
 #include "common/angleutils.h"
 #include "libANGLE/Constants.h"
 #include "libANGLE/Error.h"
+#include "libANGLE/SizedMRUCache.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
+
+namespace rx
+{
+struct PackedAttributeLayout;
+}  // namespace rx
+
+namespace std
+{
+template <>
+struct hash<rx::PackedAttributeLayout>
+{
+    size_t operator()(const rx::PackedAttributeLayout &value) const
+    {
+        return angle::ComputeGenericHash(value);
+    }
+};
+}  // namespace std
 
 namespace gl
 {
 class Program;
-}
+}  // namespace gl
 
 namespace rx
 {
@@ -36,15 +55,35 @@ struct SourceIndexData;
 class ProgramD3D;
 class Renderer11;
 
+struct PackedAttributeLayout
+{
+    PackedAttributeLayout();
+    void addAttributeData(GLenum glType,
+                          UINT semanticIndex,
+                          gl::VertexFormatType vertexFormatType,
+                          unsigned int divisor);
+
+    bool operator==(const PackedAttributeLayout &other) const;
+
+    enum Flags
+    {
+        FLAG_USES_INSTANCED_SPRITES     = 0x1,
+        FLAG_INSTANCED_SPRITES_ACTIVE   = 0x2,
+        FLAG_INSTANCED_RENDERING_ACTIVE = 0x4,
+    };
+
+    size_t numAttributes;
+    unsigned int flags;
+    std::array<uint32_t, gl::MAX_VERTEX_ATTRIBS> attributeData;
+};
+
 class InputLayoutCache : angle::NonCopyable
 {
   public:
     InputLayoutCache();
-    virtual ~InputLayoutCache();
+    ~InputLayoutCache();
 
-    void initialize();
     void clear();
-    void markDirty();
 
     gl::Error applyVertexBuffers(Renderer11 *renderer,
                                  const gl::State &state,
@@ -60,36 +99,9 @@ class InputLayoutCache : angle::NonCopyable
                                                           GLsizei emulatedInstanceId);
 
     // Useful for testing
-    void setCacheSize(unsigned int cacheSize) { mCacheSize = cacheSize; }
+    void setCacheSize(size_t newCacheSize);
 
   private:
-    struct PackedAttributeLayout
-    {
-        PackedAttributeLayout()
-            : numAttributes(0),
-              flags(0)
-        {
-        }
-
-        void addAttributeData(GLenum glType,
-                              UINT semanticIndex,
-                              gl::VertexFormatType vertexFormatType,
-                              unsigned int divisor);
-
-        bool operator<(const PackedAttributeLayout &other) const;
-
-        enum Flags
-        {
-            FLAG_USES_INSTANCED_SPRITES     = 0x1,
-            FLAG_INSTANCED_SPRITES_ACTIVE   = 0x2,
-            FLAG_INSTANCED_RENDERING_ACTIVE = 0x4,
-        };
-
-        size_t numAttributes;
-        unsigned int flags;
-        uint32_t attributeData[gl::MAX_VERTEX_ATTRIBS];
-    };
-
     gl::Error updateInputLayout(Renderer11 *renderer,
                                 const gl::State &state,
                                 GLenum mode,
@@ -100,20 +112,21 @@ class InputLayoutCache : angle::NonCopyable
                                 GLenum mode,
                                 gl::Program *program,
                                 GLsizei numIndicesPerInstance,
-                                ID3D11InputLayout **inputLayoutOut);
+                                d3d11::InputLayout *inputLayoutOut);
 
-    std::map<PackedAttributeLayout, ID3D11InputLayout *> mLayoutMap;
+    // Starting cache size.
+    static constexpr size_t kDefaultCacheSize = 1024;
 
-    uintptr_t mCurrentIL;
-    std::array<ID3D11Buffer *, gl::MAX_VERTEX_ATTRIBS> mCurrentBuffers;
-    std::array<UINT, gl::MAX_VERTEX_ATTRIBS> mCurrentVertexStrides;
-    std::array<UINT, gl::MAX_VERTEX_ATTRIBS> mCurrentVertexOffsets;
-    std::vector<const TranslatedAttribute *> mCurrentAttributes;
+    // The cache tries to clean up this many states at once.
+    static constexpr size_t kGCLimit = 128;
 
-    ID3D11Buffer *mPointSpriteVertexBuffer;
-    ID3D11Buffer *mPointSpriteIndexBuffer;
+    using LayoutCache = angle::base::HashingMRUCache<PackedAttributeLayout, d3d11::InputLayout>;
+    LayoutCache mLayoutCache;
+
+    std::vector<const TranslatedAttribute *> mCurrentAttributes;
 
-    unsigned int mCacheSize;
+    d3d11::Buffer mPointSpriteVertexBuffer;
+    d3d11::Buffer mPointSpriteIndexBuffer;
 };
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp
index e82b7ba1107..a6f02d1c6a2 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp
@@ -36,28 +36,16 @@ namespace rx
 PixelTransfer11::PixelTransfer11(Renderer11 *renderer)
     : mRenderer(renderer),
       mResourcesLoaded(false),
-      mBufferToTextureVS(nullptr),
-      mBufferToTextureGS(nullptr),
-      mParamsConstantBuffer(nullptr),
-      mCopyRasterizerState(nullptr),
-      mCopyDepthStencilState(nullptr)
+      mBufferToTextureVS(),
+      mBufferToTextureGS(),
+      mParamsConstantBuffer(),
+      mCopyRasterizerState(),
+      mCopyDepthStencilState()
 {
 }
 
 PixelTransfer11::~PixelTransfer11()
 {
-    for (auto shaderMapIt = mBufferToTexturePSMap.begin(); shaderMapIt != mBufferToTexturePSMap.end(); shaderMapIt++)
-    {
-        SafeRelease(shaderMapIt->second);
-    }
-
-    mBufferToTexturePSMap.clear();
-
-    SafeRelease(mBufferToTextureVS);
-    SafeRelease(mBufferToTextureGS);
-    SafeRelease(mParamsConstantBuffer);
-    SafeRelease(mCopyRasterizerState);
-    SafeRelease(mCopyDepthStencilState);
 }
 
 gl::Error PixelTransfer11::loadResources()
@@ -67,9 +55,6 @@ gl::Error PixelTransfer11::loadResources()
         return gl::NoError();
     }
 
-    HRESULT result = S_OK;
-    ID3D11Device *device = mRenderer->getDevice();
-
     D3D11_RASTERIZER_DESC rasterDesc;
     rasterDesc.FillMode = D3D11_FILL_SOLID;
     rasterDesc.CullMode = D3D11_CULL_NONE;
@@ -82,12 +67,7 @@ gl::Error PixelTransfer11::loadResources()
     rasterDesc.MultisampleEnable = FALSE;
     rasterDesc.AntialiasedLineEnable = FALSE;
 
-    result = device->CreateRasterizerState(&rasterDesc, &mCopyRasterizerState);
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal pixel transfer rasterizer state, result: 0x%X.", result);
-    }
+    ANGLE_TRY(mRenderer->allocateResource(rasterDesc, &mCopyRasterizerState));
 
     D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
     depthStencilDesc.DepthEnable = true;
@@ -105,12 +85,7 @@ gl::Error PixelTransfer11::loadResources()
     depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
     depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 
-    result = device->CreateDepthStencilState(&depthStencilDesc, &mCopyDepthStencilState);
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal pixel transfer depth stencil state, result: 0x%X.", result);
-    }
+    ANGLE_TRY(mRenderer->allocateResource(depthStencilDesc, &mCopyDepthStencilState));
 
     D3D11_BUFFER_DESC constantBufferDesc = { 0 };
     constantBufferDesc.ByteWidth = roundUp<UINT>(sizeof(CopyShaderParams), 32u);
@@ -120,26 +95,15 @@ gl::Error PixelTransfer11::loadResources()
     constantBufferDesc.MiscFlags = 0;
     constantBufferDesc.StructureByteStride = 0;
 
-    result = device->CreateBuffer(&constantBufferDesc, nullptr, &mParamsConstantBuffer);
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal pixel transfer constant buffer, result: 0x%X.", result);
-    }
-    d3d11::SetDebugName(mParamsConstantBuffer, "PixelTransfer11 constant buffer");
+    ANGLE_TRY(mRenderer->allocateResource(constantBufferDesc, &mParamsConstantBuffer));
+    mParamsConstantBuffer.setDebugName("PixelTransfer11 constant buffer");
 
     // init shaders
-    mBufferToTextureVS = d3d11::CompileVS(device, g_VS_BufferToTexture, "BufferToTexture VS");
-    if (!mBufferToTextureVS)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture vertex shader.");
-    }
+    ANGLE_TRY(mRenderer->allocateResource(ShaderData(g_VS_BufferToTexture), &mBufferToTextureVS));
+    mBufferToTextureVS.setDebugName("BufferToTexture VS");
 
-    mBufferToTextureGS = d3d11::CompileGS(device, g_GS_BufferToTexture, "BufferToTexture GS");
-    if (!mBufferToTextureGS)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture geometry shader.");
-    }
+    ANGLE_TRY(mRenderer->allocateResource(ShaderData(g_GS_BufferToTexture), &mBufferToTextureGS));
+    mBufferToTextureGS.setDebugName("BufferToTexture GS");
 
     ANGLE_TRY(buildShaderMap());
 
@@ -173,8 +137,13 @@ void PixelTransfer11::setBufferToTextureCopyParams(const gl::Box &destArea, cons
     parametersOut->FirstSlice           = destArea.z;
 }
 
-gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
-                                               GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea)
+gl::Error PixelTransfer11::copyBufferToTexture(const gl::Context *context,
+                                               const gl::PixelUnpackState &unpack,
+                                               unsigned int offset,
+                                               RenderTargetD3D *destRenderTarget,
+                                               GLenum destinationFormat,
+                                               GLenum sourcePixelsType,
+                                               const gl::Box &destArea)
 {
     ANGLE_TRY(loadResources());
 
@@ -188,7 +157,7 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
 
     ASSERT(mRenderer->supportsFastCopyBufferToTexture(destinationFormat));
 
-    ID3D11PixelShader *pixelShader = findBufferToTexturePS(destinationFormat);
+    const d3d11::PixelShader *pixelShader = findBufferToTexturePS(destinationFormat);
     ASSERT(pixelShader);
 
     // The SRV must be in the proper read format, which may be different from the destination format
@@ -216,34 +185,30 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
 
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
-    ID3D11Buffer *nullBuffer = nullptr;
-    UINT zero = 0;
-
     // Are we doing a 2D or 3D copy?
-    ID3D11GeometryShader *geometryShader = ((destSize.depth > 1) ? mBufferToTextureGS : nullptr);
-    auto stateManager                    = mRenderer->getStateManager();
+    const auto *geometryShader = ((destSize.depth > 1) ? &mBufferToTextureGS : nullptr);
+    auto stateManager          = mRenderer->getStateManager();
 
-    deviceContext->VSSetShader(mBufferToTextureVS, nullptr, 0);
-    deviceContext->GSSetShader(geometryShader, nullptr, 0);
-    deviceContext->PSSetShader(pixelShader, nullptr, 0);
+    stateManager->setDrawShaders(&mBufferToTextureVS, geometryShader, pixelShader);
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, bufferSRV);
-    deviceContext->IASetInputLayout(nullptr);
-    deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
+    stateManager->setInputLayout(nullptr);
+    stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
 
-    deviceContext->IASetVertexBuffers(0, 1, &nullBuffer, &zero, &zero);
+    stateManager->setSingleVertexBuffer(nullptr, 0, 0);
     deviceContext->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);
-    deviceContext->OMSetDepthStencilState(mCopyDepthStencilState, 0xFFFFFFFF);
-    deviceContext->RSSetState(mCopyRasterizerState);
+    deviceContext->OMSetDepthStencilState(mCopyDepthStencilState.get(), 0xFFFFFFFF);
+    deviceContext->RSSetState(mCopyRasterizerState.get());
 
-    stateManager->setOneTimeRenderTarget(textureRTV.get(), nullptr);
+    stateManager->setOneTimeRenderTarget(context, textureRTV.get(), nullptr);
 
     if (!StructEquals(mParamsData, shaderParams))
     {
-        d3d11::SetBufferData(deviceContext, mParamsConstantBuffer, shaderParams);
+        d3d11::SetBufferData(deviceContext, mParamsConstantBuffer.get(), shaderParams);
         mParamsData = shaderParams;
     }
 
-    deviceContext->VSSetConstantBuffers(0, 1, &mParamsConstantBuffer);
+    ID3D11Buffer *paramsBuffer = mParamsConstantBuffer.get();
+    deviceContext->VSSetConstantBuffers(0, 1, &paramsBuffer);
 
     // Set the viewport
     D3D11_VIEWPORT viewport;
@@ -258,36 +223,42 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
     UINT numPixels = (destArea.width * destArea.height * destArea.depth);
     deviceContext->Draw(numPixels, 0);
 
-    // Unbind textures and render targets and vertex buffer
+    // Unbind shader resources and invalidate state.
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
+
+    ID3D11Buffer *nullBuffer = nullptr;
     deviceContext->VSSetConstantBuffers(0, 1, &nullBuffer);
 
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
 
     return gl::NoError();
 }
 
 gl::Error PixelTransfer11::buildShaderMap()
 {
-    ID3D11Device *device = mRenderer->getDevice();
+    d3d11::PixelShader bufferToTextureFloat;
+    d3d11::PixelShader bufferToTextureInt;
+    d3d11::PixelShader bufferToTextureUint;
 
-    mBufferToTexturePSMap[GL_FLOAT]        = d3d11::CompilePS(device, g_PS_BufferToTexture_4F,  "BufferToTexture RGBA ps");
-    mBufferToTexturePSMap[GL_INT]          = d3d11::CompilePS(device, g_PS_BufferToTexture_4I,  "BufferToTexture RGBA-I ps");
-    mBufferToTexturePSMap[GL_UNSIGNED_INT] = d3d11::CompilePS(device, g_PS_BufferToTexture_4UI, "BufferToTexture RGBA-UI ps");
+    ANGLE_TRY(
+        mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4F), &bufferToTextureFloat));
+    ANGLE_TRY(
+        mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4I), &bufferToTextureInt));
+    ANGLE_TRY(
+        mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4UI), &bufferToTextureUint));
 
-    // Check that all the shaders were created successfully
-    for (auto shaderMapIt = mBufferToTexturePSMap.begin(); shaderMapIt != mBufferToTexturePSMap.end(); shaderMapIt++)
-    {
-        if (shaderMapIt->second == nullptr)
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture pixel shader.");
-        }
-    }
+    bufferToTextureFloat.setDebugName("BufferToTexture RGBA ps");
+    bufferToTextureInt.setDebugName("BufferToTexture RGBA-I ps");
+    bufferToTextureUint.setDebugName("BufferToTexture RGBA-UI ps");
+
+    mBufferToTexturePSMap[GL_FLOAT]        = std::move(bufferToTextureFloat);
+    mBufferToTexturePSMap[GL_INT]          = std::move(bufferToTextureInt);
+    mBufferToTexturePSMap[GL_UNSIGNED_INT] = std::move(bufferToTextureUint);
 
     return gl::NoError();
 }
 
-ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat) const
+const d3d11::PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat) const
 {
     GLenum componentType = gl::GetSizedInternalFormatInfo(internalFormat).componentType;
     if (componentType == GL_SIGNED_NORMALIZED || componentType == GL_UNSIGNED_NORMALIZED)
@@ -296,7 +267,7 @@ ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat)
     }
 
     auto shaderMapIt = mBufferToTexturePSMap.find(componentType);
-    return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : shaderMapIt->second);
+    return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : &shaderMapIt->second);
 }
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h
index 1672121ec7f..a93544247ee 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h
@@ -11,14 +11,14 @@
 #ifndef LIBANGLE_RENDERER_D3D_D3D11_PIXELTRANSFER11_H_
 #define LIBANGLE_RENDERER_D3D_D3D11_PIXELTRANSFER11_H_
 
-#include "libANGLE/Error.h"
-
-#include "common/platform.h"
-
 #include <GLES2/gl2.h>
 
 #include <map>
 
+#include "common/platform.h"
+#include "libANGLE/Error.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
+
 namespace gl
 {
 
@@ -45,8 +45,13 @@ class PixelTransfer11
     // destRenderTarget: individual slice/layer of a target texture
     // destinationFormat/sourcePixelsType: determines shaders + shader parameters
     // destArea: the sub-section of destRenderTarget to copy to
-    gl::Error copyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
-                                  GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea);
+    gl::Error copyBufferToTexture(const gl::Context *context,
+                                  const gl::PixelUnpackState &unpack,
+                                  unsigned int offset,
+                                  RenderTargetD3D *destRenderTarget,
+                                  GLenum destinationFormat,
+                                  GLenum sourcePixelsType,
+                                  const gl::Box &destArea);
 
   private:
 
@@ -68,22 +73,21 @@ class PixelTransfer11
 
     gl::Error loadResources();
     gl::Error buildShaderMap();
-    ID3D11PixelShader *findBufferToTexturePS(GLenum internalFormat) const;
+    const d3d11::PixelShader *findBufferToTexturePS(GLenum internalFormat) const;
 
     Renderer11 *mRenderer;
 
     bool mResourcesLoaded;
-    std::map<GLenum, ID3D11PixelShader *> mBufferToTexturePSMap;
-    ID3D11VertexShader *mBufferToTextureVS;
-    ID3D11GeometryShader *mBufferToTextureGS;
-    ID3D11Buffer *mParamsConstantBuffer;
+    std::map<GLenum, d3d11::PixelShader> mBufferToTexturePSMap;
+    d3d11::VertexShader mBufferToTextureVS;
+    d3d11::GeometryShader mBufferToTextureGS;
+    d3d11::Buffer mParamsConstantBuffer;
     CopyShaderParams mParamsData;
 
-    ID3D11RasterizerState *mCopyRasterizerState;
-    ID3D11DepthStencilState *mCopyDepthStencilState;
-
+    d3d11::RasterizerState mCopyRasterizerState;
+    d3d11::DepthStencilState mCopyDepthStencilState;
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_PIXELTRANSFER11_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.cpp
index 5c7961d513a..66b9476e7f4 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.cpp
@@ -48,16 +48,12 @@ GLuint64 MergeQueryResults(GLenum type, GLuint64 currentResult, GLuint64 newResu
 namespace rx
 {
 
-Query11::QueryState::QueryState()
-    : query(nullptr), beginTimestamp(nullptr), endTimestamp(nullptr), finished(false)
+Query11::QueryState::QueryState() : query(), beginTimestamp(), endTimestamp(), finished(false)
 {
 }
 
 Query11::QueryState::~QueryState()
 {
-    SafeRelease(beginTimestamp);
-    SafeRelease(endTimestamp);
-    SafeRelease(query);
 }
 
 Query11::Query11(Renderer11 *renderer, GLenum type)
@@ -95,7 +91,7 @@ gl::Error Query11::queryCounter()
 template <typename T>
 gl::Error Query11::getResultBase(T *params)
 {
-    ASSERT(mActiveQuery->query == nullptr);
+    ASSERT(!mActiveQuery->query.valid());
     ANGLE_TRY(flush(true));
     ASSERT(mPendingQueries.empty());
     *params = static_cast<T>(mResultSum);
@@ -133,7 +129,7 @@ gl::Error Query11::isResultAvailable(bool *available)
 
 gl::Error Query11::pause()
 {
-    if (mActiveQuery->query != nullptr)
+    if (mActiveQuery->query.valid())
     {
         ID3D11DeviceContext *context = mRenderer->getDeviceContext();
         GLenum queryType             = getType();
@@ -141,10 +137,10 @@ gl::Error Query11::pause()
         // If we are doing time elapsed query the end timestamp
         if (queryType == GL_TIME_ELAPSED_EXT)
         {
-            context->End(mActiveQuery->endTimestamp);
+            context->End(mActiveQuery->endTimestamp.get());
         }
 
-        context->End(mActiveQuery->query);
+        context->End(mActiveQuery->query.get());
 
         mPendingQueries.push_back(std::move(mActiveQuery));
         mActiveQuery = std::unique_ptr<QueryState>(new QueryState());
@@ -155,7 +151,7 @@ gl::Error Query11::pause()
 
 gl::Error Query11::resume()
 {
-    if (mActiveQuery->query == nullptr)
+    if (!mActiveQuery->query.valid())
     {
         ANGLE_TRY(flush(false));
 
@@ -166,14 +162,7 @@ gl::Error Query11::resume()
         queryDesc.Query     = d3dQueryType;
         queryDesc.MiscFlags = 0;
 
-        ID3D11Device *device = mRenderer->getDevice();
-
-        HRESULT result = device->CreateQuery(&queryDesc, &mActiveQuery->query);
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Internal query creation failed, result: 0x%X.",
-                             result);
-        }
+        ANGLE_TRY(mRenderer->allocateResource(queryDesc, &mActiveQuery->query));
 
         // If we are doing time elapsed we also need a query to actually query the timestamp
         if (queryType == GL_TIME_ELAPSED_EXT)
@@ -181,31 +170,22 @@ gl::Error Query11::resume()
             D3D11_QUERY_DESC desc;
             desc.Query     = D3D11_QUERY_TIMESTAMP;
             desc.MiscFlags = 0;
-            result         = device->CreateQuery(&desc, &mActiveQuery->beginTimestamp);
-            if (FAILED(result))
-            {
-                return gl::Error(GL_OUT_OF_MEMORY, "Internal query creation failed, result: 0x%X.",
-                                 result);
-            }
-            result = device->CreateQuery(&desc, &mActiveQuery->endTimestamp);
-            if (FAILED(result))
-            {
-                return gl::Error(GL_OUT_OF_MEMORY, "Internal query creation failed, result: 0x%X.",
-                                 result);
-            }
+
+            ANGLE_TRY(mRenderer->allocateResource(desc, &mActiveQuery->beginTimestamp));
+            ANGLE_TRY(mRenderer->allocateResource(desc, &mActiveQuery->endTimestamp));
         }
 
         ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
         if (d3dQueryType != D3D11_QUERY_EVENT)
         {
-            context->Begin(mActiveQuery->query);
+            context->Begin(mActiveQuery->query.get());
         }
 
         // If we are doing time elapsed, query the begin timestamp
         if (queryType == GL_TIME_ELAPSED_EXT)
         {
-            context->End(mActiveQuery->beginTimestamp);
+            context->End(mActiveQuery->beginTimestamp.get());
         }
     }
 
@@ -244,15 +224,14 @@ gl::Error Query11::testQuery(QueryState *queryState)
             case GL_ANY_SAMPLES_PASSED_EXT:
             case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
             {
-                ASSERT(queryState->query);
+                ASSERT(queryState->query.valid());
                 UINT64 numPixels = 0;
                 HRESULT result =
-                    context->GetData(queryState->query, &numPixels, sizeof(numPixels), 0);
+                    context->GetData(queryState->query.get(), &numPixels, sizeof(numPixels), 0);
                 if (FAILED(result))
                 {
-                    return gl::Error(GL_OUT_OF_MEMORY,
-                                     "Failed to get the data of an internal query, result: 0x%X.",
-                                     result);
+                    return gl::OutOfMemory()
+                           << "Failed to get the data of an internal query, " << gl::FmtHR(result);
                 }
 
                 if (result == S_OK)
@@ -265,14 +244,14 @@ gl::Error Query11::testQuery(QueryState *queryState)
 
             case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
             {
-                ASSERT(queryState->query);
+                ASSERT(queryState->query.valid());
                 D3D11_QUERY_DATA_SO_STATISTICS soStats = {0};
-                HRESULT result = context->GetData(queryState->query, &soStats, sizeof(soStats), 0);
+                HRESULT result =
+                    context->GetData(queryState->query.get(), &soStats, sizeof(soStats), 0);
                 if (FAILED(result))
                 {
-                    return gl::Error(GL_OUT_OF_MEMORY,
-                                     "Failed to get the data of an internal query, result: 0x%X.",
-                                     result);
+                    return gl::OutOfMemory()
+                           << "Failed to get the data of an internal query, " << gl::FmtHR(result);
                 }
 
                 if (result == S_OK)
@@ -285,38 +264,35 @@ gl::Error Query11::testQuery(QueryState *queryState)
 
             case GL_TIME_ELAPSED_EXT:
             {
-                ASSERT(queryState->query);
-                ASSERT(queryState->beginTimestamp);
-                ASSERT(queryState->endTimestamp);
+                ASSERT(queryState->query.valid());
+                ASSERT(queryState->beginTimestamp.valid());
+                ASSERT(queryState->endTimestamp.valid());
                 D3D11_QUERY_DATA_TIMESTAMP_DISJOINT timeStats = {0};
                 HRESULT result =
-                    context->GetData(queryState->query, &timeStats, sizeof(timeStats), 0);
+                    context->GetData(queryState->query.get(), &timeStats, sizeof(timeStats), 0);
                 if (FAILED(result))
                 {
-                    return gl::Error(GL_OUT_OF_MEMORY,
-                                     "Failed to get the data of an internal query, result: 0x%X.",
-                                     result);
+                    return gl::OutOfMemory()
+                           << "Failed to get the data of an internal query, " << gl::FmtHR(result);
                 }
 
                 if (result == S_OK)
                 {
                     UINT64 beginTime = 0;
-                    HRESULT beginRes =
-                        context->GetData(queryState->beginTimestamp, &beginTime, sizeof(UINT64), 0);
+                    HRESULT beginRes = context->GetData(queryState->beginTimestamp.get(),
+                                                        &beginTime, sizeof(UINT64), 0);
                     if (FAILED(beginRes))
                     {
-                        return gl::Error(
-                            GL_OUT_OF_MEMORY,
-                            "Failed to get the data of an internal query, result: 0x%X.", beginRes);
+                        return gl::OutOfMemory() << "Failed to get the data of an internal query, "
+                                                 << gl::FmtHR(beginRes);
                     }
                     UINT64 endTime = 0;
-                    HRESULT endRes =
-                        context->GetData(queryState->endTimestamp, &endTime, sizeof(UINT64), 0);
+                    HRESULT endRes = context->GetData(queryState->endTimestamp.get(), &endTime,
+                                                      sizeof(UINT64), 0);
                     if (FAILED(endRes))
                     {
-                        return gl::Error(
-                            GL_OUT_OF_MEMORY,
-                            "Failed to get the data of an internal query, result: 0x%X.", endRes);
+                        return gl::OutOfMemory() << "Failed to get the data of an internal query, "
+                                                 << gl::FmtHR(endRes);
                     }
 
                     if (beginRes == S_OK && endRes == S_OK)
@@ -354,7 +330,7 @@ gl::Error Query11::testQuery(QueryState *queryState)
                 // D3D11 doesn't support GL timestamp queries as D3D timestamps are not guaranteed
                 // to have any sort of continuity outside of a disjoint timestamp query block, which
                 // GL depends on
-                ASSERT(queryState->query == nullptr);
+                ASSERT(!queryState->query.valid());
                 mResult              = 0;
                 queryState->finished = true;
             }
@@ -362,15 +338,14 @@ gl::Error Query11::testQuery(QueryState *queryState)
 
             case GL_COMMANDS_COMPLETED_CHROMIUM:
             {
-                ASSERT(queryState->query);
+                ASSERT(queryState->query.valid());
                 BOOL completed = 0;
                 HRESULT result =
-                    context->GetData(queryState->query, &completed, sizeof(completed), 0);
+                    context->GetData(queryState->query.get(), &completed, sizeof(completed), 0);
                 if (FAILED(result))
                 {
-                    return gl::Error(GL_OUT_OF_MEMORY,
-                                     "Failed to get the data of an internal query, result: 0x%X.",
-                                     result);
+                    return gl::OutOfMemory()
+                           << "Failed to get the data of an internal query, " << gl::FmtHR(result);
                 }
 
                 if (result == S_OK)
@@ -390,7 +365,7 @@ gl::Error Query11::testQuery(QueryState *queryState)
         if (!queryState->finished && mRenderer->testDeviceLost())
         {
             mRenderer->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to test get query result, device is lost.");
+            return gl::OutOfMemory() << "Failed to test get query result, device is lost.";
         }
     }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.h
index 9b6fcf661ea..a88a8892aae 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Query11.h
@@ -12,6 +12,7 @@
 #include <deque>
 
 #include "libANGLE/renderer/QueryImpl.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
 
 namespace rx
 {
@@ -41,9 +42,9 @@ class Query11 : public QueryImpl
         QueryState();
         ~QueryState();
 
-        ID3D11Query *query;
-        ID3D11Query *beginTimestamp;
-        ID3D11Query *endTimestamp;
+        d3d11::Query query;
+        d3d11::Query beginTimestamp;
+        d3d11::Query endTimestamp;
         bool finished;
     };
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp
index c76d98366e5..4b35610138d 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp
@@ -12,93 +12,45 @@
 #include <float.h>
 
 #include "common/debug.h"
+#include "common/third_party/murmurhash/MurmurHash3.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
 #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
 #include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
-#include "third_party/murmurhash/MurmurHash3.h"
 
 namespace rx
 {
 using namespace gl_d3d11;
 
-template <typename mapType>
-static void ClearStateMap(mapType &map)
-{
-    for (typename mapType::iterator i = map.begin(); i != map.end(); i++)
-    {
-        SafeRelease(i->second.first);
-    }
-    map.clear();
-}
-
-// MSDN's documentation of ID3D11Device::CreateBlendState, ID3D11Device::CreateRasterizerState,
-// ID3D11Device::CreateDepthStencilState and ID3D11Device::CreateSamplerState claims the maximum
-// number of unique states of each type an application can create is 4096
-// TODO(ShahmeerEsmail): Revisit the cache sizes to make sure they are appropriate for most
-// scenarios.
-const unsigned int RenderStateCache::kMaxBlendStates        = 2048;
-const unsigned int RenderStateCache::kMaxRasterizerStates   = 2048;
-const unsigned int RenderStateCache::kMaxDepthStencilStates = 2048;
-const unsigned int RenderStateCache::kMaxSamplerStates      = 2048;
-
-RenderStateCache::RenderStateCache(Renderer11 *renderer)
-    : mRenderer(renderer),
-      mCounter(0),
-      mBlendStateCache(kMaxBlendStates, HashBlendState, CompareBlendStates),
-      mRasterizerStateCache(kMaxRasterizerStates, HashRasterizerState, CompareRasterizerStates),
-      mDepthStencilStateCache(kMaxDepthStencilStates,
-                              HashDepthStencilState,
-                              CompareDepthStencilStates),
-      mSamplerStateCache(kMaxSamplerStates, HashSamplerState, CompareSamplerStates),
-      mDevice(nullptr)
+RenderStateCache::RenderStateCache()
+    : mBlendStateCache(kMaxStates),
+      mRasterizerStateCache(kMaxStates),
+      mDepthStencilStateCache(kMaxStates),
+      mSamplerStateCache(kMaxStates)
 {
 }
 
 RenderStateCache::~RenderStateCache()
 {
-    clear();
-}
-
-void RenderStateCache::initialize(ID3D11Device *device)
-{
-    clear();
-    mDevice = device;
 }
 
 void RenderStateCache::clear()
 {
-    ClearStateMap(mBlendStateCache);
-    ClearStateMap(mRasterizerStateCache);
-    ClearStateMap(mDepthStencilStateCache);
-    ClearStateMap(mSamplerStateCache);
-}
-
-// static
-std::size_t RenderStateCache::HashBlendState(const d3d11::BlendStateKey &blendState)
-{
-    static const unsigned int seed = 0xABCDEF98;
-
-    std::size_t hash = 0;
-    MurmurHash3_x86_32(&blendState, sizeof(d3d11::BlendStateKey), seed, &hash);
-    return hash;
-}
-
-// static
-bool RenderStateCache::CompareBlendStates(const d3d11::BlendStateKey &a,
-                                          const d3d11::BlendStateKey &b)
-{
-    return memcmp(&a, &b, sizeof(d3d11::BlendStateKey)) == 0;
+    mBlendStateCache.Clear();
+    mRasterizerStateCache.Clear();
+    mDepthStencilStateCache.Clear();
+    mSamplerStateCache.Clear();
 }
 
 // static
-d3d11::BlendStateKey RenderStateCache::GetBlendStateKey(const gl::Framebuffer *framebuffer,
+d3d11::BlendStateKey RenderStateCache::GetBlendStateKey(const gl::Context *context,
+                                                        const gl::Framebuffer *framebuffer,
                                                         const gl::BlendState &blendState)
 {
     d3d11::BlendStateKey key;
-    const FramebufferD3D *framebufferD3D   = GetImplAs<FramebufferD3D>(framebuffer);
-    const gl::AttachmentList &colorbuffers = framebufferD3D->getColorAttachmentsForRender();
+    FramebufferD3D *framebufferD3D         = GetImplAs<FramebufferD3D>(framebuffer);
+    const gl::AttachmentList &colorbuffers = framebufferD3D->getColorAttachmentsForRender(context);
     const UINT8 blendStateMask =
         gl_d3d11::ConvertColorMask(blendState.colorMaskRed, blendState.colorMaskGreen,
                                    blendState.colorMaskBlue, blendState.colorMaskAlpha);
@@ -134,229 +86,125 @@ d3d11::BlendStateKey RenderStateCache::GetBlendStateKey(const gl::Framebuffer *f
     return key;
 }
 
-gl::Error RenderStateCache::getBlendState(const d3d11::BlendStateKey &key,
+gl::Error RenderStateCache::getBlendState(Renderer11 *renderer,
+                                          const d3d11::BlendStateKey &key,
                                           ID3D11BlendState **outBlendState)
 {
-    if (!mDevice)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal error, RenderStateCache is not initialized.");
-    }
-
-    BlendStateMap::iterator keyIter = mBlendStateCache.find(key);
+    auto keyIter = mBlendStateCache.Get(key);
     if (keyIter != mBlendStateCache.end())
     {
-        BlendStateCounterPair &state = keyIter->second;
-        state.second = mCounter++;
-        *outBlendState = state.first;
+        *outBlendState = keyIter->second.get();
         return gl::NoError();
     }
-    else
-    {
-        if (mBlendStateCache.size() >= kMaxBlendStates)
-        {
-            WARN() << "Overflowed the limit of " << kMaxBlendStates
-                   << " blend states, removing the least recently used to make room.";
-
-            BlendStateMap::iterator leastRecentlyUsed = mBlendStateCache.begin();
-            for (BlendStateMap::iterator i = mBlendStateCache.begin(); i != mBlendStateCache.end(); i++)
-            {
-                if (i->second.second < leastRecentlyUsed->second.second)
-                {
-                    leastRecentlyUsed = i;
-                }
-            }
-            SafeRelease(leastRecentlyUsed->second.first);
-            mBlendStateCache.erase(leastRecentlyUsed);
-        }
-
-        // Create a new blend state and insert it into the cache
-        D3D11_BLEND_DESC blendDesc;
-        D3D11_RENDER_TARGET_BLEND_DESC &rtDesc0 = blendDesc.RenderTarget[0];
-        const gl::BlendState &blendState        = key.blendState;
 
-        blendDesc.AlphaToCoverageEnable  = blendState.sampleAlphaToCoverage;
-        blendDesc.IndependentBlendEnable = key.mrt ? TRUE : FALSE;
+    TrimCache(kMaxStates, kGCLimit, "blend state", &mBlendStateCache);
 
-        rtDesc0 = {};
+    // Create a new blend state and insert it into the cache
+    D3D11_BLEND_DESC blendDesc;
+    D3D11_RENDER_TARGET_BLEND_DESC &rtDesc0 = blendDesc.RenderTarget[0];
+    const gl::BlendState &blendState        = key.blendState;
 
-        if (blendState.blend)
-        {
-            rtDesc0.BlendEnable    = true;
-            rtDesc0.SrcBlend       = gl_d3d11::ConvertBlendFunc(blendState.sourceBlendRGB, false);
-            rtDesc0.DestBlend      = gl_d3d11::ConvertBlendFunc(blendState.destBlendRGB, false);
-            rtDesc0.BlendOp        = gl_d3d11::ConvertBlendOp(blendState.blendEquationRGB);
-            rtDesc0.SrcBlendAlpha  = gl_d3d11::ConvertBlendFunc(blendState.sourceBlendAlpha, true);
-            rtDesc0.DestBlendAlpha = gl_d3d11::ConvertBlendFunc(blendState.destBlendAlpha, true);
-            rtDesc0.BlendOpAlpha   = gl_d3d11::ConvertBlendOp(blendState.blendEquationAlpha);
-        }
+    blendDesc.AlphaToCoverageEnable  = blendState.sampleAlphaToCoverage;
+    blendDesc.IndependentBlendEnable = key.mrt ? TRUE : FALSE;
 
-        rtDesc0.RenderTargetWriteMask = key.rtvMasks[0];
-
-        for (unsigned int i = 1; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
-        {
-            blendDesc.RenderTarget[i]                       = rtDesc0;
-            blendDesc.RenderTarget[i].RenderTargetWriteMask = key.rtvMasks[i];
-        }
+    rtDesc0 = {};
 
-        HRESULT result = mDevice->CreateBlendState(&blendDesc, outBlendState);
-        if (FAILED(result) || !(*outBlendState))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Unable to create a ID3D11BlendState, HRESULT: 0x%X.", result);
-        }
+    if (blendState.blend)
+    {
+        rtDesc0.BlendEnable    = true;
+        rtDesc0.SrcBlend       = gl_d3d11::ConvertBlendFunc(blendState.sourceBlendRGB, false);
+        rtDesc0.DestBlend      = gl_d3d11::ConvertBlendFunc(blendState.destBlendRGB, false);
+        rtDesc0.BlendOp        = gl_d3d11::ConvertBlendOp(blendState.blendEquationRGB);
+        rtDesc0.SrcBlendAlpha  = gl_d3d11::ConvertBlendFunc(blendState.sourceBlendAlpha, true);
+        rtDesc0.DestBlendAlpha = gl_d3d11::ConvertBlendFunc(blendState.destBlendAlpha, true);
+        rtDesc0.BlendOpAlpha   = gl_d3d11::ConvertBlendOp(blendState.blendEquationAlpha);
+    }
 
-        mBlendStateCache.insert(std::make_pair(key, std::make_pair(*outBlendState, mCounter++)));
+    rtDesc0.RenderTargetWriteMask = key.rtvMasks[0];
 
-        return gl::NoError();
+    for (unsigned int i = 1; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+    {
+        blendDesc.RenderTarget[i]                       = rtDesc0;
+        blendDesc.RenderTarget[i].RenderTargetWriteMask = key.rtvMasks[i];
     }
-}
 
-// static
-std::size_t RenderStateCache::HashRasterizerState(const RasterizerStateKey &rasterState)
-{
-    static const unsigned int seed = 0xABCDEF98;
-
-    std::size_t hash = 0;
-    MurmurHash3_x86_32(&rasterState, sizeof(RasterizerStateKey), seed, &hash);
-    return hash;
-}
+    d3d11::BlendState d3dBlendState;
+    ANGLE_TRY(renderer->allocateResource(blendDesc, &d3dBlendState));
+    *outBlendState = d3dBlendState.get();
+    mBlendStateCache.Put(key, std::move(d3dBlendState));
 
-// static
-bool RenderStateCache::CompareRasterizerStates(const RasterizerStateKey &a, const RasterizerStateKey &b)
-{
-    return memcmp(&a, &b, sizeof(RasterizerStateKey)) == 0;
+    return gl::NoError();
 }
 
-gl::Error RenderStateCache::getRasterizerState(const gl::RasterizerState &rasterState, bool scissorEnabled,
+gl::Error RenderStateCache::getRasterizerState(Renderer11 *renderer,
+                                               const gl::RasterizerState &rasterState,
+                                               bool scissorEnabled,
                                                ID3D11RasterizerState **outRasterizerState)
 {
-    if (!mDevice)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal error, RenderStateCache is not initialized.");
-    }
-
-    RasterizerStateKey key = {};
+    d3d11::RasterizerStateKey key;
     key.rasterizerState = rasterState;
     key.scissorEnabled = scissorEnabled;
 
-    RasterizerStateMap::iterator keyIter = mRasterizerStateCache.find(key);
+    auto keyIter = mRasterizerStateCache.Get(key);
     if (keyIter != mRasterizerStateCache.end())
     {
-        RasterizerStateCounterPair &state = keyIter->second;
-        state.second = mCounter++;
-        *outRasterizerState = state.first;
+        *outRasterizerState = keyIter->second.get();
         return gl::NoError();
     }
-    else
-    {
-        if (mRasterizerStateCache.size() >= kMaxRasterizerStates)
-        {
-            WARN() << "Overflowed the limit of " << kMaxRasterizerStates
-                   << " rasterizer states, removing the least recently used to make room.";
-
-            RasterizerStateMap::iterator leastRecentlyUsed = mRasterizerStateCache.begin();
-            for (RasterizerStateMap::iterator i = mRasterizerStateCache.begin(); i != mRasterizerStateCache.end(); i++)
-            {
-                if (i->second.second < leastRecentlyUsed->second.second)
-                {
-                    leastRecentlyUsed = i;
-                }
-            }
-            SafeRelease(leastRecentlyUsed->second.first);
-            mRasterizerStateCache.erase(leastRecentlyUsed);
-        }
 
-        D3D11_CULL_MODE cullMode = gl_d3d11::ConvertCullMode(rasterState.cullFace, rasterState.cullMode);
+    TrimCache(kMaxStates, kGCLimit, "rasterizer state", &mRasterizerStateCache);
 
-        // Disable culling if drawing points
-        if (rasterState.pointDrawMode)
-        {
-            cullMode = D3D11_CULL_NONE;
-        }
+    D3D11_CULL_MODE cullMode =
+        gl_d3d11::ConvertCullMode(rasterState.cullFace, rasterState.cullMode);
 
-        D3D11_RASTERIZER_DESC rasterDesc;
-        rasterDesc.FillMode = D3D11_FILL_SOLID;
-        rasterDesc.CullMode = cullMode;
-        rasterDesc.FrontCounterClockwise = (rasterState.frontFace == GL_CCW) ? FALSE: TRUE;
-        rasterDesc.DepthBiasClamp = 0.0f; // MSDN documentation of DepthBiasClamp implies a value of zero will preform no clamping, must be tested though.
-        rasterDesc.DepthClipEnable = TRUE;
-        rasterDesc.ScissorEnable = scissorEnabled ? TRUE : FALSE;
-        rasterDesc.MultisampleEnable = rasterState.multiSample;
-        rasterDesc.AntialiasedLineEnable = FALSE;
-
-        if (rasterState.polygonOffsetFill)
-        {
-            rasterDesc.SlopeScaledDepthBias = rasterState.polygonOffsetFactor;
-            rasterDesc.DepthBias = (INT)rasterState.polygonOffsetUnits;
-        }
-        else
-        {
-            rasterDesc.SlopeScaledDepthBias = 0.0f;
-            rasterDesc.DepthBias = 0;
-        }
-
-        ID3D11RasterizerState *dx11RasterizerState = nullptr;
-        HRESULT result = mDevice->CreateRasterizerState(&rasterDesc, &dx11RasterizerState);
-        if (FAILED(result) || !dx11RasterizerState)
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Unable to create a ID3D11RasterizerState, HRESULT: 0x%X.", result);
-        }
-
-        mRasterizerStateCache.insert(std::make_pair(key, std::make_pair(dx11RasterizerState, mCounter++)));
-
-        *outRasterizerState = dx11RasterizerState;
-        return gl::NoError();
+    // Disable culling if drawing points
+    if (rasterState.pointDrawMode)
+    {
+        cullMode = D3D11_CULL_NONE;
     }
-}
 
-// static
-std::size_t RenderStateCache::HashDepthStencilState(const gl::DepthStencilState &dsState)
-{
-    static const unsigned int seed = 0xABCDEF98;
+    D3D11_RASTERIZER_DESC rasterDesc;
+    rasterDesc.FillMode              = D3D11_FILL_SOLID;
+    rasterDesc.CullMode              = cullMode;
+    rasterDesc.FrontCounterClockwise = (rasterState.frontFace == GL_CCW) ? FALSE : TRUE;
+    rasterDesc.DepthBiasClamp = 0.0f;  // MSDN documentation of DepthBiasClamp implies a value of
+                                       // zero will preform no clamping, must be tested though.
+    rasterDesc.DepthClipEnable       = TRUE;
+    rasterDesc.ScissorEnable         = scissorEnabled ? TRUE : FALSE;
+    rasterDesc.MultisampleEnable     = rasterState.multiSample;
+    rasterDesc.AntialiasedLineEnable = FALSE;
+
+    if (rasterState.polygonOffsetFill)
+    {
+        rasterDesc.SlopeScaledDepthBias = rasterState.polygonOffsetFactor;
+        rasterDesc.DepthBias            = (INT)rasterState.polygonOffsetUnits;
+    }
+    else
+    {
+        rasterDesc.SlopeScaledDepthBias = 0.0f;
+        rasterDesc.DepthBias            = 0;
+    }
 
-    std::size_t hash = 0;
-    MurmurHash3_x86_32(&dsState, sizeof(gl::DepthStencilState), seed, &hash);
-    return hash;
-}
+    d3d11::RasterizerState dx11RasterizerState;
+    ANGLE_TRY(renderer->allocateResource(rasterDesc, &dx11RasterizerState));
+    *outRasterizerState = dx11RasterizerState.get();
+    mRasterizerStateCache.Put(key, std::move(dx11RasterizerState));
 
-// static
-bool RenderStateCache::CompareDepthStencilStates(const gl::DepthStencilState &a, const gl::DepthStencilState &b)
-{
-    return memcmp(&a, &b, sizeof(gl::DepthStencilState)) == 0;
+    return gl::NoError();
 }
 
-gl::Error RenderStateCache::getDepthStencilState(const gl::DepthStencilState &glState,
+gl::Error RenderStateCache::getDepthStencilState(Renderer11 *renderer,
+                                                 const gl::DepthStencilState &glState,
                                                  ID3D11DepthStencilState **outDSState)
 {
-    if (!mDevice)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal error, RenderStateCache is not initialized.");
-    }
-
-    auto keyIter = mDepthStencilStateCache.find(glState);
+    auto keyIter = mDepthStencilStateCache.Get(glState);
     if (keyIter != mDepthStencilStateCache.end())
     {
-        DepthStencilStateCounterPair &state = keyIter->second;
-        state.second = mCounter++;
-        *outDSState = state.first;
+        *outDSState = keyIter->second.get();
         return gl::NoError();
     }
 
-    if (mDepthStencilStateCache.size() >= kMaxDepthStencilStates)
-    {
-        WARN() << "Overflowed the limit of " << kMaxDepthStencilStates
-               << " depth stencil states, removing the least recently used to make room.";
-
-        auto leastRecentlyUsed = mDepthStencilStateCache.begin();
-        for (auto i = mDepthStencilStateCache.begin(); i != mDepthStencilStateCache.end(); i++)
-        {
-            if (i->second.second < leastRecentlyUsed->second.second)
-            {
-                leastRecentlyUsed = i;
-            }
-        }
-        SafeRelease(leastRecentlyUsed->second.first);
-        mDepthStencilStateCache.erase(leastRecentlyUsed);
-    }
+    TrimCache(kMaxStates, kGCLimit, "depth stencil state", &mDepthStencilStateCache);
 
     D3D11_DEPTH_STENCIL_DESC dsDesc     = {0};
     dsDesc.DepthEnable                  = glState.depthTest ? TRUE : FALSE;
@@ -374,110 +222,65 @@ gl::Error RenderStateCache::getDepthStencilState(const gl::DepthStencilState &gl
     dsDesc.BackFace.StencilPassOp       = ConvertStencilOp(glState.stencilBackPassDepthPass);
     dsDesc.BackFace.StencilFunc         = ConvertComparison(glState.stencilBackFunc);
 
-    ID3D11DepthStencilState *dx11DepthStencilState = nullptr;
-    HRESULT result = mDevice->CreateDepthStencilState(&dsDesc, &dx11DepthStencilState);
-    if (FAILED(result) || !dx11DepthStencilState)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Unable to create a ID3D11DepthStencilState, HRESULT: 0x%X.", result);
-    }
-
-    mDepthStencilStateCache.insert(
-        std::make_pair(glState, std::make_pair(dx11DepthStencilState, mCounter++)));
+    d3d11::DepthStencilState dx11DepthStencilState;
+    ANGLE_TRY(renderer->allocateResource(dsDesc, &dx11DepthStencilState));
+    *outDSState = dx11DepthStencilState.get();
+    mDepthStencilStateCache.Put(glState, std::move(dx11DepthStencilState));
 
-    *outDSState = dx11DepthStencilState;
     return gl::NoError();
 }
 
-// static
-std::size_t RenderStateCache::HashSamplerState(const gl::SamplerState &samplerState)
-{
-    static const unsigned int seed = 0xABCDEF98;
-
-    std::size_t hash = 0;
-    MurmurHash3_x86_32(&samplerState, sizeof(gl::SamplerState), seed, &hash);
-    return hash;
-}
-
-// static
-bool RenderStateCache::CompareSamplerStates(const gl::SamplerState &a, const gl::SamplerState &b)
-{
-    return memcmp(&a, &b, sizeof(gl::SamplerState)) == 0;
-}
-
-gl::Error RenderStateCache::getSamplerState(const gl::SamplerState &samplerState, ID3D11SamplerState **outSamplerState)
+gl::Error RenderStateCache::getSamplerState(Renderer11 *renderer,
+                                            const gl::SamplerState &samplerState,
+                                            ID3D11SamplerState **outSamplerState)
 {
-    if (!mDevice)
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal error, RenderStateCache is not initialized.");
-    }
-
-    SamplerStateMap::iterator keyIter = mSamplerStateCache.find(samplerState);
+    auto keyIter = mSamplerStateCache.Get(samplerState);
     if (keyIter != mSamplerStateCache.end())
     {
-        SamplerStateCounterPair &state = keyIter->second;
-        state.second = mCounter++;
-        *outSamplerState = state.first;
+        *outSamplerState = keyIter->second.get();
         return gl::NoError();
     }
-    else
-    {
-        if (mSamplerStateCache.size() >= kMaxSamplerStates)
-        {
-            WARN() << "Overflowed the limit of " << kMaxSamplerStates
-                   << " sampler states, removing the least recently used to make room.";
 
-            SamplerStateMap::iterator leastRecentlyUsed = mSamplerStateCache.begin();
-            for (SamplerStateMap::iterator i = mSamplerStateCache.begin(); i != mSamplerStateCache.end(); i++)
-            {
-                if (i->second.second < leastRecentlyUsed->second.second)
-                {
-                    leastRecentlyUsed = i;
-                }
-            }
-            SafeRelease(leastRecentlyUsed->second.first);
-            mSamplerStateCache.erase(leastRecentlyUsed);
-        }
-
-        D3D11_SAMPLER_DESC samplerDesc;
-        samplerDesc.Filter = gl_d3d11::ConvertFilter(samplerState.minFilter, samplerState.magFilter,
-                                                     samplerState.maxAnisotropy, samplerState.compareMode);
-        samplerDesc.AddressU = gl_d3d11::ConvertTextureWrap(samplerState.wrapS);
-        samplerDesc.AddressV = gl_d3d11::ConvertTextureWrap(samplerState.wrapT);
-        samplerDesc.AddressW = gl_d3d11::ConvertTextureWrap(samplerState.wrapR);
-        samplerDesc.MipLODBias = 0;
-        samplerDesc.MaxAnisotropy =
-            gl_d3d11::ConvertMaxAnisotropy(samplerState.maxAnisotropy, mDevice->GetFeatureLevel());
-        samplerDesc.ComparisonFunc = gl_d3d11::ConvertComparison(samplerState.compareFunc);
-        samplerDesc.BorderColor[0] = 0.0f;
-        samplerDesc.BorderColor[1] = 0.0f;
-        samplerDesc.BorderColor[2] = 0.0f;
-        samplerDesc.BorderColor[3] = 0.0f;
-        samplerDesc.MinLOD = samplerState.minLod;
-        samplerDesc.MaxLOD = samplerState.maxLod;
-
-        if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
-        {
-            // Check that maxLOD is nearly FLT_MAX (1000.0f is the default), since 9_3 doesn't support anything other than FLT_MAX.
-            // Note that Feature Level 9_* only supports GL ES 2.0, so the consumer of ANGLE can't modify the Max LOD themselves.
-            ASSERT(samplerState.maxLod >= 999.9f);
-
-            // Now just set MaxLOD to FLT_MAX. Other parts of the renderer (e.g. the non-zero max LOD workaround) should take account of this.
-            samplerDesc.MaxLOD = FLT_MAX;
-        }
-
-        ID3D11SamplerState *dx11SamplerState = nullptr;
-        HRESULT result = mDevice->CreateSamplerState(&samplerDesc, &dx11SamplerState);
-        if (FAILED(result) || !dx11SamplerState)
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Unable to create a ID3D11SamplerState, HRESULT: 0x%X.", result);
-        }
+    TrimCache(kMaxStates, kGCLimit, "sampler state", &mSamplerStateCache);
+
+    const auto &featureLevel = renderer->getRenderer11DeviceCaps().featureLevel;
+
+    D3D11_SAMPLER_DESC samplerDesc;
+    samplerDesc.Filter =
+        gl_d3d11::ConvertFilter(samplerState.minFilter, samplerState.magFilter,
+                                samplerState.maxAnisotropy, samplerState.compareMode);
+    samplerDesc.AddressU   = gl_d3d11::ConvertTextureWrap(samplerState.wrapS);
+    samplerDesc.AddressV   = gl_d3d11::ConvertTextureWrap(samplerState.wrapT);
+    samplerDesc.AddressW   = gl_d3d11::ConvertTextureWrap(samplerState.wrapR);
+    samplerDesc.MipLODBias = 0;
+    samplerDesc.MaxAnisotropy =
+        gl_d3d11::ConvertMaxAnisotropy(samplerState.maxAnisotropy, featureLevel);
+    samplerDesc.ComparisonFunc = gl_d3d11::ConvertComparison(samplerState.compareFunc);
+    samplerDesc.BorderColor[0] = 0.0f;
+    samplerDesc.BorderColor[1] = 0.0f;
+    samplerDesc.BorderColor[2] = 0.0f;
+    samplerDesc.BorderColor[3] = 0.0f;
+    samplerDesc.MinLOD         = samplerState.minLod;
+    samplerDesc.MaxLOD         = samplerState.maxLod;
+
+    if (featureLevel <= D3D_FEATURE_LEVEL_9_3)
+    {
+        // Check that maxLOD is nearly FLT_MAX (1000.0f is the default), since 9_3 doesn't support
+        // anything other than FLT_MAX. Note that Feature Level 9_* only supports GL ES 2.0, so the
+        // consumer of ANGLE can't modify the Max LOD themselves.
+        ASSERT(samplerState.maxLod >= 999.9f);
+
+        // Now just set MaxLOD to FLT_MAX. Other parts of the renderer (e.g. the non-zero max LOD
+        // workaround) should take account of this.
+        samplerDesc.MaxLOD = FLT_MAX;
+    }
 
-        mSamplerStateCache.insert(std::make_pair(samplerState, std::make_pair(dx11SamplerState, mCounter++)));
+    d3d11::SamplerState dx11SamplerState;
+    ANGLE_TRY(renderer->allocateResource(samplerDesc, &dx11SamplerState));
+    *outSamplerState = dx11SamplerState.get();
+    mSamplerStateCache.Put(samplerState, std::move(dx11SamplerState));
 
-        *outSamplerState = dx11SamplerState;
-        return gl::NoError();
-    }
+    return gl::NoError();
 }
 
-}
+}  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h
index b9981052654..73ea22c937c 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderStateCache.h
@@ -10,9 +10,10 @@
 #ifndef LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_
 #define LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_
 
-#include "libANGLE/angletypes.h"
-#include "libANGLE/Error.h"
 #include "common/angleutils.h"
+#include "libANGLE/Error.h"
+#include "libANGLE/SizedMRUCache.h"
+#include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
 
 #include <unordered_map>
@@ -22,6 +23,42 @@ namespace gl
 class Framebuffer;
 }
 
+namespace std
+{
+template <>
+struct hash<rx::d3d11::BlendStateKey>
+{
+    size_t operator()(const rx::d3d11::BlendStateKey &key) const
+    {
+        return angle::ComputeGenericHash(key);
+    }
+};
+
+template <>
+struct hash<rx::d3d11::RasterizerStateKey>
+{
+    size_t operator()(const rx::d3d11::RasterizerStateKey &key) const
+    {
+        return angle::ComputeGenericHash(key);
+    }
+};
+
+template <>
+struct hash<gl::DepthStencilState>
+{
+    size_t operator()(const gl::DepthStencilState &key) const
+    {
+        return angle::ComputeGenericHash(key);
+    }
+};
+
+template <>
+struct hash<gl::SamplerState>
+{
+    size_t operator()(const gl::SamplerState &key) const { return angle::ComputeGenericHash(key); }
+};
+}  // namespace std
+
 namespace rx
 {
 class Renderer11;
@@ -29,87 +66,58 @@ class Renderer11;
 class RenderStateCache : angle::NonCopyable
 {
   public:
-    RenderStateCache(Renderer11 *renderer);
+    RenderStateCache();
     virtual ~RenderStateCache();
 
-    void initialize(ID3D11Device *device);
     void clear();
 
-    static d3d11::BlendStateKey GetBlendStateKey(const gl::Framebuffer *framebuffer,
+    static d3d11::BlendStateKey GetBlendStateKey(const gl::Context *context,
+                                                 const gl::Framebuffer *framebuffer,
                                                  const gl::BlendState &blendState);
-    gl::Error getBlendState(const d3d11::BlendStateKey &key, ID3D11BlendState **outBlendState);
-    gl::Error getRasterizerState(const gl::RasterizerState &rasterState, bool scissorEnabled, ID3D11RasterizerState **outRasterizerState);
-    gl::Error getDepthStencilState(const gl::DepthStencilState &dsState,
+    gl::Error getBlendState(Renderer11 *renderer,
+                            const d3d11::BlendStateKey &key,
+                            ID3D11BlendState **outBlendState);
+    gl::Error getRasterizerState(Renderer11 *renderer,
+                                 const gl::RasterizerState &rasterState,
+                                 bool scissorEnabled,
+                                 ID3D11RasterizerState **outRasterizerState);
+    gl::Error getDepthStencilState(Renderer11 *renderer,
+                                   const gl::DepthStencilState &dsState,
                                    ID3D11DepthStencilState **outDSState);
-    gl::Error getSamplerState(const gl::SamplerState &samplerState, ID3D11SamplerState **outSamplerState);
+    gl::Error getSamplerState(Renderer11 *renderer,
+                              const gl::SamplerState &samplerState,
+                              ID3D11SamplerState **outSamplerState);
 
   private:
-    Renderer11 *mRenderer;
-    unsigned long long mCounter;
+    // MSDN's documentation of ID3D11Device::CreateBlendState, ID3D11Device::CreateRasterizerState,
+    // ID3D11Device::CreateDepthStencilState and ID3D11Device::CreateSamplerState claims the maximum
+    // number of unique states of each type an application can create is 4096
+    // TODO(ShahmeerEsmail): Revisit the cache sizes to make sure they are appropriate for most
+    // scenarios.
+    static constexpr unsigned int kMaxStates = 4096;
+
+    // The cache tries to clean up this many states at once.
+    static constexpr unsigned int kGCLimit = 128;
 
     // Blend state cache
-    static std::size_t HashBlendState(const d3d11::BlendStateKey &blendState);
-    static bool CompareBlendStates(const d3d11::BlendStateKey &a, const d3d11::BlendStateKey &b);
-    static const unsigned int kMaxBlendStates;
-
-    typedef std::size_t (*BlendStateHashFunction)(const d3d11::BlendStateKey &);
-    typedef bool (*BlendStateEqualityFunction)(const d3d11::BlendStateKey &,
-                                               const d3d11::BlendStateKey &);
-    typedef std::pair<ID3D11BlendState*, unsigned long long> BlendStateCounterPair;
-    typedef std::unordered_map<d3d11::BlendStateKey,
-                               BlendStateCounterPair,
-                               BlendStateHashFunction,
-                               BlendStateEqualityFunction>
-        BlendStateMap;
+    using BlendStateMap = angle::base::HashingMRUCache<d3d11::BlendStateKey, d3d11::BlendState>;
     BlendStateMap mBlendStateCache;
 
     // Rasterizer state cache
-    struct RasterizerStateKey
-    {
-        gl::RasterizerState rasterizerState;
-        bool scissorEnabled;
-    };
-    static std::size_t HashRasterizerState(const RasterizerStateKey &rasterState);
-    static bool CompareRasterizerStates(const RasterizerStateKey &a, const RasterizerStateKey &b);
-    static const unsigned int kMaxRasterizerStates;
-
-    typedef std::size_t (*RasterizerStateHashFunction)(const RasterizerStateKey &);
-    typedef bool (*RasterizerStateEqualityFunction)(const RasterizerStateKey &, const RasterizerStateKey &);
-    typedef std::pair<ID3D11RasterizerState*, unsigned long long> RasterizerStateCounterPair;
-    typedef std::unordered_map<RasterizerStateKey, RasterizerStateCounterPair, RasterizerStateHashFunction, RasterizerStateEqualityFunction> RasterizerStateMap;
+    using RasterizerStateMap =
+        angle::base::HashingMRUCache<d3d11::RasterizerStateKey, d3d11::RasterizerState>;
     RasterizerStateMap mRasterizerStateCache;
 
     // Depth stencil state cache
-    static std::size_t HashDepthStencilState(const gl::DepthStencilState &dsState);
-    static bool CompareDepthStencilStates(const gl::DepthStencilState &a, const gl::DepthStencilState &b);
-    static const unsigned int kMaxDepthStencilStates;
-
-    typedef std::size_t (*DepthStencilStateHashFunction)(const gl::DepthStencilState &);
-    typedef bool (*DepthStencilStateEqualityFunction)(const gl::DepthStencilState &, const gl::DepthStencilState &);
-    typedef std::pair<ID3D11DepthStencilState*, unsigned long long> DepthStencilStateCounterPair;
-    typedef std::unordered_map<gl::DepthStencilState,
-                               DepthStencilStateCounterPair,
-                               DepthStencilStateHashFunction,
-                               DepthStencilStateEqualityFunction> DepthStencilStateMap;
+    using DepthStencilStateMap =
+        angle::base::HashingMRUCache<gl::DepthStencilState, d3d11::DepthStencilState>;
     DepthStencilStateMap mDepthStencilStateCache;
 
     // Sample state cache
-    static std::size_t HashSamplerState(const gl::SamplerState &samplerState);
-    static bool CompareSamplerStates(const gl::SamplerState &a, const gl::SamplerState &b);
-    static const unsigned int kMaxSamplerStates;
-
-    typedef std::size_t (*SamplerStateHashFunction)(const gl::SamplerState &);
-    typedef bool (*SamplerStateEqualityFunction)(const gl::SamplerState &, const gl::SamplerState &);
-    typedef std::pair<ID3D11SamplerState*, unsigned long long> SamplerStateCounterPair;
-    typedef std::unordered_map<gl::SamplerState,
-                               SamplerStateCounterPair,
-                               SamplerStateHashFunction,
-                               SamplerStateEqualityFunction> SamplerStateMap;
+    using SamplerStateMap = angle::base::HashingMRUCache<gl::SamplerState, d3d11::SamplerState>;
     SamplerStateMap mSamplerStateCache;
-
-    ID3D11Device *mDevice;
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERSTATECACHE_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp
index 34e359c3faa..b019488e4f5 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp
@@ -212,7 +212,7 @@ void RenderTarget11::signalDirty()
 }
 
 TextureRenderTarget11::TextureRenderTarget11(d3d11::RenderTargetView &&rtv,
-                                             ID3D11Resource *resource,
+                                             const TextureHelper11 &resource,
                                              const d3d11::SharedSRV &srv,
                                              const d3d11::SharedSRV &blitSRV,
                                              GLenum internalFormat,
@@ -231,23 +231,18 @@ TextureRenderTarget11::TextureRenderTarget11(d3d11::RenderTargetView &&rtv,
       mTexture(resource),
       mRenderTarget(std::move(rtv)),
       mDepthStencil(),
-      mShaderResource(srv),
-      mBlitShaderResource(blitSRV)
+      mShaderResource(srv.makeCopy()),
+      mBlitShaderResource(blitSRV.makeCopy())
 {
-    if (mTexture)
+    if (mRenderTarget.valid() && mTexture.valid())
     {
-        mTexture->AddRef();
-    }
-
-    if (mRenderTarget.valid() && mTexture)
-    {
-        mSubresourceIndex = GetRTVSubresourceIndex(mTexture, mRenderTarget.get());
+        mSubresourceIndex = GetRTVSubresourceIndex(mTexture.get(), mRenderTarget.get());
     }
     ASSERT(mFormatSet.formatID != angle::Format::ID::NONE || mWidth == 0 || mHeight == 0);
 }
 
 TextureRenderTarget11::TextureRenderTarget11(d3d11::DepthStencilView &&dsv,
-                                             ID3D11Resource *resource,
+                                             const TextureHelper11 &resource,
                                              const d3d11::SharedSRV &srv,
                                              GLenum internalFormat,
                                              const d3d11::Format &formatSet,
@@ -265,27 +260,21 @@ TextureRenderTarget11::TextureRenderTarget11(d3d11::DepthStencilView &&dsv,
       mTexture(resource),
       mRenderTarget(),
       mDepthStencil(std::move(dsv)),
-      mShaderResource(srv),
+      mShaderResource(srv.makeCopy()),
       mBlitShaderResource()
 {
-    if (mTexture)
-    {
-        mTexture->AddRef();
-    }
-
-    if (mDepthStencil.valid() && mTexture)
+    if (mDepthStencil.valid() && mTexture.valid())
     {
-        mSubresourceIndex = GetDSVSubresourceIndex(mTexture, mDepthStencil.get());
+        mSubresourceIndex = GetDSVSubresourceIndex(mTexture.get(), mDepthStencil.get());
     }
     ASSERT(mFormatSet.formatID != angle::Format::ID::NONE || mWidth == 0 || mHeight == 0);
 }
 
 TextureRenderTarget11::~TextureRenderTarget11()
 {
-    SafeRelease(mTexture);
 }
 
-ID3D11Resource *TextureRenderTarget11::getTexture() const
+const TextureHelper11 &TextureRenderTarget11::getTexture() const
 {
     return mTexture;
 }
@@ -379,7 +368,7 @@ GLsizei SurfaceRenderTarget11::getSamples() const
     return mSwapChain->getSamples();
 }
 
-ID3D11Resource *SurfaceRenderTarget11::getTexture() const
+const TextureHelper11 &SurfaceRenderTarget11::getTexture() const
 {
     return (mDepth ? mSwapChain->getDepthStencilTexture() : mSwapChain->getOffscreenTexture());
 }
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h
index 2b442c5f875..579ded4de76 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h
@@ -26,7 +26,7 @@ class RenderTarget11 : public RenderTargetD3D
     RenderTarget11(const d3d11::Format &formatSet);
     virtual ~RenderTarget11();
 
-    virtual ID3D11Resource *getTexture() const = 0;
+    virtual const TextureHelper11 &getTexture() const                  = 0;
     virtual const d3d11::RenderTargetView &getRenderTargetView() const = 0;
     virtual const d3d11::DepthStencilView &getDepthStencilView() const = 0;
     virtual const d3d11::SharedSRV &getShaderResourceView() const      = 0;
@@ -49,7 +49,7 @@ class TextureRenderTarget11 : public RenderTarget11
   public:
     // TextureRenderTarget11 takes ownership of any D3D11 resources it is given and will AddRef them
     TextureRenderTarget11(d3d11::RenderTargetView &&rtv,
-                          ID3D11Resource *resource,
+                          const TextureHelper11 &resource,
                           const d3d11::SharedSRV &srv,
                           const d3d11::SharedSRV &blitSRV,
                           GLenum internalFormat,
@@ -59,7 +59,7 @@ class TextureRenderTarget11 : public RenderTarget11
                           GLsizei depth,
                           GLsizei samples);
     TextureRenderTarget11(d3d11::DepthStencilView &&dsv,
-                          ID3D11Resource *resource,
+                          const TextureHelper11 &resource,
                           const d3d11::SharedSRV &srv,
                           GLenum internalFormat,
                           const d3d11::Format &formatSet,
@@ -75,7 +75,7 @@ class TextureRenderTarget11 : public RenderTarget11
     GLenum getInternalFormat() const override;
     GLsizei getSamples() const override;
 
-    ID3D11Resource *getTexture() const override;
+    const TextureHelper11 &getTexture() const override;
     const d3d11::RenderTargetView &getRenderTargetView() const override;
     const d3d11::DepthStencilView &getDepthStencilView() const override;
     const d3d11::SharedSRV &getShaderResourceView() const override;
@@ -91,7 +91,7 @@ class TextureRenderTarget11 : public RenderTarget11
     GLsizei mSamples;
 
     unsigned int mSubresourceIndex;
-    ID3D11Resource *mTexture;
+    TextureHelper11 mTexture;
     d3d11::RenderTargetView mRenderTarget;
     d3d11::DepthStencilView mDepthStencil;
     d3d11::SharedSRV mShaderResource;
@@ -113,7 +113,7 @@ class SurfaceRenderTarget11 : public RenderTarget11
     GLenum getInternalFormat() const override;
     GLsizei getSamples() const override;
 
-    ID3D11Resource *getTexture() const override;
+    const TextureHelper11 &getTexture() const override;
     const d3d11::RenderTargetView &getRenderTargetView() const override;
     const d3d11::DepthStencilView &getDepthStencilView() const override;
     const d3d11::SharedSRV &getShaderResourceView() const override;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
index bc57c68bb05..45e7706bd33 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
@@ -15,6 +15,7 @@
 #include "common/tls.h"
 #include "common/utilities.h"
 #include "libANGLE/Buffer.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
@@ -381,7 +382,8 @@ const uint32_t ScratchMemoryBufferLifetime = 1000;
 
 Renderer11::Renderer11(egl::Display *display)
     : RendererD3D(display),
-      mStateCache(this),
+      mCreateDebugDevice(false),
+      mStateCache(),
       mStateManager(this),
       mLastHistogramUpdateTime(
           ANGLEPlatformCurrent()->monotonicallyIncreasingTime(ANGLEPlatformCurrent())),
@@ -403,8 +405,6 @@ Renderer11::Renderer11(egl::Display *display)
 
     mTrim = nullptr;
 
-    mSyncQuery = nullptr;
-
     mRenderer11DeviceCaps.supportsClearView             = false;
     mRenderer11DeviceCaps.supportsConstantBufferOffsets = false;
     mRenderer11DeviceCaps.supportsDXGI1_2               = false;
@@ -424,15 +424,6 @@ Renderer11::Renderer11(egl::Display *display)
     mDxgiAdapter    = nullptr;
     mDxgiFactory    = nullptr;
 
-    mDriverConstantBufferVS = nullptr;
-    mDriverConstantBufferPS = nullptr;
-    mDriverConstantBufferCS = nullptr;
-
-    mAppliedVertexShader   = angle::DirtyPointer;
-    mAppliedGeometryShader = angle::DirtyPointer;
-    mAppliedPixelShader    = angle::DirtyPointer;
-    mAppliedComputeShader  = angle::DirtyPointer;
-
     mAppliedTFObject = angle::DirtyPointer;
 
     ZeroMemory(&mAdapterDescription, sizeof(mAdapterDescription));
@@ -498,6 +489,8 @@ Renderer11::Renderer11(egl::Display *display)
         const EGLenum presentPath = static_cast<EGLenum>(attributes.get(
             EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE, EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE));
         mPresentPathFastEnabled = (presentPath == EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE);
+
+        mCreateDebugDevice = ShouldUseDebugLayers(attributes);
     }
     else if (display->getPlatform() == EGL_PLATFORM_DEVICE_EXT)
     {
@@ -567,9 +560,8 @@ egl::Error Renderer11::initialize()
             result = mDevice->QueryInterface(__uuidof(IDXGIDevice2), (void **)&dxgiDevice2);
             if (FAILED(result))
             {
-                return egl::Error(
-                    EGL_NOT_INITIALIZED, D3D11_INIT_INCOMPATIBLE_DXGI,
-                    "DXGI 1.2 required to present to HWNDs owned by another process.");
+                return egl::EglNotInitialized(D3D11_INIT_INCOMPATIBLE_DXGI)
+                       << "DXGI 1.2 required to present to HWNDs owned by another process.";
             }
             SafeRelease(dxgiDevice2);
         }
@@ -589,16 +581,15 @@ egl::Error Renderer11::initialize()
 
         if (FAILED(result))
         {
-            return egl::Error(EGL_NOT_INITIALIZED, D3D11_INIT_OTHER_ERROR,
-                              "Could not query DXGI device.");
+            return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR) << "Could not query DXGI device.";
         }
 
         result = dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void **)&mDxgiAdapter);
 
         if (FAILED(result))
         {
-            return egl::Error(EGL_NOT_INITIALIZED, D3D11_INIT_OTHER_ERROR,
-                              "Could not retrieve DXGI adapter");
+            return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR)
+                   << "Could not retrieve DXGI adapter";
         }
 
         SafeRelease(dxgiDevice);
@@ -638,8 +629,8 @@ egl::Error Renderer11::initialize()
 
         if (FAILED(result))
         {
-            return egl::Error(EGL_NOT_INITIALIZED, D3D11_INIT_OTHER_ERROR,
-                              "Could not read DXGI adaptor description.");
+            return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR)
+                   << "Could not read DXGI adaptor description.";
         }
 
         memset(mDescription, 0, sizeof(mDescription));
@@ -649,8 +640,8 @@ egl::Error Renderer11::initialize()
 
         if (!mDxgiFactory || FAILED(result))
         {
-            return egl::Error(EGL_NOT_INITIALIZED, D3D11_INIT_OTHER_ERROR,
-                              "Could not create DXGI factory.");
+            return egl::EglNotInitialized(D3D11_INIT_OTHER_ERROR)
+                   << "Could not create DXGI factory.";
         }
     }
 
@@ -682,7 +673,7 @@ egl::Error Renderer11::initialize()
 
     initializeDevice();
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 egl::Error Renderer11::initializeD3DDevice()
@@ -702,8 +693,8 @@ egl::Error Renderer11::initializeD3DDevice()
 
             if (mD3d11Module == nullptr || mDxgiModule == nullptr)
             {
-                return egl::Error(EGL_NOT_INITIALIZED, D3D11_INIT_MISSING_DEP,
-                                  "Could not load D3D11 or DXGI library.");
+                return egl::EglNotInitialized(D3D11_INIT_MISSING_DEP)
+                       << "Could not load D3D11 or DXGI library.";
             }
 
             // create the D3D11 device
@@ -713,13 +704,13 @@ egl::Error Renderer11::initializeD3DDevice()
 
             if (D3D11CreateDevice == nullptr)
             {
-                return egl::Error(EGL_NOT_INITIALIZED, D3D11_INIT_MISSING_DEP,
-                                  "Could not retrieve D3D11CreateDevice address.");
+                return egl::EglNotInitialized(D3D11_INIT_MISSING_DEP)
+                       << "Could not retrieve D3D11CreateDevice address.";
             }
         }
 #endif
 
-#ifdef _DEBUG
+        if (mCreateDebugDevice)
         {
             TRACE_EVENT0("gpu.angle", "D3D11CreateDevice (Debug)");
             result = D3D11CreateDevice(nullptr, mRequestedDriverType, nullptr,
@@ -727,15 +718,14 @@ egl::Error Renderer11::initializeD3DDevice()
                                        static_cast<unsigned int>(mAvailableFeatureLevels.size()),
                                        D3D11_SDK_VERSION, &mDevice,
                                        &(mRenderer11DeviceCaps.featureLevel), &mDeviceContext);
-        }
 
-        if (!mDevice || FAILED(result))
-        {
-            WARN() << "Failed creating Debug D3D11 device - falling back to release runtime.";
+            if (!mDevice || FAILED(result))
+            {
+                WARN() << "Failed creating Debug D3D11 device - falling back to release runtime.";
+            }
         }
 
         if (!mDevice || FAILED(result))
-#endif
         {
             SCOPED_ANGLE_HISTOGRAM_TIMER("GPU.ANGLE.D3D11CreateDeviceMS");
             TRACE_EVENT0("gpu.angle", "D3D11CreateDevice");
@@ -750,8 +740,8 @@ egl::Error Renderer11::initializeD3DDevice()
             {
                 ANGLE_HISTOGRAM_SPARSE_SLOWLY("GPU.ANGLE.D3D11CreateDeviceError",
                                               static_cast<int>(result));
-                return egl::Error(EGL_NOT_INITIALIZED, D3D11_INIT_CREATEDEVICE_ERROR,
-                                  "Could not create D3D11 device.");
+                return egl::EglNotInitialized(D3D11_INIT_CREATEDEVICE_ERROR)
+                       << "Could not create D3D11 device.";
             }
         }
     }
@@ -764,13 +754,13 @@ egl::Error Renderer11::initializeD3DDevice()
         ID3D11Device *d3dDevice = reinterpret_cast<ID3D11Device *>(device);
         if (FAILED(d3dDevice->GetDeviceRemovedReason()))
         {
-            return egl::Error(EGL_NOT_INITIALIZED, "Inputted D3D11 device has been lost.");
+            return egl::EglNotInitialized() << "Inputted D3D11 device has been lost.";
         }
 
         if (d3dDevice->GetFeatureLevel() < D3D_FEATURE_LEVEL_9_3)
         {
-            return egl::Error(EGL_NOT_INITIALIZED,
-                              "Inputted D3D11 device must be Feature Level 9_3 or greater.");
+            return egl::EglNotInitialized()
+                   << "Inputted D3D11 device must be Feature Level 9_3 or greater.";
         }
 
         // The Renderer11 adds a ref to the inputted D3D11 device, like D3D11CreateDevice does.
@@ -782,7 +772,7 @@ egl::Error Renderer11::initializeD3DDevice()
 
     d3d11::SetDebugName(mDeviceContext, "DeviceContext");
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 // do any one-time device initialization
@@ -795,8 +785,7 @@ void Renderer11::initializeDevice()
 
     populateRenderer11DeviceCaps();
 
-    mStateCache.initialize(mDevice);
-    mInputLayoutCache.initialize();
+    mStateCache.clear();
 
     ASSERT(!mVertexDataManager && !mIndexDataManager);
     mVertexDataManager = new VertexDataManager(this);
@@ -842,7 +831,8 @@ void Renderer11::initializeDevice()
 
     mStateManager.initialize(rendererCaps);
 
-    markAllStateDirty();
+    // No context is available here, use the proxy context in the display.
+    markAllStateDirty(mDisplay->getProxyContext());
 
     // Gather stats on DXGI and D3D feature level
     ANGLE_HISTOGRAM_BOOLEAN("GPU.ANGLE.SupportsDXGI1_2", mRenderer11DeviceCaps.supportsDXGI1_2);
@@ -1151,10 +1141,11 @@ void Renderer11::generateDisplayExtensions(egl::DisplayExtensions *outExtensions
     // Contexts are virtualized so textures can be shared globally
     outExtensions->displayTextureShareGroup = true;
 
-    outExtensions->createContextRobustResourceInitialization = true;
-
     // getSyncValues requires direct composition.
     outExtensions->getSyncValues = outExtensions->directComposition;
+
+    // D3D11 can be used without a swap chain
+    outExtensions->surfacelessContext = true;
 }
 
 gl::Error Renderer11::flush()
@@ -1165,25 +1156,18 @@ gl::Error Renderer11::flush()
 
 gl::Error Renderer11::finish()
 {
-    HRESULT result;
-
-    if (!mSyncQuery)
+    if (!mSyncQuery.valid())
     {
         D3D11_QUERY_DESC queryDesc;
         queryDesc.Query     = D3D11_QUERY_EVENT;
         queryDesc.MiscFlags = 0;
 
-        result = mDevice->CreateQuery(&queryDesc, &mSyncQuery);
-        ASSERT(SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create event query, result: 0x%X.",
-                             result);
-        }
+        ANGLE_TRY(allocateResource(queryDesc, &mSyncQuery));
     }
 
-    mDeviceContext->End(mSyncQuery);
+    mDeviceContext->End(mSyncQuery.get());
 
+    HRESULT result       = S_OK;
     unsigned int attempt = 0;
     do
     {
@@ -1191,11 +1175,10 @@ gl::Error Renderer11::finish()
         UINT flags = (attempt % flushFrequency == 0) ? 0 : D3D11_ASYNC_GETDATA_DONOTFLUSH;
         attempt++;
 
-        result = mDeviceContext->GetData(mSyncQuery, nullptr, 0, flags);
+        result = mDeviceContext->GetData(mSyncQuery.get(), nullptr, 0, flags);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.",
-                             result);
+            return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
         }
 
         if (result == S_FALSE)
@@ -1207,7 +1190,7 @@ gl::Error Renderer11::finish()
         if (testDeviceLost())
         {
             mDisplay->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY, "Device was lost while waiting for sync.");
+            return gl::OutOfMemory() << "Device was lost while waiting for sync.";
         }
     } while (result == S_FALSE);
 
@@ -1246,7 +1229,7 @@ egl::Error Renderer11::getD3DTextureInfo(const egl::Config *configuration,
     ID3D11Texture2D *texture = d3d11::DynamicCastComObject<ID3D11Texture2D>(d3dTexture);
     if (texture == nullptr)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "client buffer is not a ID3D11Texture2D");
+        return egl::EglBadParameter() << "client buffer is not a ID3D11Texture2D";
     }
 
     ID3D11Device *textureDevice = nullptr;
@@ -1254,7 +1237,7 @@ egl::Error Renderer11::getD3DTextureInfo(const egl::Config *configuration,
     if (textureDevice != mDevice)
     {
         SafeRelease(texture);
-        return egl::Error(EGL_BAD_PARAMETER, "Texture's device does not match.");
+        return egl::EglBadParameter() << "Texture's device does not match.";
     }
     SafeRelease(textureDevice);
 
@@ -1278,7 +1261,7 @@ egl::Error Renderer11::getD3DTextureInfo(const egl::Config *configuration,
         // not one.
         if (configuration->samples != 0 || desc.SampleDesc.Count != 1)
         {
-            return egl::Error(EGL_BAD_PARAMETER, "Texture's sample count does not match.");
+            return egl::EglBadParameter() << "Texture's sample count does not match.";
         }
     }
     // From table egl.restrictions in EGL_ANGLE_d3d_texture_client_buffer.
@@ -1293,8 +1276,8 @@ egl::Error Renderer11::getD3DTextureInfo(const egl::Config *configuration,
             break;
 
         default:
-            return egl::Error(EGL_BAD_PARAMETER, "Unknown client buffer texture format: %u.",
-                              desc.Format);
+            return egl::EglBadParameter()
+                   << "Unknown client buffer texture format: " << desc.Format;
     }
 
     if (fboFormat)
@@ -1303,7 +1286,7 @@ egl::Error Renderer11::getD3DTextureInfo(const egl::Config *configuration,
         *fboFormat                       = angleFormat.fboImplementationInternalFormat;
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 egl::Error Renderer11::validateShareHandle(const egl::Config *config,
@@ -1312,7 +1295,7 @@ egl::Error Renderer11::validateShareHandle(const egl::Config *config,
 {
     if (shareHandle == nullptr)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "NULL share handle.");
+        return egl::EglBadParameter() << "NULL share handle.";
     }
 
     ID3D11Resource *tempResource11 = nullptr;
@@ -1320,7 +1303,7 @@ egl::Error Renderer11::validateShareHandle(const egl::Config *config,
                                                  (void **)&tempResource11);
     if (FAILED(result))
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Failed to open share handle, result: 0x%X.", result);
+        return egl::EglBadParameter() << "Failed to open share handle, " << gl::FmtHR(result);
     }
 
     ID3D11Texture2D *texture2D = d3d11::DynamicCastComObject<ID3D11Texture2D>(tempResource11);
@@ -1328,8 +1311,8 @@ egl::Error Renderer11::validateShareHandle(const egl::Config *config,
 
     if (texture2D == nullptr)
     {
-        return egl::Error(EGL_BAD_PARAMETER,
-                          "Failed to query ID3D11Texture2D object from share handle.");
+        return egl::EglBadParameter()
+               << "Failed to query ID3D11Texture2D object from share handle.";
     }
 
     D3D11_TEXTURE2D_DESC desc = {0};
@@ -1346,10 +1329,10 @@ egl::Error Renderer11::validateShareHandle(const egl::Config *config,
     if (desc.Width != static_cast<UINT>(width) || desc.Height != static_cast<UINT>(height) ||
         desc.Format != backbufferFormatInfo.texFormat || desc.MipLevels != 1 || desc.ArraySize != 1)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Invalid texture parameters in share handle texture.");
+        return egl::EglBadParameter() << "Invalid texture parameters in share handle texture.";
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 SwapChainD3D *Renderer11::createSwapChain(NativeWindowD3D *nativeWindow,
@@ -1369,7 +1352,7 @@ void *Renderer11::getD3DDevice()
     return reinterpret_cast<void *>(mDevice);
 }
 
-gl::Error Renderer11::generateSwizzle(gl::Texture *texture)
+gl::Error Renderer11::generateSwizzle(const gl::Context *context, gl::Texture *texture)
 {
     if (texture)
     {
@@ -1377,36 +1360,37 @@ gl::Error Renderer11::generateSwizzle(gl::Texture *texture)
         ASSERT(textureD3D);
 
         TextureStorage *texStorage = nullptr;
-        ANGLE_TRY(textureD3D->getNativeTexture(&texStorage));
+        ANGLE_TRY(textureD3D->getNativeTexture(context, &texStorage));
 
         if (texStorage)
         {
             TextureStorage11 *storage11          = GetAs<TextureStorage11>(texStorage);
             const gl::TextureState &textureState = texture->getTextureState();
-            ANGLE_TRY(storage11->generateSwizzles(textureState.getSwizzleState()));
+            ANGLE_TRY(storage11->generateSwizzles(context, textureState.getSwizzleState()));
         }
     }
 
     return gl::NoError();
 }
 
-gl::Error Renderer11::generateSwizzles(const gl::ContextState &data, gl::SamplerType type)
+gl::Error Renderer11::generateSwizzles(const gl::Context *context, gl::SamplerType type)
 {
-    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.getState().getProgram());
+    const auto &glState    = context->getGLState();
+    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
 
     unsigned int samplerRange = programD3D->getUsedSamplerRange(type);
 
     for (unsigned int i = 0; i < samplerRange; i++)
     {
         GLenum textureType = programD3D->getSamplerTextureType(type, i);
-        GLint textureUnit  = programD3D->getSamplerMapping(type, i, data.getCaps());
+        GLint textureUnit  = programD3D->getSamplerMapping(type, i, context->getCaps());
         if (textureUnit != -1)
         {
-            gl::Texture *texture = data.getState().getSamplerTexture(textureUnit, textureType);
+            gl::Texture *texture = glState.getSamplerTexture(textureUnit, textureType);
             ASSERT(texture);
             if (texture->getTextureState().swizzleRequired())
             {
-                ANGLE_TRY(generateSwizzle(texture));
+                ANGLE_TRY(generateSwizzle(context, texture));
             }
         }
     }
@@ -1414,13 +1398,14 @@ gl::Error Renderer11::generateSwizzles(const gl::ContextState &data, gl::Sampler
     return gl::NoError();
 }
 
-gl::Error Renderer11::generateSwizzles(const gl::ContextState &data)
+gl::Error Renderer11::generateSwizzles(const gl::Context *context)
 {
-    ANGLE_TRY(generateSwizzles(data, gl::SAMPLER_VERTEX));
-    ANGLE_TRY(generateSwizzles(data, gl::SAMPLER_PIXEL));
+    ANGLE_TRY(generateSwizzles(context, gl::SAMPLER_VERTEX));
+    ANGLE_TRY(generateSwizzles(context, gl::SAMPLER_PIXEL));
     return gl::NoError();
 }
-gl::Error Renderer11::setSamplerState(gl::SamplerType type,
+gl::Error Renderer11::setSamplerState(const gl::Context *context,
+                                      gl::SamplerType type,
                                       int index,
                                       gl::Texture *texture,
                                       const gl::SamplerState &samplerState)
@@ -1430,7 +1415,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
     TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
 
     TextureStorage *storage = nullptr;
-    ANGLE_TRY(textureD3D->getNativeTexture(&storage));
+    ANGLE_TRY(textureD3D->getNativeTexture(context, &storage));
 
     // Storage should exist, texture should be complete
     ASSERT(storage);
@@ -1449,7 +1434,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
             memcmp(&samplerState, &mCurPixelSamplerStates[index], sizeof(gl::SamplerState)) != 0)
         {
             ID3D11SamplerState *dxSamplerState = nullptr;
-            ANGLE_TRY(mStateCache.getSamplerState(samplerState, &dxSamplerState));
+            ANGLE_TRY(mStateCache.getSamplerState(this, samplerState, &dxSamplerState));
 
             ASSERT(dxSamplerState != nullptr);
             mDeviceContext->PSSetSamplers(index, 1, &dxSamplerState);
@@ -1469,7 +1454,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
             memcmp(&samplerState, &mCurVertexSamplerStates[index], sizeof(gl::SamplerState)) != 0)
         {
             ID3D11SamplerState *dxSamplerState = nullptr;
-            ANGLE_TRY(mStateCache.getSamplerState(samplerState, &dxSamplerState));
+            ANGLE_TRY(mStateCache.getSamplerState(this, samplerState, &dxSamplerState));
 
             ASSERT(dxSamplerState != nullptr);
             mDeviceContext->VSSetSamplers(index, 1, &dxSamplerState);
@@ -1489,7 +1474,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
             memcmp(&samplerState, &mCurComputeSamplerStates[index], sizeof(gl::SamplerState)) != 0)
         {
             ID3D11SamplerState *dxSamplerState = nullptr;
-            ANGLE_TRY(mStateCache.getSamplerState(samplerState, &dxSamplerState));
+            ANGLE_TRY(mStateCache.getSamplerState(this, samplerState, &dxSamplerState));
 
             ASSERT(dxSamplerState != nullptr);
             mDeviceContext->CSSetSamplers(index, 1, &dxSamplerState);
@@ -1510,27 +1495,30 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
     return gl::NoError();
 }
 
-gl::Error Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *texture)
+gl::Error Renderer11::setTexture(const gl::Context *context,
+                                 gl::SamplerType type,
+                                 int index,
+                                 gl::Texture *texture)
 {
-    d3d11::SharedSRV textureSRV;
+    const d3d11::SharedSRV *textureSRV = nullptr;
 
     if (texture)
     {
         TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
 
         TextureStorage *texStorage = nullptr;
-        ANGLE_TRY(textureImpl->getNativeTexture(&texStorage));
+        ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage));
 
         // Texture should be complete and have a storage
         ASSERT(texStorage);
 
         TextureStorage11 *storage11 = GetAs<TextureStorage11>(texStorage);
 
-        ANGLE_TRY(storage11->getSRV(texture->getTextureState(), &textureSRV));
+        ANGLE_TRY(storage11->getSRV(context, texture->getTextureState(), &textureSRV));
 
-        // If we get NULL back from getSRV here, something went wrong in the texture class and we're
-        // unexpectedly missing the shader resource view
-        ASSERT(textureSRV.valid());
+        // If we get an invalid SRV here, something went wrong in the texture class and we're
+        // unexpectedly missing the shader resource view.
+        ASSERT(textureSRV->valid());
 
         textureImpl->resetDirty();
     }
@@ -1540,7 +1528,7 @@ gl::Error Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *t
            (type == gl::SAMPLER_VERTEX &&
             static_cast<unsigned int>(index) < getNativeCaps().maxVertexTextureImageUnits));
 
-    mStateManager.setShaderResource(type, index, textureSRV.get());
+    mStateManager.setShaderResource(type, index, textureSRV->get());
 
     return gl::NoError();
 }
@@ -1559,7 +1547,7 @@ gl::Error Renderer11::setUniformBuffers(const gl::ContextState &data,
             continue;
         }
 
-        const OffsetBindingPointer<gl::Buffer> &uniformBuffer =
+        const gl::OffsetBindingPointer<gl::Buffer> &uniformBuffer =
             data.getState().getIndexedUniformBuffer(binding);
         GLintptr uniformBufferOffset = uniformBuffer.getOffset();
         GLsizeiptr uniformBufferSize = uniformBuffer.getSize();
@@ -1580,7 +1568,7 @@ gl::Error Renderer11::setUniformBuffers(const gl::ContextState &data,
 
         if (!constantBuffer)
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Error retrieving constant buffer");
+            return gl::OutOfMemory() << "Error retrieving constant buffer";
         }
 
         if (mCurrentConstantBufferVS[uniformBufferIndex] != bufferStorage->getSerial() ||
@@ -1619,7 +1607,7 @@ gl::Error Renderer11::setUniformBuffers(const gl::ContextState &data,
             continue;
         }
 
-        const OffsetBindingPointer<gl::Buffer> &uniformBuffer =
+        const gl::OffsetBindingPointer<gl::Buffer> &uniformBuffer =
             data.getState().getIndexedUniformBuffer(binding);
         GLintptr uniformBufferOffset = uniformBuffer.getOffset();
         GLsizeiptr uniformBufferSize = uniformBuffer.getSize();
@@ -1640,7 +1628,7 @@ gl::Error Renderer11::setUniformBuffers(const gl::ContextState &data,
 
         if (!constantBuffer)
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Error retrieving constant buffer");
+            return gl::OutOfMemory() << "Error retrieving constant buffer";
         }
 
         if (mCurrentConstantBufferPS[uniformBufferIndex] != bufferStorage->getSerial() ||
@@ -1671,58 +1659,6 @@ gl::Error Renderer11::setUniformBuffers(const gl::ContextState &data,
     return gl::NoError();
 }
 
-gl::Error Renderer11::updateState(ContextImpl *contextImpl, GLenum drawMode)
-{
-    const auto &data    = contextImpl->getContextState();
-    const auto &glState = data.getState();
-
-    // Applies the render target surface, depth stencil surface, viewport rectangle and
-    // scissor rectangle to the renderer
-    gl::Framebuffer *framebuffer = glState.getDrawFramebuffer();
-    ASSERT(framebuffer && !framebuffer->hasAnyDirtyBit() && framebuffer->cachedComplete());
-    ANGLE_TRY(mStateManager.syncFramebuffer(contextImpl, framebuffer));
-
-    // Set the present path state
-    auto firstColorAttachment        = framebuffer->getFirstColorbuffer();
-    const bool presentPathFastActive = UsePresentPathFast(this, firstColorAttachment);
-    mStateManager.updatePresentPath(presentPathFastActive, firstColorAttachment);
-
-    // Setting viewport state
-    mStateManager.setViewport(&data.getCaps(), glState.getViewport(), glState.getNearPlane(),
-                              glState.getFarPlane());
-
-    // Setting scissor state
-    mStateManager.setScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled());
-
-    // Applying rasterizer state to D3D11 device
-    // Since framebuffer->getSamples will return the original samples which may be different with
-    // the sample counts that we set in render target view, here we use renderTarget->getSamples to
-    // get the actual samples.
-    GLsizei samples = 0;
-    if (firstColorAttachment)
-    {
-        ASSERT(firstColorAttachment->isAttached());
-        RenderTarget11 *renderTarget = nullptr;
-        ANGLE_TRY(firstColorAttachment->getRenderTarget(&renderTarget));
-        samples = renderTarget->getSamples();
-    }
-    gl::RasterizerState rasterizer = glState.getRasterizerState();
-    rasterizer.pointDrawMode       = (drawMode == GL_POINTS);
-    rasterizer.multiSample         = (samples != 0);
-
-    ANGLE_TRY(mStateManager.setRasterizerState(rasterizer));
-
-    // Setting blend state
-    unsigned int mask = GetBlendSampleMask(data, samples);
-    ANGLE_TRY(mStateManager.setBlendState(framebuffer, glState.getBlendState(),
-                                          glState.getBlendColor(), mask));
-
-    // Setting depth stencil state
-    ANGLE_TRY(mStateManager.setDepthStencilState(glState));
-
-    return gl::NoError();
-}
-
 bool Renderer11::applyPrimitiveType(GLenum mode, GLsizei count, bool usesPointSize)
 {
     D3D11_PRIMITIVE_TOPOLOGY primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
@@ -1774,26 +1710,23 @@ bool Renderer11::applyPrimitiveType(GLenum mode, GLsizei count, bool usesPointSi
         primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
     }
 
-    if (primitiveTopology != mCurrentPrimitiveTopology)
-    {
-        mDeviceContext->IASetPrimitiveTopology(primitiveTopology);
-        mCurrentPrimitiveTopology = primitiveTopology;
-    }
+    mStateManager.setPrimitiveTopology(primitiveTopology);
 
     return count >= minCount;
 }
 
-gl::Error Renderer11::applyVertexBuffer(const gl::State &state,
+gl::Error Renderer11::applyVertexBuffer(const gl::Context *context,
                                         GLenum mode,
                                         GLint first,
                                         GLsizei count,
                                         GLsizei instances,
                                         TranslatedIndexData *indexInfo)
 {
+    const auto &state       = context->getGLState();
     const auto &vertexArray = state.getVertexArray();
     auto *vertexArray11     = GetImplAs<VertexArray11>(vertexArray);
 
-    ANGLE_TRY(vertexArray11->updateDirtyAndDynamicAttribs(mVertexDataManager, state, first, count,
+    ANGLE_TRY(vertexArray11->updateDirtyAndDynamicAttribs(context, mVertexDataManager, first, count,
                                                           instances));
 
     ANGLE_TRY(mStateManager.updateCurrentValueAttribs(state, mVertexDataManager));
@@ -1852,7 +1785,7 @@ gl::Error Renderer11::applyIndexBuffer(const gl::ContextState &data,
     else
     {
         IndexBuffer11 *indexBuffer = GetAs<IndexBuffer11>(indexInfo->indexBuffer);
-        buffer                     = indexBuffer->getBuffer();
+        buffer                     = indexBuffer->getBuffer().get();
     }
 
     mAppliedIBChanged = false;
@@ -1906,12 +1839,13 @@ gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::ContextState &data
     return gl::NoError();
 }
 
-gl::Error Renderer11::drawArraysImpl(const gl::ContextState &data,
+gl::Error Renderer11::drawArraysImpl(const gl::Context *context,
                                      GLenum mode,
                                      GLint startVertex,
                                      GLsizei count,
                                      GLsizei instances)
 {
+    const auto &data       = context->getContextState();
     const auto &glState    = data.getState();
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
 
@@ -1921,7 +1855,7 @@ gl::Error Renderer11::drawArraysImpl(const gl::ContextState &data,
         // won't get the correct output. To work around this, draw with *only* the stream out
         // first (no pixel shader) to feed the stream out buffers and then draw again with the
         // geometry shader + pixel shader to rasterize the primitives.
-        mDeviceContext->PSSetShader(nullptr, nullptr, 0);
+        mStateManager.setPixelShader(nullptr);
 
         if (instances > 0)
         {
@@ -1933,8 +1867,8 @@ gl::Error Renderer11::drawArraysImpl(const gl::ContextState &data,
         }
 
         rx::ShaderExecutableD3D *pixelExe = nullptr;
-        ANGLE_TRY(
-            programD3D->getPixelExecutableForFramebuffer(glState.getDrawFramebuffer(), &pixelExe));
+        ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(
+            context, glState.getDrawFramebuffer(), &pixelExe));
 
         // Skip the draw call if rasterizer discard is enabled (or no fragment shader).
         if (!pixelExe || glState.getRasterizerState().rasterizerDiscard)
@@ -1942,20 +1876,15 @@ gl::Error Renderer11::drawArraysImpl(const gl::ContextState &data,
             return gl::NoError();
         }
 
-        ID3D11PixelShader *pixelShader = GetAs<ShaderExecutable11>(pixelExe)->getPixelShader();
-        ASSERT(reinterpret_cast<uintptr_t>(pixelShader) == mAppliedPixelShader);
-        mDeviceContext->PSSetShader(pixelShader, nullptr, 0);
+        mStateManager.setPixelShader(&GetAs<ShaderExecutable11>(pixelExe)->getPixelShader());
 
         // Retrieve the geometry shader.
         rx::ShaderExecutableD3D *geometryExe = nullptr;
         ANGLE_TRY(
             programD3D->getGeometryExecutableForPrimitiveType(data, mode, &geometryExe, nullptr));
 
-        ID3D11GeometryShader *geometryShader =
-            (geometryExe ? GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
-        mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
-        ASSERT(geometryShader);
-        mDeviceContext->GSSetShader(geometryShader, nullptr, 0);
+        mStateManager.setGeometryShader(
+            &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader());
 
         if (instances > 0)
         {
@@ -2092,14 +2021,15 @@ gl::Error Renderer11::drawElementsImpl(const gl::ContextState &data,
     return gl::NoError();
 }
 
-bool Renderer11::supportsFastIndirectDraw(const gl::State &state, GLenum mode, GLenum type)
+bool Renderer11::supportsFastIndirectDraw(const gl::Context *context, GLenum mode, GLenum type)
 {
-    const auto &vertexArray = state.getVertexArray();
+    const auto &glState     = context->getGLState();
+    const auto &vertexArray = glState.getVertexArray();
     auto *vertexArray11     = GetImplAs<VertexArray11>(vertexArray);
     // Indirect drawing doesn't support dynamic attribute storage since it needs the first and count
     // to translate when applyVertexBuffer. GL_LINE_LOOP and GL_TRIANGLE_FAN are not supported
     // either since we need to simulate them in D3D.
-    if (vertexArray11->hasDynamicAttrib(state) || mode == GL_LINE_LOOP || mode == GL_TRIANGLE_FAN)
+    if (vertexArray11->hasDynamicAttrib(context) || mode == GL_LINE_LOOP || mode == GL_TRIANGLE_FAN)
     {
         return false;
     }
@@ -2113,31 +2043,32 @@ bool Renderer11::supportsFastIndirectDraw(const gl::State &state, GLenum mode, G
         // primitive restart index in it since it also needs to know the index range and count.
         // So, for all other situations, we fall back to normal draw instead of indirect draw.
         bool primitiveRestartWorkaround = mIndexDataManager->usePrimitiveRestartWorkaround(
-            state.isPrimitiveRestartEnabled(), type);
+            glState.isPrimitiveRestartEnabled(), type);
         return !mIndexDataManager->isStreamingIndexData(primitiveRestartWorkaround, type,
                                                         elementArrayBuffer);
     }
     return true;
 }
 
-gl::Error Renderer11::drawArraysIndirectImpl(const gl::ContextState &data,
+gl::Error Renderer11::drawArraysIndirectImpl(const gl::Context *context,
                                              GLenum mode,
                                              const void *indirect)
 {
-    if (skipDraw(data, mode))
+    const auto &contextState = context->getContextState();
+    if (skipDraw(contextState, mode))
     {
         return gl::NoError();
     }
 
-    const auto &glState            = data.getState();
+    const auto &glState            = context->getGLState();
     gl::Buffer *drawIndirectBuffer = glState.getDrawIndirectBuffer();
     ASSERT(drawIndirectBuffer);
     Buffer11 *storage = GetImplAs<Buffer11>(drawIndirectBuffer);
     uintptr_t offset  = reinterpret_cast<uintptr_t>(indirect);
 
-    if (supportsFastIndirectDraw(glState, mode, GL_NONE))
+    if (supportsFastIndirectDraw(context, mode, GL_NONE))
     {
-        applyVertexBuffer(glState, mode, 0, 0, 0, nullptr);
+        applyVertexBuffer(context, mode, 0, 0, 0, nullptr);
         ID3D11Buffer *buffer = nullptr;
         ANGLE_TRY_RESULT(storage->getBuffer(BUFFER_USAGE_INDIRECT), buffer);
         mDeviceContext->DrawInstancedIndirect(buffer, static_cast<unsigned int>(offset));
@@ -2153,42 +2084,43 @@ gl::Error Renderer11::drawArraysIndirectImpl(const gl::ContextState &data,
     GLuint instances = args->instanceCount;
     GLuint first     = args->first;
 
-    ANGLE_TRY(applyVertexBuffer(glState, mode, first, count, instances, nullptr));
+    ANGLE_TRY(applyVertexBuffer(context, mode, first, count, instances, nullptr));
 
     if (mode == GL_LINE_LOOP)
     {
-        return drawLineLoop(data, count, GL_NONE, nullptr, 0, instances);
+        return drawLineLoop(contextState, count, GL_NONE, nullptr, 0, instances);
     }
     if (mode == GL_TRIANGLE_FAN)
     {
-        return drawTriangleFan(data, count, GL_NONE, nullptr, 0, instances);
+        return drawTriangleFan(contextState, count, GL_NONE, nullptr, 0, instances);
     }
 
     mDeviceContext->DrawInstanced(count, instances, 0, 0);
     return gl::NoError();
 }
 
-gl::Error Renderer11::drawElementsIndirectImpl(const gl::ContextState &data,
+gl::Error Renderer11::drawElementsIndirectImpl(const gl::Context *context,
                                                GLenum mode,
                                                GLenum type,
                                                const void *indirect)
 {
-    if (skipDraw(data, mode))
+    const auto &contextState = context->getContextState();
+    if (skipDraw(contextState, mode))
     {
         return gl::NoError();
     }
 
-    const auto &glState            = data.getState();
+    const auto &glState            = context->getGLState();
     gl::Buffer *drawIndirectBuffer = glState.getDrawIndirectBuffer();
     ASSERT(drawIndirectBuffer);
     Buffer11 *storage = GetImplAs<Buffer11>(drawIndirectBuffer);
     uintptr_t offset  = reinterpret_cast<uintptr_t>(indirect);
 
     TranslatedIndexData indexInfo;
-    if (supportsFastIndirectDraw(glState, mode, type))
+    if (supportsFastIndirectDraw(context, mode, type))
     {
-        ANGLE_TRY(applyIndexBuffer(data, nullptr, 0, mode, type, &indexInfo));
-        ANGLE_TRY(applyVertexBuffer(glState, mode, 0, 0, 0, &indexInfo));
+        ANGLE_TRY(applyIndexBuffer(contextState, nullptr, 0, mode, type, &indexInfo));
+        ANGLE_TRY(applyVertexBuffer(context, mode, 0, 0, 0, &indexInfo));
         ID3D11Buffer *buffer = nullptr;
         ANGLE_TRY_RESULT(storage->getBuffer(BUFFER_USAGE_INDIRECT), buffer);
         mDeviceContext->DrawIndexedInstancedIndirect(buffer, static_cast<unsigned int>(offset));
@@ -2216,20 +2148,20 @@ gl::Error Renderer11::drawElementsIndirectImpl(const gl::ContextState &data,
                                                 glState.isPrimitiveRestartEnabled(), &indexRange));
 
     indexInfo.indexRange = indexRange;
-    ANGLE_TRY(applyIndexBuffer(data, indices, count, mode, type, &indexInfo));
+    ANGLE_TRY(applyIndexBuffer(contextState, indices, count, mode, type, &indexInfo));
     size_t vertexCount = indexRange.vertexCount();
-    ANGLE_TRY(applyVertexBuffer(glState, mode, static_cast<GLsizei>(indexRange.start) + baseVertex,
+    ANGLE_TRY(applyVertexBuffer(context, mode, static_cast<GLsizei>(indexRange.start) + baseVertex,
                                 static_cast<GLsizei>(vertexCount), instances, &indexInfo));
 
     int baseVertexLocation = -static_cast<int>(indexRange.start);
     if (mode == GL_LINE_LOOP)
     {
-        return drawLineLoop(data, count, type, indices, baseVertexLocation, instances);
+        return drawLineLoop(contextState, count, type, indices, baseVertexLocation, instances);
     }
 
     if (mode == GL_TRIANGLE_FAN)
     {
-        return drawTriangleFan(data, count, type, indices, baseVertexLocation, instances);
+        return drawTriangleFan(contextState, count, type, indices, baseVertexLocation, instances);
     }
 
     mDeviceContext->DrawIndexedInstanced(count, instances, 0, baseVertexLocation, 0);
@@ -2279,9 +2211,8 @@ gl::Error Renderer11::drawLineLoop(const gl::ContextState &data,
     if (static_cast<unsigned int>(count) + 1 >
         (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to create a 32-bit looping index buffer for GL_LINE_LOOP, too "
-                         "many indices required.");
+        return gl::OutOfMemory() << "Failed to create a 32-bit looping index buffer for "
+                                    "GL_LINE_LOOP, too many indices required.";
     }
 
     GetLineLoopIndices(indices, type, static_cast<GLuint>(count),
@@ -2302,14 +2233,14 @@ gl::Error Renderer11::drawLineLoop(const gl::ContextState &data,
     ANGLE_TRY(mLineLoopIB->unmapBuffer());
 
     IndexBuffer11 *indexBuffer   = GetAs<IndexBuffer11>(mLineLoopIB->getIndexBuffer());
-    ID3D11Buffer *d3dIndexBuffer = indexBuffer->getBuffer();
+    const d3d11::Buffer &d3dIndexBuffer = indexBuffer->getBuffer();
     DXGI_FORMAT indexFormat      = indexBuffer->getIndexFormat();
 
-    if (mAppliedIB != d3dIndexBuffer || mAppliedIBFormat != indexFormat ||
+    if (mAppliedIB != d3dIndexBuffer.get() || mAppliedIBFormat != indexFormat ||
         mAppliedIBOffset != offset)
     {
-        mDeviceContext->IASetIndexBuffer(d3dIndexBuffer, indexFormat, offset);
-        mAppliedIB       = d3dIndexBuffer;
+        mDeviceContext->IASetIndexBuffer(d3dIndexBuffer.get(), indexFormat, offset);
+        mAppliedIB       = d3dIndexBuffer.get();
         mAppliedIBFormat = indexFormat;
         mAppliedIBOffset = offset;
     }
@@ -2371,9 +2302,8 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
 
     if (numTris > (std::numeric_limits<unsigned int>::max() / (sizeof(unsigned int) * 3)))
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to create a scratch index buffer for GL_TRIANGLE_FAN, too many "
-                         "indices required.");
+        return gl::OutOfMemory() << "Failed to create a scratch index buffer for GL_TRIANGLE_FAN, "
+                                    "too many indices required.";
     }
 
     GetTriFanIndices(indexPointer, type, count, data.getState().isPrimitiveRestartEnabled(),
@@ -2392,14 +2322,14 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
     ANGLE_TRY(mTriangleFanIB->unmapBuffer());
 
     IndexBuffer11 *indexBuffer   = GetAs<IndexBuffer11>(mTriangleFanIB->getIndexBuffer());
-    ID3D11Buffer *d3dIndexBuffer = indexBuffer->getBuffer();
+    const d3d11::Buffer &d3dIndexBuffer = indexBuffer->getBuffer();
     DXGI_FORMAT indexFormat      = indexBuffer->getIndexFormat();
 
-    if (mAppliedIB != d3dIndexBuffer || mAppliedIBFormat != indexFormat ||
+    if (mAppliedIB != d3dIndexBuffer.get() || mAppliedIBFormat != indexFormat ||
         mAppliedIBOffset != offset)
     {
-        mDeviceContext->IASetIndexBuffer(d3dIndexBuffer, indexFormat, offset);
-        mAppliedIB       = d3dIndexBuffer;
+        mDeviceContext->IASetIndexBuffer(d3dIndexBuffer.get(), indexFormat, offset);
+        mAppliedIB       = d3dIndexBuffer.get();
         mAppliedIBFormat = indexFormat;
         mAppliedIBOffset = offset;
     }
@@ -2418,11 +2348,12 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
     return gl::NoError();
 }
 
-gl::Error Renderer11::applyShaders(const gl::ContextState &data, GLenum drawMode)
+gl::Error Renderer11::applyShaders(const gl::Context *context, GLenum drawMode)
 {
     // This method is called single-threaded.
     ANGLE_TRY(ensureHLSLCompilerInitialized());
 
+    const auto &data       = context->getContextState();
     const auto &glState    = data.getState();
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
     programD3D->updateCachedInputLayout(glState);
@@ -2434,63 +2365,35 @@ gl::Error Renderer11::applyShaders(const gl::ContextState &data, GLenum drawMode
 
     const gl::Framebuffer *drawFramebuffer = glState.getDrawFramebuffer();
     ShaderExecutableD3D *pixelExe          = nullptr;
-    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(drawFramebuffer, &pixelExe));
+    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(context, drawFramebuffer, &pixelExe));
 
     ShaderExecutableD3D *geometryExe = nullptr;
     ANGLE_TRY(
         programD3D->getGeometryExecutableForPrimitiveType(data, drawMode, &geometryExe, nullptr));
 
-    ID3D11VertexShader *vertexShader =
-        (vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
+    const d3d11::VertexShader *vertexShader =
+        (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
 
-    ID3D11PixelShader *pixelShader = nullptr;
     // Skip pixel shader if we're doing rasterizer discard.
-    bool rasterizerDiscard = glState.getRasterizerState().rasterizerDiscard;
-    if (!rasterizerDiscard)
+    const d3d11::PixelShader *pixelShader = nullptr;
+    if (!glState.getRasterizerState().rasterizerDiscard)
     {
-        pixelShader = (pixelExe ? GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
+        pixelShader = (pixelExe ? &GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
     }
 
-    ID3D11GeometryShader *geometryShader = nullptr;
-    bool transformFeedbackActive         = glState.isTransformFeedbackActiveUnpaused();
-    if (transformFeedbackActive)
+    const d3d11::GeometryShader *geometryShader = nullptr;
+    if (glState.isTransformFeedbackActiveUnpaused())
     {
         geometryShader =
-            (vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
+            (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
     }
     else
     {
         geometryShader =
-            (geometryExe ? GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
-    }
-
-    bool dirtyUniforms = false;
-
-    if (reinterpret_cast<uintptr_t>(vertexShader) != mAppliedVertexShader)
-    {
-        mDeviceContext->VSSetShader(vertexShader, nullptr, 0);
-        mAppliedVertexShader = reinterpret_cast<uintptr_t>(vertexShader);
-        dirtyUniforms        = true;
-    }
-
-    if (reinterpret_cast<uintptr_t>(geometryShader) != mAppliedGeometryShader)
-    {
-        mDeviceContext->GSSetShader(geometryShader, nullptr, 0);
-        mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
-        dirtyUniforms          = true;
-    }
-
-    if (reinterpret_cast<uintptr_t>(pixelShader) != mAppliedPixelShader)
-    {
-        mDeviceContext->PSSetShader(pixelShader, nullptr, 0);
-        mAppliedPixelShader = reinterpret_cast<uintptr_t>(pixelShader);
-        dirtyUniforms       = true;
+            (geometryExe ? &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
     }
 
-    if (dirtyUniforms)
-    {
-        programD3D->dirtyAllUniforms();
-    }
+    mStateManager.setDrawShaders(vertexShader, geometryShader, pixelShader);
 
     return programD3D->applyUniforms(drawMode);
 }
@@ -2520,15 +2423,17 @@ gl::Error Renderer11::applyUniforms(const ProgramD3D &programD3D,
         }
     }
 
-    const UniformStorage11 *vertexUniformStorage =
+    UniformStorage11 *vertexUniformStorage =
         GetAs<UniformStorage11>(&programD3D.getVertexUniformStorage());
-    const UniformStorage11 *fragmentUniformStorage =
+    UniformStorage11 *fragmentUniformStorage =
         GetAs<UniformStorage11>(&programD3D.getFragmentUniformStorage());
     ASSERT(vertexUniformStorage);
     ASSERT(fragmentUniformStorage);
 
-    ID3D11Buffer *vertexConstantBuffer = vertexUniformStorage->getConstantBuffer();
-    ID3D11Buffer *pixelConstantBuffer  = fragmentUniformStorage->getConstantBuffer();
+    const d3d11::Buffer *vertexConstantBuffer = nullptr;
+    ANGLE_TRY(vertexUniformStorage->getConstantBuffer(this, &vertexConstantBuffer));
+    const d3d11::Buffer *pixelConstantBuffer = nullptr;
+    ANGLE_TRY(fragmentUniformStorage->getConstantBuffer(this, &pixelConstantBuffer));
 
     float(*mapVS)[4] = nullptr;
     float(*mapPS)[4] = nullptr;
@@ -2537,7 +2442,7 @@ gl::Error Renderer11::applyUniforms(const ProgramD3D &programD3D,
     {
         D3D11_MAPPED_SUBRESOURCE map = {0};
         HRESULT result =
-            mDeviceContext->Map(vertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
+            mDeviceContext->Map(vertexConstantBuffer->get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
         ASSERT(SUCCEEDED(result));
         mapVS = (float(*)[4])map.pData;
     }
@@ -2546,7 +2451,7 @@ gl::Error Renderer11::applyUniforms(const ProgramD3D &programD3D,
     {
         D3D11_MAPPED_SUBRESOURCE map = {0};
         HRESULT result =
-            mDeviceContext->Map(pixelConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
+            mDeviceContext->Map(pixelConstantBuffer->get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &map);
         ASSERT(SUCCEEDED(result));
         mapPS = (float(*)[4])map.pData;
     }
@@ -2576,62 +2481,53 @@ gl::Error Renderer11::applyUniforms(const ProgramD3D &programD3D,
 
     if (mapVS)
     {
-        mDeviceContext->Unmap(vertexConstantBuffer, 0);
+        mDeviceContext->Unmap(vertexConstantBuffer->get(), 0);
     }
 
     if (mapPS)
     {
-        mDeviceContext->Unmap(pixelConstantBuffer, 0);
+        mDeviceContext->Unmap(pixelConstantBuffer->get(), 0);
     }
 
-    if (mCurrentVertexConstantBuffer != vertexConstantBuffer)
+    ID3D11Buffer *appliedVertexConstants = vertexConstantBuffer->get();
+    if (mCurrentVertexConstantBuffer != reinterpret_cast<uintptr_t>(appliedVertexConstants))
     {
         mDeviceContext->VSSetConstantBuffers(
-            d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK, 1, &vertexConstantBuffer);
-        mCurrentVertexConstantBuffer = vertexConstantBuffer;
+            d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK, 1, &appliedVertexConstants);
+        mCurrentVertexConstantBuffer = reinterpret_cast<uintptr_t>(appliedVertexConstants);
     }
 
-    if (mCurrentPixelConstantBuffer != pixelConstantBuffer)
+    ID3D11Buffer *appliedPixelConstants = pixelConstantBuffer->get();
+    if (mCurrentPixelConstantBuffer != reinterpret_cast<uintptr_t>(appliedPixelConstants))
     {
         mDeviceContext->PSSetConstantBuffers(
-            d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK, 1, &pixelConstantBuffer);
-        mCurrentPixelConstantBuffer = pixelConstantBuffer;
+            d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK, 1, &appliedPixelConstants);
+        mCurrentPixelConstantBuffer = reinterpret_cast<uintptr_t>(appliedPixelConstants);
     }
 
-    if (!mDriverConstantBufferVS)
+    if (!mDriverConstantBufferVS.valid())
     {
         D3D11_BUFFER_DESC constantBufferDescription = {0};
         d3d11::InitConstantBufferDesc(
             &constantBufferDescription,
             sizeof(dx_VertexConstants11) + mSamplerMetadataVS.sizeBytes());
-        HRESULT result =
-            mDevice->CreateBuffer(&constantBufferDescription, nullptr, &mDriverConstantBufferVS);
-        ASSERT(SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create vertex shader constant buffer, result: 0x%X.",
-                             result);
-        }
+        ANGLE_TRY(allocateResource(constantBufferDescription, &mDriverConstantBufferVS));
+
+        ID3D11Buffer *driverVSConstants = mDriverConstantBufferVS.get();
         mDeviceContext->VSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1,
-                                             &mDriverConstantBufferVS);
+                                             &driverVSConstants);
     }
-    if (!mDriverConstantBufferPS)
+
+    if (!mDriverConstantBufferPS.valid())
     {
         D3D11_BUFFER_DESC constantBufferDescription = {0};
         d3d11::InitConstantBufferDesc(&constantBufferDescription,
                                       sizeof(dx_PixelConstants11) + mSamplerMetadataPS.sizeBytes());
-        HRESULT result =
-            mDevice->CreateBuffer(&constantBufferDescription, nullptr, &mDriverConstantBufferPS);
-        ASSERT(SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create pixel shader constant buffer, result: 0x%X.",
-                             result);
-        }
+        ANGLE_TRY(allocateResource(constantBufferDescription, &mDriverConstantBufferPS));
+
+        ID3D11Buffer *driverVSConstants = mDriverConstantBufferPS.get();
         mDeviceContext->PSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1,
-                                             &mDriverConstantBufferPS);
+                                             &driverVSConstants);
     }
 
     // Sampler metadata and driver constants need to coexist in the same constant buffer to conserve
@@ -2652,11 +2548,12 @@ gl::Error Renderer11::applyUniforms(const ProgramD3D &programD3D,
     if (programD3D.usesGeometryShader(drawMode))
     {
         // needed for the point sprite geometry shader
-        if (mCurrentGeometryConstantBuffer != mDriverConstantBufferPS)
+        ID3D11Buffer *appliedGeometryConstants = mDriverConstantBufferPS.get();
+        if (mCurrentGeometryConstantBuffer != reinterpret_cast<uintptr_t>(appliedGeometryConstants))
         {
-            ASSERT(mDriverConstantBufferPS != nullptr);
-            mDeviceContext->GSSetConstantBuffers(0, 1, &mDriverConstantBufferPS);
-            mCurrentGeometryConstantBuffer = mDriverConstantBufferPS;
+            ASSERT(mDriverConstantBufferPS.valid());
+            mDeviceContext->GSSetConstantBuffers(0, 1, &appliedGeometryConstants);
+            mCurrentGeometryConstantBuffer = reinterpret_cast<uintptr_t>(appliedGeometryConstants);
         }
     }
 
@@ -2773,24 +2670,24 @@ void Renderer11::applyDriverConstantsIfNeeded(TShaderConstants *appliedConstants
                                               const TShaderConstants &constants,
                                               SamplerMetadataD3D11 *samplerMetadata,
                                               size_t samplerMetadataReferencedBytes,
-                                              ID3D11Buffer *driverConstantBuffer)
+                                              const d3d11::Buffer &driverConstantBuffer)
 {
-    ASSERT(driverConstantBuffer != nullptr);
+    ASSERT(driverConstantBuffer.valid());
     if (memcmp(appliedConstants, &constants, sizeof(TShaderConstants)) != 0 ||
         samplerMetadata->isDirty())
     {
         memcpy(appliedConstants, &constants, sizeof(TShaderConstants));
 
         D3D11_MAPPED_SUBRESOURCE mapping = {0};
-        HRESULT result =
-            mDeviceContext->Map(driverConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapping);
+        HRESULT result = mDeviceContext->Map(driverConstantBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD,
+                                             0, &mapping);
         ASSERT(SUCCEEDED(result));
         memcpy(mapping.pData, appliedConstants, sizeof(TShaderConstants));
         // Previous buffer contents were discarded, so we need to refresh also the area of the
         // buffer that isn't used by this program.
         memcpy(&reinterpret_cast<uint8_t *>(mapping.pData)[sizeof(TShaderConstants)],
                samplerMetadata->getData(), samplerMetadata->sizeBytes());
-        mDeviceContext->Unmap(driverConstantBuffer, 0);
+        mDeviceContext->Unmap(driverConstantBuffer.get(), 0);
 
         samplerMetadata->markClean();
     }
@@ -2801,21 +2698,21 @@ template void Renderer11::applyDriverConstantsIfNeeded<dx_VertexConstants11>(
     const dx_VertexConstants11 &constants,
     SamplerMetadataD3D11 *samplerMetadata,
     size_t samplerMetadataReferencedBytes,
-    ID3D11Buffer *driverConstantBuffer);
+    const d3d11::Buffer &driverConstantBuffer);
 template void Renderer11::applyDriverConstantsIfNeeded<dx_PixelConstants11>(
     dx_PixelConstants11 *appliedConstants,
     const dx_PixelConstants11 &constants,
     SamplerMetadataD3D11 *samplerMetadata,
     size_t samplerMetadataReferencedBytes,
-    ID3D11Buffer *driverConstantBuffer);
+    const d3d11::Buffer &driverConstantBuffer);
 template void Renderer11::applyDriverConstantsIfNeeded<dx_ComputeConstants11>(
     dx_ComputeConstants11 *appliedConstants,
     const dx_ComputeConstants11 &constants,
     SamplerMetadataD3D11 *samplerMetadata,
     size_t samplerMetadataReferencedBytes,
-    ID3D11Buffer *driverConstantBuffer);
+    const d3d11::Buffer &driverConstantBuffer);
 
-void Renderer11::markAllStateDirty()
+void Renderer11::markAllStateDirty(const gl::Context *context)
 {
     TRACE_EVENT0("gpu.angle", "Renderer11::markAllStateDirty");
 
@@ -2834,24 +2731,17 @@ void Renderer11::markAllStateDirty()
         mForceSetComputeSamplerStates[csamplerId] = true;
     }
 
-    mStateManager.invalidateEverything();
+    mStateManager.invalidateEverything(context);
 
     mAppliedIB       = nullptr;
     mAppliedIBFormat = DXGI_FORMAT_UNKNOWN;
     mAppliedIBOffset = 0;
 
-    mAppliedVertexShader   = angle::DirtyPointer;
-    mAppliedGeometryShader = angle::DirtyPointer;
-    mAppliedPixelShader    = angle::DirtyPointer;
-    mAppliedComputeShader  = angle::DirtyPointer;
-
     mAppliedTFObject = angle::DirtyPointer;
 
     memset(&mAppliedVertexConstants, 0, sizeof(dx_VertexConstants11));
     memset(&mAppliedPixelConstants, 0, sizeof(dx_PixelConstants11));
 
-    mInputLayoutCache.markDirty();
-
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS; i++)
     {
         mCurrentConstantBufferVS[i]       = static_cast<unsigned int>(-1);
@@ -2862,12 +2752,10 @@ void Renderer11::markAllStateDirty()
         mCurrentConstantBufferPSSize[i]   = 0;
     }
 
-    mCurrentVertexConstantBuffer   = nullptr;
-    mCurrentPixelConstantBuffer    = nullptr;
-    mCurrentGeometryConstantBuffer = nullptr;
-    mCurrentComputeConstantBuffer  = nullptr;
-
-    mCurrentPrimitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
+    mCurrentVertexConstantBuffer   = angle::DirtyPointer;
+    mCurrentPixelConstantBuffer    = angle::DirtyPointer;
+    mCurrentGeometryConstantBuffer = angle::DirtyPointer;
+    mCurrentComputeConstantBuffer  = angle::DirtyPointer;
 }
 
 void Renderer11::releaseDeviceResources()
@@ -2885,10 +2773,10 @@ void Renderer11::releaseDeviceResources()
     SafeDelete(mTrim);
     SafeDelete(mPixelTransfer);
 
-    SafeRelease(mDriverConstantBufferVS);
-    SafeRelease(mDriverConstantBufferPS);
-    SafeRelease(mDriverConstantBufferCS);
-    SafeRelease(mSyncQuery);
+    mDriverConstantBufferVS.reset();
+    mDriverConstantBufferPS.reset();
+    mDriverConstantBufferCS.reset();
+    mSyncQuery.reset();
 }
 
 // set notify to true to broadcast a message to all contexts of the device loss
@@ -2927,17 +2815,13 @@ bool Renderer11::testDeviceResettable()
     ID3D11Device *dummyDevice;
     D3D_FEATURE_LEVEL dummyFeatureLevel;
     ID3D11DeviceContext *dummyContext;
+    UINT flags = (mCreateDebugDevice ? D3D11_CREATE_DEVICE_DEBUG : 0);
 
     ASSERT(mRequestedDriverType != D3D_DRIVER_TYPE_UNKNOWN);
     HRESULT result = D3D11CreateDevice(
-        nullptr, mRequestedDriverType, nullptr,
-#if defined(_DEBUG)
-        D3D11_CREATE_DEVICE_DEBUG,
-#else
-        0,
-#endif
-        mAvailableFeatureLevels.data(), static_cast<unsigned int>(mAvailableFeatureLevels.size()),
-        D3D11_SDK_VERSION, &dummyDevice, &dummyFeatureLevel, &dummyContext);
+        nullptr, mRequestedDriverType, nullptr, flags, mAvailableFeatureLevels.data(),
+        static_cast<unsigned int>(mAvailableFeatureLevels.size()), D3D11_SDK_VERSION, &dummyDevice,
+        &dummyFeatureLevel, &dummyContext);
 
     if (!mDevice || FAILED(result))
     {
@@ -3245,7 +3129,8 @@ const angle::WorkaroundsD3D &RendererD3D::getWorkarounds() const
     return mWorkarounds;
 }
 
-gl::Error Renderer11::copyImageInternal(const gl::Framebuffer *framebuffer,
+gl::Error Renderer11::copyImageInternal(const gl::Context *context,
+                                        const gl::Framebuffer *framebuffer,
                                         const gl::Rectangle &sourceRect,
                                         GLenum destFormat,
                                         const gl::Offset &destOffset,
@@ -3255,7 +3140,7 @@ gl::Error Renderer11::copyImageInternal(const gl::Framebuffer *framebuffer,
     ASSERT(colorAttachment);
 
     RenderTarget11 *sourceRenderTarget = nullptr;
-    ANGLE_TRY(colorAttachment->getRenderTarget(&sourceRenderTarget));
+    ANGLE_TRY(colorAttachment->getRenderTarget(context, &sourceRenderTarget));
     ASSERT(sourceRenderTarget);
 
     const d3d11::SharedSRV &source = sourceRenderTarget->getBlitShaderResourceView();
@@ -3281,14 +3166,15 @@ gl::Error Renderer11::copyImageInternal(const gl::Framebuffer *framebuffer,
     // Use nearest filtering because source and destination are the same size for the direct copy.
     // Convert to the unsized format before calling copyTexture.
     GLenum sourceFormat = colorAttachment->getFormat().info->format;
-    ANGLE_TRY(mBlit->copyTexture(source, sourceArea, sourceSize, sourceFormat, dest, destArea,
-                                 destSize, nullptr, gl::GetUnsizedFormat(destFormat), GL_NEAREST,
-                                 false, false, false));
+    ANGLE_TRY(mBlit->copyTexture(context, source, sourceArea, sourceSize, sourceFormat, dest,
+                                 destArea, destSize, nullptr, gl::GetUnsizedFormat(destFormat),
+                                 GL_NEAREST, false, false, false));
 
     return gl::NoError();
 }
 
-gl::Error Renderer11::copyImage2D(const gl::Framebuffer *framebuffer,
+gl::Error Renderer11::copyImage2D(const gl::Context *context,
+                                  const gl::Framebuffer *framebuffer,
                                   const gl::Rectangle &sourceRect,
                                   GLenum destFormat,
                                   const gl::Offset &destOffset,
@@ -3300,17 +3186,19 @@ gl::Error Renderer11::copyImage2D(const gl::Framebuffer *framebuffer,
 
     gl::ImageIndex index              = gl::ImageIndex::Make2D(level);
     RenderTargetD3D *destRenderTarget = nullptr;
-    ANGLE_TRY(storage11->getRenderTarget(index, &destRenderTarget));
+    ANGLE_TRY(storage11->getRenderTarget(context, index, &destRenderTarget));
     ASSERT(destRenderTarget);
 
-    ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget));
+    ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset,
+                                destRenderTarget));
 
     storage11->markLevelDirty(level);
 
     return gl::NoError();
 }
 
-gl::Error Renderer11::copyImageCube(const gl::Framebuffer *framebuffer,
+gl::Error Renderer11::copyImageCube(const gl::Context *context,
+                                    const gl::Framebuffer *framebuffer,
                                     const gl::Rectangle &sourceRect,
                                     GLenum destFormat,
                                     const gl::Offset &destOffset,
@@ -3323,17 +3211,19 @@ gl::Error Renderer11::copyImageCube(const gl::Framebuffer *framebuffer,
 
     gl::ImageIndex index              = gl::ImageIndex::MakeCube(target, level);
     RenderTargetD3D *destRenderTarget = nullptr;
-    ANGLE_TRY(storage11->getRenderTarget(index, &destRenderTarget));
+    ANGLE_TRY(storage11->getRenderTarget(context, index, &destRenderTarget));
     ASSERT(destRenderTarget);
 
-    ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget));
+    ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset,
+                                destRenderTarget));
 
     storage11->markLevelDirty(level);
 
     return gl::NoError();
 }
 
-gl::Error Renderer11::copyImage3D(const gl::Framebuffer *framebuffer,
+gl::Error Renderer11::copyImage3D(const gl::Context *context,
+                                  const gl::Framebuffer *framebuffer,
                                   const gl::Rectangle &sourceRect,
                                   GLenum destFormat,
                                   const gl::Offset &destOffset,
@@ -3345,17 +3235,19 @@ gl::Error Renderer11::copyImage3D(const gl::Framebuffer *framebuffer,
 
     gl::ImageIndex index              = gl::ImageIndex::Make3D(level, destOffset.z);
     RenderTargetD3D *destRenderTarget = nullptr;
-    ANGLE_TRY(storage11->getRenderTarget(index, &destRenderTarget));
+    ANGLE_TRY(storage11->getRenderTarget(context, index, &destRenderTarget));
     ASSERT(destRenderTarget);
 
-    ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget));
+    ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset,
+                                destRenderTarget));
 
     storage11->markLevelDirty(level);
 
     return gl::NoError();
 }
 
-gl::Error Renderer11::copyImage2DArray(const gl::Framebuffer *framebuffer,
+gl::Error Renderer11::copyImage2DArray(const gl::Context *context,
+                                       const gl::Framebuffer *framebuffer,
                                        const gl::Rectangle &sourceRect,
                                        GLenum destFormat,
                                        const gl::Offset &destOffset,
@@ -3367,16 +3259,18 @@ gl::Error Renderer11::copyImage2DArray(const gl::Framebuffer *framebuffer,
 
     gl::ImageIndex index              = gl::ImageIndex::Make2DArray(level, destOffset.z);
     RenderTargetD3D *destRenderTarget = nullptr;
-    ANGLE_TRY(storage11->getRenderTarget(index, &destRenderTarget));
+    ANGLE_TRY(storage11->getRenderTarget(context, index, &destRenderTarget));
     ASSERT(destRenderTarget);
 
-    ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget));
+    ANGLE_TRY(copyImageInternal(context, framebuffer, sourceRect, destFormat, destOffset,
+                                destRenderTarget));
     storage11->markLevelDirty(level);
 
     return gl::NoError();
 }
 
-gl::Error Renderer11::copyTexture(const gl::Texture *source,
+gl::Error Renderer11::copyTexture(const gl::Context *context,
+                                  const gl::Texture *source,
                                   GLint sourceLevel,
                                   const gl::Rectangle &sourceRect,
                                   GLenum destFormat,
@@ -3388,10 +3282,10 @@ gl::Error Renderer11::copyTexture(const gl::Texture *source,
                                   bool unpackPremultiplyAlpha,
                                   bool unpackUnmultiplyAlpha)
 {
-    const TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source);
+    TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source);
 
     TextureStorage *sourceStorage = nullptr;
-    ANGLE_TRY(const_cast<TextureD3D *>(sourceD3D)->getNativeTexture(&sourceStorage));
+    ANGLE_TRY(sourceD3D->getNativeTexture(context, &sourceStorage));
 
     TextureStorage11_2D *sourceStorage11 = GetAs<TextureStorage11_2D>(sourceStorage);
     ASSERT(sourceStorage11);
@@ -3404,14 +3298,14 @@ gl::Error Renderer11::copyTexture(const gl::Texture *source,
         source->getFormat(GL_TEXTURE_2D, sourceLevel).info->format == destFormat &&
         sourceStorage11->getFormatSet().texFormat == destStorage11->getFormatSet().texFormat)
     {
-        ID3D11Resource *sourceResource = nullptr;
-        ANGLE_TRY(sourceStorage11->getResource(&sourceResource));
+        const TextureHelper11 *sourceResource = nullptr;
+        ANGLE_TRY(sourceStorage11->getResource(context, &sourceResource));
 
         gl::ImageIndex sourceIndex = gl::ImageIndex::Make2D(sourceLevel);
         UINT sourceSubresource     = sourceStorage11->getSubresourceIndex(sourceIndex);
 
-        ID3D11Resource *destResource = nullptr;
-        ANGLE_TRY(destStorage11->getResource(&destResource));
+        const TextureHelper11 *destResource = nullptr;
+        ANGLE_TRY(destStorage11->getResource(context, &destResource));
 
         gl::ImageIndex destIndex = gl::ImageIndex::MakeGeneric(destTarget, destLevel);
         UINT destSubresource     = destStorage11->getSubresourceIndex(destIndex);
@@ -3425,18 +3319,18 @@ gl::Error Renderer11::copyTexture(const gl::Texture *source,
             1u,
         };
 
-        mDeviceContext->CopySubresourceRegion(destResource, destSubresource, destOffset.x,
-                                              destOffset.y, destOffset.z, sourceResource,
+        mDeviceContext->CopySubresourceRegion(destResource->get(), destSubresource, destOffset.x,
+                                              destOffset.y, destOffset.z, sourceResource->get(),
                                               sourceSubresource, &sourceBox);
     }
     else
     {
-        d3d11::SharedSRV sourceSRV;
-        ANGLE_TRY(sourceStorage11->getSRVLevels(sourceLevel, sourceLevel, &sourceSRV));
+        const d3d11::SharedSRV *sourceSRV = nullptr;
+        ANGLE_TRY(sourceStorage11->getSRVLevels(context, sourceLevel, sourceLevel, &sourceSRV));
 
         gl::ImageIndex destIndex             = gl::ImageIndex::MakeGeneric(destTarget, destLevel);
         RenderTargetD3D *destRenderTargetD3D = nullptr;
-        ANGLE_TRY(destStorage11->getRenderTarget(destIndex, &destRenderTargetD3D));
+        ANGLE_TRY(destStorage11->getRenderTarget(context, destIndex, &destRenderTargetD3D));
 
         RenderTarget11 *destRenderTarget11 = GetAs<RenderTarget11>(destRenderTargetD3D);
 
@@ -3459,9 +3353,9 @@ gl::Error Renderer11::copyTexture(const gl::Texture *source,
         // Use nearest filtering because source and destination are the same size for the direct
         // copy
         GLenum sourceFormat = source->getFormat(GL_TEXTURE_2D, sourceLevel).info->format;
-        ANGLE_TRY(mBlit->copyTexture(sourceSRV, sourceArea, sourceSize, sourceFormat, destRTV,
-                                     destArea, destSize, nullptr, destFormat, GL_NEAREST, false,
-                                     unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
+        ANGLE_TRY(mBlit->copyTexture(context, *sourceSRV, sourceArea, sourceSize, sourceFormat,
+                                     destRTV, destArea, destSize, nullptr, destFormat, GL_NEAREST,
+                                     false, unpackPremultiplyAlpha, unpackUnmultiplyAlpha));
     }
 
     destStorage11->markLevelDirty(destLevel);
@@ -3469,7 +3363,8 @@ gl::Error Renderer11::copyTexture(const gl::Texture *source,
     return gl::NoError();
 }
 
-gl::Error Renderer11::copyCompressedTexture(const gl::Texture *source,
+gl::Error Renderer11::copyCompressedTexture(const gl::Context *context,
+                                            const gl::Texture *source,
                                             GLint sourceLevel,
                                             TextureStorage *storage,
                                             GLint destLevel)
@@ -3477,8 +3372,8 @@ gl::Error Renderer11::copyCompressedTexture(const gl::Texture *source,
     TextureStorage11_2D *destStorage11 = GetAs<TextureStorage11_2D>(storage);
     ASSERT(destStorage11);
 
-    ID3D11Resource *destResource = nullptr;
-    ANGLE_TRY(destStorage11->getResource(&destResource));
+    const TextureHelper11 *destResource = nullptr;
+    ANGLE_TRY(destStorage11->getResource(context, &destResource));
 
     gl::ImageIndex destIndex = gl::ImageIndex::Make2D(destLevel);
     UINT destSubresource     = destStorage11->getSubresourceIndex(destIndex);
@@ -3487,19 +3382,19 @@ gl::Error Renderer11::copyCompressedTexture(const gl::Texture *source,
     ASSERT(sourceD3D);
 
     TextureStorage *sourceStorage = nullptr;
-    ANGLE_TRY(sourceD3D->getNativeTexture(&sourceStorage));
+    ANGLE_TRY(sourceD3D->getNativeTexture(context, &sourceStorage));
 
     TextureStorage11_2D *sourceStorage11 = GetAs<TextureStorage11_2D>(sourceStorage);
     ASSERT(sourceStorage11);
 
-    ID3D11Resource *sourceResource = nullptr;
-    ANGLE_TRY(sourceStorage11->getResource(&sourceResource));
+    const TextureHelper11 *sourceResource = nullptr;
+    ANGLE_TRY(sourceStorage11->getResource(context, &sourceResource));
 
     gl::ImageIndex sourceIndex = gl::ImageIndex::Make2D(sourceLevel);
     UINT sourceSubresource     = sourceStorage11->getSubresourceIndex(sourceIndex);
 
-    mDeviceContext->CopySubresourceRegion(destResource, destSubresource, 0, 0, 0, sourceResource,
-                                          sourceSubresource, nullptr);
+    mDeviceContext->CopySubresourceRegion(destResource->get(), destSubresource, 0, 0, 0,
+                                          sourceResource->get(), sourceSubresource, nullptr);
 
     return gl::NoError();
 }
@@ -3555,14 +3450,8 @@ gl::Error Renderer11::createRenderTarget(int width,
         // The format must be either an RTV or a DSV
         ASSERT(bindRTV != bindDSV);
 
-        ID3D11Texture2D *texture = nullptr;
-        HRESULT result           = mDevice->CreateTexture2D(&desc, nullptr, &texture);
-        if (FAILED(result))
-        {
-            ASSERT(result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create render target texture, result: 0x%X.", result);
-        }
+        TextureHelper11 texture;
+        ANGLE_TRY(allocateTexture(desc, formatInfo, &texture));
 
         d3d11::SharedSRV srv;
         d3d11::SharedSRV blitSRV;
@@ -3575,12 +3464,7 @@ gl::Error Renderer11::createRenderTarget(int width,
             srvDesc.Texture2D.MostDetailedMip = 0;
             srvDesc.Texture2D.MipLevels       = 1;
 
-            gl::Error err = allocateResource(srvDesc, texture, &srv);
-            if (err.isError())
-            {
-                SafeRelease(texture);
-                return err;
-            }
+            ANGLE_TRY(allocateResource(srvDesc, texture.get(), &srv));
 
             if (formatInfo.blitSRVFormat != formatInfo.srvFormat)
             {
@@ -3592,16 +3476,11 @@ gl::Error Renderer11::createRenderTarget(int width,
                 blitSRVDesc.Texture2D.MostDetailedMip = 0;
                 blitSRVDesc.Texture2D.MipLevels       = 1;
 
-                err = allocateResource(blitSRVDesc, texture, &blitSRV);
-                if (err.isError())
-                {
-                    SafeRelease(texture);
-                    return err;
-                }
+                ANGLE_TRY(allocateResource(blitSRVDesc, texture.get(), &blitSRV));
             }
             else
             {
-                blitSRV = srv;
+                blitSRV = srv.makeCopy();
             }
         }
 
@@ -3615,12 +3494,7 @@ gl::Error Renderer11::createRenderTarget(int width,
             dsvDesc.Flags              = 0;
 
             d3d11::DepthStencilView dsv;
-            gl::Error err = allocateResource(dsvDesc, texture, &dsv);
-            if (err.isError())
-            {
-                SafeRelease(texture);
-                return err;
-            }
+            ANGLE_TRY(allocateResource(dsvDesc, texture.get(), &dsv));
 
             *outRT = new TextureRenderTarget11(std::move(dsv), texture, srv, format, formatInfo,
                                                width, height, 1, supportedSamples);
@@ -3634,12 +3508,7 @@ gl::Error Renderer11::createRenderTarget(int width,
             rtvDesc.Texture2D.MipSlice = 0;
 
             d3d11::RenderTargetView rtv;
-            gl::Error err = allocateResource(rtvDesc, texture, &rtv);
-            if (err.isError())
-            {
-                SafeRelease(texture);
-                return err;
-            }
+            ANGLE_TRY(allocateResource(rtvDesc, texture.get(), &rtv));
 
             if (formatInfo.dataInitializerFunction != nullptr)
             {
@@ -3654,14 +3523,13 @@ gl::Error Renderer11::createRenderTarget(int width,
         {
             UNREACHABLE();
         }
-
-        SafeRelease(texture);
     }
     else
     {
-        *outRT = new TextureRenderTarget11(
-            d3d11::RenderTargetView(), nullptr, d3d11::SharedSRV(), d3d11::SharedSRV(), format,
-            d3d11::Format::Get(GL_NONE, mRenderer11DeviceCaps), width, height, 1, supportedSamples);
+        *outRT = new TextureRenderTarget11(d3d11::RenderTargetView(), TextureHelper11(),
+                                           d3d11::SharedSRV(), d3d11::SharedSRV(), format,
+                                           d3d11::Format::Get(GL_NONE, mRenderer11DeviceCaps),
+                                           width, height, 1, supportedSamples);
     }
 
     return gl::NoError();
@@ -3678,33 +3546,29 @@ gl::Error Renderer11::createRenderTargetCopy(RenderTargetD3D *source, RenderTarg
     RenderTarget11 *source11 = GetAs<RenderTarget11>(source);
     RenderTarget11 *dest11   = GetAs<RenderTarget11>(newRT);
 
-    mDeviceContext->CopySubresourceRegion(dest11->getTexture(), dest11->getSubresourceIndex(), 0, 0,
-                                          0, source11->getTexture(),
+    mDeviceContext->CopySubresourceRegion(dest11->getTexture().get(), dest11->getSubresourceIndex(),
+                                          0, 0, 0, source11->getTexture().get(),
                                           source11->getSubresourceIndex(), nullptr);
     *outRT = newRT;
     return gl::NoError();
 }
 
-gl::Error Renderer11::loadExecutable(const void *function,
+gl::Error Renderer11::loadExecutable(const uint8_t *function,
                                      size_t length,
                                      ShaderType type,
                                      const std::vector<D3DVarying> &streamOutVaryings,
                                      bool separatedOutputBuffers,
                                      ShaderExecutableD3D **outExecutable)
 {
+    ShaderData shaderData(function, length);
+
     switch (type)
     {
         case SHADER_VERTEX:
         {
-            ID3D11VertexShader *vertexShader      = nullptr;
-            ID3D11GeometryShader *streamOutShader = nullptr;
-
-            HRESULT result = mDevice->CreateVertexShader(function, length, nullptr, &vertexShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create vertex shader, " << result;
-            }
+            d3d11::VertexShader vertexShader;
+            d3d11::GeometryShader streamOutShader;
+            ANGLE_TRY(allocateResource(shaderData, &vertexShader));
 
             if (!streamOutVaryings.empty())
             {
@@ -3724,68 +3588,37 @@ gl::Error Renderer11::loadExecutable(const void *function,
                     soDeclaration.push_back(entry);
                 }
 
-                result = mDevice->CreateGeometryShaderWithStreamOutput(
-                    function, static_cast<unsigned int>(length), soDeclaration.data(),
-                    static_cast<unsigned int>(soDeclaration.size()), nullptr, 0, 0, nullptr,
-                    &streamOutShader);
-                ASSERT(SUCCEEDED(result));
-                if (FAILED(result))
-                {
-                    return gl::OutOfMemory() << "Failed to create steam output shader, " << result;
-                }
+                ANGLE_TRY(allocateResource(shaderData, &soDeclaration, &streamOutShader));
             }
 
-            *outExecutable =
-                new ShaderExecutable11(function, length, vertexShader, streamOutShader);
+            *outExecutable = new ShaderExecutable11(function, length, std::move(vertexShader),
+                                                    std::move(streamOutShader));
         }
         break;
         case SHADER_PIXEL:
         {
-            ID3D11PixelShader *pixelShader = nullptr;
-
-            HRESULT result = mDevice->CreatePixelShader(function, length, nullptr, &pixelShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create pixel shader, " << result;
-            }
-
-            *outExecutable = new ShaderExecutable11(function, length, pixelShader);
+            d3d11::PixelShader pixelShader;
+            ANGLE_TRY(allocateResource(shaderData, &pixelShader));
+            *outExecutable = new ShaderExecutable11(function, length, std::move(pixelShader));
         }
         break;
         case SHADER_GEOMETRY:
         {
-            ID3D11GeometryShader *geometryShader = nullptr;
-
-            HRESULT result =
-                mDevice->CreateGeometryShader(function, length, nullptr, &geometryShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create geometry shader, " << result;
-            }
-
-            *outExecutable = new ShaderExecutable11(function, length, geometryShader);
+            d3d11::GeometryShader geometryShader;
+            ANGLE_TRY(allocateResource(shaderData, &geometryShader));
+            *outExecutable = new ShaderExecutable11(function, length, std::move(geometryShader));
         }
         break;
         case SHADER_COMPUTE:
         {
-            ID3D11ComputeShader *computeShader = nullptr;
-
-            HRESULT result =
-                mDevice->CreateComputeShader(function, length, nullptr, &computeShader);
-            ASSERT(SUCCEEDED(result));
-            if (FAILED(result))
-            {
-                return gl::OutOfMemory() << "Failed to create compute shader, " << result;
-            }
-
-            *outExecutable = new ShaderExecutable11(function, length, computeShader);
+            d3d11::ComputeShader computeShader;
+            ANGLE_TRY(allocateResource(shaderData, &computeShader));
+            *outExecutable = new ShaderExecutable11(function, length, std::move(computeShader));
         }
         break;
         default:
             UNREACHABLE();
-            return gl::Error(GL_INVALID_OPERATION);
+            return gl::InternalError();
     }
 
     return gl::NoError();
@@ -3817,7 +3650,7 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
             break;
         default:
             UNREACHABLE();
-            return gl::Error(GL_INVALID_OPERATION);
+            return gl::InternalError();
     }
 
     profileStream << "_" << getMajorShaderModel() << "_" << getMinorShaderModel()
@@ -3857,6 +3690,7 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
 
     D3D_SHADER_MACRO loopMacros[] = {{"ANGLE_ENABLE_LOOP_FLATTEN", "1"}, {0, 0}};
 
+    // TODO(jmadill): Use ComPtr?
     ID3DBlob *binary = nullptr;
     std::string debugInfo;
     ANGLE_TRY(mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, loopMacros, &binary,
@@ -3871,8 +3705,9 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
         return gl::NoError();
     }
 
-    gl::Error error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
-                                     streamOutVaryings, separatedOutputBuffers, outExectuable);
+    gl::Error error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
+                                     binary->GetBufferSize(), type, streamOutVaryings,
+                                     separatedOutputBuffers, outExectuable);
 
     SafeRelease(binary);
     if (error.isError())
@@ -3895,7 +3730,7 @@ gl::Error Renderer11::ensureHLSLCompilerInitialized()
 
 UniformStorageD3D *Renderer11::createUniformStorage(size_t storageSize)
 {
-    return new UniformStorage11(this, storageSize);
+    return new UniformStorage11(storageSize);
 }
 
 VertexBuffer *Renderer11::createVertexBuffer()
@@ -3962,7 +3797,8 @@ bool Renderer11::supportsFastCopyBufferToTexture(GLenum internalFormat) const
     return true;
 }
 
-gl::Error Renderer11::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack,
+gl::Error Renderer11::fastCopyBufferToTexture(const gl::Context *context,
+                                              const gl::PixelUnpackState &unpack,
                                               unsigned int offset,
                                               RenderTargetD3D *destRenderTarget,
                                               GLenum destinationFormat,
@@ -3970,8 +3806,8 @@ gl::Error Renderer11::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack
                                               const gl::Box &destArea)
 {
     ASSERT(supportsFastCopyBufferToTexture(destinationFormat));
-    return mPixelTransfer->copyBufferToTexture(unpack, offset, destRenderTarget, destinationFormat,
-                                               sourcePixelsType, destArea);
+    return mPixelTransfer->copyBufferToTexture(context, unpack, offset, destRenderTarget,
+                                               destinationFormat, sourcePixelsType, destArea);
 }
 
 ImageD3D *Renderer11::createImage()
@@ -3979,14 +3815,15 @@ ImageD3D *Renderer11::createImage()
     return new Image11(this);
 }
 
-gl::Error Renderer11::generateMipmap(ImageD3D *dest, ImageD3D *src)
+gl::Error Renderer11::generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *src)
 {
     Image11 *dest11 = GetAs<Image11>(dest);
     Image11 *src11  = GetAs<Image11>(src);
-    return Image11::generateMipmap(dest11, src11, mRenderer11DeviceCaps);
+    return Image11::GenerateMipmap(context, dest11, src11, mRenderer11DeviceCaps);
 }
 
-gl::Error Renderer11::generateMipmapUsingD3D(TextureStorage *storage,
+gl::Error Renderer11::generateMipmapUsingD3D(const gl::Context *context,
+                                             TextureStorage *storage,
                                              const gl::TextureState &textureState)
 {
     TextureStorage11 *storage11 = GetAs<TextureStorage11>(storage);
@@ -3994,15 +3831,30 @@ gl::Error Renderer11::generateMipmapUsingD3D(TextureStorage *storage,
     ASSERT(storage11->isRenderTarget());
     ASSERT(storage11->supportsNativeMipmapFunction());
 
-    d3d11::SharedSRV srv;
-    ANGLE_TRY(storage11->getSRVLevels(textureState.getEffectiveBaseLevel(),
+    const d3d11::SharedSRV *srv = nullptr;
+    ANGLE_TRY(storage11->getSRVLevels(context, textureState.getEffectiveBaseLevel(),
                                       textureState.getEffectiveMaxLevel(), &srv));
 
-    mDeviceContext->GenerateMips(srv.get());
+    mDeviceContext->GenerateMips(srv->get());
 
     return gl::NoError();
 }
 
+gl::Error Renderer11::copyImage(const gl::Context *context,
+                                ImageD3D *dest,
+                                ImageD3D *source,
+                                const gl::Rectangle &sourceRect,
+                                const gl::Offset &destOffset,
+                                bool unpackFlipY,
+                                bool unpackPremultiplyAlpha,
+                                bool unpackUnmultiplyAlpha)
+{
+    Image11 *dest11 = GetAs<Image11>(dest);
+    Image11 *src11  = GetAs<Image11>(source);
+    return Image11::CopyImage(context, dest11, src11, sourceRect, destOffset, unpackFlipY,
+                              unpackPremultiplyAlpha, unpackUnmultiplyAlpha, mRenderer11DeviceCaps);
+}
+
 TextureStorage *Renderer11::createTextureStorage2D(SwapChainD3D *swapChain)
 {
     SwapChain11 *swapChain11 = GetAs<SwapChain11>(swapChain);
@@ -4065,7 +3917,19 @@ TextureStorage *Renderer11::createTextureStorage2DArray(GLenum internalformat,
                                         levels);
 }
 
-gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAttachment,
+TextureStorage *Renderer11::createTextureStorage2DMultisample(GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height,
+                                                              int levels,
+                                                              int samples,
+                                                              GLboolean fixedSampleLocations)
+{
+    return new TextureStorage11_2DMultisample(this, internalformat, width, height, levels, samples,
+                                              fixedSampleLocations);
+}
+
+gl::Error Renderer11::readFromAttachment(const gl::Context *context,
+                                         const gl::FramebufferAttachment &srcAttachment,
                                          const gl::Rectangle &sourceArea,
                                          GLenum format,
                                          GLenum type,
@@ -4078,14 +3942,11 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt
 
     const bool invertTexture = UsePresentPathFast(this, &srcAttachment);
 
-    RenderTargetD3D *renderTarget = nullptr;
-    ANGLE_TRY(srcAttachment.getRenderTarget(&renderTarget));
-
-    RenderTarget11 *rt11 = GetAs<RenderTarget11>(renderTarget);
-    ASSERT(rt11->getTexture());
+    RenderTarget11 *rt11 = nullptr;
+    ANGLE_TRY(srcAttachment.getRenderTarget(context, &rt11));
+    ASSERT(rt11->getTexture().valid());
 
-    TextureHelper11 textureHelper =
-        TextureHelper11::MakeAndReference(rt11->getTexture(), rt11->getFormatSet());
+    const TextureHelper11 &textureHelper = rt11->getTexture();
     unsigned int sourceSubResource = rt11->getSubresourceIndex();
 
     const gl::Extents &texSize = textureHelper.getExtents();
@@ -4129,7 +3990,7 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt
     // For 2D multisampled textures, it points to the multisampled resolve texture.
     const TextureHelper11 *srcTexture = &textureHelper;
 
-    if (textureHelper.getTextureType() == GL_TEXTURE_2D && textureHelper.getSampleCount() > 1)
+    if (textureHelper.is2D() && textureHelper.getSampleCount() > 1)
     {
         D3D11_TEXTURE2D_DESC resolveDesc;
         resolveDesc.Width              = static_cast<UINT>(texSize.width);
@@ -4144,20 +4005,11 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt
         resolveDesc.CPUAccessFlags     = 0;
         resolveDesc.MiscFlags          = 0;
 
-        ID3D11Texture2D *resolveTex2D = nullptr;
-        HRESULT result = mDevice->CreateTexture2D(&resolveDesc, nullptr, &resolveTex2D);
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Renderer11::readTextureData failed to create internal resolve "
-                             "texture for ReadPixels, HRESULT: 0x%X.",
-                             result);
-        }
+        ANGLE_TRY(
+            allocateTexture(resolveDesc, textureHelper.getFormatSet(), &resolvedTextureHelper));
 
-        mDeviceContext->ResolveSubresource(resolveTex2D, 0, textureHelper.getTexture2D(),
+        mDeviceContext->ResolveSubresource(resolvedTextureHelper.get(), 0, textureHelper.get(),
                                            sourceSubResource, textureHelper.getFormat());
-        resolvedTextureHelper =
-            TextureHelper11::MakeAndReference(resolveTex2D, textureHelper.getFormatSet());
 
         sourceSubResource = 0;
         srcTexture        = &resolvedTextureHelper;
@@ -4171,14 +4023,14 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt
 
     // Select the correct layer from a 3D attachment
     srcBox.front = 0;
-    if (textureHelper.getTextureType() == GL_TEXTURE_3D)
+    if (textureHelper.is3D())
     {
         srcBox.front = static_cast<UINT>(srcAttachment.layer());
     }
     srcBox.back = srcBox.front + 1;
 
-    mDeviceContext->CopySubresourceRegion(stagingHelper.getResource(), 0, 0, 0, 0,
-                                          srcTexture->getResource(), sourceSubResource, &srcBox);
+    mDeviceContext->CopySubresourceRegion(stagingHelper.get(), 0, 0, 0, 0, srcTexture->get(),
+                                          sourceSubResource, &srcBox);
 
     if (!invertTexture)
     {
@@ -4193,12 +4045,12 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt
     // tracking in the 'pixelBuffer' members, causing leaks. Instead we must use
     // pixelBuffer.set() twice, which performs the addRef/release correctly
     invertTexturePack.alignment = pack.alignment;
-    invertTexturePack.pixelBuffer.set(pack.pixelBuffer.get());
+    invertTexturePack.pixelBuffer.set(context, pack.pixelBuffer.get());
     invertTexturePack.reverseRowOrder = !pack.reverseRowOrder;
 
     PackPixelsParams packParams(safeArea, format, type, outputPitch, invertTexturePack, 0);
     gl::Error error = packPixels(stagingHelper, packParams, pixelsOut);
-    invertTexturePack.pixelBuffer.set(nullptr);
+    invertTexturePack.pixelBuffer.set(context, nullptr);
     ANGLE_TRY(error);
     return gl::NoError();
 }
@@ -4207,15 +4059,14 @@ gl::Error Renderer11::packPixels(const TextureHelper11 &textureHelper,
                                  const PackPixelsParams &params,
                                  uint8_t *pixelsOut)
 {
-    ID3D11Resource *readResource = textureHelper.getResource();
+    ID3D11Resource *readResource = textureHelper.get();
 
     D3D11_MAPPED_SUBRESOURCE mapping;
     HRESULT hr = mDeviceContext->Map(readResource, 0, D3D11_MAP_READ, 0, &mapping);
     if (FAILED(hr))
     {
         ASSERT(hr == E_OUTOFMEMORY);
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to map internal texture for reading, result: 0x%X.", hr);
+        return gl::OutOfMemory() << "Failed to map internal texture for reading, " << gl::FmtHR(hr);
     }
 
     uint8_t *source = static_cast<uint8_t *>(mapping.pData);
@@ -4231,7 +4082,8 @@ gl::Error Renderer11::packPixels(const TextureHelper11 &textureHelper,
     return gl::NoError();
 }
 
-gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn,
+gl::Error Renderer11::blitRenderbufferRect(const gl::Context *context,
+                                           const gl::Rectangle &readRectIn,
                                            const gl::Rectangle &drawRectIn,
                                            RenderTargetD3D *readRenderTarget,
                                            RenderTargetD3D *drawRenderTarget,
@@ -4253,8 +4105,7 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn,
                << "Failed to retrieve the internal draw render target from the draw framebuffer.";
     }
 
-    TextureHelper11 drawTexture = TextureHelper11::MakeAndReference(
-        drawRenderTarget11->getTexture(), drawRenderTarget11->getFormatSet());
+    const TextureHelper11 &drawTexture = drawRenderTarget11->getTexture();
     unsigned int drawSubresource    = drawRenderTarget11->getSubresourceIndex();
 
     RenderTarget11 *readRenderTarget11 = GetAs<RenderTarget11>(readRenderTarget);
@@ -4270,8 +4121,9 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn,
 
     if (readRenderTarget->getSamples() > 1)
     {
-        ANGLE_TRY_RESULT(resolveMultisampledTexture(readRenderTarget11, depthBlit, stencilBlit),
-                         readTexture);
+        ANGLE_TRY_RESULT(
+            resolveMultisampledTexture(context, readRenderTarget11, depthBlit, stencilBlit),
+            readTexture);
 
         if (!stencilBlit)
         {
@@ -4283,20 +4135,19 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn,
             viewDesc.Texture2D.MipLevels       = 1;
             viewDesc.Texture2D.MostDetailedMip = 0;
 
-            ANGLE_TRY(allocateResource(viewDesc, readTexture.getResource(), &readSRV));
+            ANGLE_TRY(allocateResource(viewDesc, readTexture.get(), &readSRV));
         }
     }
     else
     {
         ASSERT(readRenderTarget11);
-        readTexture = TextureHelper11::MakeAndReference(readRenderTarget11->getTexture(),
-                                                        readRenderTarget11->getFormatSet());
+        readTexture     = readRenderTarget11->getTexture();
         readSubresource = readRenderTarget11->getSubresourceIndex();
-        readSRV         = readRenderTarget11->getBlitShaderResourceView();
+        readSRV         = readRenderTarget11->getBlitShaderResourceView().makeCopy();
         if (!readSRV.valid())
         {
             ASSERT(depthBlit || stencilBlit);
-            readSRV = readRenderTarget11->getShaderResourceView();
+            readSRV = readRenderTarget11->getShaderResourceView().makeCopy();
         }
         ASSERT(readSRV.valid());
     }
@@ -4456,9 +4307,8 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn,
         // We also require complete framebuffer copies for depth-stencil blit.
         D3D11_BOX *pSrcBox = wholeBufferCopy ? nullptr : &readBox;
 
-        mDeviceContext->CopySubresourceRegion(drawTexture.getResource(), drawSubresource, dstX,
-                                              dstY, 0, readTexture.getResource(), readSubresource,
-                                              pSrcBox);
+        mDeviceContext->CopySubresourceRegion(drawTexture.get(), drawSubresource, dstX, dstY, 0,
+                                              readTexture.get(), readSubresource, pSrcBox);
     }
     else
     {
@@ -4475,12 +4325,12 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn,
         {
             const d3d11::DepthStencilView &drawDSV = drawRenderTarget11->getDepthStencilView();
             ASSERT(readSRV.valid());
-            ANGLE_TRY(mBlit->copyDepth(readSRV, readArea, readSize, drawDSV, drawArea, drawSize,
-                                       scissor));
+            ANGLE_TRY(mBlit->copyDepth(context, readSRV, readArea, readSize, drawDSV, drawArea,
+                                       drawSize, scissor));
         }
         else if (stencilBlit)
         {
-            ANGLE_TRY(mBlit->copyStencil(readTexture, readSubresource, readArea, readSize,
+            ANGLE_TRY(mBlit->copyStencil(context, readTexture, readSubresource, readArea, readSize,
                                          drawTexture, drawSubresource, drawArea, drawSize,
                                          scissor));
         }
@@ -4491,9 +4341,9 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn,
             // We don't currently support masking off any other channel than alpha
             bool maskOffAlpha = colorMaskingNeeded && colorMask.alpha;
             ASSERT(readSRV.valid());
-            ANGLE_TRY(mBlit->copyTexture(readSRV, readArea, readSize, srcFormatInfo.format, drawRTV,
-                                         drawArea, drawSize, scissor, destFormatInfo.format, filter,
-                                         maskOffAlpha, false, false));
+            ANGLE_TRY(mBlit->copyTexture(
+                context, readSRV, readArea, readSize, srcFormatInfo.format, drawRTV, drawArea,
+                drawSize, scissor, destFormatInfo.format, filter, maskOffAlpha, false, false));
         }
     }
 
@@ -4546,17 +4396,20 @@ void Renderer11::onBufferDelete(const Buffer11 *deleted)
     mAliveBuffers.erase(deleted);
 }
 
-gl::ErrorOrResult<TextureHelper11>
-Renderer11::resolveMultisampledTexture(RenderTarget11 *renderTarget, bool depth, bool stencil)
+gl::ErrorOrResult<TextureHelper11> Renderer11::resolveMultisampledTexture(
+    const gl::Context *context,
+    RenderTarget11 *renderTarget,
+    bool depth,
+    bool stencil)
 {
     if (depth && !stencil)
     {
-        return mBlit->resolveDepth(renderTarget);
+        return mBlit->resolveDepth(context, renderTarget);
     }
 
     if (stencil)
     {
-        return mBlit->resolveStencil(renderTarget, depth);
+        return mBlit->resolveStencil(context, renderTarget, depth);
     }
 
     const auto &formatSet = renderTarget->getFormatSet();
@@ -4576,17 +4429,12 @@ Renderer11::resolveMultisampledTexture(RenderTarget11 *renderTarget, bool depth,
     resolveDesc.CPUAccessFlags     = 0;
     resolveDesc.MiscFlags          = 0;
 
-    ID3D11Texture2D *resolveTexture = nullptr;
-    HRESULT result = mDevice->CreateTexture2D(&resolveDesc, nullptr, &resolveTexture);
-    if (FAILED(result))
-    {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to create a multisample resolve texture, HRESULT: 0x%X.", result);
-    }
+    TextureHelper11 resolveTexture;
+    ANGLE_TRY(allocateTexture(resolveDesc, formatSet, &resolveTexture));
 
-    mDeviceContext->ResolveSubresource(resolveTexture, 0, renderTarget->getTexture(),
+    mDeviceContext->ResolveSubresource(resolveTexture.get(), 0, renderTarget->getTexture().get(),
                                        renderTarget->getSubresourceIndex(), formatSet.texFormat);
-    return TextureHelper11::MakeAndPossess2D(resolveTexture, renderTarget->getFormatSet());
+    return resolveTexture;
 }
 
 bool Renderer11::getLUID(LUID *adapterLuid) const
@@ -4634,15 +4482,16 @@ gl::ErrorOrResult<unsigned int> Renderer11::getVertexSpaceRequired(
         return 16u;
     }
 
-    unsigned int elementCount = 0;
-    if (instances == 0 || binding.divisor == 0)
+    unsigned int elementCount  = 0;
+    const unsigned int divisor = binding.getDivisor();
+    if (instances == 0 || divisor == 0)
     {
         elementCount = count;
     }
     else
     {
         // Round up to divisor, if possible
-        elementCount = UnsignedCeilDivide(static_cast<unsigned int>(instances), binding.divisor);
+        elementCount = UnsignedCeilDivide(static_cast<unsigned int>(instances), divisor);
     }
 
     gl::VertexFormatType formatType      = gl::GetVertexFormatType(attrib);
@@ -4654,7 +4503,7 @@ gl::ErrorOrResult<unsigned int> Renderer11::getVertexSpaceRequired(
     unsigned int elementSize = dxgiFormatInfo.pixelBytes;
     if (elementSize > std::numeric_limits<unsigned int>::max() / elementCount)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "New vertex buffer size would result in an overflow.");
+        return gl::OutOfMemory() << "New vertex buffer size would result in an overflow.";
     }
 
     return elementSize * elementCount;
@@ -4674,7 +4523,10 @@ angle::WorkaroundsD3D Renderer11::generateWorkarounds() const
     return d3d11::GenerateWorkarounds(mRenderer11DeviceCaps, mAdapterDescription);
 }
 
-gl::Error Renderer11::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd)
+gl::Error Renderer11::clearTextures(const gl::Context *context,
+                                    gl::SamplerType samplerType,
+                                    size_t rangeStart,
+                                    size_t rangeEnd)
 {
     return mStateManager.clearTextures(samplerType, rangeStart, rangeEnd);
 }
@@ -4696,7 +4548,7 @@ egl::Error Renderer11::getEGLDevice(DeviceImpl **device)
     }
 
     *device = static_cast<DeviceImpl *>(mEGLDevice);
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 ContextImpl *Renderer11::createContext(const gl::ContextState &state)
@@ -4704,7 +4556,7 @@ ContextImpl *Renderer11::createContext(const gl::ContextState &state)
     return new Context11(state, this);
 }
 
-gl::Error Renderer11::genericDrawElements(Context11 *context,
+gl::Error Renderer11::genericDrawElements(const gl::Context *context,
                                           GLenum mode,
                                           GLsizei count,
                                           GLenum type,
@@ -4721,14 +4573,14 @@ gl::Error Renderer11::genericDrawElements(Context11 *context,
 
     programD3D->updateSamplerMapping();
 
-    ANGLE_TRY(generateSwizzles(data));
+    ANGLE_TRY(generateSwizzles(context));
 
     if (!applyPrimitiveType(mode, count, usesPointSize))
     {
         return gl::NoError();
     }
 
-    ANGLE_TRY(updateState(context, mode));
+    ANGLE_TRY(mStateManager.updateState(context, mode));
 
     TranslatedIndexData indexInfo;
     indexInfo.indexRange = indexRange;
@@ -4741,10 +4593,10 @@ gl::Error Renderer11::genericDrawElements(Context11 *context,
     ASSERT(!glState.isTransformFeedbackActiveUnpaused());
 
     size_t vertexCount = indexInfo.indexRange.vertexCount();
-    ANGLE_TRY(applyVertexBuffer(glState, mode, static_cast<GLsizei>(indexInfo.indexRange.start),
+    ANGLE_TRY(applyVertexBuffer(context, mode, static_cast<GLsizei>(indexInfo.indexRange.start),
                                 static_cast<GLsizei>(vertexCount), instances, &indexInfo));
-    ANGLE_TRY(applyTextures(context, data));
-    ANGLE_TRY(applyShaders(data, mode));
+    ANGLE_TRY(applyTextures(context));
+    ANGLE_TRY(applyShaders(context, mode));
     ANGLE_TRY(programD3D->applyUniformBuffers(data));
 
     if (!skipDraw(data, mode))
@@ -4755,7 +4607,7 @@ gl::Error Renderer11::genericDrawElements(Context11 *context,
     return gl::NoError();
 }
 
-gl::Error Renderer11::genericDrawArrays(Context11 *context,
+gl::Error Renderer11::genericDrawArrays(const gl::Context *context,
                                         GLenum mode,
                                         GLint first,
                                         GLsizei count,
@@ -4770,22 +4622,22 @@ gl::Error Renderer11::genericDrawArrays(Context11 *context,
 
     programD3D->updateSamplerMapping();
 
-    ANGLE_TRY(generateSwizzles(data));
+    ANGLE_TRY(generateSwizzles(context));
     if (!applyPrimitiveType(mode, count, usesPointSize))
     {
         return gl::NoError();
     }
 
-    ANGLE_TRY(updateState(context, mode));
+    ANGLE_TRY(mStateManager.updateState(context, mode));
     ANGLE_TRY(applyTransformFeedbackBuffers(data));
-    ANGLE_TRY(applyVertexBuffer(glState, mode, first, count, instances, nullptr));
-    ANGLE_TRY(applyTextures(context, data));
-    ANGLE_TRY(applyShaders(data, mode));
+    ANGLE_TRY(applyVertexBuffer(context, mode, first, count, instances, nullptr));
+    ANGLE_TRY(applyTextures(context));
+    ANGLE_TRY(applyShaders(context, mode));
     ANGLE_TRY(programD3D->applyUniformBuffers(data));
 
     if (!skipDraw(data, mode))
     {
-        ANGLE_TRY(drawArraysImpl(data, mode, first, count, instances));
+        ANGLE_TRY(drawArraysImpl(context, mode, first, count, instances));
 
         if (glState.isTransformFeedbackActiveUnpaused())
         {
@@ -4796,35 +4648,35 @@ gl::Error Renderer11::genericDrawArrays(Context11 *context,
     return gl::NoError();
 }
 
-gl::Error Renderer11::genericDrawIndirect(Context11 *context,
+gl::Error Renderer11::genericDrawIndirect(const gl::Context *context,
                                           GLenum mode,
                                           GLenum type,
                                           const void *indirect)
 {
-    const auto &data     = context->getContextState();
-    const auto &glState  = data.getState();
+    const auto &contextState = context->getContextState();
+    const auto &glState      = context->getGLState();
     gl::Program *program = glState.getProgram();
     ASSERT(program != nullptr);
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
     bool usesPointSize     = programD3D->usesPointSize();
     programD3D->updateSamplerMapping();
 
-    ANGLE_TRY(generateSwizzles(data));
+    ANGLE_TRY(generateSwizzles(context));
     applyPrimitiveType(mode, 0, usesPointSize);
-    ANGLE_TRY(updateState(context, mode));
-    ANGLE_TRY(applyTransformFeedbackBuffers(data));
+    ANGLE_TRY(mStateManager.updateState(context, mode));
+    ANGLE_TRY(applyTransformFeedbackBuffers(contextState));
     ASSERT(!glState.isTransformFeedbackActiveUnpaused());
-    ANGLE_TRY(applyTextures(context, data));
-    ANGLE_TRY(applyShaders(data, mode));
-    ANGLE_TRY(programD3D->applyUniformBuffers(data));
+    ANGLE_TRY(applyTextures(context));
+    ANGLE_TRY(applyShaders(context, mode));
+    ANGLE_TRY(programD3D->applyUniformBuffers(contextState));
 
     if (type == GL_NONE)
     {
-        ANGLE_TRY(drawArraysIndirectImpl(data, mode, indirect));
+        ANGLE_TRY(drawArraysIndirectImpl(context, mode, indirect));
     }
     else
     {
-        ANGLE_TRY(drawElementsIndirectImpl(data, mode, type, indirect));
+        ANGLE_TRY(drawElementsIndirectImpl(context, mode, type, indirect));
     }
 
     return gl::NoError();
@@ -4863,28 +4715,14 @@ gl::Error Renderer11::applyComputeShader(const gl::ContextState &data)
 
     ShaderExecutableD3D *computeExe = nullptr;
     ANGLE_TRY(programD3D->getComputeExecutable(&computeExe));
-
     ASSERT(computeExe != nullptr);
-    ID3D11ComputeShader *computeShader = GetAs<ShaderExecutable11>(computeExe)->getComputeShader();
-
-    bool dirtyUniforms = false;
 
-    if (reinterpret_cast<uintptr_t>(computeShader) != mAppliedComputeShader)
-    {
-        mDeviceContext->CSSetShader(computeShader, nullptr, 0);
-        mAppliedComputeShader = reinterpret_cast<uintptr_t>(computeShader);
-        dirtyUniforms         = true;
-    }
-
-    if (dirtyUniforms)
-    {
-        programD3D->dirtyAllUniforms();
-    }
+    mStateManager.setComputeShader(&GetAs<ShaderExecutable11>(computeExe)->getComputeShader());
 
     return programD3D->applyComputeUniforms();
 }
 
-gl::Error Renderer11::dispatchCompute(Context11 *context,
+gl::Error Renderer11::dispatchCompute(const gl::Context *context,
                                       GLuint numGroupsX,
                                       GLuint numGroupsY,
                                       GLuint numGroupsZ)
@@ -4898,8 +4736,8 @@ gl::Error Renderer11::dispatchCompute(Context11 *context,
 
     programD3D->updateSamplerMapping();
 
-    ANGLE_TRY(generateSwizzles(data, gl::SAMPLER_COMPUTE));
-    ANGLE_TRY(applyTextures(context, data));
+    ANGLE_TRY(generateSwizzles(context, gl::SAMPLER_COMPUTE));
+    ANGLE_TRY(applyTextures(context));
     ANGLE_TRY(applyComputeShader(data));
     // TODO(Xinghua): applyUniformBuffers for compute shader.
     mDeviceContext->Dispatch(numGroupsX, numGroupsY, numGroupsZ);
@@ -4925,11 +4763,14 @@ gl::Error Renderer11::applyComputeUniforms(const ProgramD3D &programD3D,
         }
     }
 
-    const UniformStorage11 *computeUniformStorage =
+    UniformStorage11 *computeUniformStorage =
         GetAs<UniformStorage11>(&programD3D.getComputeUniformStorage());
     ASSERT(computeUniformStorage);
 
-    ID3D11Buffer *computeConstantBuffer = computeUniformStorage->getConstantBuffer();
+    const d3d11::Buffer *computeConstantBufferObj = nullptr;
+    ANGLE_TRY(computeUniformStorage->getConstantBuffer(this, &computeConstantBufferObj));
+
+    ID3D11Buffer *computeConstantBuffer = computeConstantBufferObj->get();
 
     if (totalRegisterCountCS > 0 && computeUniformsDirty)
     {
@@ -4957,29 +4798,23 @@ gl::Error Renderer11::applyComputeUniforms(const ProgramD3D &programD3D,
         mDeviceContext->Unmap(computeConstantBuffer, 0);
     }
 
-    if (mCurrentComputeConstantBuffer != computeConstantBuffer)
+    if (mCurrentComputeConstantBuffer != reinterpret_cast<uintptr_t>(computeConstantBuffer))
     {
         mDeviceContext->CSSetConstantBuffers(
             d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DEFAULT_UNIFORM_BLOCK, 1, &computeConstantBuffer);
-        mCurrentComputeConstantBuffer = computeConstantBuffer;
+        mCurrentComputeConstantBuffer = reinterpret_cast<uintptr_t>(computeConstantBuffer);
     }
 
-    if (!mDriverConstantBufferCS)
+    if (!mDriverConstantBufferCS.valid())
     {
         D3D11_BUFFER_DESC constantBufferDescription = {0};
         d3d11::InitConstantBufferDesc(
             &constantBufferDescription,
             sizeof(dx_ComputeConstants11) + mSamplerMetadataCS.sizeBytes());
-        HRESULT result =
-            mDevice->CreateBuffer(&constantBufferDescription, nullptr, &mDriverConstantBufferCS);
-        ASSERT(SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::OutOfMemory()
-                   << "Failed to create compute shader constant buffer, " << result;
-        }
+        ANGLE_TRY(allocateResource(constantBufferDescription, &mDriverConstantBufferCS));
+        ID3D11Buffer *buffer = mDriverConstantBufferCS.get();
         mDeviceContext->CSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1,
-                                             &mDriverConstantBufferCS);
+                                             &buffer);
     }
 
     const dx_ComputeConstants11 &computeConstants = mStateManager.getComputeConstants();
@@ -4992,12 +4827,12 @@ gl::Error Renderer11::applyComputeUniforms(const ProgramD3D &programD3D,
 }
 
 gl::ErrorOrResult<TextureHelper11> Renderer11::createStagingTexture(
-    GLenum textureType,
+    ResourceType textureType,
     const d3d11::Format &formatSet,
     const gl::Extents &size,
     StagingAccess readAndWriteAccess)
 {
-    if (textureType == GL_TEXTURE_2D)
+    if (textureType == ResourceType::Texture2D)
     {
         D3D11_TEXTURE2D_DESC stagingDesc;
         stagingDesc.Width              = size.width;
@@ -5017,16 +4852,11 @@ gl::ErrorOrResult<TextureHelper11> Renderer11::createStagingTexture(
             stagingDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
         }
 
-        ID3D11Texture2D *stagingTex = nullptr;
-        HRESULT result              = mDevice->CreateTexture2D(&stagingDesc, nullptr, &stagingTex);
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY, "createStagingTexture failed, HRESULT: 0x%X.",
-                             result);
-        }
-        return TextureHelper11::MakeAndPossess2D(stagingTex, formatSet);
+        TextureHelper11 stagingTex;
+        ANGLE_TRY(allocateTexture(stagingDesc, formatSet, &stagingTex));
+        return stagingTex;
     }
-    ASSERT(textureType == GL_TEXTURE_3D);
+    ASSERT(textureType == ResourceType::Texture3D);
 
     D3D11_TEXTURE3D_DESC stagingDesc;
     stagingDesc.Width          = size.width;
@@ -5039,14 +4869,67 @@ gl::ErrorOrResult<TextureHelper11> Renderer11::createStagingTexture(
     stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
     stagingDesc.MiscFlags      = 0;
 
-    ID3D11Texture3D *stagingTex = nullptr;
-    HRESULT result              = mDevice->CreateTexture3D(&stagingDesc, nullptr, &stagingTex);
-    if (FAILED(result))
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "createStagingTexture failed, HRESULT: 0x%X.", result);
-    }
+    TextureHelper11 stagingTex;
+    ANGLE_TRY(allocateTexture(stagingDesc, formatSet, &stagingTex));
+    return stagingTex;
+}
+
+gl::Error Renderer11::allocateTexture(const D3D11_TEXTURE2D_DESC &desc,
+                                      const d3d11::Format &format,
+                                      const D3D11_SUBRESOURCE_DATA *initData,
+                                      TextureHelper11 *textureOut)
+{
+    d3d11::Texture2D texture;
+    ANGLE_TRY(mResourceManager11.allocate(this, &desc, initData, &texture));
+    textureOut->init(std::move(texture), desc, format);
+    return gl::NoError();
+}
+
+gl::Error Renderer11::allocateTexture(const D3D11_TEXTURE3D_DESC &desc,
+                                      const d3d11::Format &format,
+                                      const D3D11_SUBRESOURCE_DATA *initData,
+                                      TextureHelper11 *textureOut)
+{
+    d3d11::Texture3D texture;
+    ANGLE_TRY(mResourceManager11.allocate(this, &desc, initData, &texture));
+    textureOut->init(std::move(texture), desc, format);
+    return gl::NoError();
+}
+
+gl::Error Renderer11::getBlendState(const d3d11::BlendStateKey &key,
+                                    ID3D11BlendState **outBlendState)
+{
+    return mStateCache.getBlendState(this, key, outBlendState);
+}
+
+gl::Error Renderer11::getRasterizerState(const gl::RasterizerState &rasterState,
+                                         bool scissorEnabled,
+                                         ID3D11RasterizerState **outRasterizerState)
+{
+    return mStateCache.getRasterizerState(this, rasterState, scissorEnabled, outRasterizerState);
+}
+
+gl::Error Renderer11::getDepthStencilState(const gl::DepthStencilState &dsState,
+                                           ID3D11DepthStencilState **outDSState)
+{
+    return mStateCache.getDepthStencilState(this, dsState, outDSState);
+}
 
-    return TextureHelper11::MakeAndPossess3D(stagingTex, formatSet);
+gl::Error Renderer11::getSamplerState(const gl::SamplerState &samplerState,
+                                      ID3D11SamplerState **outSamplerState)
+{
+    return mStateCache.getSamplerState(this, samplerState, outSamplerState);
+}
+
+gl::Error Renderer11::clearRenderTarget(RenderTargetD3D *renderTarget,
+                                        const gl::ColorF &clearValues)
+{
+    RenderTarget11 *renderTarget11     = GetAs<RenderTarget11>(renderTarget);
+    const d3d11::RenderTargetView &rtv = renderTarget11->getRenderTargetView();
+
+    mDeviceContext->ClearRenderTargetView(rtv.get(), &clearValues.red);
+
+    return gl::NoError();
 }
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
index 7371a0dd1b3..b70cb937b61 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
@@ -138,23 +138,25 @@ class Renderer11 : public RendererD3D
                                    HANDLE shareHandle,
                                    const egl::AttributeMap &attribs) const override;
 
-    gl::Error setSamplerState(gl::SamplerType type,
+    gl::Error setSamplerState(const gl::Context *context,
+                              gl::SamplerType type,
                               int index,
                               gl::Texture *texture,
                               const gl::SamplerState &sampler) override;
-    gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture) override;
+    gl::Error setTexture(const gl::Context *context,
+                         gl::SamplerType type,
+                         int index,
+                         gl::Texture *texture) override;
 
     gl::Error setUniformBuffers(const gl::ContextState &data,
                                 const std::vector<GLint> &vertexUniformBuffers,
                                 const std::vector<GLint> &fragmentUniformBuffers) override;
 
-    gl::Error updateState(ContextImpl *contextImpl, GLenum drawMode);
-
     bool applyPrimitiveType(GLenum mode, GLsizei count, bool usesPointSize);
     gl::Error applyUniforms(const ProgramD3D &programD3D,
                             GLenum drawMode,
                             const std::vector<D3DUniform *> &uniformArray) override;
-    gl::Error applyVertexBuffer(const gl::State &state,
+    gl::Error applyVertexBuffer(const gl::Context *context,
                                 GLenum mode,
                                 GLint first,
                                 GLsizei count,
@@ -189,33 +191,38 @@ class Renderer11 : public RendererD3D
     std::string getShaderModelSuffix() const override;
 
     // Pixel operations
-    gl::Error copyImage2D(const gl::Framebuffer *framebuffer,
+    gl::Error copyImage2D(const gl::Context *context,
+                          const gl::Framebuffer *framebuffer,
                           const gl::Rectangle &sourceRect,
                           GLenum destFormat,
                           const gl::Offset &destOffset,
                           TextureStorage *storage,
                           GLint level) override;
-    gl::Error copyImageCube(const gl::Framebuffer *framebuffer,
+    gl::Error copyImageCube(const gl::Context *context,
+                            const gl::Framebuffer *framebuffer,
                             const gl::Rectangle &sourceRect,
                             GLenum destFormat,
                             const gl::Offset &destOffset,
                             TextureStorage *storage,
                             GLenum target,
                             GLint level) override;
-    gl::Error copyImage3D(const gl::Framebuffer *framebuffer,
+    gl::Error copyImage3D(const gl::Context *context,
+                          const gl::Framebuffer *framebuffer,
                           const gl::Rectangle &sourceRect,
                           GLenum destFormat,
                           const gl::Offset &destOffset,
                           TextureStorage *storage,
                           GLint level) override;
-    gl::Error copyImage2DArray(const gl::Framebuffer *framebuffer,
+    gl::Error copyImage2DArray(const gl::Context *context,
+                               const gl::Framebuffer *framebuffer,
                                const gl::Rectangle &sourceRect,
                                GLenum destFormat,
                                const gl::Offset &destOffset,
                                TextureStorage *storage,
                                GLint level) override;
 
-    gl::Error copyTexture(const gl::Texture *source,
+    gl::Error copyTexture(const gl::Context *context,
+                          const gl::Texture *source,
                           GLint sourceLevel,
                           const gl::Rectangle &sourceRect,
                           GLenum destFormat,
@@ -226,7 +233,8 @@ class Renderer11 : public RendererD3D
                           bool unpackFlipY,
                           bool unpackPremultiplyAlpha,
                           bool unpackUnmultiplyAlpha) override;
-    gl::Error copyCompressedTexture(const gl::Texture *source,
+    gl::Error copyCompressedTexture(const gl::Context *context,
+                                    const gl::Texture *source,
                                     GLint sourceLevel,
                                     TextureStorage *storage,
                                     GLint destLevel) override;
@@ -240,7 +248,7 @@ class Renderer11 : public RendererD3D
     gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) override;
 
     // Shader operations
-    gl::Error loadExecutable(const void *function,
+    gl::Error loadExecutable(const uint8_t *function,
                              size_t length,
                              ShaderType type,
                              const std::vector<D3DVarying> &streamOutVaryings,
@@ -259,9 +267,18 @@ class Renderer11 : public RendererD3D
 
     // Image operations
     ImageD3D *createImage() override;
-    gl::Error generateMipmap(ImageD3D *dest, ImageD3D *source) override;
-    gl::Error generateMipmapUsingD3D(TextureStorage *storage,
+    gl::Error generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *source) override;
+    gl::Error generateMipmapUsingD3D(const gl::Context *context,
+                                     TextureStorage *storage,
                                      const gl::TextureState &textureState) override;
+    gl::Error copyImage(const gl::Context *context,
+                        ImageD3D *dest,
+                        ImageD3D *source,
+                        const gl::Rectangle &sourceRect,
+                        const gl::Offset &destOffset,
+                        bool unpackFlipY,
+                        bool unpackPremultiplyAlpha,
+                        bool unpackUnmultiplyAlpha) override;
     TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain) override;
     TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage,
                                                  RenderTargetD3D *renderTargetD3D) override;
@@ -291,6 +308,12 @@ class Renderer11 : public RendererD3D
                                                 GLsizei height,
                                                 GLsizei depth,
                                                 int levels) override;
+    TextureStorage *createTextureStorage2DMultisample(GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      int levels,
+                                                      int samples,
+                                                      GLboolean fixedSampleLocations) override;
 
     VertexBuffer *createVertexBuffer() override;
     IndexBuffer *createIndexBuffer() override;
@@ -307,7 +330,14 @@ class Renderer11 : public RendererD3D
     ID3D11DeviceContext1 *getDeviceContext1IfSupported() { return mDeviceContext1; };
     IDXGIFactory *getDxgiFactory() { return mDxgiFactory; };
 
-    RenderStateCache &getStateCache() { return mStateCache; }
+    gl::Error getBlendState(const d3d11::BlendStateKey &key, ID3D11BlendState **outBlendState);
+    gl::Error getRasterizerState(const gl::RasterizerState &rasterState,
+                                 bool scissorEnabled,
+                                 ID3D11RasterizerState **outRasterizerState);
+    gl::Error getDepthStencilState(const gl::DepthStencilState &dsState,
+                                   ID3D11DepthStencilState **outDSState);
+    gl::Error getSamplerState(const gl::SamplerState &samplerState,
+                              ID3D11SamplerState **outSamplerState);
 
     Blit11 *getBlitter() { return mBlit; }
     Clear11 *getClearer() { return mClear; }
@@ -315,14 +345,15 @@ class Renderer11 : public RendererD3D
 
     // Buffer-to-texture and Texture-to-buffer copies
     bool supportsFastCopyBufferToTexture(GLenum internalFormat) const override;
-    gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack,
+    gl::Error fastCopyBufferToTexture(const gl::Context *context,
+                                      const gl::PixelUnpackState &unpack,
                                       unsigned int offset,
                                       RenderTargetD3D *destRenderTarget,
                                       GLenum destinationFormat,
                                       GLenum sourcePixelsType,
                                       const gl::Box &destArea) override;
 
-    void markAllStateDirty();
+    void markAllStateDirty(const gl::Context *context);
     gl::Error packPixels(const TextureHelper11 &textureHelper,
                          const PackPixelsParams &params,
                          uint8_t *pixelsOut);
@@ -339,7 +370,8 @@ class Renderer11 : public RendererD3D
                                                            GLsizei count,
                                                            GLsizei instances) const override;
 
-    gl::Error readFromAttachment(const gl::FramebufferAttachment &srcAttachment,
+    gl::Error readFromAttachment(const gl::Context *context,
+                                 const gl::FramebufferAttachment &srcAttachment,
                                  const gl::Rectangle &sourceArea,
                                  GLenum format,
                                  GLenum type,
@@ -347,7 +379,8 @@ class Renderer11 : public RendererD3D
                                  const gl::PixelPackState &pack,
                                  uint8_t *pixels);
 
-    gl::Error blitRenderbufferRect(const gl::Rectangle &readRect,
+    gl::Error blitRenderbufferRect(const gl::Context *context,
+                                   const gl::Rectangle &readRect,
                                    const gl::Rectangle &drawRect,
                                    RenderTargetD3D *readRenderTarget,
                                    RenderTargetD3D *drawRenderTarget,
@@ -370,13 +403,13 @@ class Renderer11 : public RendererD3D
 
     egl::Error getEGLDevice(DeviceImpl **device) override;
 
-    gl::Error genericDrawArrays(Context11 *context,
+    gl::Error genericDrawArrays(const gl::Context *context,
                                 GLenum mode,
                                 GLint first,
                                 GLsizei count,
                                 GLsizei instances);
 
-    gl::Error genericDrawElements(Context11 *context,
+    gl::Error genericDrawElements(const gl::Context *context,
                                   GLenum mode,
                                   GLsizei count,
                                   GLenum type,
@@ -384,7 +417,7 @@ class Renderer11 : public RendererD3D
                                   GLsizei instances,
                                   const gl::IndexRange &indexRange);
 
-    gl::Error genericDrawIndirect(Context11 *context,
+    gl::Error genericDrawIndirect(const gl::Context *context,
                                   GLenum mode,
                                   GLenum type,
                                   const void *indirect);
@@ -396,7 +429,7 @@ class Renderer11 : public RendererD3D
 
     gl::Version getMaxSupportedESVersion() const override;
 
-    gl::Error dispatchCompute(Context11 *context,
+    gl::Error dispatchCompute(const gl::Context *context,
                               GLuint numGroupsX,
                               GLuint numGroupsY,
                               GLuint numGroupsZ);
@@ -404,11 +437,17 @@ class Renderer11 : public RendererD3D
                                    const std::vector<D3DUniform *> &uniformArray) override;
     gl::Error applyComputeShader(const gl::ContextState &data);
 
-    gl::ErrorOrResult<TextureHelper11> createStagingTexture(GLenum textureType,
+    gl::ErrorOrResult<TextureHelper11> createStagingTexture(ResourceType textureType,
                                                             const d3d11::Format &formatSet,
                                                             const gl::Extents &size,
                                                             StagingAccess readAndWriteAccess);
 
+    template <typename DescT, typename ResourceT>
+    gl::Error allocateResource(const DescT &desc, ResourceT *resourceOut)
+    {
+        return mResourceManager11.allocate(this, &desc, nullptr, resourceOut);
+    }
+
     template <typename DescT, typename InitDataT, typename ResourceT>
     gl::Error allocateResource(const DescT &desc, InitDataT *initData, ResourceT *resourceOut)
     {
@@ -421,13 +460,35 @@ class Renderer11 : public RendererD3D
         return mResourceManager11.allocate(this, nullptr, initData, resourceOut);
     }
 
+    template <typename DescT>
+    gl::Error allocateTexture(const DescT &desc,
+                              const d3d11::Format &format,
+                              TextureHelper11 *textureOut)
+    {
+        return allocateTexture(desc, format, nullptr, textureOut);
+    }
+
+    gl::Error allocateTexture(const D3D11_TEXTURE2D_DESC &desc,
+                              const d3d11::Format &format,
+                              const D3D11_SUBRESOURCE_DATA *initData,
+                              TextureHelper11 *textureOut);
+
+    gl::Error allocateTexture(const D3D11_TEXTURE3D_DESC &desc,
+                              const d3d11::Format &format,
+                              const D3D11_SUBRESOURCE_DATA *initData,
+                              TextureHelper11 *textureOut);
+
+    gl::Error clearRenderTarget(RenderTargetD3D *renderTarget,
+                                const gl::ColorF &clearValues) override;
+
   protected:
-    gl::Error clearTextures(gl::SamplerType samplerType,
+    gl::Error clearTextures(const gl::Context *context,
+                            gl::SamplerType samplerType,
                             size_t rangeStart,
                             size_t rangeEnd) override;
 
   private:
-    gl::Error drawArraysImpl(const gl::ContextState &data,
+    gl::Error drawArraysImpl(const gl::Context *context,
                              GLenum mode,
                              GLint startVertex,
                              GLsizei count,
@@ -439,16 +500,14 @@ class Renderer11 : public RendererD3D
                                GLenum type,
                                const void *indices,
                                GLsizei instances);
-    gl::Error drawArraysIndirectImpl(const gl::ContextState &data,
-                                     GLenum mode,
-                                     const void *indirect);
-    gl::Error drawElementsIndirectImpl(const gl::ContextState &data,
+    gl::Error drawArraysIndirectImpl(const gl::Context *context, GLenum mode, const void *indirect);
+    gl::Error drawElementsIndirectImpl(const gl::Context *context,
                                        GLenum mode,
                                        GLenum type,
                                        const void *indirect);
 
     // Support directly using indirect draw buffer.
-    bool supportsFastIndirectDraw(const gl::State &state, GLenum mode, GLenum type);
+    bool supportsFastIndirectDraw(const gl::Context *context, GLenum mode, GLenum type);
 
     void generateCaps(gl::Caps *outCaps,
                       gl::TextureCapsMap *outTextureCaps,
@@ -470,12 +529,13 @@ class Renderer11 : public RendererD3D
                               int baseVertex,
                               int instances);
 
-    gl::Error applyShaders(const gl::ContextState &data, GLenum drawMode);
-    gl::Error generateSwizzle(gl::Texture *texture);
-    gl::Error generateSwizzles(const gl::ContextState &data, gl::SamplerType type);
-    gl::Error generateSwizzles(const gl::ContextState &data);
+    gl::Error applyShaders(const gl::Context *context, GLenum drawMode);
+    gl::Error generateSwizzle(const gl::Context *context, gl::Texture *texture);
+    gl::Error generateSwizzles(const gl::Context *context, gl::SamplerType type);
+    gl::Error generateSwizzles(const gl::Context *context);
 
-    gl::ErrorOrResult<TextureHelper11> resolveMultisampledTexture(RenderTarget11 *renderTarget,
+    gl::ErrorOrResult<TextureHelper11> resolveMultisampledTexture(const gl::Context *context,
+                                                                  RenderTarget11 *renderTarget,
                                                                   bool depth,
                                                                   bool stencil);
 
@@ -517,9 +577,10 @@ class Renderer11 : public RendererD3D
                                       const TShaderConstants &constants,
                                       SamplerMetadataD3D11 *samplerMetadata,
                                       size_t samplerMetadataReferencedBytes,
-                                      ID3D11Buffer *driverConstantBuffer);
+                                      const d3d11::Buffer &driverConstantBuffer);
 
-    gl::Error copyImageInternal(const gl::Framebuffer *framebuffer,
+    gl::Error copyImageInternal(const gl::Context *context,
+                                const gl::Framebuffer *framebuffer,
                                 const gl::Rectangle &sourceRect,
                                 GLenum destFormat,
                                 const gl::Offset &destOffset,
@@ -529,23 +590,24 @@ class Renderer11 : public RendererD3D
         const gl::TextureCaps &colorBufferFormatCaps,
         const gl::TextureCaps &depthStencilBufferFormatCaps) const;
 
+    egl::Error initializeD3DDevice();
+    void initializeDevice();
+    void releaseDeviceResources();
+    void release();
+
+    d3d11::ANGLED3D11DeviceType getDeviceType() const;
+
     HMODULE mD3d11Module;
     HMODULE mDxgiModule;
     HMODULE mDCompModule;
     std::vector<D3D_FEATURE_LEVEL> mAvailableFeatureLevels;
     D3D_DRIVER_TYPE mRequestedDriverType;
+    bool mCreateDebugDevice;
     bool mCreatedWithDeviceEXT;
     DeviceD3D *mEGLDevice;
 
     HLSLCompiler mCompiler;
 
-    egl::Error initializeD3DDevice();
-    void initializeDevice();
-    void releaseDeviceResources();
-    void release();
-
-    d3d11::ANGLED3D11DeviceType getDeviceType() const;
-
     RenderStateCache mStateCache;
 
     // Currently applied sampler states
@@ -560,9 +622,6 @@ class Renderer11 : public RendererD3D
 
     StateManager11 mStateManager;
 
-    // Currently applied primitive topology
-    D3D11_PRIMITIVE_TOPOLOGY mCurrentPrimitiveTopology;
-
     // Currently applied index buffer
     ID3D11Buffer *mAppliedIB;
     DXGI_FORMAT mAppliedIBFormat;
@@ -572,34 +631,28 @@ class Renderer11 : public RendererD3D
     // Currently applied transform feedback buffers
     uintptr_t mAppliedTFObject;
 
-    // Currently applied shaders
-    uintptr_t mAppliedVertexShader;
-    uintptr_t mAppliedGeometryShader;
-    uintptr_t mAppliedPixelShader;
-    uintptr_t mAppliedComputeShader;
-
     dx_VertexConstants11 mAppliedVertexConstants;
-    ID3D11Buffer *mDriverConstantBufferVS;
+    d3d11::Buffer mDriverConstantBufferVS;
     SamplerMetadataD3D11 mSamplerMetadataVS;
-    ID3D11Buffer *mCurrentVertexConstantBuffer;
+    uintptr_t mCurrentVertexConstantBuffer;
     unsigned int mCurrentConstantBufferVS[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
     GLintptr mCurrentConstantBufferVSOffset[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
     GLsizeiptr mCurrentConstantBufferVSSize[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
 
     dx_PixelConstants11 mAppliedPixelConstants;
-    ID3D11Buffer *mDriverConstantBufferPS;
+    d3d11::Buffer mDriverConstantBufferPS;
     SamplerMetadataD3D11 mSamplerMetadataPS;
-    ID3D11Buffer *mCurrentPixelConstantBuffer;
+    uintptr_t mCurrentPixelConstantBuffer;
     unsigned int mCurrentConstantBufferPS[gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS];
     GLintptr mCurrentConstantBufferPSOffset[gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS];
     GLsizeiptr mCurrentConstantBufferPSSize[gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS];
 
     dx_ComputeConstants11 mAppliedComputeConstants;
-    ID3D11Buffer *mDriverConstantBufferCS;
+    d3d11::Buffer mDriverConstantBufferCS;
     SamplerMetadataD3D11 mSamplerMetadataCS;
-    ID3D11Buffer *mCurrentComputeConstantBuffer;
+    uintptr_t mCurrentComputeConstantBuffer;
 
-    ID3D11Buffer *mCurrentGeometryConstantBuffer;
+    uintptr_t mCurrentGeometryConstantBuffer;
 
     // Vertex, index and input layouts
     VertexDataManager *mVertexDataManager;
@@ -620,7 +673,7 @@ class Renderer11 : public RendererD3D
     Trim11 *mTrim;
 
     // Sync query
-    ID3D11Query *mSyncQuery;
+    d3d11::Query mSyncQuery;
 
     // Created objects state tracking
     std::set<const Buffer11 *> mAliveBuffers;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp
index 8cf8a25f857..7c99fa8f89b 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp
@@ -17,12 +17,109 @@ namespace rx
 
 namespace
 {
+size_t ComputeMippedMemoryUsage(unsigned int width,
+                                unsigned int height,
+                                unsigned int depth,
+                                size_t pixelSize,
+                                unsigned int mipLevels)
+{
+    size_t sizeSum = 0;
+
+    for (unsigned int level = 0; level < mipLevels; ++level)
+    {
+        unsigned int mipWidth  = std::max(width >> level, 1u);
+        unsigned int mipHeight = std::max(height >> level, 1u);
+        unsigned int mipDepth  = std::max(depth >> level, 1u);
+        sizeSum += static_cast<size_t>(mipWidth * mipHeight * mipDepth) * pixelSize;
+    }
+
+    return sizeSum;
+}
+
+size_t ComputeMemoryUsage(const D3D11_TEXTURE2D_DESC *desc)
+{
+    ASSERT(desc);
+    size_t pixelBytes = static_cast<size_t>(d3d11::GetDXGIFormatSizeInfo(desc->Format).pixelBytes);
+    return ComputeMippedMemoryUsage(desc->Width, desc->Height, 1, pixelBytes, desc->MipLevels);
+}
+
+size_t ComputeMemoryUsage(const D3D11_TEXTURE3D_DESC *desc)
+{
+    ASSERT(desc);
+    size_t pixelBytes = static_cast<size_t>(d3d11::GetDXGIFormatSizeInfo(desc->Format).pixelBytes);
+    return ComputeMippedMemoryUsage(desc->Width, desc->Height, desc->Depth, pixelBytes,
+                                    desc->MipLevels);
+}
+
+size_t ComputeMemoryUsage(const D3D11_BUFFER_DESC *desc)
+{
+    ASSERT(desc);
+    return static_cast<size_t>(desc->ByteWidth);
+}
+
 template <typename T>
 size_t ComputeMemoryUsage(const T *desc)
 {
     return 0;
 }
 
+template <ResourceType ResourceT>
+size_t ComputeGenericMemoryUsage(ID3D11DeviceChild *genericResource)
+{
+    auto *typedResource = static_cast<GetD3D11Type<ResourceT> *>(genericResource);
+    GetDescType<ResourceT> desc;
+    typedResource->GetDesc(&desc);
+    return ComputeMemoryUsage(&desc);
+}
+
+size_t ComputeGenericMemoryUsage(ResourceType resourceType, ID3D11DeviceChild *resource)
+{
+    switch (resourceType)
+    {
+        case ResourceType::Texture2D:
+            return ComputeGenericMemoryUsage<ResourceType::Texture2D>(resource);
+        case ResourceType::Texture3D:
+            return ComputeGenericMemoryUsage<ResourceType::Texture3D>(resource);
+        case ResourceType::Buffer:
+            return ComputeGenericMemoryUsage<ResourceType::Buffer>(resource);
+
+        default:
+            return 0;
+    }
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_BLEND_DESC *desc,
+                       void * /*initData*/,
+                       ID3D11BlendState **blendState)
+{
+    return device->CreateBlendState(desc, blendState);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_BUFFER_DESC *desc,
+                       const D3D11_SUBRESOURCE_DATA *initData,
+                       ID3D11Buffer **buffer)
+{
+    return device->CreateBuffer(desc, initData, buffer);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       void * /*initData*/,
+                       ID3D11ComputeShader **resourceOut)
+{
+    return device->CreateComputeShader(desc->get(), desc->size(), nullptr, resourceOut);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_DEPTH_STENCIL_DESC *desc,
+                       void * /*initData*/,
+                       ID3D11DepthStencilState **resourceOut)
+{
+    return device->CreateDepthStencilState(desc, resourceOut);
+}
+
 HRESULT CreateResource(ID3D11Device *device,
                        const D3D11_DEPTH_STENCIL_VIEW_DESC *desc,
                        ID3D11Resource *resource,
@@ -32,6 +129,56 @@ HRESULT CreateResource(ID3D11Device *device,
 }
 
 HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       const std::vector<D3D11_SO_DECLARATION_ENTRY> *initData,
+                       ID3D11GeometryShader **resourceOut)
+{
+    if (initData)
+    {
+        return device->CreateGeometryShaderWithStreamOutput(
+            desc->get(), desc->size(), initData->data(), static_cast<UINT>(initData->size()),
+            nullptr, 0, 0, nullptr, resourceOut);
+    }
+    else
+    {
+        return device->CreateGeometryShader(desc->get(), desc->size(), nullptr, resourceOut);
+    }
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const InputElementArray *desc,
+                       const ShaderData *initData,
+                       ID3D11InputLayout **resourceOut)
+{
+    return device->CreateInputLayout(desc->get(), static_cast<UINT>(desc->size()), initData->get(),
+                                     initData->size(), resourceOut);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       void * /*initData*/,
+                       ID3D11PixelShader **resourceOut)
+{
+    return device->CreatePixelShader(desc->get(), desc->size(), nullptr, resourceOut);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_QUERY_DESC *desc,
+                       void * /*initData*/,
+                       ID3D11Query **resourceOut)
+{
+    return device->CreateQuery(desc, resourceOut);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_RASTERIZER_DESC *desc,
+                       void * /*initData*/,
+                       ID3D11RasterizerState **rasterizerState)
+{
+    return device->CreateRasterizerState(desc, rasterizerState);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
                        const D3D11_RENDER_TARGET_VIEW_DESC *desc,
                        ID3D11Resource *resource,
                        ID3D11RenderTargetView **renderTargetView)
@@ -40,6 +187,14 @@ HRESULT CreateResource(ID3D11Device *device,
 }
 
 HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_SAMPLER_DESC *desc,
+                       void * /*initData*/,
+                       ID3D11SamplerState **resourceOut)
+{
+    return device->CreateSamplerState(desc, resourceOut);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
                        const D3D11_SHADER_RESOURCE_VIEW_DESC *desc,
                        ID3D11Resource *resource,
                        ID3D11ShaderResourceView **resourceOut)
@@ -47,10 +202,128 @@ HRESULT CreateResource(ID3D11Device *device,
     return device->CreateShaderResourceView(resource, desc, resourceOut);
 }
 
-#define ANGLE_RESOURCE_STRINGIFY_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) #RESTYPE
+HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_TEXTURE2D_DESC *desc,
+                       const D3D11_SUBRESOURCE_DATA *initData,
+                       ID3D11Texture2D **texture)
+{
+    return device->CreateTexture2D(desc, initData, texture);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const D3D11_TEXTURE3D_DESC *desc,
+                       const D3D11_SUBRESOURCE_DATA *initData,
+                       ID3D11Texture3D **texture)
+{
+    return device->CreateTexture3D(desc, initData, texture);
+}
+
+HRESULT CreateResource(ID3D11Device *device,
+                       const ShaderData *desc,
+                       void * /*initData*/,
+                       ID3D11VertexShader **resourceOut)
+{
+    return device->CreateVertexShader(desc->get(), desc->size(), nullptr, resourceOut);
+}
+
+DXGI_FORMAT GetTypedDepthStencilFormat(DXGI_FORMAT dxgiFormat)
+{
+    switch (dxgiFormat)
+    {
+        case DXGI_FORMAT_R16_TYPELESS:
+            return DXGI_FORMAT_D16_UNORM;
+        case DXGI_FORMAT_R24G8_TYPELESS:
+            return DXGI_FORMAT_D24_UNORM_S8_UINT;
+        case DXGI_FORMAT_R32_TYPELESS:
+            return DXGI_FORMAT_D32_FLOAT;
+        case DXGI_FORMAT_R32G8X24_TYPELESS:
+            return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
+        default:
+            return dxgiFormat;
+    }
+}
+
+template <typename DescT, typename ResourceT>
+gl::Error ClearResource(Renderer11 *renderer, const DescT *desc, ResourceT *texture)
+{
+    // No-op.
+    return gl::NoError();
+}
+
+template <>
+gl::Error ClearResource(Renderer11 *renderer,
+                        const D3D11_TEXTURE2D_DESC *desc,
+                        ID3D11Texture2D *texture)
+{
+    ID3D11DeviceContext *context = renderer->getDeviceContext();
+
+    if ((desc->BindFlags & D3D11_BIND_DEPTH_STENCIL) != 0)
+    {
+        D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
+        dsvDesc.Flags  = 0;
+        dsvDesc.Format = GetTypedDepthStencilFormat(desc->Format);
+
+        const auto &format = d3d11_angle::GetFormat(dsvDesc.Format);
+        UINT clearFlags    = (format.depthBits > 0 ? D3D11_CLEAR_DEPTH : 0) |
+                          (format.stencilBits > 0 ? D3D11_CLEAR_STENCIL : 0);
+
+        // Must process each mip level individually.
+        for (UINT mipLevel = 0; mipLevel < desc->MipLevels; ++mipLevel)
+        {
+            if (desc->SampleDesc.Count == 0)
+            {
+                dsvDesc.Texture2D.MipSlice = mipLevel;
+                dsvDesc.ViewDimension      = D3D11_DSV_DIMENSION_TEXTURE2D;
+            }
+            else
+            {
+                dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
+            }
+
+            d3d11::DepthStencilView dsv;
+            ANGLE_TRY(renderer->allocateResource(dsvDesc, texture, &dsv));
+
+            context->ClearDepthStencilView(dsv.get(), clearFlags, 1.0f, 0);
+        }
+    }
+    else
+    {
+        ASSERT((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0);
+        d3d11::RenderTargetView rtv;
+        ANGLE_TRY(renderer->allocateResourceNoDesc(texture, &rtv));
+
+        const FLOAT zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+        context->ClearRenderTargetView(rtv.get(), zero);
+    }
+
+    return gl::NoError();
+}
+
+template <>
+gl::Error ClearResource(Renderer11 *renderer,
+                        const D3D11_TEXTURE3D_DESC *desc,
+                        ID3D11Texture3D *texture)
+{
+    ID3D11DeviceContext *context = renderer->getDeviceContext();
+
+    ASSERT((desc->BindFlags & D3D11_BIND_DEPTH_STENCIL) == 0);
+    ASSERT((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0);
+
+    d3d11::RenderTargetView rtv;
+    ANGLE_TRY(renderer->allocateResourceNoDesc(texture, &rtv));
+
+    const FLOAT zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+    context->ClearRenderTargetView(rtv.get(), zero);
+    return gl::NoError();
+}
+
+#define ANGLE_RESOURCE_STRINGIFY_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) #RESTYPE,
 
 constexpr std::array<const char *, NumResourceTypes> kResourceTypeNames = {
     {ANGLE_RESOURCE_TYPE_OP(Stringify, ANGLE_RESOURCE_STRINGIFY_OP)}};
+static_assert(kResourceTypeNames[NumResourceTypes - 1] != nullptr,
+              "All members must be initialized.");
+
 }  // anonymous namespace
 
 // ResourceManager11 Implementation.
@@ -81,8 +354,13 @@ gl::Error ResourceManager11::allocate(Renderer11 *renderer,
     ID3D11Device *device = renderer->getDevice();
     T *resource          = nullptr;
 
-    HRESULT hr = CreateResource(device, desc, initData, &resource);
+    GetInitDataFromD3D11<T> *shadowInitData = initData;
+    if (!shadowInitData && renderer->isRobustResourceInitEnabled())
+    {
+        shadowInitData = createInitDataIfNeeded<T>(desc);
+    }
 
+    HRESULT hr = CreateResource(device, desc, shadowInitData, &resource);
     if (FAILED(hr))
     {
         ASSERT(!resource);
@@ -95,6 +373,11 @@ gl::Error ResourceManager11::allocate(Renderer11 *renderer,
                                  << gl::FmtHR(hr);
     }
 
+    if (!shadowInitData && renderer->isRobustResourceInitEnabled())
+    {
+        ANGLE_TRY(ClearResource(renderer, desc, resource));
+    }
+
     ASSERT(resource);
     incrResource(GetResourceTypeFromD3D11<T>(), ComputeMemoryUsage(desc));
     *resourceOut = std::move(Resource11<T>(resource, this));
@@ -115,32 +398,114 @@ void ResourceManager11::decrResource(ResourceType resourceType, size_t memorySiz
     mAllocatedResourceDeviceMemory[ResourceTypeIndex(resourceType)] -= memorySize;
 }
 
-template <typename T>
-void ResourceManager11::onRelease(T *resource)
+void ResourceManager11::onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource)
 {
     ASSERT(resource);
+    decrResource(resourceType, ComputeGenericMemoryUsage(resourceType, resource));
+}
 
-    GetDescFromD3D11<T> desc;
-    resource->GetDesc(&desc);
-    decrResource(GetResourceTypeFromD3D11<T>(), ComputeMemoryUsage(&desc));
+template <>
+const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Texture2D>(
+    const D3D11_TEXTURE2D_DESC *desc)
+{
+    ASSERT(desc);
+
+    if ((desc->BindFlags & (D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_RENDER_TARGET)) != 0)
+    {
+        // This will be done using ClearView methods.
+        return nullptr;
+    }
+
+    size_t requiredSize = ComputeMemoryUsage(desc);
+    if (mZeroMemory.size() < requiredSize)
+    {
+        mZeroMemory.resize(requiredSize);
+        mZeroMemory.fill(0);
+    }
+
+    const auto &formatSizeInfo = d3d11::GetDXGIFormatSizeInfo(desc->Format);
+
+    UINT subresourceCount = desc->MipLevels * desc->ArraySize;
+    if (mShadowInitData.size() < subresourceCount)
+    {
+        mShadowInitData.resize(subresourceCount);
+    }
+
+    for (UINT mipLevel = 0; mipLevel < desc->MipLevels; ++mipLevel)
+    {
+        for (UINT arrayIndex = 0; arrayIndex < desc->ArraySize; ++arrayIndex)
+        {
+            UINT subresourceIndex = D3D11CalcSubresource(mipLevel, arrayIndex, desc->MipLevels);
+            D3D11_SUBRESOURCE_DATA *data = &mShadowInitData[subresourceIndex];
+
+            UINT levelWidth  = std::max(desc->Width >> mipLevel, 1u);
+            UINT levelHeight = std::max(desc->Height >> mipLevel, 1u);
+
+            data->SysMemPitch      = levelWidth * formatSizeInfo.pixelBytes;
+            data->SysMemSlicePitch = data->SysMemPitch * levelHeight;
+            data->pSysMem          = mZeroMemory.data();
+        }
+    }
+
+    return mShadowInitData.data();
 }
 
-#define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \
-    \
-template gl::Error                                                             \
-    ResourceManager11::allocate(\
-Renderer11 *,                                                                  \
-                                \
-const DESCTYPE *,                                                              \
-                                \
-INITDATATYPE *,                                                                \
-                                \
-Resource11<D3D11TYPE> *);                                                      \
+template <>
+const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Texture3D>(
+    const D3D11_TEXTURE3D_DESC *desc)
+{
+    ASSERT(desc);
+
+    if ((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0)
+    {
+        // This will be done using ClearView methods.
+        return nullptr;
+    }
+
+    size_t requiredSize = ComputeMemoryUsage(desc);
+    if (mZeroMemory.size() < requiredSize)
+    {
+        mZeroMemory.resize(requiredSize);
+        mZeroMemory.fill(0);
+    }
+
+    const auto &formatSizeInfo = d3d11::GetDXGIFormatSizeInfo(desc->Format);
+
+    UINT subresourceCount = desc->MipLevels;
+    if (mShadowInitData.size() < subresourceCount)
+    {
+        mShadowInitData.resize(subresourceCount);
+    }
+
+    for (UINT mipLevel = 0; mipLevel < desc->MipLevels; ++mipLevel)
+    {
+        UINT subresourceIndex        = D3D11CalcSubresource(mipLevel, 0, desc->MipLevels);
+        D3D11_SUBRESOURCE_DATA *data = &mShadowInitData[subresourceIndex];
+
+        UINT levelWidth  = std::max(desc->Width >> mipLevel, 1u);
+        UINT levelHeight = std::max(desc->Height >> mipLevel, 1u);
+
+        data->SysMemPitch      = levelWidth * formatSizeInfo.pixelBytes;
+        data->SysMemSlicePitch = data->SysMemPitch * levelHeight;
+        data->pSysMem          = mZeroMemory.data();
+    }
+
+    return mShadowInitData.data();
+}
+
+template <typename T>
+GetInitDataFromD3D11<T> *ResourceManager11::createInitDataIfNeeded(const GetDescFromD3D11<T> *desc)
+{
+    // No-op.
+    return nullptr;
+}
+
+#define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE)  \
     \
-\
-template void                                                                  \
-    ResourceManager11::onRelease(D3D11TYPE *);
+template \
+gl::Error                                                                       \
+    ResourceManager11::allocate(Renderer11 *, const DESCTYPE *, INITDATATYPE *, \
+                                Resource11<D3D11TYPE> *);
 
 ANGLE_RESOURCE_TYPE_OP(Instantitate, ANGLE_INSTANTIATE_OP)
-
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h
index 1847c649a9d..ee3a1e7989b 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h
@@ -12,25 +12,57 @@
 #include <array>
 #include <memory>
 
+#include "common/MemoryBuffer.h"
 #include "common/angleutils.h"
 #include "common/debug.h"
 #include "libANGLE/Error.h"
+#include "libANGLE/renderer/renderer_utils.h"
 
 namespace rx
 {
+// These two methods are declared here to prevent circular includes.
+namespace d3d11
+{
+HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name);
+
+template <typename T>
+HRESULT SetDebugName(angle::ComPtr<T> &resource, const char *name)
+{
+    return SetDebugName(resource.Get(), name);
+}
+}  // namespace d3d11
+
 class Renderer11;
 class ResourceManager11;
 template <typename T>
 class SharedResource11;
+class TextureHelper11;
+
+using InputElementArray = WrappedArray<D3D11_INPUT_ELEMENT_DESC>;
+using ShaderData        = WrappedArray<uint8_t>;
 
 // Format: ResourceType, D3D11 type, DESC type, init data type.
-#define ANGLE_RESOURCE_TYPE_OP(NAME, OP)                                                    \
-    OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC,       \
-       ID3D11Resource)                                                                      \
-    OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC,       \
-       ID3D11Resource)                                                                      \
-    OP(NAME, ShaderResourceView, ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC, \
-       ID3D11Resource)
+#define ANGLE_RESOURCE_TYPE_OP(NAME, OP)                                                     \
+    OP(NAME, BlendState, ID3D11BlendState, D3D11_BLEND_DESC, void)                           \
+    OP(NAME, Buffer, ID3D11Buffer, D3D11_BUFFER_DESC, const D3D11_SUBRESOURCE_DATA)          \
+    OP(NAME, ComputeShader, ID3D11ComputeShader, ShaderData, void)                           \
+    OP(NAME, DepthStencilState, ID3D11DepthStencilState, D3D11_DEPTH_STENCIL_DESC, void)     \
+    OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC,        \
+       ID3D11Resource)                                                                       \
+    OP(NAME, GeometryShader, ID3D11GeometryShader, ShaderData,                               \
+       const std::vector<D3D11_SO_DECLARATION_ENTRY>)                                        \
+    OP(NAME, InputLayout, ID3D11InputLayout, InputElementArray, const ShaderData)            \
+    OP(NAME, PixelShader, ID3D11PixelShader, ShaderData, void)                               \
+    OP(NAME, Query, ID3D11Query, D3D11_QUERY_DESC, void)                                     \
+    OP(NAME, RasterizerState, ID3D11RasterizerState, D3D11_RASTERIZER_DESC, void)            \
+    OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC,        \
+       ID3D11Resource)                                                                       \
+    OP(NAME, SamplerState, ID3D11SamplerState, D3D11_SAMPLER_DESC, void)                     \
+    OP(NAME, ShaderResourceView, ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC,  \
+       ID3D11Resource)                                                                       \
+    OP(NAME, Texture2D, ID3D11Texture2D, D3D11_TEXTURE2D_DESC, const D3D11_SUBRESOURCE_DATA) \
+    OP(NAME, Texture3D, ID3D11Texture3D, D3D11_TEXTURE3D_DESC, const D3D11_SUBRESOURCE_DATA) \
+    OP(NAME, VertexShader, ID3D11VertexShader, ShaderData, void)
 
 #define ANGLE_RESOURCE_TYPE_LIST(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) RESTYPE,
 
@@ -156,7 +188,14 @@ class Resource11Base : angle::NonCopyable
 
     void reset() { mData.reset(new DataT()); }
 
+    ResourceSerial getSerial() const
+    {
+        return ResourceSerial(reinterpret_cast<uintptr_t>(mData->object));
+    }
+
   protected:
+    friend class TextureHelper11;
+
     Resource11Base() : mData(new DataT()) {}
 
     Resource11Base(Resource11Base &&movedObj) : mData(new DataT())
@@ -221,12 +260,11 @@ class SharedResource11 : public Resource11Base<T, std::shared_ptr, TypedData<T>>
         return *this;
     }
 
-    SharedResource11(const SharedResource11 &sharedObj) { this->mData = sharedObj.mData; }
-
-    SharedResource11 &operator=(const SharedResource11 &sharedObj)
+    SharedResource11 makeCopy() const
     {
-        this->mData = sharedObj.mData;
-        return *this;
+        SharedResource11 copy;
+        copy.mData = this->mData;
+        return std::move(copy);
     }
 
   private:
@@ -267,14 +305,25 @@ class ResourceManager11 final : angle::NonCopyable
     }
 
     template <typename T>
-    void onRelease(T *resource);
+    void onRelease(T *resource)
+    {
+        onReleaseGeneric(GetResourceTypeFromD3D11<T>(), resource);
+    }
+
+    void onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource);
 
   private:
     void incrResource(ResourceType resourceType, size_t memorySize);
     void decrResource(ResourceType resourceType, size_t memorySize);
 
+    template <typename T>
+    GetInitDataFromD3D11<T> *createInitDataIfNeeded(const GetDescFromD3D11<T> *desc);
+
     std::array<size_t, NumResourceTypes> mAllocatedResourceCounts;
     std::array<size_t, NumResourceTypes> mAllocatedResourceDeviceMemory;
+    angle::MemoryBuffer mZeroMemory;
+
+    std::vector<D3D11_SUBRESOURCE_DATA> mShadowInitData;
 };
 
 template <typename ResourceT>
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp
index ca0bd3f86c6..9d70dbff3ac 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp
@@ -13,106 +13,111 @@
 namespace rx
 {
 
-ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable)
-    : ShaderExecutableD3D(function, length)
+ShaderExecutable11::ShaderExecutable11(const void *function,
+                                       size_t length,
+                                       d3d11::PixelShader &&executable)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(std::move(executable)),
+      mVertexExecutable(),
+      mGeometryExecutable(),
+      mStreamOutExecutable(),
+      mComputeExecutable()
 {
-    mPixelExecutable = executable;
-    mVertexExecutable    = nullptr;
-    mGeometryExecutable  = nullptr;
-    mStreamOutExecutable = nullptr;
-    mComputeExecutable   = nullptr;
 }
 
-ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut)
-    : ShaderExecutableD3D(function, length)
+ShaderExecutable11::ShaderExecutable11(const void *function,
+                                       size_t length,
+                                       d3d11::VertexShader &&executable,
+                                       d3d11::GeometryShader &&streamOut)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(),
+      mVertexExecutable(std::move(executable)),
+      mGeometryExecutable(),
+      mStreamOutExecutable(std::move(streamOut)),
+      mComputeExecutable()
 {
-    mVertexExecutable = executable;
-    mPixelExecutable     = nullptr;
-    mGeometryExecutable  = nullptr;
-    mStreamOutExecutable = streamOut;
-    mComputeExecutable   = nullptr;
 }
 
-ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable)
-    : ShaderExecutableD3D(function, length)
+ShaderExecutable11::ShaderExecutable11(const void *function,
+                                       size_t length,
+                                       d3d11::GeometryShader &&executable)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(),
+      mVertexExecutable(),
+      mGeometryExecutable(std::move(executable)),
+      mStreamOutExecutable(),
+      mComputeExecutable()
 {
-    mGeometryExecutable = executable;
-    mVertexExecutable    = nullptr;
-    mPixelExecutable     = nullptr;
-    mStreamOutExecutable = nullptr;
-    mComputeExecutable   = nullptr;
 }
 
 ShaderExecutable11::ShaderExecutable11(const void *function,
                                        size_t length,
-                                       ID3D11ComputeShader *executable)
-    : ShaderExecutableD3D(function, length)
+                                       d3d11::ComputeShader &&executable)
+    : ShaderExecutableD3D(function, length),
+      mPixelExecutable(),
+      mVertexExecutable(),
+      mGeometryExecutable(),
+      mStreamOutExecutable(),
+      mComputeExecutable(std::move(executable))
 {
-    mComputeExecutable   = executable;
-    mPixelExecutable     = nullptr;
-    mVertexExecutable    = nullptr;
-    mGeometryExecutable  = nullptr;
-    mStreamOutExecutable = nullptr;
 }
 
 ShaderExecutable11::~ShaderExecutable11()
 {
-    SafeRelease(mVertexExecutable);
-    SafeRelease(mPixelExecutable);
-    SafeRelease(mGeometryExecutable);
-    SafeRelease(mStreamOutExecutable);
-    SafeRelease(mComputeExecutable);
 }
 
-ID3D11VertexShader *ShaderExecutable11::getVertexShader() const
+const d3d11::VertexShader &ShaderExecutable11::getVertexShader() const
 {
     return mVertexExecutable;
 }
 
-ID3D11PixelShader *ShaderExecutable11::getPixelShader() const
+const d3d11::PixelShader &ShaderExecutable11::getPixelShader() const
 {
     return mPixelExecutable;
 }
 
-ID3D11GeometryShader *ShaderExecutable11::getGeometryShader() const
+const d3d11::GeometryShader &ShaderExecutable11::getGeometryShader() const
 {
     return mGeometryExecutable;
 }
 
-ID3D11GeometryShader *ShaderExecutable11::getStreamOutShader() const
+const d3d11::GeometryShader &ShaderExecutable11::getStreamOutShader() const
 {
     return mStreamOutExecutable;
 }
 
-ID3D11ComputeShader *ShaderExecutable11::getComputeShader() const
+const d3d11::ComputeShader &ShaderExecutable11::getComputeShader() const
 {
     return mComputeExecutable;
 }
 
-UniformStorage11::UniformStorage11(Renderer11 *renderer, size_t initialSize)
-    : UniformStorageD3D(initialSize), mConstantBuffer(nullptr)
+UniformStorage11::UniformStorage11(size_t initialSize)
+    : UniformStorageD3D(initialSize), mConstantBuffer()
 {
-    ID3D11Device *d3d11Device = renderer->getDevice();
+}
 
-    if (initialSize > 0)
+UniformStorage11::~UniformStorage11()
+{
+}
+
+gl::Error UniformStorage11::getConstantBuffer(Renderer11 *renderer, const d3d11::Buffer **bufferOut)
+{
+    if (size() > 0 && !mConstantBuffer.valid())
     {
         D3D11_BUFFER_DESC constantBufferDescription = {0};
-        constantBufferDescription.ByteWidth           = static_cast<unsigned int>(initialSize);
+
+        constantBufferDescription.ByteWidth           = static_cast<unsigned int>(size());
         constantBufferDescription.Usage = D3D11_USAGE_DYNAMIC;
         constantBufferDescription.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
         constantBufferDescription.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
         constantBufferDescription.MiscFlags = 0;
         constantBufferDescription.StructureByteStride = 0;
 
-        HRESULT result =
-            d3d11Device->CreateBuffer(&constantBufferDescription, nullptr, &mConstantBuffer);
-        ASSERT(SUCCEEDED(result));
+        ANGLE_TRY(renderer->allocateResource(constantBufferDescription, &mConstantBuffer));
     }
-}
 
-UniformStorage11::~UniformStorage11()
-{
-    SafeRelease(mConstantBuffer);
+    *bufferOut = &mConstantBuffer;
+    return gl::NoError();
 }
 
-}
+}  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h
index 1fe1a20a914..c9a4b610142 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h
@@ -11,6 +11,7 @@
 #define LIBANGLE_RENDERER_D3D_D3D11_SHADEREXECUTABLE11_H_
 
 #include "libANGLE/renderer/d3d/ShaderExecutableD3D.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
 
 namespace rx
 {
@@ -20,39 +21,42 @@ class UniformStorage11;
 class ShaderExecutable11 : public ShaderExecutableD3D
 {
   public:
-    ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable);
-    ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut);
-    ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable);
-    ShaderExecutable11(const void *function, size_t length, ID3D11ComputeShader *executable);
+    ShaderExecutable11(const void *function, size_t length, d3d11::PixelShader &&executable);
+    ShaderExecutable11(const void *function,
+                       size_t length,
+                       d3d11::VertexShader &&executable,
+                       d3d11::GeometryShader &&streamOut);
+    ShaderExecutable11(const void *function, size_t length, d3d11::GeometryShader &&executable);
+    ShaderExecutable11(const void *function, size_t length, d3d11::ComputeShader &&executable);
 
     virtual ~ShaderExecutable11();
 
-    ID3D11PixelShader *getPixelShader() const;
-    ID3D11VertexShader *getVertexShader() const;
-    ID3D11GeometryShader *getGeometryShader() const;
-    ID3D11GeometryShader *getStreamOutShader() const;
-    ID3D11ComputeShader *getComputeShader() const;
+    const d3d11::PixelShader &getPixelShader() const;
+    const d3d11::VertexShader &getVertexShader() const;
+    const d3d11::GeometryShader &getGeometryShader() const;
+    const d3d11::GeometryShader &getStreamOutShader() const;
+    const d3d11::ComputeShader &getComputeShader() const;
 
   private:
-    ID3D11PixelShader *mPixelExecutable;
-    ID3D11VertexShader *mVertexExecutable;
-    ID3D11GeometryShader *mGeometryExecutable;
-    ID3D11GeometryShader *mStreamOutExecutable;
-    ID3D11ComputeShader *mComputeExecutable;
+    d3d11::PixelShader mPixelExecutable;
+    d3d11::VertexShader mVertexExecutable;
+    d3d11::GeometryShader mGeometryExecutable;
+    d3d11::GeometryShader mStreamOutExecutable;
+    d3d11::ComputeShader mComputeExecutable;
 };
 
 class UniformStorage11 : public UniformStorageD3D
 {
   public:
-    UniformStorage11(Renderer11 *renderer, size_t initialSize);
+    UniformStorage11(size_t initialSize);
     virtual ~UniformStorage11();
 
-    ID3D11Buffer *getConstantBuffer() const { return mConstantBuffer; }
+    gl::Error getConstantBuffer(Renderer11 *renderer, const d3d11::Buffer **bufferOut);
 
   private:
-    ID3D11Buffer *mConstantBuffer;
+    d3d11::Buffer mConstantBuffer;
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_SHADEREXECUTABLE11_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp
index 2a446f403f4..5beb6479ba3 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp
@@ -10,11 +10,12 @@
 
 #include "common/bitset_utils.h"
 #include "common/utilities.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Query.h"
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h"
-#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
 #include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
+#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
 
 namespace rx
 {
@@ -141,25 +142,25 @@ static const GLenum QueryTypes[] = {GL_ANY_SAMPLES_PASSED, GL_ANY_SAMPLES_PASSED
 
 StateManager11::StateManager11(Renderer11 *renderer)
     : mRenderer(renderer),
-      mBlendStateIsDirty(false),
+      mInternalDirtyBits(),
       mCurBlendColor(0, 0, 0, 0),
       mCurSampleMask(0),
-      mDepthStencilStateIsDirty(false),
       mCurStencilRef(0),
       mCurStencilBackRef(0),
       mCurStencilSize(0),
-      mRasterizerStateIsDirty(false),
-      mScissorStateIsDirty(false),
       mCurScissorEnabled(false),
       mCurScissorRect(),
-      mViewportStateIsDirty(false),
       mCurViewport(),
       mCurNear(0.0f),
       mCurFar(0.0f),
       mViewportBounds(),
-      mRenderTargetIsDirty(false),
+      mCurPresentPathFastEnabled(false),
+      mCurPresentPathFastColorBufferHeight(0),
       mDirtyCurrentValueAttribs(),
-      mCurrentValueAttribs()
+      mCurrentValueAttribs(),
+      mCurrentInputLayout(),
+      mDirtyVertexBufferRange(gl::MAX_VERTEX_ATTRIBS, 0),
+      mCurrentPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_UNDEFINED)
 {
     mCurBlendState.blend                 = false;
     mCurBlendState.sourceBlendRGB        = GL_ONE;
@@ -203,6 +204,10 @@ StateManager11::StateManager11(Renderer11 *renderer)
 
     // Initially all current value attributes must be updated on first use.
     mDirtyCurrentValueAttribs.flip();
+
+    mCurrentVertexBuffers.fill(nullptr);
+    mCurrentVertexStrides.fill(std::numeric_limits<UINT>::max());
+    mCurrentVertexOffsets.fill(std::numeric_limits<UINT>::max());
 }
 
 StateManager11::~StateManager11()
@@ -214,35 +219,36 @@ void StateManager11::updateStencilSizeIfChanged(bool depthStencilInitialized,
 {
     if (!depthStencilInitialized || stencilSize != mCurStencilSize)
     {
-        mCurStencilSize           = stencilSize;
-        mDepthStencilStateIsDirty = true;
+        mCurStencilSize = stencilSize;
+        mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
     }
 }
 
-void StateManager11::setViewportBounds(const int width, const int height)
+void StateManager11::checkPresentPath(const gl::Context *context)
 {
-    if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3 &&
-        (mViewportBounds.width != width || mViewportBounds.height != height))
-    {
-        mViewportBounds       = gl::Extents(width, height, 1);
-        mViewportStateIsDirty = true;
-    }
-}
+    if (!mRenderer->presentPathFastEnabled())
+        return;
 
-void StateManager11::updatePresentPath(bool presentPathFastActive,
-                                       const gl::FramebufferAttachment *framebufferAttachment)
-{
-    const int colorBufferHeight =
-        framebufferAttachment ? framebufferAttachment->getSize().height : 0;
+    const auto *framebuffer          = context->getGLState().getDrawFramebuffer();
+    const auto *firstColorAttachment = framebuffer->getFirstColorbuffer();
+    const bool presentPathFastActive = UsePresentPathFast(mRenderer, firstColorAttachment);
+
+    const int colorBufferHeight = firstColorAttachment ? firstColorAttachment->getSize().height : 0;
 
     if ((mCurPresentPathFastEnabled != presentPathFastActive) ||
         (presentPathFastActive && (colorBufferHeight != mCurPresentPathFastColorBufferHeight)))
     {
         mCurPresentPathFastEnabled           = presentPathFastActive;
         mCurPresentPathFastColorBufferHeight = colorBufferHeight;
-        mViewportStateIsDirty                = true;  // Viewport may need to be vertically inverted
-        mScissorStateIsDirty                 = true;  // Scissor rect may need to be vertically inverted
-        mRasterizerStateIsDirty              = true;  // Cull Mode may need to be inverted
+
+        // Scissor rect may need to be vertically inverted
+        mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE);
+
+        // Cull Mode may need to be inverted
+        mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
+
+        // Viewport may need to be vertically inverted
+        mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE);
     }
 }
 
@@ -253,13 +259,15 @@ void StateManager11::setComputeConstants(GLuint numGroupsX, GLuint numGroupsY, G
     mComputeConstants.numWorkGroups[2] = numGroupsZ;
 }
 
-void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
+void StateManager11::syncState(const gl::Context *context, const gl::State::DirtyBits &dirtyBits)
 {
     if (!dirtyBits.any())
     {
         return;
     }
 
+    const auto &state = context->getGLState();
+
     for (auto dirtyBit : dirtyBits)
     {
         switch (dirtyBit)
@@ -270,7 +278,7 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                 if (blendState.blendEquationRGB != mCurBlendState.blendEquationRGB ||
                     blendState.blendEquationAlpha != mCurBlendState.blendEquationAlpha)
                 {
-                    mBlendStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
                 }
                 break;
             }
@@ -282,27 +290,27 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                     blendState.sourceBlendAlpha != mCurBlendState.sourceBlendAlpha ||
                     blendState.destBlendAlpha != mCurBlendState.destBlendAlpha)
                 {
-                    mBlendStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
                 }
                 break;
             }
             case gl::State::DIRTY_BIT_BLEND_ENABLED:
                 if (state.getBlendState().blend != mCurBlendState.blend)
                 {
-                    mBlendStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE_ENABLED:
                 if (state.getBlendState().sampleAlphaToCoverage !=
                     mCurBlendState.sampleAlphaToCoverage)
                 {
-                    mBlendStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_DITHER_ENABLED:
                 if (state.getBlendState().dither != mCurBlendState.dither)
                 {
-                    mBlendStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_COLOR_MASK:
@@ -313,38 +321,38 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                     blendState.colorMaskBlue != mCurBlendState.colorMaskBlue ||
                     blendState.colorMaskAlpha != mCurBlendState.colorMaskAlpha)
                 {
-                    mBlendStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
                 }
                 break;
             }
             case gl::State::DIRTY_BIT_BLEND_COLOR:
                 if (state.getBlendColor() != mCurBlendColor)
                 {
-                    mBlendStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_DEPTH_MASK:
                 if (state.getDepthStencilState().depthMask != mCurDepthStencilState.depthMask)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED:
                 if (state.getDepthStencilState().depthTest != mCurDepthStencilState.depthTest)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_DEPTH_FUNC:
                 if (state.getDepthStencilState().depthFunc != mCurDepthStencilState.depthFunc)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED:
                 if (state.getDepthStencilState().stencilTest != mCurDepthStencilState.stencilTest)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT:
@@ -354,7 +362,7 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                     depthStencil.stencilMask != mCurDepthStencilState.stencilMask ||
                     state.getStencilRef() != mCurStencilRef)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             }
@@ -365,7 +373,7 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                     depthStencil.stencilBackMask != mCurDepthStencilState.stencilBackMask ||
                     state.getStencilBackRef() != mCurStencilBackRef)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             }
@@ -373,14 +381,14 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                 if (state.getDepthStencilState().stencilWritemask !=
                     mCurDepthStencilState.stencilWritemask)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK:
                 if (state.getDepthStencilState().stencilBackWritemask !=
                     mCurDepthStencilState.stencilBackWritemask)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_STENCIL_OPS_FRONT:
@@ -391,7 +399,7 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                         mCurDepthStencilState.stencilPassDepthFail ||
                     depthStencil.stencilPassDepthPass != mCurDepthStencilState.stencilPassDepthPass)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             }
@@ -404,33 +412,33 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                     depthStencil.stencilBackPassDepthPass !=
                         mCurDepthStencilState.stencilBackPassDepthPass)
                 {
-                    mDepthStencilStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
                 }
                 break;
             }
             case gl::State::DIRTY_BIT_CULL_FACE_ENABLED:
                 if (state.getRasterizerState().cullFace != mCurRasterState.cullFace)
                 {
-                    mRasterizerStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_CULL_FACE:
                 if (state.getRasterizerState().cullMode != mCurRasterState.cullMode)
                 {
-                    mRasterizerStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_FRONT_FACE:
                 if (state.getRasterizerState().frontFace != mCurRasterState.frontFace)
                 {
-                    mRasterizerStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_POLYGON_OFFSET_FILL_ENABLED:
                 if (state.getRasterizerState().polygonOffsetFill !=
                     mCurRasterState.polygonOffsetFill)
                 {
-                    mRasterizerStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_POLYGON_OFFSET:
@@ -439,7 +447,7 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                 if (rasterState.polygonOffsetFactor != mCurRasterState.polygonOffsetFactor ||
                     rasterState.polygonOffsetUnits != mCurRasterState.polygonOffsetUnits)
                 {
-                    mRasterizerStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
                 }
                 break;
             }
@@ -447,37 +455,37 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                 if (state.getRasterizerState().rasterizerDiscard !=
                     mCurRasterState.rasterizerDiscard)
                 {
-                    mRasterizerStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_SCISSOR:
                 if (state.getScissor() != mCurScissorRect)
                 {
-                    mScissorStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_SCISSOR_TEST_ENABLED:
                 if (state.isScissorTestEnabled() != mCurScissorEnabled)
                 {
-                    mScissorStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE);
                     // Rasterizer state update needs mCurScissorsEnabled and updates when it changes
-                    mRasterizerStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_DEPTH_RANGE:
                 if (state.getNearPlane() != mCurNear || state.getFarPlane() != mCurFar)
                 {
-                    mViewportStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_VIEWPORT:
                 if (state.getViewport() != mCurViewport)
                 {
-                    mViewportStateIsDirty = true;
+                    mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE);
                 }
                 break;
             case gl::State::DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING:
-                mRenderTargetIsDirty = true;
+                invalidateRenderTarget(context);
                 break;
             default:
                 if (dirtyBit >= gl::State::DIRTY_BIT_CURRENT_VALUE_0 &&
@@ -490,22 +498,21 @@ void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBit
                 break;
         }
     }
+
+    // TODO(jmadill): Input layout and vertex buffer state.
 }
 
-gl::Error StateManager11::setBlendState(const gl::Framebuffer *framebuffer,
-                                        const gl::BlendState &blendState,
-                                        const gl::ColorF &blendColor,
-                                        unsigned int sampleMask)
+gl::Error StateManager11::syncBlendState(const gl::Context *context,
+                                         const gl::Framebuffer *framebuffer,
+                                         const gl::BlendState &blendState,
+                                         const gl::ColorF &blendColor,
+                                         unsigned int sampleMask)
 {
-    if (!mBlendStateIsDirty && sampleMask == mCurSampleMask)
-    {
-        return gl::NoError();
-    }
-
     ID3D11BlendState *dxBlendState = nullptr;
-    const d3d11::BlendStateKey &key = RenderStateCache::GetBlendStateKey(framebuffer, blendState);
+    const d3d11::BlendStateKey &key =
+        RenderStateCache::GetBlendStateKey(context, framebuffer, blendState);
 
-    ANGLE_TRY(mRenderer->getStateCache().getBlendState(key, &dxBlendState));
+    ANGLE_TRY(mRenderer->getBlendState(key, &dxBlendState));
 
     ASSERT(dxBlendState != nullptr);
 
@@ -534,36 +541,14 @@ gl::Error StateManager11::setBlendState(const gl::Framebuffer *framebuffer,
     mCurBlendColor = blendColor;
     mCurSampleMask = sampleMask;
 
-    mBlendStateIsDirty = false;
-
     return gl::NoError();
 }
 
-gl::Error StateManager11::setDepthStencilState(const gl::State &glState)
+gl::Error StateManager11::syncDepthStencilState(const gl::State &glState)
 {
-    const auto &fbo = *glState.getDrawFramebuffer();
-
-    // Disable the depth test/depth write if we are using a stencil-only attachment.
-    // This is because ANGLE emulates stencil-only with D24S8 on D3D11 - we should neither read
-    // nor write to the unused depth part of this emulated texture.
-    bool disableDepth = (!fbo.hasDepth() && fbo.hasStencil());
-
-    // Similarly we disable the stencil portion of the DS attachment if the app only binds depth.
-    bool disableStencil = (fbo.hasDepth() && !fbo.hasStencil());
-
-    // CurDisableDepth/Stencil are reset automatically after we call forceSetDepthStencilState.
-    if (!mDepthStencilStateIsDirty && mCurDisableDepth.valid() &&
-        disableDepth == mCurDisableDepth.value() && mCurDisableStencil.valid() &&
-        disableStencil == mCurDisableStencil.value())
-    {
-        return gl::NoError();
-    }
-
     mCurDepthStencilState = glState.getDepthStencilState();
     mCurStencilRef        = glState.getStencilRef();
     mCurStencilBackRef    = glState.getStencilBackRef();
-    mCurDisableDepth      = disableDepth;
-    mCurDisableStencil    = disableStencil;
 
     // get the maximum size of the stencil ref
     unsigned int maxStencil = 0;
@@ -577,25 +562,26 @@ gl::Error StateManager11::setDepthStencilState(const gl::State &glState)
     ASSERT((mCurDepthStencilState.stencilMask & maxStencil) ==
            (mCurDepthStencilState.stencilBackMask & maxStencil));
 
-    ID3D11DepthStencilState *dxDepthStencilState = nullptr;
-    gl::DepthStencilState dsStateKey             = glState.getDepthStencilState();
+    gl::DepthStencilState modifiedGLState = glState.getDepthStencilState();
 
-    if (disableDepth)
+    ASSERT(mCurDisableDepth.valid() && mCurDisableStencil.valid());
+
+    if (mCurDisableDepth.value())
     {
-        dsStateKey.depthTest = false;
-        dsStateKey.depthMask = false;
+        modifiedGLState.depthTest = false;
+        modifiedGLState.depthMask = false;
     }
 
-    if (disableStencil)
+    if (mCurDisableStencil.value())
     {
-        dsStateKey.stencilWritemask     = 0;
-        dsStateKey.stencilBackWritemask = 0;
-        dsStateKey.stencilTest          = false;
+        modifiedGLState.stencilWritemask     = 0;
+        modifiedGLState.stencilBackWritemask = 0;
+        modifiedGLState.stencilTest          = false;
     }
 
-    ANGLE_TRY(mRenderer->getStateCache().getDepthStencilState(dsStateKey, &dxDepthStencilState));
-
-    ASSERT(dxDepthStencilState);
+    ID3D11DepthStencilState *d3dState = nullptr;
+    ANGLE_TRY(mRenderer->getDepthStencilState(modifiedGLState, &d3dState));
+    ASSERT(d3dState);
 
     // Max D3D11 stencil reference value is 0xFF,
     // corresponding to the max 8 bits in a stencil buffer
@@ -607,21 +593,17 @@ gl::Error StateManager11::setDepthStencilState(const gl::State &glState)
                   "Unexpected value of D3D11_DEFAULT_STENCIL_WRITE_MASK");
     UINT dxStencilRef = std::min<UINT>(mCurStencilRef, 0xFFu);
 
-    mRenderer->getDeviceContext()->OMSetDepthStencilState(dxDepthStencilState, dxStencilRef);
-
-    mDepthStencilStateIsDirty = false;
+    mRenderer->getDeviceContext()->OMSetDepthStencilState(d3dState, dxStencilRef);
 
     return gl::NoError();
 }
 
-gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterState)
+gl::Error StateManager11::syncRasterizerState(const gl::Context *context, bool pointDrawMode)
 {
     // TODO: Remove pointDrawMode and multiSample from gl::RasterizerState.
-    if (!mRasterizerStateIsDirty && rasterState.pointDrawMode == mCurRasterState.pointDrawMode &&
-        rasterState.multiSample == mCurRasterState.multiSample)
-    {
-        return gl::NoError();
-    }
+    gl::RasterizerState rasterState = context->getGLState().getRasterizerState();
+    rasterState.pointDrawMode       = pointDrawMode;
+    rasterState.multiSample         = mCurRasterState.multiSample;
 
     ID3D11RasterizerState *dxRasterState = nullptr;
 
@@ -642,28 +624,23 @@ gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterSt
             modifiedRasterState.frontFace = GL_CCW;
         }
 
-        ANGLE_TRY(mRenderer->getStateCache().getRasterizerState(
-            modifiedRasterState, mCurScissorEnabled, &dxRasterState));
+        ANGLE_TRY(
+            mRenderer->getRasterizerState(modifiedRasterState, mCurScissorEnabled, &dxRasterState));
     }
     else
     {
-        ANGLE_TRY(mRenderer->getStateCache().getRasterizerState(rasterState, mCurScissorEnabled,
-                                                                &dxRasterState));
+        ANGLE_TRY(mRenderer->getRasterizerState(rasterState, mCurScissorEnabled, &dxRasterState));
     }
 
     mRenderer->getDeviceContext()->RSSetState(dxRasterState);
 
-    mCurRasterState         = rasterState;
-    mRasterizerStateIsDirty = false;
+    mCurRasterState = rasterState;
 
     return gl::NoError();
 }
 
-void StateManager11::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
+void StateManager11::syncScissorRectangle(const gl::Rectangle &scissor, bool enabled)
 {
-    if (!mScissorStateIsDirty)
-        return;
-
     int modifiedScissorY = scissor.y;
     if (mCurPresentPathFastEnabled)
     {
@@ -683,17 +660,13 @@ void StateManager11::setScissorRectangle(const gl::Rectangle &scissor, bool enab
 
     mCurScissorRect      = scissor;
     mCurScissorEnabled   = enabled;
-    mScissorStateIsDirty = false;
 }
 
-void StateManager11::setViewport(const gl::Caps *caps,
-                                 const gl::Rectangle &viewport,
-                                 float zNear,
-                                 float zFar)
+void StateManager11::syncViewport(const gl::Caps *caps,
+                                  const gl::Rectangle &viewport,
+                                  float zNear,
+                                  float zFar)
 {
-    if (!mViewportStateIsDirty)
-        return;
-
     float actualZNear = gl::clamp01(zNear);
     float actualZFar  = gl::clamp01(zFar);
 
@@ -791,50 +764,119 @@ void StateManager11::setViewport(const gl::Caps *caps,
     mVertexConstants.viewScale[1] = mPixelConstants.viewScale[1];
     mVertexConstants.viewScale[2] = mPixelConstants.viewScale[2];
     mVertexConstants.viewScale[3] = mPixelConstants.viewScale[3];
-
-    mViewportStateIsDirty = false;
 }
 
-void StateManager11::invalidateRenderTarget()
+void StateManager11::invalidateRenderTarget(const gl::Context *context)
 {
-    mRenderTargetIsDirty = true;
+    mInternalDirtyBits.set(DIRTY_BIT_RENDER_TARGET);
+
+    // The D3D11 blend state is heavily dependent on the current render target.
+    mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
+
+    // nullptr only on display initialization.
+    if (!context)
+    {
+        return;
+    }
+
+    gl::Framebuffer *fbo = context->getGLState().getDrawFramebuffer();
+
+    // nullptr fbo can occur in some egl events like display initialization.
+    if (!fbo)
+    {
+        return;
+    }
+
+    // Disable the depth test/depth write if we are using a stencil-only attachment.
+    // This is because ANGLE emulates stencil-only with D24S8 on D3D11 - we should neither read
+    // nor write to the unused depth part of this emulated texture.
+    bool disableDepth = (!fbo->hasDepth() && fbo->hasStencil());
+
+    // Similarly we disable the stencil portion of the DS attachment if the app only binds depth.
+    bool disableStencil = (fbo->hasDepth() && !fbo->hasStencil());
+
+    if (!mCurDisableDepth.valid() || disableDepth != mCurDisableDepth.value() ||
+        !mCurDisableStencil.valid() || disableStencil != mCurDisableStencil.value())
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_DEPTH_STENCIL_STATE);
+        mCurDisableDepth   = disableDepth;
+        mCurDisableStencil = disableStencil;
+    }
+
+    bool multiSample = (fbo->getCachedSamples(context) != 0);
+    if (multiSample != mCurRasterState.multiSample)
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
+        mCurRasterState.multiSample = multiSample;
+    }
+
+    checkPresentPath(context);
+
+    if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
+    {
+        auto *firstAttachment = fbo->getFirstNonNullAttachment();
+        const auto &size      = firstAttachment->getSize();
+        if (mViewportBounds.width != size.width || mViewportBounds.height != size.height)
+        {
+            mViewportBounds = gl::Extents(size.width, size.height, 1);
+            mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE);
+        }
+    }
 }
 
-void StateManager11::invalidateBoundViews()
+void StateManager11::invalidateBoundViews(const gl::Context *context)
 {
     mCurVertexSRVs.clear();
     mCurPixelSRVs.clear();
 
-    invalidateRenderTarget();
+    invalidateRenderTarget(context);
 }
 
-void StateManager11::invalidateEverything()
+void StateManager11::invalidateEverything(const gl::Context *context)
 {
-    mBlendStateIsDirty        = true;
-    mDepthStencilStateIsDirty = true;
-    mRasterizerStateIsDirty   = true;
-    mScissorStateIsDirty      = true;
-    mViewportStateIsDirty     = true;
+    mInternalDirtyBits.set();
 
     // We reset the current SRV data because it might not be in sync with D3D's state
     // anymore. For example when a currently used SRV is used as an RTV, D3D silently
     // remove it from its state.
-    invalidateBoundViews();
+    invalidateBoundViews(context);
+
+    // All calls to IASetInputLayout go through the state manager, so it shouldn't be
+    // necessary to invalidate the state.
+
+    // Invalidate the vertex buffer state.
+    invalidateVertexBuffer();
+
+    mCurrentPrimitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
+
+    mAppliedVertexShader.dirty();
+    mAppliedGeometryShader.dirty();
+    mAppliedPixelShader.dirty();
+    mAppliedComputeShader.dirty();
+}
+
+void StateManager11::invalidateVertexBuffer()
+{
+    unsigned int limit = std::min<unsigned int>(mRenderer->getNativeCaps().maxVertexAttributes,
+                                                gl::MAX_VERTEX_ATTRIBS);
+    mDirtyVertexBufferRange = gl::RangeUI(0, limit);
 }
 
-void StateManager11::setOneTimeRenderTarget(ID3D11RenderTargetView *rtv,
+void StateManager11::setOneTimeRenderTarget(const gl::Context *context,
+                                            ID3D11RenderTargetView *rtv,
                                             ID3D11DepthStencilView *dsv)
 {
     mRenderer->getDeviceContext()->OMSetRenderTargets(1, &rtv, dsv);
-    mRenderTargetIsDirty = true;
+    invalidateRenderTarget(context);
 }
 
-void StateManager11::setOneTimeRenderTargets(ID3D11RenderTargetView **rtvs,
+void StateManager11::setOneTimeRenderTargets(const gl::Context *context,
+                                             ID3D11RenderTargetView **rtvs,
                                              UINT numRtvs,
                                              ID3D11DepthStencilView *dsv)
 {
     mRenderer->getDeviceContext()->OMSetRenderTargets(numRtvs, (numRtvs > 0) ? rtvs : nullptr, dsv);
-    mRenderTargetIsDirty = true;
+    invalidateRenderTarget(context);
 }
 
 void StateManager11::onBeginQuery(Query11 *query)
@@ -847,9 +889,9 @@ void StateManager11::onDeleteQueryObject(Query11 *query)
     mCurrentQueries.erase(query);
 }
 
-gl::Error StateManager11::onMakeCurrent(const gl::ContextState &data)
+gl::Error StateManager11::onMakeCurrent(const gl::Context *context)
 {
-    const gl::State &state = data.getState();
+    const gl::State &state = context->getGLState();
 
     for (Query11 *query : mCurrentQueries)
     {
@@ -907,9 +949,7 @@ gl::Error StateManager11::clearTextures(gl::SamplerType samplerType,
 
     auto &currentSRVs = (samplerType == gl::SAMPLER_VERTEX ? mCurVertexSRVs : mCurPixelSRVs);
 
-    gl::Range<size_t> clearRange(rangeStart, rangeStart);
-    clearRange.extend(std::min(rangeEnd, currentSRVs.highestUsed()));
-
+    gl::Range<size_t> clearRange(rangeStart, std::min(rangeEnd, currentSRVs.highestUsed()));
     if (clearRange.empty())
     {
         return gl::NoError();
@@ -918,18 +958,18 @@ gl::Error StateManager11::clearTextures(gl::SamplerType samplerType,
     auto deviceContext = mRenderer->getDeviceContext();
     if (samplerType == gl::SAMPLER_VERTEX)
     {
-        deviceContext->VSSetShaderResources(static_cast<unsigned int>(rangeStart),
-                                            static_cast<unsigned int>(rangeEnd - rangeStart),
+        deviceContext->VSSetShaderResources(static_cast<unsigned int>(clearRange.low()),
+                                            static_cast<unsigned int>(clearRange.length()),
                                             &mNullSRVs[0]);
     }
     else
     {
-        deviceContext->PSSetShaderResources(static_cast<unsigned int>(rangeStart),
-                                            static_cast<unsigned int>(rangeEnd - rangeStart),
+        deviceContext->PSSetShaderResources(static_cast<unsigned int>(clearRange.low()),
+                                            static_cast<unsigned int>(clearRange.length()),
                                             &mNullSRVs[0]);
     }
 
-    for (size_t samplerIndex = rangeStart; samplerIndex < rangeEnd; ++samplerIndex)
+    for (size_t samplerIndex : clearRange)
     {
         currentSRVs.update(samplerIndex, nullptr);
     }
@@ -987,23 +1027,13 @@ void StateManager11::deinitialize()
     mCurrentValueAttribs.clear();
 }
 
-gl::Error StateManager11::syncFramebuffer(ContextImpl *contextImpl, gl::Framebuffer *framebuffer)
+gl::Error StateManager11::syncFramebuffer(const gl::Context *context, gl::Framebuffer *framebuffer)
 {
     Framebuffer11 *framebuffer11 = GetImplAs<Framebuffer11>(framebuffer);
-    ANGLE_TRY(framebuffer11->markAttachmentsDirty());
 
-    if (framebuffer11->hasAnyInternalDirtyBit())
-    {
-        ASSERT(framebuffer->id() != 0);
-        framebuffer11->syncInternalState(contextImpl);
-    }
-
-    if (!mRenderTargetIsDirty)
-    {
-        return gl::NoError();
-    }
-
-    mRenderTargetIsDirty = false;
+    // Applies the render target surface, depth stencil surface, viewport rectangle and
+    // scissor rectangle to the renderer
+    ASSERT(framebuffer && !framebuffer->hasAnyDirtyBit() && framebuffer->cachedComplete());
 
     // Check for zero-sized default framebuffer, which is a special case.
     // in this case we do not wish to modify any state and just silently return false.
@@ -1018,20 +1048,15 @@ gl::Error StateManager11::syncFramebuffer(ContextImpl *contextImpl, gl::Framebuf
         }
     }
 
-    // Get the color render buffer and serial
-    // Also extract the render target dimensions and view
-    unsigned int renderTargetWidth  = 0;
-    unsigned int renderTargetHeight = 0;
-    RTVArray framebufferRTVs;
-    bool missingColorRenderTarget = true;
-
-    framebufferRTVs.fill(nullptr);
+    RTVArray framebufferRTVs = {{}};
 
     const auto &colorRTs = framebuffer11->getCachedColorRenderTargets();
 
     size_t appliedRTIndex  = 0;
     bool skipInactiveRTs   = mRenderer->getWorkarounds().mrtPerfWorkaround;
     const auto &drawStates = framebuffer->getDrawBufferStates();
+    gl::DrawBufferMask activeProgramOutputs =
+        context->getContextState().getState().getProgram()->getActiveOutputVariables();
     UINT maxExistingRT     = 0;
 
     for (size_t rtIndex = 0; rtIndex < colorRTs.size(); ++rtIndex)
@@ -1039,7 +1064,8 @@ gl::Error StateManager11::syncFramebuffer(ContextImpl *contextImpl, gl::Framebuf
         const RenderTarget11 *renderTarget = colorRTs[rtIndex];
 
         // Skip inactive rendertargets if the workaround is enabled.
-        if (skipInactiveRTs && (!renderTarget || drawStates[rtIndex] == GL_NONE))
+        if (skipInactiveRTs &&
+            (!renderTarget || drawStates[rtIndex] == GL_NONE || !activeProgramOutputs[rtIndex]))
         {
             continue;
         }
@@ -1049,19 +1075,12 @@ gl::Error StateManager11::syncFramebuffer(ContextImpl *contextImpl, gl::Framebuf
             framebufferRTVs[appliedRTIndex] = renderTarget->getRenderTargetView().get();
             ASSERT(framebufferRTVs[appliedRTIndex]);
             maxExistingRT = static_cast<UINT>(appliedRTIndex) + 1;
-
-            if (missingColorRenderTarget)
-            {
-                renderTargetWidth        = renderTarget->getWidth();
-                renderTargetHeight       = renderTarget->getHeight();
-                missingColorRenderTarget = false;
-            }
         }
 
         // Unset conflicting texture SRVs
         const auto *attachment = framebuffer->getColorbuffer(rtIndex);
         ASSERT(attachment);
-        unsetConflictingAttachmentResources(attachment, renderTarget->getTexture());
+        unsetConflictingAttachmentResources(attachment, renderTarget->getTexture().get());
 
         appliedRTIndex++;
     }
@@ -1074,18 +1093,11 @@ gl::Error StateManager11::syncFramebuffer(ContextImpl *contextImpl, gl::Framebuf
         framebufferDSV = depthStencilRenderTarget->getDepthStencilView().get();
         ASSERT(framebufferDSV);
 
-        // If there is no render buffer, the width, height and format values come from
-        // the depth stencil
-        if (missingColorRenderTarget)
-        {
-            renderTargetWidth  = depthStencilRenderTarget->getWidth();
-            renderTargetHeight = depthStencilRenderTarget->getHeight();
-        }
-
         // Unset conflicting texture SRVs
         const auto *attachment = framebuffer->getDepthOrStencilbuffer();
         ASSERT(attachment);
-        unsetConflictingAttachmentResources(attachment, depthStencilRenderTarget->getTexture());
+        unsetConflictingAttachmentResources(attachment,
+                                            depthStencilRenderTarget->getTexture().get());
     }
 
     // TODO(jmadill): Use context caps?
@@ -1095,11 +1107,6 @@ gl::Error StateManager11::syncFramebuffer(ContextImpl *contextImpl, gl::Framebuf
     mRenderer->getDeviceContext()->OMSetRenderTargets(maxExistingRT, framebufferRTVs.data(),
                                                       framebufferDSV);
 
-    // The D3D11 blend state is heavily dependent on the current render target.
-    mBlendStateIsDirty = true;
-
-    setViewportBounds(renderTargetWidth, renderTargetHeight);
-
     return gl::NoError();
 }
 
@@ -1137,4 +1144,216 @@ const std::vector<TranslatedAttribute> &StateManager11::getCurrentValueAttribs()
     return mCurrentValueAttribs;
 }
 
+void StateManager11::setInputLayout(const d3d11::InputLayout *inputLayout)
+{
+    ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
+    if (inputLayout == nullptr)
+    {
+        if (mCurrentInputLayout != 0)
+        {
+            deviceContext->IASetInputLayout(nullptr);
+            mCurrentInputLayout = 0;
+        }
+    }
+    else if (inputLayout->getSerial() != mCurrentInputLayout)
+    {
+        deviceContext->IASetInputLayout(inputLayout->get());
+        mCurrentInputLayout = inputLayout->getSerial();
+    }
+}
+
+bool StateManager11::queueVertexBufferChange(size_t bufferIndex,
+                                             ID3D11Buffer *buffer,
+                                             UINT stride,
+                                             UINT offset)
+{
+    if (buffer != mCurrentVertexBuffers[bufferIndex] ||
+        stride != mCurrentVertexStrides[bufferIndex] ||
+        offset != mCurrentVertexOffsets[bufferIndex])
+    {
+        mDirtyVertexBufferRange.extend(static_cast<unsigned int>(bufferIndex));
+
+        mCurrentVertexBuffers[bufferIndex] = buffer;
+        mCurrentVertexStrides[bufferIndex] = stride;
+        mCurrentVertexOffsets[bufferIndex] = offset;
+        return true;
+    }
+
+    return false;
+}
+
+bool StateManager11::queueVertexOffsetChange(size_t bufferIndex, UINT offsetOnly)
+{
+    if (offsetOnly != mCurrentVertexOffsets[bufferIndex])
+    {
+        mDirtyVertexBufferRange.extend(static_cast<unsigned int>(bufferIndex));
+        mCurrentVertexOffsets[bufferIndex] = offsetOnly;
+        return true;
+    }
+    return false;
+}
+
+void StateManager11::applyVertexBufferChanges()
+{
+    if (mDirtyVertexBufferRange.empty())
+    {
+        return;
+    }
+
+    ASSERT(mDirtyVertexBufferRange.high() <= gl::MAX_VERTEX_ATTRIBS);
+
+    UINT start = static_cast<UINT>(mDirtyVertexBufferRange.low());
+
+    ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
+    deviceContext->IASetVertexBuffers(start, static_cast<UINT>(mDirtyVertexBufferRange.length()),
+                                      &mCurrentVertexBuffers[start], &mCurrentVertexStrides[start],
+                                      &mCurrentVertexOffsets[start]);
+
+    mDirtyVertexBufferRange = gl::RangeUI(gl::MAX_VERTEX_ATTRIBS, 0);
+}
+
+void StateManager11::setSingleVertexBuffer(const d3d11::Buffer *buffer, UINT stride, UINT offset)
+{
+    ID3D11Buffer *native = buffer ? buffer->get() : nullptr;
+    if (queueVertexBufferChange(0, native, stride, offset))
+    {
+        applyVertexBufferChanges();
+    }
+}
+
+gl::Error StateManager11::updateState(const gl::Context *context, GLenum drawMode)
+{
+    const auto &data    = context->getContextState();
+    const auto &glState = data.getState();
+
+    gl::Framebuffer *framebuffer = glState.getDrawFramebuffer();
+    Framebuffer11 *framebuffer11 = GetImplAs<Framebuffer11>(framebuffer);
+    ANGLE_TRY(framebuffer11->markAttachmentsDirty(context));
+
+    if (framebuffer11->hasAnyInternalDirtyBit())
+    {
+        ASSERT(framebuffer->id() != 0);
+        framebuffer11->syncInternalState(context);
+    }
+
+    bool pointDrawMode = (drawMode == GL_POINTS);
+    if (pointDrawMode != mCurRasterState.pointDrawMode)
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_RASTERIZER_STATE);
+    }
+
+    // TODO(jmadill): This can be recomputed only on framebuffer changes.
+    RenderTarget11 *firstRT = framebuffer11->getFirstRenderTarget();
+    int samples             = (firstRT ? firstRT->getSamples() : 0);
+    unsigned int sampleMask = GetBlendSampleMask(data, samples);
+    if (sampleMask != mCurSampleMask)
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
+    }
+
+    auto dirtyBitsCopy = mInternalDirtyBits;
+    mInternalDirtyBits.reset();
+
+    for (auto dirtyBit : dirtyBitsCopy)
+    {
+        switch (dirtyBit)
+        {
+            case DIRTY_BIT_RENDER_TARGET:
+                ANGLE_TRY(syncFramebuffer(context, framebuffer));
+                break;
+            case DIRTY_BIT_VIEWPORT_STATE:
+                syncViewport(&data.getCaps(), glState.getViewport(), glState.getNearPlane(),
+                             glState.getFarPlane());
+                break;
+            case DIRTY_BIT_SCISSOR_STATE:
+                syncScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled());
+                break;
+            case DIRTY_BIT_RASTERIZER_STATE:
+                ANGLE_TRY(syncRasterizerState(context, pointDrawMode));
+                break;
+            case DIRTY_BIT_BLEND_STATE:
+                ANGLE_TRY(syncBlendState(context, framebuffer, glState.getBlendState(),
+                                         glState.getBlendColor(), sampleMask));
+                break;
+            case DIRTY_BIT_DEPTH_STENCIL_STATE:
+                ANGLE_TRY(syncDepthStencilState(glState));
+                break;
+            default:
+                UNREACHABLE();
+                break;
+        }
+    }
+
+    // Check that we haven't set any dirty bits in the flushing of the dirty bits loop.
+    ASSERT(mInternalDirtyBits.none());
+
+    return gl::NoError();
+}
+
+void StateManager11::setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology)
+{
+    if (primitiveTopology != mCurrentPrimitiveTopology)
+    {
+        mRenderer->getDeviceContext()->IASetPrimitiveTopology(primitiveTopology);
+        mCurrentPrimitiveTopology = primitiveTopology;
+    }
+}
+
+void StateManager11::setDrawShaders(const d3d11::VertexShader *vertexShader,
+                                    const d3d11::GeometryShader *geometryShader,
+                                    const d3d11::PixelShader *pixelShader)
+{
+    setVertexShader(vertexShader);
+    setGeometryShader(geometryShader);
+    setPixelShader(pixelShader);
+}
+
+void StateManager11::setVertexShader(const d3d11::VertexShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedVertexShader)
+    {
+        ID3D11VertexShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->VSSetShader(appliedShader, nullptr, 0);
+        mAppliedVertexShader = serial;
+    }
+}
+
+void StateManager11::setGeometryShader(const d3d11::GeometryShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedGeometryShader)
+    {
+        ID3D11GeometryShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->GSSetShader(appliedShader, nullptr, 0);
+        mAppliedGeometryShader = serial;
+    }
+}
+
+void StateManager11::setPixelShader(const d3d11::PixelShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedPixelShader)
+    {
+        ID3D11PixelShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->PSSetShader(appliedShader, nullptr, 0);
+        mAppliedPixelShader = serial;
+    }
+}
+
+void StateManager11::setComputeShader(const d3d11::ComputeShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedComputeShader)
+    {
+        ID3D11ComputeShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->CSSetShader(appliedShader, nullptr, 0);
+        mAppliedComputeShader = serial;
+    }
+}
+
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.h
index 83e8dfacecd..bc0f47675fd 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.h
@@ -55,23 +55,8 @@ class StateManager11 final : angle::NonCopyable
 
     void initialize(const gl::Caps &caps);
     void deinitialize();
-    void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
 
-    gl::Error setBlendState(const gl::Framebuffer *framebuffer,
-                            const gl::BlendState &blendState,
-                            const gl::ColorF &blendColor,
-                            unsigned int sampleMask);
-
-    gl::Error setDepthStencilState(const gl::State &glState);
-
-    gl::Error setRasterizerState(const gl::RasterizerState &rasterState);
-
-    void setScissorRectangle(const gl::Rectangle &scissor, bool enabled);
-
-    void setViewport(const gl::Caps *caps, const gl::Rectangle &viewport, float zNear, float zFar);
-
-    void updatePresentPath(bool presentPathFastActive,
-                           const gl::FramebufferAttachment *framebufferAttachment);
+    void syncState(const gl::Context *context, const gl::State::DirtyBits &dirtyBits);
 
     const dx_VertexConstants11 &getVertexConstants() const { return mVertexConstants; }
     const dx_PixelConstants11 &getPixelConstants() const { return mPixelConstants; }
@@ -86,46 +71,104 @@ class StateManager11 final : angle::NonCopyable
                            ID3D11ShaderResourceView *srv);
     gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd);
 
-    gl::Error syncFramebuffer(ContextImpl *contextImpl, gl::Framebuffer *framebuffer);
-
-    void invalidateRenderTarget();
-    void invalidateBoundViews();
-    void invalidateEverything();
-
-    void setOneTimeRenderTarget(ID3D11RenderTargetView *rtv, ID3D11DepthStencilView *dsv);
-    void setOneTimeRenderTargets(ID3D11RenderTargetView **rtvs,
+    // Checks are done on a framebuffer state change to trigger other state changes.
+    // The Context is allowed to be nullptr for these methods, when called in EGL init code.
+    void invalidateRenderTarget(const gl::Context *context);
+    void invalidateBoundViews(const gl::Context *context);
+    void invalidateVertexBuffer();
+    void invalidateEverything(const gl::Context *context);
+
+    void setOneTimeRenderTarget(const gl::Context *context,
+                                ID3D11RenderTargetView *rtv,
+                                ID3D11DepthStencilView *dsv);
+    void setOneTimeRenderTargets(const gl::Context *context,
+                                 ID3D11RenderTargetView **rtvs,
                                  UINT numRtvs,
                                  ID3D11DepthStencilView *dsv);
 
     void onBeginQuery(Query11 *query);
     void onDeleteQueryObject(Query11 *query);
-    gl::Error onMakeCurrent(const gl::ContextState &data);
+    gl::Error onMakeCurrent(const gl::Context *context);
 
     gl::Error updateCurrentValueAttribs(const gl::State &state,
                                         VertexDataManager *vertexDataManager);
 
     const std::vector<TranslatedAttribute> &getCurrentValueAttribs() const;
 
+    void setInputLayout(const d3d11::InputLayout *inputLayout);
+
+    // TODO(jmadill): Migrate to d3d11::Buffer.
+    bool queueVertexBufferChange(size_t bufferIndex,
+                                 ID3D11Buffer *buffer,
+                                 UINT stride,
+                                 UINT offset);
+    bool queueVertexOffsetChange(size_t bufferIndex, UINT offsetOnly);
+    void applyVertexBufferChanges();
+
+    void setSingleVertexBuffer(const d3d11::Buffer *buffer, UINT stride, UINT offset);
+
+    gl::Error updateState(const gl::Context *context, GLenum drawMode);
+
+    void setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology);
+
+    void setDrawShaders(const d3d11::VertexShader *vertexShader,
+                        const d3d11::GeometryShader *geometryShader,
+                        const d3d11::PixelShader *pixelShader);
+    void setVertexShader(const d3d11::VertexShader *shader);
+    void setGeometryShader(const d3d11::GeometryShader *shader);
+    void setPixelShader(const d3d11::PixelShader *shader);
+    void setComputeShader(const d3d11::ComputeShader *shader);
+
   private:
-    void setViewportBounds(const int width, const int height);
     void unsetConflictingSRVs(gl::SamplerType shaderType,
                               uintptr_t resource,
                               const gl::ImageIndex &index);
     void unsetConflictingAttachmentResources(const gl::FramebufferAttachment *attachment,
                                              ID3D11Resource *resource);
 
+    gl::Error syncBlendState(const gl::Context *context,
+                             const gl::Framebuffer *framebuffer,
+                             const gl::BlendState &blendState,
+                             const gl::ColorF &blendColor,
+                             unsigned int sampleMask);
+
+    gl::Error syncDepthStencilState(const gl::State &glState);
+
+    gl::Error syncRasterizerState(const gl::Context *context, bool pointDrawMode);
+
+    void syncScissorRectangle(const gl::Rectangle &scissor, bool enabled);
+
+    void syncViewport(const gl::Caps *caps, const gl::Rectangle &viewport, float zNear, float zFar);
+
+    void checkPresentPath(const gl::Context *context);
+
+    gl::Error syncFramebuffer(const gl::Context *context, gl::Framebuffer *framebuffer);
+
+    enum DirtyBitType
+    {
+        DIRTY_BIT_RENDER_TARGET,
+        DIRTY_BIT_VIEWPORT_STATE,
+        DIRTY_BIT_SCISSOR_STATE,
+        DIRTY_BIT_RASTERIZER_STATE,
+        DIRTY_BIT_BLEND_STATE,
+        DIRTY_BIT_DEPTH_STENCIL_STATE,
+        DIRTY_BIT_INVALID,
+        DIRTY_BIT_MAX = DIRTY_BIT_INVALID,
+    };
+
+    using DirtyBits = angle::BitSet<DIRTY_BIT_MAX>;
+
     Renderer11 *mRenderer;
 
+    // Internal dirty bits.
+    DirtyBits mInternalDirtyBits;
+
     // Blend State
-    bool mBlendStateIsDirty;
-    // TODO(dianx) temporary representation of a dirty bit. once we move enough states in,
-    // try experimenting with dirty bit instead of a bool
     gl::BlendState mCurBlendState;
     gl::ColorF mCurBlendColor;
     unsigned int mCurSampleMask;
 
     // Currently applied depth stencil state
-    bool mDepthStencilStateIsDirty;
     gl::DepthStencilState mCurDepthStencilState;
     int mCurStencilRef;
     int mCurStencilBackRef;
@@ -134,16 +177,13 @@ class StateManager11 final : angle::NonCopyable
     Optional<bool> mCurDisableStencil;
 
     // Currently applied rasterizer state
-    bool mRasterizerStateIsDirty;
     gl::RasterizerState mCurRasterState;
 
     // Currently applied scissor rectangle state
-    bool mScissorStateIsDirty;
     bool mCurScissorEnabled;
     gl::Rectangle mCurScissorRect;
 
     // Currently applied viewport state
-    bool mViewportStateIsDirty;
     gl::Rectangle mCurViewport;
     float mCurNear;
     float mCurFar;
@@ -161,9 +201,6 @@ class StateManager11 final : angle::NonCopyable
     bool mCurPresentPathFastEnabled;
     int mCurPresentPathFastColorBufferHeight;
 
-    // Current RenderTarget state
-    bool mRenderTargetIsDirty;
-
     // Queries that are currently active in this state
     std::set<Query11 *> mCurrentQueries;
 
@@ -207,6 +244,25 @@ class StateManager11 final : angle::NonCopyable
     // Current translations of "Current-Value" data - owned by Context, not VertexArray.
     gl::AttributesMask mDirtyCurrentValueAttribs;
     std::vector<TranslatedAttribute> mCurrentValueAttribs;
+
+    // Current applied input layout.
+    ResourceSerial mCurrentInputLayout;
+
+    // Current applied vertex states.
+    // TODO(jmadill): Figure out how to use ResourceSerial here.
+    std::array<ID3D11Buffer *, gl::MAX_VERTEX_ATTRIBS> mCurrentVertexBuffers;
+    std::array<UINT, gl::MAX_VERTEX_ATTRIBS> mCurrentVertexStrides;
+    std::array<UINT, gl::MAX_VERTEX_ATTRIBS> mCurrentVertexOffsets;
+    gl::RangeUI mDirtyVertexBufferRange;
+
+    // Currently applied primitive topology
+    D3D11_PRIMITIVE_TOPOLOGY mCurrentPrimitiveTopology;
+
+    // Currently applied shaders
+    ResourceSerial mAppliedVertexShader;
+    ResourceSerial mAppliedGeometryShader;
+    ResourceSerial mAppliedPixelShader;
+    ResourceSerial mAppliedComputeShader;
 };
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StreamProducerNV12.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StreamProducerNV12.cpp
index fbbdf552a14..1981b5f7b26 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StreamProducerNV12.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StreamProducerNV12.cpp
@@ -34,7 +34,7 @@ egl::Error StreamProducerNV12::validateD3DNV12Texture(void *pointer) const
     textureD3D->GetDevice(&device);
     if (device != mRenderer->getDevice())
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Texture not created on ANGLE D3D device");
+        return egl::EglBadParameter() << "Texture not created on ANGLE D3D device";
     }
 
     // Get the description and validate it
@@ -42,17 +42,17 @@ egl::Error StreamProducerNV12::validateD3DNV12Texture(void *pointer) const
     textureD3D->GetDesc(&desc);
     if (desc.Format != DXGI_FORMAT_NV12)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Texture format not DXGI_FORMAT_NV12");
+        return egl::EglBadParameter() << "Texture format not DXGI_FORMAT_NV12";
     }
     if (desc.Width < 1 || desc.Height < 1)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Texture is of size 0");
+        return egl::EglBadParameter() << "Texture is of size 0";
     }
     if ((desc.Width % 2) != 0 || (desc.Height % 2) != 0)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Texture dimensions are not even");
+        return egl::EglBadParameter() << "Texture dimensions are not even";
     }
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 void StreamProducerNV12::postD3DNV12Texture(void *pointer, const egl::AttributeMap &attributes)
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
index 67554d37ca6..24420243ed0 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
@@ -11,9 +11,9 @@
 #include <EGL/eglext.h>
 
 #include "libANGLE/features.h"
-#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
 #include "libANGLE/renderer/d3d/d3d11/NativeWindow11.h"
 #include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
+#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
 #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
 #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
 #include "third_party/trace_event/trace_event.h"
@@ -70,22 +70,22 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
       mSwapChain(nullptr),
       mSwapChain1(nullptr),
       mKeyedMutex(nullptr),
-      mBackBufferTexture(nullptr),
+      mBackBufferTexture(),
       mBackBufferRTView(),
       mBackBufferSRView(),
       mNeedsOffscreenTexture(NeedsOffscreenTexture(renderer, nativeWindow, orientation)),
-      mOffscreenTexture(nullptr),
+      mOffscreenTexture(),
       mOffscreenRTView(),
       mOffscreenSRView(),
-      mDepthStencilTexture(nullptr),
+      mDepthStencilTexture(),
       mDepthStencilDSView(),
       mDepthStencilSRView(),
-      mQuadVB(nullptr),
-      mPassThroughSampler(nullptr),
-      mPassThroughIL(nullptr),
-      mPassThroughVS(nullptr),
-      mPassThroughPS(nullptr),
-      mPassThroughRS(nullptr),
+      mQuadVB(),
+      mPassThroughSampler(),
+      mPassThroughIL(),
+      mPassThroughVS(),
+      mPassThroughPS(),
+      mPassThroughRS(),
       mColorRenderTarget(this, renderer, false),
       mDepthStencilRenderTarget(this, renderer, true),
       mEGLSamples(samples)
@@ -111,21 +111,21 @@ void SwapChain11::release()
     SafeRelease(mSwapChain1);
     SafeRelease(mSwapChain);
     SafeRelease(mKeyedMutex);
-    SafeRelease(mBackBufferTexture);
+    mBackBufferTexture.reset();
     mBackBufferRTView.reset();
     mBackBufferSRView.reset();
-    SafeRelease(mOffscreenTexture);
+    mOffscreenTexture.reset();
     mOffscreenRTView.reset();
     mOffscreenSRView.reset();
-    SafeRelease(mDepthStencilTexture);
+    mDepthStencilTexture.reset();
     mDepthStencilDSView.reset();
     mDepthStencilSRView.reset();
-    SafeRelease(mQuadVB);
-    SafeRelease(mPassThroughSampler);
-    SafeRelease(mPassThroughIL);
-    SafeRelease(mPassThroughVS);
-    SafeRelease(mPassThroughPS);
-    SafeRelease(mPassThroughRS);
+    mQuadVB.reset();
+    mPassThroughSampler.reset();
+    mPassThroughIL.reset();
+    mPassThroughVS.reset();
+    mPassThroughPS.reset();
+    mPassThroughRS.reset();
 
     if (!mAppCreatedShareHandle)
     {
@@ -135,23 +135,25 @@ void SwapChain11::release()
 
 void SwapChain11::releaseOffscreenColorBuffer()
 {
-    SafeRelease(mOffscreenTexture);
+    mOffscreenTexture.reset();
     mOffscreenRTView.reset();
     mOffscreenSRView.reset();
 }
 
 void SwapChain11::releaseOffscreenDepthBuffer()
 {
-    SafeRelease(mDepthStencilTexture);
+    mDepthStencilTexture.reset();
     mDepthStencilDSView.reset();
     mDepthStencilSRView.reset();
 }
 
-EGLint SwapChain11::resetOffscreenBuffers(int backbufferWidth, int backbufferHeight)
+EGLint SwapChain11::resetOffscreenBuffers(const gl::Context *context,
+                                          int backbufferWidth,
+                                          int backbufferHeight)
 {
     if (mNeedsOffscreenTexture)
     {
-        EGLint result = resetOffscreenColorBuffer(backbufferWidth, backbufferHeight);
+        EGLint result = resetOffscreenColorBuffer(context, backbufferWidth, backbufferHeight);
         if (result != EGL_SUCCESS)
         {
             return result;
@@ -170,7 +172,9 @@ EGLint SwapChain11::resetOffscreenBuffers(int backbufferWidth, int backbufferHei
     return EGL_SUCCESS;
 }
 
-EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbufferHeight)
+EGLint SwapChain11::resetOffscreenColorBuffer(const gl::Context *context,
+                                              int backbufferWidth,
+                                              int backbufferHeight)
 {
     ASSERT(mNeedsOffscreenTexture);
 
@@ -184,11 +188,7 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
     ASSERT(backbufferHeight >= 1);
 
     // Preserve the render target content
-    ID3D11Texture2D *previousOffscreenTexture = mOffscreenTexture;
-    if (previousOffscreenTexture)
-    {
-        previousOffscreenTexture->AddRef();
-    }
+    TextureHelper11 previousOffscreenTexture(std::move(mOffscreenTexture));
     const int previousWidth = mWidth;
     const int previousHeight = mHeight;
 
@@ -209,19 +209,21 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
                                                         (void **)&tempResource11);
             ASSERT(SUCCEEDED(result));
 
-            mOffscreenTexture = d3d11::DynamicCastComObject<ID3D11Texture2D>(tempResource11);
+            mOffscreenTexture.set(d3d11::DynamicCastComObject<ID3D11Texture2D>(tempResource11),
+                                  backbufferFormatInfo);
             SafeRelease(tempResource11);
         }
         else if (mD3DTexture != nullptr)
         {
-            mOffscreenTexture = d3d11::DynamicCastComObject<ID3D11Texture2D>(mD3DTexture);
+            mOffscreenTexture.set(d3d11::DynamicCastComObject<ID3D11Texture2D>(mD3DTexture),
+                                  backbufferFormatInfo);
         }
         else
         {
             UNREACHABLE();
         }
-        ASSERT(mOffscreenTexture != nullptr);
-        mOffscreenTexture->GetDesc(&offscreenTextureDesc);
+        ASSERT(mOffscreenTexture.valid());
+        mOffscreenTexture.getDesc(&offscreenTextureDesc);
     }
     else
     {
@@ -240,31 +242,23 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
         offscreenTextureDesc.CPUAccessFlags = 0;
         offscreenTextureDesc.MiscFlags = useSharedResource ? ANGLE_RESOURCE_SHARE_TYPE : 0;
 
-        HRESULT result =
-            device->CreateTexture2D(&offscreenTextureDesc, nullptr, &mOffscreenTexture);
-
-        if (FAILED(result))
+        gl::Error err = mRenderer->allocateTexture(offscreenTextureDesc, backbufferFormatInfo,
+                                                   &mOffscreenTexture);
+        if (err.isError())
         {
-            ERR() << "Could not create offscreen texture, " << gl::FmtHR(result);
+            ERR() << "Could not create offscreen texture, " << err;
             release();
-
-            if (d3d11::isDeviceLostError(result))
-            {
-                return EGL_CONTEXT_LOST;
-            }
-            else
-            {
-                return EGL_BAD_ALLOC;
-            }
+            return EGL_BAD_ALLOC;
         }
 
-        d3d11::SetDebugName(mOffscreenTexture, "Offscreen back buffer texture");
+        mOffscreenTexture.setDebugName("Offscreen back buffer texture");
 
         // EGL_ANGLE_surface_d3d_texture_2d_share_handle requires that we store a share handle for the client
         if (useSharedResource)
         {
             IDXGIResource *offscreenTextureResource = nullptr;
-            result = mOffscreenTexture->QueryInterface(__uuidof(IDXGIResource), (void**)&offscreenTextureResource);
+            HRESULT result                          = mOffscreenTexture.get()->QueryInterface(
+                __uuidof(IDXGIResource), (void **)&offscreenTextureResource);
 
             // Fall back to no share handle on failure
             if (FAILED(result))
@@ -286,7 +280,7 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
     }
 
     // This may return null if the original texture was created without a keyed mutex.
-    mKeyedMutex = d3d11::DynamicCastComObject<IDXGIKeyedMutex>(mOffscreenTexture);
+    mKeyedMutex = d3d11::DynamicCastComObject<IDXGIKeyedMutex>(mOffscreenTexture.get());
 
     D3D11_RENDER_TARGET_VIEW_DESC offscreenRTVDesc;
     offscreenRTVDesc.Format             = backbufferFormatInfo.rtvFormat;
@@ -295,7 +289,7 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
     offscreenRTVDesc.Texture2D.MipSlice = 0;
 
     gl::Error err =
-        mRenderer->allocateResource(offscreenRTVDesc, mOffscreenTexture, &mOffscreenRTView);
+        mRenderer->allocateResource(offscreenRTVDesc, mOffscreenTexture.get(), &mOffscreenRTView);
     ASSERT(!err.isError());
     mOffscreenRTView.setDebugName("Offscreen back buffer render target");
 
@@ -308,12 +302,13 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
 
     if (offscreenTextureDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE)
     {
-        err = mRenderer->allocateResource(offscreenSRVDesc, mOffscreenTexture, &mOffscreenSRView);
+        err = mRenderer->allocateResource(offscreenSRVDesc, mOffscreenTexture.get(),
+                                          &mOffscreenSRView);
         ASSERT(!err.isError());
         mOffscreenSRView.setDebugName("Offscreen back buffer shader resource");
     }
 
-    if (previousOffscreenTexture != nullptr)
+    if (previousOffscreenTexture.valid())
     {
         D3D11_BOX sourceBox = {0};
         sourceBox.left      = 0;
@@ -325,14 +320,12 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
 
         ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
         const int yoffset = std::max(backbufferHeight - previousHeight, 0);
-        deviceContext->CopySubresourceRegion(mOffscreenTexture, 0, 0, yoffset, 0,
-                                             previousOffscreenTexture, 0, &sourceBox);
-
-        SafeRelease(previousOffscreenTexture);
+        deviceContext->CopySubresourceRegion(mOffscreenTexture.get(), 0, 0, yoffset, 0,
+                                             previousOffscreenTexture.get(), 0, &sourceBox);
 
         if (mSwapChain)
         {
-            swapRect(0, 0, backbufferWidth, backbufferHeight);
+            swapRect(context, 0, 0, backbufferWidth, backbufferHeight);
         }
     }
 
@@ -355,10 +348,22 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
         depthStencilTextureDesc.MipLevels = 1;
         depthStencilTextureDesc.ArraySize = 1;
         depthStencilTextureDesc.SampleDesc.Count   = getD3DSamples();
-        depthStencilTextureDesc.SampleDesc.Quality = 0;
         depthStencilTextureDesc.Usage = D3D11_USAGE_DEFAULT;
         depthStencilTextureDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
 
+        // If there is a multisampled offscreen color texture, the offscreen depth-stencil texture
+        // must also have the same quality value.
+        if (mOffscreenTexture.valid() && getD3DSamples() > 1)
+        {
+            D3D11_TEXTURE2D_DESC offscreenTextureDesc = {0};
+            mOffscreenTexture.getDesc(&offscreenTextureDesc);
+            depthStencilTextureDesc.SampleDesc.Quality = offscreenTextureDesc.SampleDesc.Quality;
+        }
+        else
+        {
+            depthStencilTextureDesc.SampleDesc.Quality = 0;
+        }
+
         if (depthBufferFormatInfo.srvFormat != DXGI_FORMAT_UNKNOWN)
         {
             depthStencilTextureDesc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
@@ -367,25 +372,15 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
         depthStencilTextureDesc.CPUAccessFlags = 0;
         depthStencilTextureDesc.MiscFlags = 0;
 
-        ID3D11Device *device = mRenderer->getDevice();
-        HRESULT result =
-            device->CreateTexture2D(&depthStencilTextureDesc, nullptr, &mDepthStencilTexture);
-        if (FAILED(result))
+        gl::Error err = mRenderer->allocateTexture(depthStencilTextureDesc, depthBufferFormatInfo,
+                                                   &mDepthStencilTexture);
+        if (err.isError())
         {
-            ERR() << "Could not create depthstencil surface for new swap chain, "
-                  << gl::FmtHR(result);
+            ERR() << "Could not create depthstencil surface for new swap chain, " << err;
             release();
-
-            if (d3d11::isDeviceLostError(result))
-            {
-                return EGL_CONTEXT_LOST;
-            }
-            else
-            {
-                return EGL_BAD_ALLOC;
-            }
+            return EGL_BAD_ALLOC;
         }
-        d3d11::SetDebugName(mDepthStencilTexture, "Offscreen depth stencil texture");
+        mDepthStencilTexture.setDebugName("Offscreen depth stencil texture");
 
         D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilDesc;
         depthStencilDesc.Format             = depthBufferFormatInfo.dsvFormat;
@@ -394,8 +389,8 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
         depthStencilDesc.Flags = 0;
         depthStencilDesc.Texture2D.MipSlice = 0;
 
-        gl::Error err = mRenderer->allocateResource(depthStencilDesc, mDepthStencilTexture,
-                                                    &mDepthStencilDSView);
+        err = mRenderer->allocateResource(depthStencilDesc, mDepthStencilTexture.get(),
+                                          &mDepthStencilDSView);
         ASSERT(!err.isError());
         mDepthStencilDSView.setDebugName("Offscreen depth stencil view");
 
@@ -409,7 +404,7 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
             depthStencilSRVDesc.Texture2D.MostDetailedMip = 0;
             depthStencilSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1);
 
-            err = mRenderer->allocateResource(depthStencilSRVDesc, mDepthStencilTexture,
+            err = mRenderer->allocateResource(depthStencilSRVDesc, mDepthStencilTexture.get(),
                                               &mDepthStencilSRView);
             ASSERT(!err.isError());
             mDepthStencilSRView.setDebugName("Offscreen depth stencil shader resource");
@@ -419,7 +414,9 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
     return EGL_SUCCESS;
 }
 
-EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
+EGLint SwapChain11::resize(const gl::Context *context,
+                           EGLint backbufferWidth,
+                           EGLint backbufferHeight)
 {
     TRACE_EVENT0("gpu.angle", "SwapChain11::resize");
     ID3D11Device *device = mRenderer->getDevice();
@@ -442,10 +439,10 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
     }
 
     // Can only call resize if we have already created our swap buffer and resources
-    ASSERT(mSwapChain && mBackBufferTexture && mBackBufferRTView.valid() &&
+    ASSERT(mSwapChain && mBackBufferTexture.valid() && mBackBufferRTView.valid() &&
            mBackBufferSRView.valid());
 
-    SafeRelease(mBackBufferTexture);
+    mBackBufferTexture.reset();
     mBackBufferRTView.reset();
     mBackBufferSRView.reset();
 
@@ -476,24 +473,30 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
         }
     }
 
-    result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackBufferTexture);
+    ID3D11Texture2D *backbufferTexture = nullptr;
+    result                             = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+                                   reinterpret_cast<void **>(&backbufferTexture));
     ASSERT(SUCCEEDED(result));
     if (SUCCEEDED(result))
     {
-        d3d11::SetDebugName(mBackBufferTexture, "Back buffer texture");
+        const auto &format =
+            d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps());
+        mBackBufferTexture.set(backbufferTexture, format);
+        mBackBufferTexture.setDebugName("Back buffer texture");
 
-        gl::Error err = mRenderer->allocateResourceNoDesc(mBackBufferTexture, &mBackBufferRTView);
+        gl::Error err =
+            mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferRTView);
         ASSERT(!err.isError());
         mBackBufferRTView.setDebugName("Back buffer render target");
 
-        err = mRenderer->allocateResourceNoDesc(mBackBufferTexture, &mBackBufferSRView);
+        err = mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferSRView);
         ASSERT(!err.isError());
         mBackBufferSRView.setDebugName("Back buffer shader resource");
     }
 
     mFirstSwap = true;
 
-    return resetOffscreenBuffers(backbufferWidth, backbufferHeight);
+    return resetOffscreenBuffers(context, backbufferWidth, backbufferHeight);
 }
 
 DXGI_FORMAT SwapChain11::getSwapChainNativeFormat() const
@@ -524,7 +527,10 @@ DXGI_FORMAT SwapChain11::getSwapChainNativeFormat() const
     }
 }
 
-EGLint SwapChain11::reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval)
+EGLint SwapChain11::reset(const gl::Context *context,
+                          EGLint backbufferWidth,
+                          EGLint backbufferHeight,
+                          EGLint swapInterval)
 {
     mSwapInterval = static_cast<unsigned int>(swapInterval);
     if (mSwapInterval > 4)
@@ -537,7 +543,7 @@ EGLint SwapChain11::reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLin
     // If the swap chain already exists, just resize
     if (mSwapChain != nullptr)
     {
-        return resize(backbufferWidth, backbufferHeight);
+        return resize(context, backbufferWidth, backbufferHeight);
     }
 
     TRACE_EVENT0("gpu.angle", "SwapChain11::reset");
@@ -552,7 +558,7 @@ EGLint SwapChain11::reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLin
     // old render target still exists for the purpose of preserving its contents.
     SafeRelease(mSwapChain1);
     SafeRelease(mSwapChain);
-    SafeRelease(mBackBufferTexture);
+    mBackBufferTexture.reset();
     mBackBufferRTView.reset();
 
     // EGL allows creating a surface with 0x0 dimension, however, DXGI does not like 0x0 swapchains
@@ -589,22 +595,28 @@ EGLint SwapChain11::reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLin
             mSwapChain1 = d3d11::DynamicCastComObject<IDXGISwapChain1>(mSwapChain);
         }
 
-        result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackBufferTexture);
+        ID3D11Texture2D *backbufferTex = nullptr;
+        result                         = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+                                       reinterpret_cast<LPVOID *>(&backbufferTex));
         ASSERT(SUCCEEDED(result));
-        d3d11::SetDebugName(mBackBufferTexture, "Back buffer texture");
+        const auto &format =
+            d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps());
+        mBackBufferTexture.set(backbufferTex, format);
+        mBackBufferTexture.setDebugName("Back buffer texture");
 
-        gl::Error err = mRenderer->allocateResourceNoDesc(mBackBufferTexture, &mBackBufferRTView);
+        gl::Error err =
+            mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferRTView);
         ASSERT(!err.isError());
         mBackBufferRTView.setDebugName("Back buffer render target");
 
-        err = mRenderer->allocateResourceNoDesc(mBackBufferTexture, &mBackBufferSRView);
+        err = mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferSRView);
         ASSERT(!err.isError());
         mBackBufferSRView.setDebugName("Back buffer shader resource view");
     }
 
     mFirstSwap = true;
 
-    return resetOffscreenBuffers(backbufferWidth, backbufferHeight);
+    return resetOffscreenBuffers(context, backbufferWidth, backbufferHeight);
 }
 
 void SwapChain11::initPassThroughResources()
@@ -620,8 +632,8 @@ void SwapChain11::initPassThroughResources()
     ASSERT(device != nullptr);
 
     // Make sure our resources are all not allocated, when we create
-    ASSERT(mQuadVB == nullptr && mPassThroughSampler == nullptr);
-    ASSERT(mPassThroughIL == nullptr && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
+    ASSERT(!mQuadVB.valid() && !mPassThroughSampler.valid());
+    ASSERT(!mPassThroughIL.valid() && !mPassThroughVS.valid() && !mPassThroughPS.valid());
 
     D3D11_BUFFER_DESC vbDesc;
     vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
@@ -631,9 +643,9 @@ void SwapChain11::initPassThroughResources()
     vbDesc.MiscFlags = 0;
     vbDesc.StructureByteStride = 0;
 
-    HRESULT result = device->CreateBuffer(&vbDesc, nullptr, &mQuadVB);
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mQuadVB, "Swap chain quad vertex buffer");
+    gl::Error err = mRenderer->allocateResource(vbDesc, &mQuadVB);
+    ASSERT(!err.isError());
+    mQuadVB.setDebugName("Swap chain quad vertex buffer");
 
     D3D11_SAMPLER_DESC samplerDesc;
     samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
@@ -650,9 +662,9 @@ void SwapChain11::initPassThroughResources()
     samplerDesc.MinLOD = 0;
     samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
-    result = device->CreateSamplerState(&samplerDesc, &mPassThroughSampler);
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mPassThroughSampler, "Swap chain pass through sampler");
+    err = mRenderer->allocateResource(samplerDesc, &mPassThroughSampler);
+    ASSERT(!err.isError());
+    mPassThroughSampler.setDebugName("Swap chain pass through sampler");
 
     D3D11_INPUT_ELEMENT_DESC quadLayout[] =
     {
@@ -660,28 +672,30 @@ void SwapChain11::initPassThroughResources()
         { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
     };
 
-    result = device->CreateInputLayout(quadLayout, 2, g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), &mPassThroughIL);
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mPassThroughIL, "Swap chain pass through layout");
+    InputElementArray quadElements(quadLayout);
+    ShaderData vertexShaderData(g_VS_Passthrough2D);
 
-    result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), nullptr,
-                                        &mPassThroughVS);
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mPassThroughVS, "Swap chain pass through vertex shader");
+    err = mRenderer->allocateResource(quadElements, &vertexShaderData, &mPassThroughIL);
+    ASSERT(!err.isError());
+    mPassThroughIL.setDebugName("Swap chain pass through layout");
+
+    err = mRenderer->allocateResource(vertexShaderData, &mPassThroughVS);
+    ASSERT(!err.isError());
+    mPassThroughVS.setDebugName("Swap chain pass through vertex shader");
 
     if (mEGLSamples <= 1)
     {
-        result = device->CreatePixelShader(g_PS_PassthroughRGBA2D, sizeof(g_PS_PassthroughRGBA2D),
-                                           nullptr, &mPassThroughPS);
+        ShaderData pixelShaderData(g_PS_PassthroughRGBA2D);
+        err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
     }
     else
     {
-        result = device->CreatePixelShader(
-            g_PS_PassthroughRGBA2DMS, sizeof(g_PS_PassthroughRGBA2DMS), nullptr, &mPassThroughPS);
+        ShaderData pixelShaderData(g_PS_PassthroughRGBA2DMS);
+        err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
     }
 
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mPassThroughPS, "Swap chain pass through pixel shader");
+    ASSERT(!err.isError());
+    mPassThroughPS.setDebugName("Swap chain pass through pixel shader");
 
     // Use the default rasterizer state but without culling
     D3D11_RASTERIZER_DESC rasterizerDesc;
@@ -695,26 +709,31 @@ void SwapChain11::initPassThroughResources()
     rasterizerDesc.ScissorEnable         = FALSE;
     rasterizerDesc.MultisampleEnable     = FALSE;
     rasterizerDesc.AntialiasedLineEnable = FALSE;
-    result = device->CreateRasterizerState(&rasterizerDesc, &mPassThroughRS);
-    ASSERT(SUCCEEDED(result));
-    d3d11::SetDebugName(mPassThroughRS, "Swap chain pass through rasterizer state");
+
+    err = mRenderer->allocateResource(rasterizerDesc, &mPassThroughRS);
+    ASSERT(!err.isError());
+    mPassThroughRS.setDebugName("Swap chain pass through rasterizer state");
 
     mPassThroughResourcesInit = true;
 }
 
 // parameters should be validated/clamped by caller
-EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+EGLint SwapChain11::swapRect(const gl::Context *context,
+                             EGLint x,
+                             EGLint y,
+                             EGLint width,
+                             EGLint height)
 {
     if (mNeedsOffscreenTexture)
     {
-        EGLint result = copyOffscreenToBackbuffer(x, y, width, height);
+        EGLint result = copyOffscreenToBackbuffer(context, x, y, width, height);
         if (result != EGL_SUCCESS)
         {
             return result;
         }
     }
 
-    EGLint result = present(x, y, width, height);
+    EGLint result = present(context, x, y, width, height);
     if (result != EGL_SUCCESS)
     {
         return result;
@@ -725,7 +744,11 @@ EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
     return EGL_SUCCESS;
 }
 
-EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width, EGLint height)
+EGLint SwapChain11::copyOffscreenToBackbuffer(const gl::Context *context,
+                                              EGLint x,
+                                              EGLint y,
+                                              EGLint width,
+                                              EGLint height)
 {
     if (!mSwapChain)
     {
@@ -738,7 +761,8 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
 
     // Set vertices
     D3D11_MAPPED_SUBRESOURCE mappedResource;
-    HRESULT result = deviceContext->Map(mQuadVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    HRESULT result =
+        deviceContext->Map(mQuadVB.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
         return EGL_BAD_ACCESS;
@@ -772,11 +796,12 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
     d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v1);
     d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v2);
 
-    deviceContext->Unmap(mQuadVB, 0);
+    deviceContext->Unmap(mQuadVB.get(), 0);
+
+    auto stateManager = mRenderer->getStateManager();
 
-    static UINT stride = sizeof(d3d11::PositionTexCoordVertex);
-    static UINT startIdx = 0;
-    deviceContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &startIdx);
+    constexpr UINT stride = sizeof(d3d11::PositionTexCoordVertex);
+    stateManager->setSingleVertexBuffer(&mQuadVB, stride, 0);
 
     // Apply state
     deviceContext->OMSetDepthStencilState(nullptr, 0xFFFFFFFF);
@@ -784,19 +809,15 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
     static const float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
     deviceContext->OMSetBlendState(nullptr, blendFactor, 0xFFFFFFF);
 
-    deviceContext->RSSetState(mPassThroughRS);
+    deviceContext->RSSetState(mPassThroughRS.get());
 
     // Apply shaders
-    deviceContext->IASetInputLayout(mPassThroughIL);
-    deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
-    deviceContext->VSSetShader(mPassThroughVS, nullptr, 0);
-    deviceContext->PSSetShader(mPassThroughPS, nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
+    stateManager->setInputLayout(&mPassThroughIL);
+    stateManager->setPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+    stateManager->setDrawShaders(&mPassThroughVS, nullptr, &mPassThroughPS);
 
-    auto stateManager = mRenderer->getStateManager();
-
-    // Apply render targets
-    stateManager->setOneTimeRenderTarget(mBackBufferRTView.get(), nullptr);
+    // Apply render targets. Use the proxy context in display.
+    stateManager->setOneTimeRenderTarget(context, mBackBufferRTView.get(), nullptr);
 
     // Set the viewport
     D3D11_VIEWPORT viewport;
@@ -810,7 +831,9 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
 
     // Apply textures
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, mOffscreenSRView.get());
-    deviceContext->PSSetSamplers(0, 1, &mPassThroughSampler);
+
+    ID3D11SamplerState *samplerState = mPassThroughSampler.get();
+    deviceContext->PSSetSamplers(0, 1, &samplerState);
 
     // Draw
     deviceContext->Draw(4, 0);
@@ -820,12 +843,16 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
     // cleanup is caught under the current eglSwapBuffers() PIX/Graphics Diagnostics call rather than the next one.
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
 
-    mRenderer->markAllStateDirty();
+    mRenderer->markAllStateDirty(context);
 
     return EGL_SUCCESS;
 }
 
-EGLint SwapChain11::present(EGLint x, EGLint y, EGLint width, EGLint height)
+EGLint SwapChain11::present(const gl::Context *context,
+                            EGLint x,
+                            EGLint y,
+                            EGLint width,
+                            EGLint height)
 {
     if (!mSwapChain)
     {
@@ -865,8 +892,8 @@ EGLint SwapChain11::present(EGLint x, EGLint y, EGLint width, EGLint height)
     mFirstSwap = false;
 
     // Some swapping mechanisms such as DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL unbind the current render
-    // target.  Mark it dirty.
-    mRenderer->getStateManager()->invalidateRenderTarget();
+    // target. Mark it dirty. Use the proxy context in display since there is none available.
+    mRenderer->getStateManager()->invalidateRenderTarget(context);
 
     if (result == DXGI_ERROR_DEVICE_REMOVED)
     {
@@ -889,7 +916,7 @@ EGLint SwapChain11::present(EGLint x, EGLint y, EGLint width, EGLint height)
     return EGL_SUCCESS;
 }
 
-ID3D11Texture2D *SwapChain11::getOffscreenTexture()
+const TextureHelper11 &SwapChain11::getOffscreenTexture()
 {
     return mNeedsOffscreenTexture ? mOffscreenTexture : mBackBufferTexture;
 }
@@ -914,7 +941,7 @@ const d3d11::SharedSRV &SwapChain11::getDepthStencilShaderResource()
     return mDepthStencilSRView;
 }
 
-ID3D11Texture2D *SwapChain11::getDepthStencilTexture()
+const TextureHelper11 &SwapChain11::getDepthStencilTexture()
 {
     return mDepthStencilTexture;
 }
@@ -928,7 +955,7 @@ egl::Error SwapChain11::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLu
 {
     if (!mSwapChain)
     {
-        return egl::Error(EGL_NOT_INITIALIZED, "Swap chain uninitialized");
+        return egl::EglNotInitialized() << "Swap chain uninitialized";
     }
 
     DXGI_FRAME_STATISTICS stats = {};
@@ -936,7 +963,7 @@ egl::Error SwapChain11::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLu
 
     if (FAILED(result))
     {
-        return egl::Error(EGL_BAD_ALLOC, "Failed to get frame statistics, result: 0x%X", result);
+        return egl::EglBadAlloc() << "Failed to get frame statistics, " << gl::FmtHR(result);
     }
 
     // Conversion from DXGI_FRAME_STATISTICS to the output values:
@@ -963,7 +990,7 @@ egl::Error SwapChain11::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLu
                leftoverTicks * kMicrosecondsPerSecond / mQPCFrequency;
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 UINT SwapChain11::getD3DSamples() const
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h
index 8edc56a2be7..d64d821f060 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h
@@ -31,19 +31,28 @@ class SwapChain11 final : public SwapChainD3D
                 EGLint samples);
     virtual ~SwapChain11();
 
-    EGLint resize(EGLint backbufferWidth, EGLint backbufferHeight);
-    EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval) override;
-    EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height) override;
+    EGLint resize(const gl::Context *context,
+                  EGLint backbufferWidth,
+                  EGLint backbufferHeight) override;
+    EGLint reset(const gl::Context *context,
+                 EGLint backbufferWidth,
+                 EGLint backbufferHeight,
+                 EGLint swapInterval) override;
+    EGLint swapRect(const gl::Context *context,
+                    EGLint x,
+                    EGLint y,
+                    EGLint width,
+                    EGLint height) override;
     void recreate() override;
 
     RenderTargetD3D *getColorRenderTarget() override { return &mColorRenderTarget; }
     RenderTargetD3D *getDepthStencilRenderTarget() override { return &mDepthStencilRenderTarget; }
 
-    ID3D11Texture2D *getOffscreenTexture();
+    const TextureHelper11 &getOffscreenTexture();
     const d3d11::RenderTargetView &getRenderTarget();
     const d3d11::SharedSRV &getRenderTargetShaderResource();
 
-    ID3D11Texture2D *getDepthStencilTexture();
+    const TextureHelper11 &getDepthStencilTexture();
     const d3d11::DepthStencilView &getDepthStencil();
     const d3d11::SharedSRV &getDepthStencilShaderResource();
 
@@ -60,14 +69,22 @@ class SwapChain11 final : public SwapChainD3D
 
     void releaseOffscreenColorBuffer();
     void releaseOffscreenDepthBuffer();
-    EGLint resetOffscreenBuffers(int backbufferWidth, int backbufferHeight);
-    EGLint resetOffscreenColorBuffer(int backbufferWidth, int backbufferHeight);
+    EGLint resetOffscreenBuffers(const gl::Context *context,
+                                 int backbufferWidth,
+                                 int backbufferHeight);
+    EGLint resetOffscreenColorBuffer(const gl::Context *context,
+                                     int backbufferWidth,
+                                     int backbufferHeight);
     EGLint resetOffscreenDepthBuffer(int backbufferWidth, int backbufferHeight);
 
     DXGI_FORMAT getSwapChainNativeFormat() const;
 
-    EGLint copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width, EGLint height);
-    EGLint present(EGLint x, EGLint y, EGLint width, EGLint height);
+    EGLint copyOffscreenToBackbuffer(const gl::Context *context,
+                                     EGLint x,
+                                     EGLint y,
+                                     EGLint width,
+                                     EGLint height);
+    EGLint present(const gl::Context *context, EGLint x, EGLint y, EGLint width, EGLint height);
     UINT getD3DSamples() const;
 
     Renderer11 *mRenderer;
@@ -85,25 +102,25 @@ class SwapChain11 final : public SwapChainD3D
     IDXGISwapChain1 *mSwapChain1;
     IDXGIKeyedMutex *mKeyedMutex;
 
-    ID3D11Texture2D *mBackBufferTexture;
+    TextureHelper11 mBackBufferTexture;
     d3d11::RenderTargetView mBackBufferRTView;
     d3d11::SharedSRV mBackBufferSRView;
 
     const bool mNeedsOffscreenTexture;
-    ID3D11Texture2D *mOffscreenTexture;
+    TextureHelper11 mOffscreenTexture;
     d3d11::RenderTargetView mOffscreenRTView;
     d3d11::SharedSRV mOffscreenSRView;
 
-    ID3D11Texture2D *mDepthStencilTexture;
+    TextureHelper11 mDepthStencilTexture;
     d3d11::DepthStencilView mDepthStencilDSView;
     d3d11::SharedSRV mDepthStencilSRView;
 
-    ID3D11Buffer *mQuadVB;
-    ID3D11SamplerState *mPassThroughSampler;
-    ID3D11InputLayout *mPassThroughIL;
-    ID3D11VertexShader *mPassThroughVS;
-    ID3D11PixelShader *mPassThroughPS;
-    ID3D11RasterizerState *mPassThroughRS;
+    d3d11::Buffer mQuadVB;
+    d3d11::SamplerState mPassThroughSampler;
+    d3d11::InputLayout mPassThroughIL;
+    d3d11::VertexShader mPassThroughVS;
+    d3d11::PixelShader mPassThroughPS;
+    d3d11::RasterizerState mPassThroughRS;
 
     SurfaceRenderTarget11 mColorRenderTarget;
     SurfaceRenderTarget11 mDepthStencilRenderTarget;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
index d4b6e351675..4e6ddfffa0c 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
@@ -53,7 +53,7 @@ TextureStorage11::TextureStorage11(Renderer11 *renderer,
       mTextureWidth(0),
       mTextureHeight(0),
       mTextureDepth(0),
-      mDropStencilTexture(nullptr),
+      mDropStencilTexture(),
       mBindFlags(bindFlags),
       mMiscFlags(miscFlags)
 {
@@ -62,7 +62,6 @@ TextureStorage11::TextureStorage11(Renderer11 *renderer,
 TextureStorage11::~TextureStorage11()
 {
     mSrvCache.clear();
-    SafeRelease(mDropStencilTexture);
 }
 
 DWORD TextureStorage11::GetTextureBindFlags(GLenum internalFormat,
@@ -168,7 +167,9 @@ UINT TextureStorage11::getSubresourceIndex(const gl::ImageIndex &index) const
     return subresource;
 }
 
-gl::Error TextureStorage11::getSRV(const gl::TextureState &textureState, d3d11::SharedSRV *outSRV)
+gl::Error TextureStorage11::getSRV(const gl::Context *context,
+                                   const gl::TextureState &textureState,
+                                   const d3d11::SharedSRV **outSRV)
 {
     // Make sure to add the level offset for our tiny compressed texture workaround
     const GLuint effectiveBaseLevel = textureState.getEffectiveBaseLevel();
@@ -214,7 +215,7 @@ gl::Error TextureStorage11::getSRV(const gl::TextureState &textureState, d3d11::
     {
         // Ensure drop texture gets created.
         DropStencil result = DropStencil::CREATED;
-        ANGLE_TRY_RESULT(ensureDropStencilTexture(), result);
+        ANGLE_TRY_RESULT(ensureDropStencilTexture(context), result);
 
         // Clear the SRV cache if necessary.
         // TODO(jmadill): Re-use find query result.
@@ -225,21 +226,23 @@ gl::Error TextureStorage11::getSRV(const gl::TextureState &textureState, d3d11::
         }
     }
 
-    ANGLE_TRY(getCachedOrCreateSRV(key, outSRV));
+    ANGLE_TRY(getCachedOrCreateSRV(context, key, outSRV));
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11::getCachedOrCreateSRV(const SRVKey &key, d3d11::SharedSRV *outSRV)
+gl::Error TextureStorage11::getCachedOrCreateSRV(const gl::Context *context,
+                                                 const SRVKey &key,
+                                                 const d3d11::SharedSRV **outSRV)
 {
     auto iter = mSrvCache.find(key);
     if (iter != mSrvCache.end())
     {
-        *outSRV = iter->second;
+        *outSRV = &iter->second;
         return gl::NoError();
     }
 
-    ID3D11Resource *texture = nullptr;
+    const TextureHelper11 *texture = nullptr;
     DXGI_FORMAT format      = DXGI_FORMAT_UNKNOWN;
 
     if (key.swizzle)
@@ -252,27 +255,30 @@ gl::Error TextureStorage11::getCachedOrCreateSRV(const SRVKey &key, d3d11::Share
     }
     else if (key.dropStencil)
     {
-        ASSERT(mDropStencilTexture);
-        texture = mDropStencilTexture;
+        ASSERT(mDropStencilTexture.valid());
+        texture = &mDropStencilTexture;
         format  = DXGI_FORMAT_R32_FLOAT;
     }
     else
     {
-        ANGLE_TRY(getResource(&texture));
+        ANGLE_TRY(getResource(context, &texture));
         format = mFormatInfo.srvFormat;
     }
 
     d3d11::SharedSRV srv;
 
-    ANGLE_TRY(createSRV(key.baseLevel, key.mipLevels, format, texture, &srv));
+    ANGLE_TRY(createSRV(context, key.baseLevel, key.mipLevels, format, *texture, &srv));
 
-    mSrvCache.insert(std::make_pair(key, srv));
-    *outSRV = srv;
+    const auto &insertIt = mSrvCache.insert(std::make_pair(key, std::move(srv)));
+    *outSRV              = &insertIt.first->second;
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11::getSRVLevel(int mipLevel, bool blitSRV, const d3d11::SharedSRV **outSRV)
+gl::Error TextureStorage11::getSRVLevel(const gl::Context *context,
+                                        int mipLevel,
+                                        bool blitSRV,
+                                        const d3d11::SharedSRV **outSRV)
 {
     ASSERT(mipLevel >= 0 && mipLevel < getLevelCount());
 
@@ -284,16 +290,17 @@ gl::Error TextureStorage11::getSRVLevel(int mipLevel, bool blitSRV, const d3d11:
         // Only create a different SRV for blit if blit format is different from regular srv format
         if (otherLevelSRVs[mipLevel].valid() && mFormatInfo.srvFormat == mFormatInfo.blitSRVFormat)
         {
-            levelSRVs[mipLevel] = otherLevelSRVs[mipLevel];
+            levelSRVs[mipLevel] = otherLevelSRVs[mipLevel].makeCopy();
         }
         else
         {
-            ID3D11Resource *resource = nullptr;
-            ANGLE_TRY(getResource(&resource));
+            const TextureHelper11 *resource = nullptr;
+            ANGLE_TRY(getResource(context, &resource));
 
             DXGI_FORMAT resourceFormat =
                 blitSRV ? mFormatInfo.blitSRVFormat : mFormatInfo.srvFormat;
-            ANGLE_TRY(createSRV(mipLevel, 1, resourceFormat, resource, &levelSRVs[mipLevel]));
+            ANGLE_TRY(
+                createSRV(context, mipLevel, 1, resourceFormat, *resource, &levelSRVs[mipLevel]));
         }
     }
 
@@ -302,7 +309,10 @@ gl::Error TextureStorage11::getSRVLevel(int mipLevel, bool blitSRV, const d3d11:
     return gl::NoError();
 }
 
-gl::Error TextureStorage11::getSRVLevels(GLint baseLevel, GLint maxLevel, d3d11::SharedSRV *outSRV)
+gl::Error TextureStorage11::getSRVLevels(const gl::Context *context,
+                                         GLint baseLevel,
+                                         GLint maxLevel,
+                                         const d3d11::SharedSRV **outSRV)
 {
     unsigned int mipLevels = maxLevel - baseLevel + 1;
 
@@ -324,7 +334,7 @@ gl::Error TextureStorage11::getSRVLevels(GLint baseLevel, GLint maxLevel, d3d11:
     // TODO(jmadill): Assert we don't need to drop stencil.
 
     SRVKey key(baseLevel, mipLevels, false, false);
-    ANGLE_TRY(getCachedOrCreateSRV(key, outSRV));
+    ANGLE_TRY(getCachedOrCreateSRV(context, key, outSRV));
 
     return gl::NoError();
 }
@@ -334,7 +344,8 @@ const d3d11::Format &TextureStorage11::getFormatSet() const
     return mFormatInfo;
 }
 
-gl::Error TextureStorage11::generateSwizzles(const gl::SwizzleState &swizzleTarget)
+gl::Error TextureStorage11::generateSwizzles(const gl::Context *context,
+                                             const gl::SwizzleState &swizzleTarget)
 {
     for (int level = 0; level < getLevelCount(); level++)
     {
@@ -343,7 +354,7 @@ gl::Error TextureStorage11::generateSwizzles(const gl::SwizzleState &swizzleTarg
         {
             // Need to re-render the swizzle for this level
             const d3d11::SharedSRV *sourceSRV = nullptr;
-            ANGLE_TRY(getSRVLevel(level, true, &sourceSRV));
+            ANGLE_TRY(getSRVLevel(context, level, true, &sourceSRV));
 
             const d3d11::RenderTargetView *destRTV;
             ANGLE_TRY(getSwizzleRenderTarget(level, &destRTV));
@@ -352,7 +363,7 @@ gl::Error TextureStorage11::generateSwizzles(const gl::SwizzleState &swizzleTarg
 
             Blit11 *blitter = mRenderer->getBlitter();
 
-            ANGLE_TRY(blitter->swizzleTexture(*sourceSRV, *destRTV, size, swizzleTarget));
+            ANGLE_TRY(blitter->swizzleTexture(context, *sourceSRV, *destRTV, size, swizzleTarget));
 
             mSwizzleCache[level] = swizzleTarget;
         }
@@ -370,7 +381,7 @@ void TextureStorage11::markLevelDirty(int mipLevel)
         mSwizzleCache[mipLevel] = gl::SwizzleState();
     }
 
-    SafeRelease(mDropStencilTexture);
+    mDropStencilTexture.reset();
 }
 
 void TextureStorage11::markDirty()
@@ -381,12 +392,13 @@ void TextureStorage11::markDirty()
     }
 }
 
-gl::Error TextureStorage11::updateSubresourceLevel(ID3D11Resource *srcTexture,
+gl::Error TextureStorage11::updateSubresourceLevel(const gl::Context *context,
+                                                   const TextureHelper11 &srcTexture,
                                                    unsigned int sourceSubresource,
                                                    const gl::ImageIndex &index,
                                                    const gl::Box &copyArea)
 {
-    ASSERT(srcTexture);
+    ASSERT(srcTexture.valid());
 
     const GLint level = index.mipIndex;
 
@@ -398,22 +410,22 @@ gl::Error TextureStorage11::updateSubresourceLevel(ID3D11Resource *srcTexture,
                     copyArea.width == texSize.width && copyArea.height == texSize.height &&
                     copyArea.depth == texSize.depth;
 
-    ID3D11Resource *dstTexture = nullptr;
+    const TextureHelper11 *dstTexture = nullptr;
 
     // If the zero-LOD workaround is active and we want to update a level greater than zero, then we
     // should update the mipmapped texture, even if mapmaps are currently disabled.
     if (index.mipIndex > 0 && mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
-        ANGLE_TRY(getMippedResource(&dstTexture));
+        ANGLE_TRY(getMippedResource(context, &dstTexture));
     }
     else
     {
-        ANGLE_TRY(getResource(&dstTexture));
+        ANGLE_TRY(getResource(context, &dstTexture));
     }
 
     unsigned int dstSubresource = getSubresourceIndex(index);
 
-    ASSERT(dstTexture);
+    ASSERT(dstTexture->valid());
 
     const d3d11::DXGIFormatSize &dxgiFormatSizeInfo =
         d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat);
@@ -421,10 +433,8 @@ gl::Error TextureStorage11::updateSubresourceLevel(ID3D11Resource *srcTexture,
     {
         // CopySubresourceRegion cannot copy partial depth stencils, use the blitter instead
         Blit11 *blitter        = mRenderer->getBlitter();
-        TextureHelper11 source = TextureHelper11::MakeAndReference(srcTexture, getFormatSet());
-        TextureHelper11 dest   = TextureHelper11::MakeAndReference(dstTexture, getFormatSet());
-        return blitter->copyDepthStencil(source, sourceSubresource, copyArea, texSize, dest,
-                                         dstSubresource, copyArea, texSize, nullptr);
+        return blitter->copyDepthStencil(srcTexture, sourceSubresource, copyArea, texSize,
+                                         *dstTexture, dstSubresource, copyArea, texSize, nullptr);
     }
 
     D3D11_BOX srcBox;
@@ -437,38 +447,40 @@ gl::Error TextureStorage11::updateSubresourceLevel(ID3D11Resource *srcTexture,
     srcBox.front = copyArea.z;
     srcBox.back  = copyArea.z + copyArea.depth;
 
-    ID3D11DeviceContext *context = mRenderer->getDeviceContext();
+    ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
-    context->CopySubresourceRegion(dstTexture, dstSubresource, copyArea.x, copyArea.y, copyArea.z,
-                                   srcTexture, sourceSubresource, fullCopy ? nullptr : &srcBox);
+    deviceContext->CopySubresourceRegion(dstTexture->get(), dstSubresource, copyArea.x, copyArea.y,
+                                         copyArea.z, srcTexture.get(), sourceSubresource,
+                                         fullCopy ? nullptr : &srcBox);
     return gl::NoError();
 }
 
-gl::Error TextureStorage11::copySubresourceLevel(ID3D11Resource *dstTexture,
+gl::Error TextureStorage11::copySubresourceLevel(const gl::Context *context,
+                                                 const TextureHelper11 &dstTexture,
                                                  unsigned int dstSubresource,
                                                  const gl::ImageIndex &index,
                                                  const gl::Box &region)
 {
-    ASSERT(dstTexture);
+    ASSERT(dstTexture.valid());
 
-    ID3D11Resource *srcTexture = nullptr;
+    const TextureHelper11 *srcTexture = nullptr;
 
     // If the zero-LOD workaround is active and we want to update a level greater than zero, then we
     // should update the mipmapped texture, even if mapmaps are currently disabled.
     if (index.mipIndex > 0 && mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
-        ANGLE_TRY(getMippedResource(&srcTexture));
+        ANGLE_TRY(getMippedResource(context, &srcTexture));
     }
     else
     {
-        ANGLE_TRY(getResource(&srcTexture));
+        ANGLE_TRY(getResource(context, &srcTexture));
     }
 
-    ASSERT(srcTexture);
+    ASSERT(srcTexture->valid());
 
     unsigned int srcSubresource = getSubresourceIndex(index);
 
-    ID3D11DeviceContext *context = mRenderer->getDeviceContext();
+    ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
     // D3D11 can't perform partial CopySubresourceRegion on depth/stencil textures, so pSrcBox
     // should be nullptr.
@@ -476,26 +488,35 @@ gl::Error TextureStorage11::copySubresourceLevel(ID3D11Resource *dstTexture,
     D3D11_BOX *pSrcBox = nullptr;
     if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
-        // However, D3D10Level9 doesn't always perform CopySubresourceRegion correctly unless the
-        // source box is specified. This is okay, since we don't perform CopySubresourceRegion on
-        // depth/stencil textures on 9_3.
-        ASSERT(mFormatInfo.dsvFormat == DXGI_FORMAT_UNKNOWN);
-        srcBox.left   = region.x;
-        srcBox.right  = region.x + region.width;
-        srcBox.top    = region.y;
-        srcBox.bottom = region.y + region.height;
-        srcBox.front  = region.z;
-        srcBox.back   = region.z + region.depth;
-        pSrcBox       = &srcBox;
+        GLsizei width  = region.width;
+        GLsizei height = region.height;
+        d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, nullptr);
+
+        // Keep srcbox as nullptr if we're dealing with tiny mips of compressed textures.
+        if (width == region.width && height == region.height)
+        {
+            // However, D3D10Level9 doesn't always perform CopySubresourceRegion correctly unless
+            // the source box is specified. This is okay, since we don't perform
+            // CopySubresourceRegion on depth/stencil textures on 9_3.
+            ASSERT(mFormatInfo.dsvFormat == DXGI_FORMAT_UNKNOWN);
+            srcBox.left   = region.x;
+            srcBox.right  = region.x + region.width;
+            srcBox.top    = region.y;
+            srcBox.bottom = region.y + region.height;
+            srcBox.front  = region.z;
+            srcBox.back   = region.z + region.depth;
+            pSrcBox       = &srcBox;
+        }
     }
 
-    context->CopySubresourceRegion(dstTexture, dstSubresource, region.x, region.y, region.z,
-                                   srcTexture, srcSubresource, pSrcBox);
+    deviceContext->CopySubresourceRegion(dstTexture.get(), dstSubresource, region.x, region.y,
+                                         region.z, srcTexture->get(), srcSubresource, pSrcBox);
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11::generateMipmap(const gl::ImageIndex &sourceIndex,
+gl::Error TextureStorage11::generateMipmap(const gl::Context *context,
+                                           const gl::ImageIndex &sourceIndex,
                                            const gl::ImageIndex &destIndex)
 {
     ASSERT(sourceIndex.layerIndex == destIndex.layerIndex);
@@ -503,10 +524,10 @@ gl::Error TextureStorage11::generateMipmap(const gl::ImageIndex &sourceIndex,
     markLevelDirty(destIndex.mipIndex);
 
     RenderTargetD3D *source = nullptr;
-    ANGLE_TRY(getRenderTarget(sourceIndex, &source));
+    ANGLE_TRY(getRenderTarget(context, sourceIndex, &source));
 
     RenderTargetD3D *dest = nullptr;
-    ANGLE_TRY(getRenderTarget(destIndex, &dest));
+    ANGLE_TRY(getRenderTarget(context, destIndex, &dest));
 
     auto rt11                              = GetAs<RenderTarget11>(source);
     const d3d11::SharedSRV &sourceSRV      = rt11->getBlitShaderResourceView();
@@ -520,8 +541,9 @@ gl::Error TextureStorage11::generateMipmap(const gl::ImageIndex &sourceIndex,
 
     Blit11 *blitter = mRenderer->getBlitter();
     GLenum format   = gl::GetUnsizedFormat(source->getInternalFormat());
-    return blitter->copyTexture(sourceSRV, sourceArea, sourceSize, format, destRTV, destArea,
-                                destSize, nullptr, format, GL_LINEAR, false, false, false);
+    return blitter->copyTexture(context, sourceSRV, sourceArea, sourceSize, format, destRTV,
+                                destArea, destSize, nullptr, format, GL_LINEAR, false, false,
+                                false);
 }
 
 void TextureStorage11::verifySwizzleExists(const gl::SwizzleState &swizzleState)
@@ -544,26 +566,27 @@ void TextureStorage11::clearSRVCache()
     }
 }
 
-gl::Error TextureStorage11::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage11::copyToStorage(const gl::Context *context, TextureStorage *destStorage)
 {
     ASSERT(destStorage);
 
-    ID3D11Resource *sourceResouce = nullptr;
-    ANGLE_TRY(getResource(&sourceResouce));
+    const TextureHelper11 *sourceResouce = nullptr;
+    ANGLE_TRY(getResource(context, &sourceResouce));
 
     TextureStorage11 *dest11     = GetAs<TextureStorage11>(destStorage);
-    ID3D11Resource *destResource = nullptr;
-    ANGLE_TRY(dest11->getResource(&destResource));
+    const TextureHelper11 *destResource = nullptr;
+    ANGLE_TRY(dest11->getResource(context, &destResource));
 
     ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext();
-    immediateContext->CopyResource(destResource, sourceResouce);
+    immediateContext->CopyResource(destResource->get(), sourceResouce->get());
 
     dest11->markDirty();
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11::setData(const gl::ImageIndex &index,
+gl::Error TextureStorage11::setData(const gl::Context *context,
+                                    const gl::ImageIndex &index,
                                     ImageD3D *image,
                                     const gl::Box *destBox,
                                     GLenum type,
@@ -574,9 +597,9 @@ gl::Error TextureStorage11::setData(const gl::ImageIndex &index,
 
     markLevelDirty(index.mipIndex);
 
-    ID3D11Resource *resource = nullptr;
-    ANGLE_TRY(getResource(&resource));
-    ASSERT(resource);
+    const TextureHelper11 *resource = nullptr;
+    ANGLE_TRY(getResource(context, &resource));
+    ASSERT(resource && resource->valid());
 
     UINT destSubresource = getSubresourceIndex(index);
 
@@ -653,19 +676,20 @@ gl::Error TextureStorage11::setData(const gl::ImageIndex &index,
         destD3DBox.front  = destBox->z;
         destD3DBox.back   = destBox->z + destBox->depth;
 
-        immediateContext->UpdateSubresource(resource, destSubresource, &destD3DBox, data,
+        immediateContext->UpdateSubresource(resource->get(), destSubresource, &destD3DBox, data,
                                             bufferRowPitch, bufferDepthPitch);
     }
     else
     {
-        immediateContext->UpdateSubresource(resource, destSubresource, nullptr, data,
+        immediateContext->UpdateSubresource(resource->get(), destSubresource, nullptr, data,
                                             bufferRowPitch, bufferDepthPitch);
     }
 
     return gl::NoError();
 }
 
-gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11::ensureDropStencilTexture()
+gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11::ensureDropStencilTexture(
+    const gl::Context *context)
 {
     UNIMPLEMENTED();
     return gl::InternalError() << "Drop stencil texture not implemented.";
@@ -677,13 +701,11 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swap
                        0,
                        swapchain->getRenderTargetInternalFormat()),
       mTexture(swapchain->getOffscreenTexture()),
-      mLevelZeroTexture(nullptr),
+      mLevelZeroTexture(),
       mLevelZeroRenderTarget(nullptr),
       mUseLevelZeroTexture(false),
-      mSwizzleTexture(nullptr)
+      mSwizzleTexture()
 {
-    mTexture->AddRef();
-
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
         mAssociatedImages[i]     = nullptr;
@@ -691,7 +713,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swap
     }
 
     D3D11_TEXTURE2D_DESC texDesc;
-    mTexture->GetDesc(&texDesc);
+    mTexture.getDesc(&texDesc);
     mMipLevels     = texDesc.MipLevels;
     mTextureWidth  = texDesc.Width;
     mTextureHeight = texDesc.Height;
@@ -714,12 +736,12 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer,
                               renderTarget,
                               levels),
           internalformat),
-      mTexture(nullptr),
+      mTexture(),
       mHasKeyedMutex(false),
-      mLevelZeroTexture(nullptr),
+      mLevelZeroTexture(),
       mLevelZeroRenderTarget(nullptr),
       mUseLevelZeroTexture(hintLevelZeroOnly && levels > 1),
-      mSwizzleTexture(nullptr)
+      mSwizzleTexture()
 {
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
@@ -737,7 +759,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer,
     ASSERT(!mUseLevelZeroTexture || mRenderer->getWorkarounds().zeroMaxLodWorkaround);
 }
 
-TextureStorage11_2D::~TextureStorage11_2D()
+gl::Error TextureStorage11_2D::onDestroy(const gl::Context *context)
 {
     for (unsigned i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
@@ -747,19 +769,10 @@ TextureStorage11_2D::~TextureStorage11_2D()
 
             // We must let the Images recover their data before we delete it from the
             // TextureStorage.
-            gl::Error error = mAssociatedImages[i]->recoverFromAssociatedStorage();
-            if (error.isError())
-            {
-                // TODO: Find a way to report this back to the context
-                ERR() << "Error initialization texture storage: " << error;
-            }
+            ANGLE_TRY(mAssociatedImages[i]->recoverFromAssociatedStorage(context));
         }
     }
 
-    SafeRelease(mTexture);
-    SafeRelease(mSwizzleTexture);
-
-    SafeRelease(mLevelZeroTexture);
     SafeDelete(mLevelZeroRenderTarget);
 
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
@@ -771,11 +784,20 @@ TextureStorage11_2D::~TextureStorage11_2D()
     {
         // If the keyed mutex is released that will unbind it and cause the state cache to become
         // desynchronized.
-        mRenderer->getStateManager()->invalidateBoundViews();
+        mRenderer->getStateManager()->invalidateBoundViews(context);
     }
+
+    delete this;
+
+    return gl::NoError();
+}
+
+TextureStorage11_2D::~TextureStorage11_2D()
+{
 }
 
-gl::Error TextureStorage11_2D::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage11_2D::copyToStorage(const gl::Context *context,
+                                             TextureStorage *destStorage)
 {
     ASSERT(destStorage);
 
@@ -786,36 +808,36 @@ gl::Error TextureStorage11_2D::copyToStorage(TextureStorage *destStorage)
     {
         // If either mTexture or mLevelZeroTexture exist, then we need to copy them into the
         // corresponding textures in destStorage.
-        if (mTexture)
+        if (mTexture.valid())
         {
             ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(false));
 
-            ID3D11Resource *destResource = nullptr;
-            ANGLE_TRY(dest11->getResource(&destResource));
+            const TextureHelper11 *destResource = nullptr;
+            ANGLE_TRY(dest11->getResource(context, &destResource));
 
-            immediateContext->CopyResource(destResource, mTexture);
+            immediateContext->CopyResource(destResource->get(), mTexture.get());
         }
 
-        if (mLevelZeroTexture)
+        if (mLevelZeroTexture.valid())
         {
             ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(true));
 
-            ID3D11Resource *destResource = nullptr;
-            ANGLE_TRY(dest11->getResource(&destResource));
+            const TextureHelper11 *destResource = nullptr;
+            ANGLE_TRY(dest11->getResource(context, &destResource));
 
-            immediateContext->CopyResource(destResource, mLevelZeroTexture);
+            immediateContext->CopyResource(destResource->get(), mLevelZeroTexture.get());
         }
 
         return gl::NoError();
     }
 
-    ID3D11Resource *sourceResouce = nullptr;
-    ANGLE_TRY(getResource(&sourceResouce));
+    const TextureHelper11 *sourceResouce = nullptr;
+    ANGLE_TRY(getResource(context, &sourceResouce));
 
-    ID3D11Resource *destResource = nullptr;
-    ANGLE_TRY(dest11->getResource(&destResource));
+    const TextureHelper11 *destResource = nullptr;
+    ANGLE_TRY(dest11->getResource(context, &destResource));
 
-    immediateContext->CopyResource(destResource, sourceResouce);
+    immediateContext->CopyResource(destResource->get(), sourceResouce->get());
     dest11->markDirty();
 
     return gl::NoError();
@@ -827,28 +849,30 @@ gl::Error TextureStorage11_2D::useLevelZeroWorkaroundTexture(bool useLevelZeroTe
 
     if (useLevelZeroTexture && mMipLevels > 1)
     {
-        if (!mUseLevelZeroTexture && mTexture)
+        if (!mUseLevelZeroTexture && mTexture.valid())
         {
             ANGLE_TRY(ensureTextureExists(1));
 
             // Pull data back from the mipped texture if necessary.
-            ASSERT(mLevelZeroTexture);
+            ASSERT(mLevelZeroTexture.valid());
             ID3D11DeviceContext *context = mRenderer->getDeviceContext();
-            context->CopySubresourceRegion(mLevelZeroTexture, 0, 0, 0, 0, mTexture, 0, nullptr);
+            context->CopySubresourceRegion(mLevelZeroTexture.get(), 0, 0, 0, 0, mTexture.get(), 0,
+                                           nullptr);
         }
 
         mUseLevelZeroTexture = true;
     }
     else
     {
-        if (mUseLevelZeroTexture && mLevelZeroTexture)
+        if (mUseLevelZeroTexture && mLevelZeroTexture.valid())
         {
             ANGLE_TRY(ensureTextureExists(mMipLevels));
 
             // Pull data back from the level zero texture if necessary.
-            ASSERT(mTexture);
+            ASSERT(mTexture.valid());
             ID3D11DeviceContext *context = mRenderer->getDeviceContext();
-            context->CopySubresourceRegion(mTexture, 0, 0, 0, 0, mLevelZeroTexture, 0, nullptr);
+            context->CopySubresourceRegion(mTexture.get(), 0, 0, 0, 0, mLevelZeroTexture.get(), 0,
+                                           nullptr);
         }
 
         mUseLevelZeroTexture = false;
@@ -908,7 +932,8 @@ void TextureStorage11_2D::disassociateImage(const gl::ImageIndex &index, Image11
 
 // releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image
 // recover its data before ending the association.
-gl::Error TextureStorage11_2D::releaseAssociatedImage(const gl::ImageIndex &index,
+gl::Error TextureStorage11_2D::releaseAssociatedImage(const gl::Context *context,
+                                                      const gl::ImageIndex &index,
                                                       Image11 *incomingImage)
 {
     const GLint level = index.mipIndex;
@@ -925,37 +950,39 @@ gl::Error TextureStorage11_2D::releaseAssociatedImage(const gl::ImageIndex &inde
 
             // Force the image to recover from storage before its data is overwritten.
             // This will reset mAssociatedImages[level] to nullptr too.
-            ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage());
+            ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage(context));
         }
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2D::getResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_2D::getResource(const gl::Context *context,
+                                           const TextureHelper11 **outResource)
 {
     if (mUseLevelZeroTexture && mMipLevels > 1)
     {
         ANGLE_TRY(ensureTextureExists(1));
 
-        *outResource = mLevelZeroTexture;
+        *outResource = &mLevelZeroTexture;
         return gl::NoError();
     }
 
     ANGLE_TRY(ensureTextureExists(mMipLevels));
 
-    *outResource = mTexture;
+    *outResource = &mTexture;
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2D::getMippedResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_2D::getMippedResource(const gl::Context *context,
+                                                 const TextureHelper11 **outResource)
 {
     // This shouldn't be called unless the zero max LOD workaround is active.
     ASSERT(mRenderer->getWorkarounds().zeroMaxLodWorkaround);
 
     ANGLE_TRY(ensureTextureExists(mMipLevels));
 
-    *outResource = mTexture;
+    *outResource = &mTexture;
     return gl::NoError();
 }
 
@@ -965,16 +992,14 @@ gl::Error TextureStorage11_2D::ensureTextureExists(int mipLevels)
     bool useLevelZeroTexture = mRenderer->getWorkarounds().zeroMaxLodWorkaround
                                    ? (mipLevels == 1) && (mMipLevels > 1)
                                    : false;
-    ID3D11Texture2D **outputTexture = useLevelZeroTexture ? &mLevelZeroTexture : &mTexture;
+    TextureHelper11 *outputTexture = useLevelZeroTexture ? &mLevelZeroTexture : &mTexture;
 
     // 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
-    if (*outputTexture == nullptr && mTextureWidth > 0 && mTextureHeight > 0)
+    if (!outputTexture->valid() && mTextureWidth > 0 && mTextureHeight > 0)
     {
         ASSERT(mipLevels > 0);
 
-        ID3D11Device *device = mRenderer->getDevice();
-
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = mTextureWidth;  // Compressed texture size constraints?
         desc.Height             = mTextureHeight;
@@ -988,29 +1013,16 @@ gl::Error TextureStorage11_2D::ensureTextureExists(int mipLevels)
         desc.CPUAccessFlags     = 0;
         desc.MiscFlags          = getMiscFlags();
 
-        HRESULT result = device->CreateTexture2D(&desc, nullptr, outputTexture);
-
-        // this can happen from windows TDR
-        if (d3d11::isDeviceLostError(result))
-        {
-            mRenderer->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create 2D texture storage, result: 0x%X.",
-                             result);
-        }
-        else if (FAILED(result))
-        {
-            ASSERT(result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create 2D texture storage, result: 0x%X.",
-                             result);
-        }
-
-        d3d11::SetDebugName(*outputTexture, "TexStorage2D.Texture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, mFormatInfo, outputTexture));
+        outputTexture->setDebugName("TexStorage2D.Texture");
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureStorage11_2D::getRenderTarget(const gl::Context *context,
+                                               const gl::ImageIndex &index,
+                                               RenderTargetD3D **outRT)
 {
     ASSERT(!index.hasLayer());
 
@@ -1033,14 +1045,14 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend
         return gl::NoError();
     }
 
-    ID3D11Resource *texture = nullptr;
-    ANGLE_TRY(getResource(&texture));
+    const TextureHelper11 *texture = nullptr;
+    ANGLE_TRY(getResource(context, &texture));
 
     const d3d11::SharedSRV *srv = nullptr;
-    ANGLE_TRY(getSRVLevel(level, false, &srv));
+    ANGLE_TRY(getSRVLevel(context, level, false, &srv));
 
     const d3d11::SharedSRV *blitSRV = nullptr;
-    ANGLE_TRY(getSRVLevel(level, true, &blitSRV));
+    ANGLE_TRY(getSRVLevel(context, level, true, &blitSRV));
 
     if (mUseLevelZeroTexture)
     {
@@ -1052,7 +1064,7 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend
             rtvDesc.Texture2D.MipSlice = mTopLevel + level;
 
             d3d11::RenderTargetView rtv;
-            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mLevelZeroTexture, &rtv));
+            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mLevelZeroTexture.get(), &rtv));
 
             mLevelZeroRenderTarget = new TextureRenderTarget11(
                 std::move(rtv), mLevelZeroTexture, d3d11::SharedSRV(), d3d11::SharedSRV(),
@@ -1072,10 +1084,10 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend
         rtvDesc.Texture2D.MipSlice = mTopLevel + level;
 
         d3d11::RenderTargetView rtv;
-        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture, &rtv));
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
 
         mRenderTarget[level] = new TextureRenderTarget11(
-            std::move(rtv), texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(),
+            std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(),
             getLevelWidth(level), getLevelHeight(level), 1, 0);
 
         *outRT = mRenderTarget[level];
@@ -1091,20 +1103,21 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend
     dsvDesc.Flags              = 0;
 
     d3d11::DepthStencilView dsv;
-    ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture, &dsv));
+    ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
 
     mRenderTarget[level] = new TextureRenderTarget11(
-        std::move(dsv), texture, *srv, mFormatInfo.internalFormat, getFormatSet(),
+        std::move(dsv), *texture, *srv, mFormatInfo.internalFormat, getFormatSet(),
         getLevelWidth(level), getLevelHeight(level), 1, 0);
 
     *outRT = mRenderTarget[level];
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2D::createSRV(int baseLevel,
+gl::Error TextureStorage11_2D::createSRV(const gl::Context *context,
+                                         int baseLevel,
                                          int mipLevels,
                                          DXGI_FORMAT format,
-                                         ID3D11Resource *texture,
+                                         const TextureHelper11 &texture,
                                          d3d11::SharedSRV *outSRV) const
 {
     ASSERT(outSRV);
@@ -1115,7 +1128,7 @@ gl::Error TextureStorage11_2D::createSRV(int baseLevel,
     srvDesc.Texture2D.MostDetailedMip = mTopLevel + baseLevel;
     srvDesc.Texture2D.MipLevels       = mipLevels;
 
-    ID3D11Resource *srvTexture = texture;
+    const TextureHelper11 *srvTexture = &texture;
 
     if (mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
@@ -1127,37 +1140,37 @@ gl::Error TextureStorage11_2D::createSRV(int baseLevel,
         if (mipLevels == 1 && mMipLevels > 1)
         {
             // We must use a SRV on the level-zero-only texture.
-            ASSERT(mLevelZeroTexture != nullptr && texture == mLevelZeroTexture);
-            srvTexture = mLevelZeroTexture;
+            ASSERT(mLevelZeroTexture.valid() && texture == mLevelZeroTexture);
+            srvTexture = &mLevelZeroTexture;
         }
         else
         {
             ASSERT(mipLevels == static_cast<int>(mMipLevels));
-            ASSERT(mTexture != nullptr && texture == mTexture);
-            srvTexture = mTexture;
+            ASSERT(mTexture.valid() && texture == mTexture);
+            srvTexture = &mTexture;
         }
     }
 
-    ANGLE_TRY(mRenderer->allocateResource(srvDesc, srvTexture, outSRV));
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, srvTexture->get(), outSRV));
     outSRV->setDebugName("TexStorage2D.SRV");
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2D::getSwizzleTexture(ID3D11Resource **outTexture)
+gl::Error TextureStorage11_2D::getSwizzleTexture(const TextureHelper11 **outTexture)
 {
     ASSERT(outTexture);
 
-    if (!mSwizzleTexture)
+    if (!mSwizzleTexture.valid())
     {
-        ID3D11Device *device = mRenderer->getDevice();
+        const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps());
 
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
         desc.MipLevels          = mMipLevels;
         desc.ArraySize          = 1;
-        desc.Format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).texFormat;
+        desc.Format             = format.texFormat;
         desc.SampleDesc.Count   = 1;
         desc.SampleDesc.Quality = 0;
         desc.Usage              = D3D11_USAGE_DEFAULT;
@@ -1165,19 +1178,11 @@ gl::Error TextureStorage11_2D::getSwizzleTexture(ID3D11Resource **outTexture)
         desc.CPUAccessFlags     = 0;
         desc.MiscFlags          = 0;
 
-        HRESULT result = device->CreateTexture2D(&desc, nullptr, &mSwizzleTexture);
-
-        ASSERT(result == E_OUTOFMEMORY || SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create internal swizzle texture, result: 0x%X.", result);
-        }
-
-        d3d11::SetDebugName(mSwizzleTexture, "TexStorage2D.SwizzleTexture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
+        mSwizzleTexture.setDebugName("TexStorage2D.SwizzleTexture");
     }
 
-    *outTexture = mSwizzleTexture;
+    *outTexture = &mSwizzleTexture;
     return gl::NoError();
 }
 
@@ -1189,7 +1194,7 @@ gl::Error TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel,
 
     if (!mSwizzleRenderTargets[mipLevel].valid())
     {
-        ID3D11Resource *swizzleTexture = nullptr;
+        const TextureHelper11 *swizzleTexture = nullptr;
         ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
 
         D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
@@ -1198,7 +1203,7 @@ gl::Error TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel,
         rtvDesc.ViewDimension      = D3D11_RTV_DIMENSION_TEXTURE2D;
         rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel;
 
-        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture,
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
                                               &mSwizzleRenderTargets[mipLevel]));
     }
 
@@ -1206,9 +1211,10 @@ gl::Error TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel,
     return gl::NoError();
 }
 
-gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_2D::ensureDropStencilTexture()
+gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_2D::ensureDropStencilTexture(
+    const gl::Context *context)
 {
-    if (mDropStencilTexture)
+    if (mDropStencilTexture.valid())
     {
         return DropStencil::ALREADY_EXISTS;
     }
@@ -1226,16 +1232,12 @@ gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_2D::ensureDrop
     dropDesc.Usage                = D3D11_USAGE_DEFAULT;
     dropDesc.Width                = mTextureWidth;
 
-    ID3D11Device *device = mRenderer->getDevice();
+    const auto &format =
+        d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps());
+    ANGLE_TRY(mRenderer->allocateTexture(dropDesc, format, &mDropStencilTexture));
+    mDropStencilTexture.setDebugName("TexStorage2D.DropStencil");
 
-    HRESULT hr = device->CreateTexture2D(&dropDesc, nullptr, &mDropStencilTexture);
-    if (FAILED(hr))
-    {
-        return gl::InternalError() << "Error creating drop stencil texture.";
-    }
-    d3d11::SetDebugName(mDropStencilTexture, "TexStorage2D.DropStencil");
-
-    ANGLE_TRY(initDropStencilTexture(gl::ImageIndexIterator::Make2D(0, mMipLevels)));
+    ANGLE_TRY(initDropStencilTexture(context, gl::ImageIndexIterator::Make2D(0, mMipLevels)));
 
     return DropStencil::CREATED;
 }
@@ -1248,31 +1250,39 @@ TextureStorage11_External::TextureStorage11_External(
 {
     ASSERT(stream->getProducerType() == egl::Stream::ProducerType::D3D11TextureNV12);
     StreamProducerNV12 *producer = static_cast<StreamProducerNV12 *>(stream->getImplementation());
-    mTexture                     = producer->getD3DTexture();
+    mTexture.set(producer->getD3DTexture(), mFormatInfo);
     mSubresourceIndex            = producer->getArraySlice();
-    mTexture->AddRef();
+    mTexture.get()->AddRef();
     mMipLevels = 1;
 
     D3D11_TEXTURE2D_DESC desc;
-    mTexture->GetDesc(&desc);
+    mTexture.getDesc(&desc);
     mTextureWidth  = desc.Width;
     mTextureHeight = desc.Height;
     mTextureDepth  = 1;
     mHasKeyedMutex = (desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0;
 }
 
-TextureStorage11_External::~TextureStorage11_External()
+gl::Error TextureStorage11_External::onDestroy(const gl::Context *context)
 {
-    SafeRelease(mTexture);
     if (mHasKeyedMutex)
     {
         // If the keyed mutex is released that will unbind it and cause the state cache to become
         // desynchronized.
-        mRenderer->getStateManager()->invalidateBoundViews();
+        mRenderer->getStateManager()->invalidateBoundViews(context);
     }
+
+    delete this;
+
+    return gl::NoError();
+}
+
+TextureStorage11_External::~TextureStorage11_External()
+{
 }
 
-gl::Error TextureStorage11_External::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage11_External::copyToStorage(const gl::Context *context,
+                                                   TextureStorage *destStorage)
 {
     UNIMPLEMENTED();
     return gl::NoError();
@@ -1298,7 +1308,8 @@ void TextureStorage11_External::disassociateImage(const gl::ImageIndex &index,
     mAssociatedImage = nullptr;
 }
 
-gl::Error TextureStorage11_External::releaseAssociatedImage(const gl::ImageIndex &index,
+gl::Error TextureStorage11_External::releaseAssociatedImage(const gl::Context *context,
+                                                            const gl::ImageIndex &index,
                                                             Image11 *incomingImage)
 {
     ASSERT(index.mipIndex == 0);
@@ -1307,36 +1318,40 @@ gl::Error TextureStorage11_External::releaseAssociatedImage(const gl::ImageIndex
     {
         mAssociatedImage->verifyAssociatedStorageValid(this);
 
-        ANGLE_TRY(mAssociatedImage->recoverFromAssociatedStorage());
+        ANGLE_TRY(mAssociatedImage->recoverFromAssociatedStorage(context));
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_External::getResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_External::getResource(const gl::Context *context,
+                                                 const TextureHelper11 **outResource)
 {
-    *outResource = mTexture;
+    *outResource = &mTexture;
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_External::getMippedResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_External::getMippedResource(const gl::Context *context,
+                                                       const TextureHelper11 **outResource)
 {
-    *outResource = mTexture;
+    *outResource = &mTexture;
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_External::getRenderTarget(const gl::ImageIndex &index,
+gl::Error TextureStorage11_External::getRenderTarget(const gl::Context *context,
+                                                     const gl::ImageIndex &index,
                                                      RenderTargetD3D **outRT)
 {
     // Render targets are not supported for external textures
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureStorage11_External::createSRV(int baseLevel,
+gl::Error TextureStorage11_External::createSRV(const gl::Context *context,
+                                               int baseLevel,
                                                int mipLevels,
                                                DXGI_FORMAT format,
-                                               ID3D11Resource *texture,
+                                               const TextureHelper11 &texture,
                                                d3d11::SharedSRV *outSRV) const
 {
     // Since external textures are treates as non-mipmapped textures, we ignore mipmap levels and
@@ -1353,25 +1368,23 @@ gl::Error TextureStorage11_External::createSRV(int baseLevel,
     srvDesc.Texture2DArray.FirstArraySlice = mSubresourceIndex;
     srvDesc.Texture2DArray.ArraySize       = 1;
 
-    ID3D11Resource *srvTexture = texture;
-
-    ANGLE_TRY(mRenderer->allocateResource(srvDesc, srvTexture, outSRV));
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
     outSRV->setDebugName("TexStorage2D.SRV");
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_External::getSwizzleTexture(ID3D11Resource **outTexture)
+gl::Error TextureStorage11_External::getSwizzleTexture(const TextureHelper11 **outTexture)
 {
     UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
 gl::Error TextureStorage11_External::getSwizzleRenderTarget(int mipLevel,
                                                             const d3d11::RenderTargetView **outRTV)
 {
     UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
 TextureStorage11_EGLImage::TextureStorage11_EGLImage(Renderer11 *renderer,
@@ -1383,7 +1396,7 @@ TextureStorage11_EGLImage::TextureStorage11_EGLImage(Renderer11 *renderer,
                        renderTarget11->getInternalFormat()),
       mImage(eglImage),
       mCurrentRenderTarget(0),
-      mSwizzleTexture(nullptr),
+      mSwizzleTexture(),
       mSwizzleRenderTargets(gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
 {
     mCurrentRenderTarget = reinterpret_cast<uintptr_t>(renderTarget11);
@@ -1396,57 +1409,61 @@ TextureStorage11_EGLImage::TextureStorage11_EGLImage(Renderer11 *renderer,
 
 TextureStorage11_EGLImage::~TextureStorage11_EGLImage()
 {
-    SafeRelease(mSwizzleTexture);
 }
 
-gl::Error TextureStorage11_EGLImage::getResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_EGLImage::getResource(const gl::Context *context,
+                                                 const TextureHelper11 **outResource)
 {
-    ANGLE_TRY(checkForUpdatedRenderTarget());
+    ANGLE_TRY(checkForUpdatedRenderTarget(context));
 
     RenderTarget11 *renderTarget11 = nullptr;
-    ANGLE_TRY(getImageRenderTarget(&renderTarget11));
-    *outResource = renderTarget11->getTexture();
+    ANGLE_TRY(getImageRenderTarget(context, &renderTarget11));
+    *outResource = &renderTarget11->getTexture();
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_EGLImage::getSRV(const gl::TextureState &textureState,
-                                            d3d11::SharedSRV *outSRV)
+gl::Error TextureStorage11_EGLImage::getSRV(const gl::Context *context,
+                                            const gl::TextureState &textureState,
+                                            const d3d11::SharedSRV **outSRV)
 {
-    ANGLE_TRY(checkForUpdatedRenderTarget());
-    return TextureStorage11::getSRV(textureState, outSRV);
+    ANGLE_TRY(checkForUpdatedRenderTarget(context));
+    return TextureStorage11::getSRV(context, textureState, outSRV);
 }
 
-gl::Error TextureStorage11_EGLImage::getMippedResource(ID3D11Resource **)
+gl::Error TextureStorage11_EGLImage::getMippedResource(const gl::Context *context,
+                                                       const TextureHelper11 **)
 {
     // This shouldn't be called unless the zero max LOD workaround is active.
     // EGL images are unavailable in this configuration.
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureStorage11_EGLImage::getRenderTarget(const gl::ImageIndex &index,
+gl::Error TextureStorage11_EGLImage::getRenderTarget(const gl::Context *context,
+                                                     const gl::ImageIndex &index,
                                                      RenderTargetD3D **outRT)
 {
     ASSERT(!index.hasLayer());
     ASSERT(index.mipIndex == 0);
 
-    ANGLE_TRY(checkForUpdatedRenderTarget());
+    ANGLE_TRY(checkForUpdatedRenderTarget(context));
 
-    return mImage->getRenderTarget(outRT);
+    return mImage->getRenderTarget(context, outRT);
 }
 
-gl::Error TextureStorage11_EGLImage::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage11_EGLImage::copyToStorage(const gl::Context *context,
+                                                   TextureStorage *destStorage)
 {
-    ID3D11Resource *sourceResouce = nullptr;
-    ANGLE_TRY(getResource(&sourceResouce));
+    const TextureHelper11 *sourceResouce = nullptr;
+    ANGLE_TRY(getResource(context, &sourceResouce));
 
     ASSERT(destStorage);
     TextureStorage11_2D *dest11  = GetAs<TextureStorage11_2D>(destStorage);
-    ID3D11Resource *destResource = nullptr;
-    ANGLE_TRY(dest11->getResource(&destResource));
+    const TextureHelper11 *destResource = nullptr;
+    ANGLE_TRY(dest11->getResource(context, &destResource));
 
     ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext();
-    immediateContext->CopyResource(destResource, sourceResouce);
+    immediateContext->CopyResource(destResource->get(), sourceResouce->get());
 
     dest11->markDirty();
 
@@ -1465,7 +1482,9 @@ void TextureStorage11_EGLImage::verifyAssociatedImageValid(const gl::ImageIndex
 {
 }
 
-gl::Error TextureStorage11_EGLImage::releaseAssociatedImage(const gl::ImageIndex &, Image11 *)
+gl::Error TextureStorage11_EGLImage::releaseAssociatedImage(const gl::Context *context,
+                                                            const gl::ImageIndex &,
+                                                            Image11 *)
 {
     return gl::NoError();
 }
@@ -1473,23 +1492,23 @@ gl::Error TextureStorage11_EGLImage::releaseAssociatedImage(const gl::ImageIndex
 gl::Error TextureStorage11_EGLImage::useLevelZeroWorkaroundTexture(bool)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureStorage11_EGLImage::getSwizzleTexture(ID3D11Resource **outTexture)
+gl::Error TextureStorage11_EGLImage::getSwizzleTexture(const TextureHelper11 **outTexture)
 {
     ASSERT(outTexture);
 
-    if (!mSwizzleTexture)
+    if (!mSwizzleTexture.valid())
     {
-        ID3D11Device *device = mRenderer->getDevice();
+        const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps());
 
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
         desc.MipLevels          = mMipLevels;
         desc.ArraySize          = 1;
-        desc.Format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).texFormat;
+        desc.Format             = format.texFormat;
         desc.SampleDesc.Count   = 1;
         desc.SampleDesc.Quality = 0;
         desc.Usage              = D3D11_USAGE_DEFAULT;
@@ -1497,19 +1516,11 @@ gl::Error TextureStorage11_EGLImage::getSwizzleTexture(ID3D11Resource **outTextu
         desc.CPUAccessFlags     = 0;
         desc.MiscFlags          = 0;
 
-        HRESULT result = device->CreateTexture2D(&desc, nullptr, &mSwizzleTexture);
-
-        ASSERT(result == E_OUTOFMEMORY || SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create internal swizzle texture, result: 0x%X.", result);
-        }
-
-        d3d11::SetDebugName(mSwizzleTexture, "TexStorageEGLImage.SwizzleTexture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
+        mSwizzleTexture.setDebugName("TexStorageEGLImage.SwizzleTexture");
     }
 
-    *outTexture = mSwizzleTexture;
+    *outTexture = &mSwizzleTexture;
     return gl::NoError();
 }
 
@@ -1521,7 +1532,7 @@ gl::Error TextureStorage11_EGLImage::getSwizzleRenderTarget(int mipLevel,
 
     if (!mSwizzleRenderTargets[mipLevel].valid())
     {
-        ID3D11Resource *swizzleTexture = nullptr;
+        const TextureHelper11 *swizzleTexture = nullptr;
         ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
 
         D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
@@ -1530,7 +1541,7 @@ gl::Error TextureStorage11_EGLImage::getSwizzleRenderTarget(int mipLevel,
         rtvDesc.ViewDimension      = D3D11_RTV_DIMENSION_TEXTURE2D;
         rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel;
 
-        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture,
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
                                               &mSwizzleRenderTargets[mipLevel]));
     }
 
@@ -1538,10 +1549,10 @@ gl::Error TextureStorage11_EGLImage::getSwizzleRenderTarget(int mipLevel,
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_EGLImage::checkForUpdatedRenderTarget()
+gl::Error TextureStorage11_EGLImage::checkForUpdatedRenderTarget(const gl::Context *context)
 {
     RenderTarget11 *renderTarget11 = nullptr;
-    ANGLE_TRY(getImageRenderTarget(&renderTarget11));
+    ANGLE_TRY(getImageRenderTarget(context, &renderTarget11));
 
     if (mCurrentRenderTarget != reinterpret_cast<uintptr_t>(renderTarget11))
     {
@@ -1552,10 +1563,11 @@ gl::Error TextureStorage11_EGLImage::checkForUpdatedRenderTarget()
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_EGLImage::createSRV(int baseLevel,
+gl::Error TextureStorage11_EGLImage::createSRV(const gl::Context *context,
+                                               int baseLevel,
                                                int mipLevels,
                                                DXGI_FORMAT format,
-                                               ID3D11Resource *texture,
+                                               const TextureHelper11 &texture,
                                                d3d11::SharedSRV *outSRV) const
 {
     ASSERT(baseLevel == 0);
@@ -1572,26 +1584,27 @@ gl::Error TextureStorage11_EGLImage::createSRV(int baseLevel,
         srvDesc.Texture2D.MostDetailedMip = mTopLevel + baseLevel;
         srvDesc.Texture2D.MipLevels       = mipLevels;
 
-        ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture, outSRV));
+        ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
         outSRV->setDebugName("TexStorageEGLImage.SRV");
     }
     else
     {
         RenderTarget11 *renderTarget = nullptr;
-        ANGLE_TRY(getImageRenderTarget(&renderTarget));
+        ANGLE_TRY(getImageRenderTarget(context, &renderTarget));
 
         ASSERT(texture == renderTarget->getTexture());
 
-        *outSRV = renderTarget->getShaderResourceView();
+        *outSRV = renderTarget->getShaderResourceView().makeCopy();
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_EGLImage::getImageRenderTarget(RenderTarget11 **outRT) const
+gl::Error TextureStorage11_EGLImage::getImageRenderTarget(const gl::Context *context,
+                                                          RenderTarget11 **outRT) const
 {
     RenderTargetD3D *renderTargetD3D = nullptr;
-    ANGLE_TRY(mImage->getRenderTarget(&renderTargetD3D));
+    ANGLE_TRY(mImage->getRenderTarget(context, &renderTargetD3D));
     *outRT = GetAs<RenderTarget11>(renderTargetD3D);
     return gl::NoError();
 }
@@ -1610,10 +1623,10 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer,
                               renderTarget,
                               levels),
           internalformat),
-      mTexture(nullptr),
-      mLevelZeroTexture(nullptr),
+      mTexture(),
+      mLevelZeroTexture(),
       mUseLevelZeroTexture(hintLevelZeroOnly && levels > 1),
-      mSwizzleTexture(nullptr)
+      mSwizzleTexture()
 {
     for (unsigned int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
     {
@@ -1642,7 +1655,7 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer,
     ASSERT(!mUseLevelZeroTexture || mRenderer->getWorkarounds().zeroMaxLodWorkaround);
 }
 
-TextureStorage11_Cube::~TextureStorage11_Cube()
+gl::Error TextureStorage11_Cube::onDestroy(const gl::Context *context)
 {
     for (unsigned int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
     {
@@ -1654,15 +1667,11 @@ TextureStorage11_Cube::~TextureStorage11_Cube()
 
                 // We must let the Images recover their data before we delete it from the
                 // TextureStorage.
-                mAssociatedImages[face][level]->recoverFromAssociatedStorage();
+                ANGLE_TRY(mAssociatedImages[face][level]->recoverFromAssociatedStorage(context));
             }
         }
     }
 
-    SafeRelease(mTexture);
-    SafeRelease(mSwizzleTexture);
-    SafeRelease(mLevelZeroTexture);
-
     for (unsigned int face = 0; face < CUBE_FACE_COUNT; face++)
     {
         SafeDelete(mLevelZeroRenderTarget[face]);
@@ -1675,6 +1684,14 @@ TextureStorage11_Cube::~TextureStorage11_Cube()
             SafeDelete(mRenderTarget[face][level]);
         }
     }
+
+    delete this;
+
+    return gl::NoError();
+}
+
+TextureStorage11_Cube::~TextureStorage11_Cube()
+{
 }
 
 UINT TextureStorage11_Cube::getSubresourceIndex(const gl::ImageIndex &index) const
@@ -1697,7 +1714,8 @@ UINT TextureStorage11_Cube::getSubresourceIndex(const gl::ImageIndex &index) con
     }
 }
 
-gl::Error TextureStorage11_Cube::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage11_Cube::copyToStorage(const gl::Context *context,
+                                               TextureStorage *destStorage)
 {
     ASSERT(destStorage);
 
@@ -1709,36 +1727,36 @@ gl::Error TextureStorage11_Cube::copyToStorage(TextureStorage *destStorage)
 
         // If either mTexture or mLevelZeroTexture exist, then we need to copy them into the
         // corresponding textures in destStorage.
-        if (mTexture)
+        if (mTexture.valid())
         {
             ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(false));
 
-            ID3D11Resource *destResource = nullptr;
-            ANGLE_TRY(dest11->getResource(&destResource));
+            const TextureHelper11 *destResource = nullptr;
+            ANGLE_TRY(dest11->getResource(context, &destResource));
 
-            immediateContext->CopyResource(destResource, mTexture);
+            immediateContext->CopyResource(destResource->get(), mTexture.get());
         }
 
-        if (mLevelZeroTexture)
+        if (mLevelZeroTexture.valid())
         {
             ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(true));
 
-            ID3D11Resource *destResource = nullptr;
-            ANGLE_TRY(dest11->getResource(&destResource));
+            const TextureHelper11 *destResource = nullptr;
+            ANGLE_TRY(dest11->getResource(context, &destResource));
 
-            immediateContext->CopyResource(destResource, mLevelZeroTexture);
+            immediateContext->CopyResource(destResource->get(), mLevelZeroTexture.get());
         }
     }
     else
     {
-        ID3D11Resource *sourceResouce = nullptr;
-        ANGLE_TRY(getResource(&sourceResouce));
+        const TextureHelper11 *sourceResouce = nullptr;
+        ANGLE_TRY(getResource(context, &sourceResouce));
 
-        ID3D11Resource *destResource = nullptr;
-        ANGLE_TRY(dest11->getResource(&destResource));
+        const TextureHelper11 *destResource = nullptr;
+        ANGLE_TRY(dest11->getResource(context, &destResource));
 
         ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext();
-        immediateContext->CopyResource(destResource, sourceResouce);
+        immediateContext->CopyResource(destResource->get(), sourceResouce->get());
     }
 
     dest11->markDirty();
@@ -1750,18 +1768,19 @@ gl::Error TextureStorage11_Cube::useLevelZeroWorkaroundTexture(bool useLevelZero
 {
     if (useLevelZeroTexture && mMipLevels > 1)
     {
-        if (!mUseLevelZeroTexture && mTexture)
+        if (!mUseLevelZeroTexture && mTexture.valid())
         {
             ANGLE_TRY(ensureTextureExists(1));
 
             // Pull data back from the mipped texture if necessary.
-            ASSERT(mLevelZeroTexture);
+            ASSERT(mLevelZeroTexture.valid());
             ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
             for (int face = 0; face < 6; face++)
             {
-                context->CopySubresourceRegion(mLevelZeroTexture, D3D11CalcSubresource(0, face, 1),
-                                               0, 0, 0, mTexture, face * mMipLevels, nullptr);
+                context->CopySubresourceRegion(mLevelZeroTexture.get(),
+                                               D3D11CalcSubresource(0, face, 1), 0, 0, 0,
+                                               mTexture.get(), face * mMipLevels, nullptr);
             }
         }
 
@@ -1769,18 +1788,19 @@ gl::Error TextureStorage11_Cube::useLevelZeroWorkaroundTexture(bool useLevelZero
     }
     else
     {
-        if (mUseLevelZeroTexture && mLevelZeroTexture)
+        if (mUseLevelZeroTexture && mLevelZeroTexture.valid())
         {
             ANGLE_TRY(ensureTextureExists(mMipLevels));
 
             // Pull data back from the level zero texture if necessary.
-            ASSERT(mTexture);
+            ASSERT(mTexture.valid());
             ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
             for (int face = 0; face < 6; face++)
             {
-                context->CopySubresourceRegion(mTexture, D3D11CalcSubresource(0, face, mMipLevels),
-                                               0, 0, 0, mLevelZeroTexture, face, nullptr);
+                context->CopySubresourceRegion(mTexture.get(),
+                                               D3D11CalcSubresource(0, face, mMipLevels), 0, 0, 0,
+                                               mLevelZeroTexture.get(), face, nullptr);
             }
         }
 
@@ -1834,7 +1854,8 @@ void TextureStorage11_Cube::disassociateImage(const gl::ImageIndex &index, Image
 
 // releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image
 // recover its data before ending the association.
-gl::Error TextureStorage11_Cube::releaseAssociatedImage(const gl::ImageIndex &index,
+gl::Error TextureStorage11_Cube::releaseAssociatedImage(const gl::Context *context,
+                                                        const gl::ImageIndex &index,
                                                         Image11 *incomingImage)
 {
     const GLint level       = index.mipIndex;
@@ -1856,7 +1877,8 @@ gl::Error TextureStorage11_Cube::releaseAssociatedImage(const gl::ImageIndex &in
 
                 // Force the image to recover from storage before its data is overwritten.
                 // This will reset mAssociatedImages[level] to nullptr too.
-                ANGLE_TRY(mAssociatedImages[layerTarget][level]->recoverFromAssociatedStorage());
+                ANGLE_TRY(
+                    mAssociatedImages[layerTarget][level]->recoverFromAssociatedStorage(context));
             }
         }
     }
@@ -1864,29 +1886,31 @@ gl::Error TextureStorage11_Cube::releaseAssociatedImage(const gl::ImageIndex &in
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_Cube::getResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_Cube::getResource(const gl::Context *context,
+                                             const TextureHelper11 **outResource)
 {
     if (mUseLevelZeroTexture && mMipLevels > 1)
     {
         ANGLE_TRY(ensureTextureExists(1));
-        *outResource = mLevelZeroTexture;
+        *outResource = &mLevelZeroTexture;
         return gl::NoError();
     }
     else
     {
         ANGLE_TRY(ensureTextureExists(mMipLevels));
-        *outResource = mTexture;
+        *outResource = &mTexture;
         return gl::NoError();
     }
 }
 
-gl::Error TextureStorage11_Cube::getMippedResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_Cube::getMippedResource(const gl::Context *context,
+                                                   const TextureHelper11 **outResource)
 {
     // This shouldn't be called unless the zero max LOD workaround is active.
     ASSERT(mRenderer->getWorkarounds().zeroMaxLodWorkaround);
 
     ANGLE_TRY(ensureTextureExists(mMipLevels));
-    *outResource = mTexture;
+    *outResource = &mTexture;
     return gl::NoError();
 }
 
@@ -1896,16 +1920,14 @@ gl::Error TextureStorage11_Cube::ensureTextureExists(int mipLevels)
     bool useLevelZeroTexture = mRenderer->getWorkarounds().zeroMaxLodWorkaround
                                    ? (mipLevels == 1) && (mMipLevels > 1)
                                    : false;
-    ID3D11Texture2D **outputTexture = useLevelZeroTexture ? &mLevelZeroTexture : &mTexture;
+    TextureHelper11 *outputTexture = useLevelZeroTexture ? &mLevelZeroTexture : &mTexture;
 
     // if the size is not positive this should be treated as an incomplete texture
     // we handle that here by skipping the d3d texture creation
-    if (*outputTexture == nullptr && mTextureWidth > 0 && mTextureHeight > 0)
+    if (!outputTexture->valid() && mTextureWidth > 0 && mTextureHeight > 0)
     {
         ASSERT(mMipLevels > 0);
 
-        ID3D11Device *device = mRenderer->getDevice();
-
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
@@ -1919,29 +1941,14 @@ gl::Error TextureStorage11_Cube::ensureTextureExists(int mipLevels)
         desc.CPUAccessFlags     = 0;
         desc.MiscFlags          = D3D11_RESOURCE_MISC_TEXTURECUBE | getMiscFlags();
 
-        HRESULT result = device->CreateTexture2D(&desc, nullptr, outputTexture);
-
-        // this can happen from windows TDR
-        if (d3d11::isDeviceLostError(result))
-        {
-            mRenderer->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create cube texture storage, result: 0x%X.", result);
-        }
-        else if (FAILED(result))
-        {
-            ASSERT(result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create cube texture storage, result: 0x%X.", result);
-        }
-
-        d3d11::SetDebugName(*outputTexture, "TexStorageCube.Texture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, mFormatInfo, outputTexture));
+        outputTexture->setDebugName("TexStorageCube.Texture");
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_Cube::createRenderTargetSRV(ID3D11Resource *texture,
+gl::Error TextureStorage11_Cube::createRenderTargetSRV(const TextureHelper11 &texture,
                                                        const gl::ImageIndex &index,
                                                        DXGI_FORMAT resourceFormat,
                                                        d3d11::SharedSRV *srv) const
@@ -1963,11 +1970,12 @@ gl::Error TextureStorage11_Cube::createRenderTargetSRV(ID3D11Resource *texture,
         srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
     }
 
-    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture, srv));
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), srv));
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
+gl::Error TextureStorage11_Cube::getRenderTarget(const gl::Context *context,
+                                                 const gl::ImageIndex &index,
                                                  RenderTargetD3D **outRT)
 {
     const int faceIndex = index.layerIndex;
@@ -1978,8 +1986,8 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
 
     if (!mRenderTarget[faceIndex][level])
     {
-        ID3D11Resource *texture = nullptr;
-        ANGLE_TRY(getResource(&texture));
+        const TextureHelper11 *texture = nullptr;
+        ANGLE_TRY(getResource(context, &texture));
 
         if (mUseLevelZeroTexture)
         {
@@ -1993,7 +2001,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
                 rtvDesc.Texture2DArray.ArraySize       = 1;
 
                 d3d11::RenderTargetView rtv;
-                ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mLevelZeroTexture, &rtv));
+                ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mLevelZeroTexture.get(), &rtv));
 
                 mLevelZeroRenderTarget[faceIndex] = new TextureRenderTarget11(
                     std::move(rtv), mLevelZeroTexture, d3d11::SharedSRV(), d3d11::SharedSRV(),
@@ -2007,15 +2015,15 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
         }
 
         d3d11::SharedSRV srv;
-        ANGLE_TRY(createRenderTargetSRV(texture, index, mFormatInfo.srvFormat, &srv));
+        ANGLE_TRY(createRenderTargetSRV(*texture, index, mFormatInfo.srvFormat, &srv));
         d3d11::SharedSRV blitSRV;
         if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat)
         {
-            ANGLE_TRY(createRenderTargetSRV(texture, index, mFormatInfo.blitSRVFormat, &blitSRV));
+            ANGLE_TRY(createRenderTargetSRV(*texture, index, mFormatInfo.blitSRVFormat, &blitSRV));
         }
         else
         {
-            blitSRV = srv;
+            blitSRV = srv.makeCopy();
         }
 
         srv.setDebugName("TexStorageCube.RenderTargetSRV");
@@ -2030,11 +2038,11 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
             rtvDesc.Texture2DArray.ArraySize       = 1;
 
             d3d11::RenderTargetView rtv;
-            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture, &rtv));
+            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
             rtv.setDebugName("TexStorageCube.RenderTargetRTV");
 
             mRenderTarget[faceIndex][level] = new TextureRenderTarget11(
-                std::move(rtv), texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(),
+                std::move(rtv), *texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(),
                 getLevelWidth(level), getLevelHeight(level), 1, 0);
         }
         else if (mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN)
@@ -2048,11 +2056,11 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
             dsvDesc.Texture2DArray.ArraySize       = 1;
 
             d3d11::DepthStencilView dsv;
-            ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture, &dsv));
+            ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
             dsv.setDebugName("TexStorageCube.RenderTargetDSV");
 
             mRenderTarget[faceIndex][level] = new TextureRenderTarget11(
-                std::move(dsv), texture, srv, mFormatInfo.internalFormat, getFormatSet(),
+                std::move(dsv), *texture, srv, mFormatInfo.internalFormat, getFormatSet(),
                 getLevelWidth(level), getLevelHeight(level), 1, 0);
         }
         else
@@ -2066,10 +2074,11 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index,
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_Cube::createSRV(int baseLevel,
+gl::Error TextureStorage11_Cube::createSRV(const gl::Context *context,
+                                           int baseLevel,
                                            int mipLevels,
                                            DXGI_FORMAT format,
-                                           ID3D11Resource *texture,
+                                           const TextureHelper11 &texture,
                                            d3d11::SharedSRV *outSRV) const
 {
     ASSERT(outSRV);
@@ -2095,7 +2104,7 @@ gl::Error TextureStorage11_Cube::createSRV(int baseLevel,
         srvDesc.TextureCube.MostDetailedMip = mTopLevel + baseLevel;
     }
 
-    ID3D11Resource *srvTexture = texture;
+    const TextureHelper11 *srvTexture = &texture;
 
     if (mRenderer->getWorkarounds().zeroMaxLodWorkaround)
     {
@@ -2107,37 +2116,37 @@ gl::Error TextureStorage11_Cube::createSRV(int baseLevel,
         if (mipLevels == 1 && mMipLevels > 1)
         {
             // We must use a SRV on the level-zero-only texture.
-            ASSERT(mLevelZeroTexture != nullptr && texture == mLevelZeroTexture);
-            srvTexture = mLevelZeroTexture;
+            ASSERT(mLevelZeroTexture.valid() && texture == mLevelZeroTexture);
+            srvTexture = &mLevelZeroTexture;
         }
         else
         {
             ASSERT(mipLevels == static_cast<int>(mMipLevels));
-            ASSERT(mTexture != nullptr && texture == mTexture);
-            srvTexture = mTexture;
+            ASSERT(mTexture.valid() && texture == mTexture);
+            srvTexture = &mTexture;
         }
     }
 
-    ANGLE_TRY(mRenderer->allocateResource(srvDesc, srvTexture, outSRV));
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, srvTexture->get(), outSRV));
     outSRV->setDebugName("TexStorageCube.SRV");
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_Cube::getSwizzleTexture(ID3D11Resource **outTexture)
+gl::Error TextureStorage11_Cube::getSwizzleTexture(const TextureHelper11 **outTexture)
 {
     ASSERT(outTexture);
 
-    if (!mSwizzleTexture)
+    if (!mSwizzleTexture.valid())
     {
-        ID3D11Device *device = mRenderer->getDevice();
+        const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps());
 
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
         desc.MipLevels          = mMipLevels;
         desc.ArraySize          = CUBE_FACE_COUNT;
-        desc.Format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).texFormat;
+        desc.Format             = format.texFormat;
         desc.SampleDesc.Count   = 1;
         desc.SampleDesc.Quality = 0;
         desc.Usage              = D3D11_USAGE_DEFAULT;
@@ -2145,19 +2154,11 @@ gl::Error TextureStorage11_Cube::getSwizzleTexture(ID3D11Resource **outTexture)
         desc.CPUAccessFlags     = 0;
         desc.MiscFlags          = D3D11_RESOURCE_MISC_TEXTURECUBE;
 
-        HRESULT result = device->CreateTexture2D(&desc, nullptr, &mSwizzleTexture);
-
-        ASSERT(result == E_OUTOFMEMORY || SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create internal swizzle texture, result: 0x%X.", result);
-        }
-
-        d3d11::SetDebugName(*outTexture, "TexStorageCube.SwizzleTexture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
+        mSwizzleTexture.setDebugName("TexStorageCube.SwizzleTexture");
     }
 
-    *outTexture = mSwizzleTexture;
+    *outTexture = &mSwizzleTexture;
     return gl::NoError();
 }
 
@@ -2169,7 +2170,7 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel,
 
     if (!mSwizzleRenderTargets[mipLevel].valid())
     {
-        ID3D11Resource *swizzleTexture = nullptr;
+        const TextureHelper11 *swizzleTexture = nullptr;
         ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
 
         D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
@@ -2180,7 +2181,7 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel,
         rtvDesc.Texture2DArray.FirstArraySlice = 0;
         rtvDesc.Texture2DArray.ArraySize       = CUBE_FACE_COUNT;
 
-        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture,
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
                                               &mSwizzleRenderTargets[mipLevel]));
     }
 
@@ -2188,14 +2189,11 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel,
     return gl::NoError();
 }
 
-gl::Error TextureStorage11::initDropStencilTexture(const gl::ImageIndexIterator &it)
+gl::Error TextureStorage11::initDropStencilTexture(const gl::Context *context,
+                                                   const gl::ImageIndexIterator &it)
 {
-    ID3D11Resource *resource = nullptr;
-    ANGLE_TRY(getResource(&resource));
-    TextureHelper11 sourceTexture = TextureHelper11::MakeAndReference(resource, mFormatInfo);
-    TextureHelper11 destTexture   = TextureHelper11::MakeAndReference(
-        mDropStencilTexture,
-        d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps()));
+    const TextureHelper11 *sourceTexture = nullptr;
+    ANGLE_TRY(getResource(context, &sourceTexture));
 
     gl::ImageIndexIterator itCopy = it;
 
@@ -2206,17 +2204,18 @@ gl::Error TextureStorage11::initDropStencilTexture(const gl::ImageIndexIterator
                           1);
         gl::Extents wholeSize(wholeArea.width, wholeArea.height, 1);
         UINT subresource = getSubresourceIndex(index);
-        ANGLE_TRY(mRenderer->getBlitter()->copyDepthStencil(sourceTexture, subresource, wholeArea,
-                                                            wholeSize, destTexture, subresource,
-                                                            wholeArea, wholeSize, nullptr));
+        ANGLE_TRY(mRenderer->getBlitter()->copyDepthStencil(
+            *sourceTexture, subresource, wholeArea, wholeSize, mDropStencilTexture, subresource,
+            wholeArea, wholeSize, nullptr));
     }
 
     return gl::NoError();
 }
 
-gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_Cube::ensureDropStencilTexture()
+gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_Cube::ensureDropStencilTexture(
+    const gl::Context *context)
 {
-    if (mDropStencilTexture)
+    if (mDropStencilTexture.valid())
     {
         return DropStencil::ALREADY_EXISTS;
     }
@@ -2234,16 +2233,12 @@ gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_Cube::ensureDr
     dropDesc.Usage                = D3D11_USAGE_DEFAULT;
     dropDesc.Width                = mTextureWidth;
 
-    ID3D11Device *device = mRenderer->getDevice();
+    const auto &format =
+        d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps());
+    ANGLE_TRY(mRenderer->allocateTexture(dropDesc, format, &mDropStencilTexture));
+    mDropStencilTexture.setDebugName("TexStorageCube.DropStencil");
 
-    HRESULT hr = device->CreateTexture2D(&dropDesc, nullptr, &mDropStencilTexture);
-    if (FAILED(hr))
-    {
-        return gl::InternalError() << "Error creating drop stencil texture.";
-    }
-    d3d11::SetDebugName(mDropStencilTexture, "TexStorageCube.DropStencil");
-
-    ANGLE_TRY(initDropStencilTexture(gl::ImageIndexIterator::MakeCube(0, mMipLevels)));
+    ANGLE_TRY(initDropStencilTexture(context, gl::ImageIndexIterator::MakeCube(0, mMipLevels)));
 
     return DropStencil::CREATED;
 }
@@ -2264,9 +2259,6 @@ TextureStorage11_3D::TextureStorage11_3D(Renderer11 *renderer,
                               levels),
           internalformat)
 {
-    mTexture        = nullptr;
-    mSwizzleTexture = nullptr;
-
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
         mAssociatedImages[i]     = nullptr;
@@ -2282,7 +2274,7 @@ TextureStorage11_3D::TextureStorage11_3D(Renderer11 *renderer,
     mTextureDepth  = depth;
 }
 
-TextureStorage11_3D::~TextureStorage11_3D()
+gl::Error TextureStorage11_3D::onDestroy(const gl::Context *context)
 {
     for (unsigned i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
@@ -2292,13 +2284,10 @@ TextureStorage11_3D::~TextureStorage11_3D()
 
             // We must let the Images recover their data before we delete it from the
             // TextureStorage.
-            mAssociatedImages[i]->recoverFromAssociatedStorage();
+            ANGLE_TRY(mAssociatedImages[i]->recoverFromAssociatedStorage(context));
         }
     }
 
-    SafeRelease(mTexture);
-    SafeRelease(mSwizzleTexture);
-
     for (RenderTargetMap::iterator i = mLevelLayerRenderTargets.begin();
          i != mLevelLayerRenderTargets.end(); i++)
     {
@@ -2310,6 +2299,14 @@ TextureStorage11_3D::~TextureStorage11_3D()
     {
         SafeDelete(mLevelRenderTargets[i]);
     }
+
+    delete this;
+
+    return gl::NoError();
+}
+
+TextureStorage11_3D::~TextureStorage11_3D()
+{
 }
 
 void TextureStorage11_3D::associateImage(Image11 *image, const gl::ImageIndex &index)
@@ -2347,7 +2344,8 @@ void TextureStorage11_3D::disassociateImage(const gl::ImageIndex &index, Image11
 
 // releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image
 // recover its data before ending the association.
-gl::Error TextureStorage11_3D::releaseAssociatedImage(const gl::ImageIndex &index,
+gl::Error TextureStorage11_3D::releaseAssociatedImage(const gl::Context *context,
+                                                      const gl::ImageIndex &index,
                                                       Image11 *incomingImage)
 {
     const GLint level = index.mipIndex;
@@ -2364,23 +2362,22 @@ gl::Error TextureStorage11_3D::releaseAssociatedImage(const gl::ImageIndex &inde
 
             // Force the image to recover from storage before its data is overwritten.
             // This will reset mAssociatedImages[level] to nullptr too.
-            ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage());
+            ANGLE_TRY(mAssociatedImages[level]->recoverFromAssociatedStorage(context));
         }
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_3D::getResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_3D::getResource(const gl::Context *context,
+                                           const TextureHelper11 **outResource)
 {
     // If the width, height or depth are not positive this should be treated as an incomplete
     // texture. We handle that here by skipping the d3d texture creation.
-    if (mTexture == nullptr && mTextureWidth > 0 && mTextureHeight > 0 && mTextureDepth > 0)
+    if (!mTexture.valid() && mTextureWidth > 0 && mTextureHeight > 0 && mTextureDepth > 0)
     {
         ASSERT(mMipLevels > 0);
 
-        ID3D11Device *device = mRenderer->getDevice();
-
         D3D11_TEXTURE3D_DESC desc;
         desc.Width          = mTextureWidth;
         desc.Height         = mTextureHeight;
@@ -2392,33 +2389,19 @@ gl::Error TextureStorage11_3D::getResource(ID3D11Resource **outResource)
         desc.CPUAccessFlags = 0;
         desc.MiscFlags      = getMiscFlags();
 
-        HRESULT result = device->CreateTexture3D(&desc, nullptr, &mTexture);
-
-        // this can happen from windows TDR
-        if (d3d11::isDeviceLostError(result))
-        {
-            mRenderer->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create 3D texture storage, result: 0x%X.",
-                             result);
-        }
-        else if (FAILED(result))
-        {
-            ASSERT(result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create 3D texture storage, result: 0x%X.",
-                             result);
-        }
-
-        d3d11::SetDebugName(mTexture, "TexStorage3D.Texture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, mFormatInfo, &mTexture));
+        mTexture.setDebugName("TexStorage3D.Texture");
     }
 
-    *outResource = mTexture;
+    *outResource = &mTexture;
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_3D::createSRV(int baseLevel,
+gl::Error TextureStorage11_3D::createSRV(const gl::Context *context,
+                                         int baseLevel,
                                          int mipLevels,
                                          DXGI_FORMAT format,
-                                         ID3D11Resource *texture,
+                                         const TextureHelper11 &texture,
                                          d3d11::SharedSRV *outSRV) const
 {
     ASSERT(outSRV);
@@ -2429,13 +2412,15 @@ gl::Error TextureStorage11_3D::createSRV(int baseLevel,
     srvDesc.Texture3D.MostDetailedMip = baseLevel;
     srvDesc.Texture3D.MipLevels       = mipLevels;
 
-    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture, outSRV));
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
     outSRV->setDebugName("TexStorage3D.SRV");
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureStorage11_3D::getRenderTarget(const gl::Context *context,
+                                               const gl::ImageIndex &index,
+                                               RenderTargetD3D **outRT)
 {
     const int mipLevel = index.mipIndex;
     ASSERT(mipLevel >= 0 && mipLevel < getLevelCount());
@@ -2446,14 +2431,14 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend
     {
         if (!mLevelRenderTargets[mipLevel])
         {
-            ID3D11Resource *texture = nullptr;
-            ANGLE_TRY(getResource(&texture));
+            const TextureHelper11 *texture = nullptr;
+            ANGLE_TRY(getResource(context, &texture));
 
             const d3d11::SharedSRV *srv = nullptr;
-            ANGLE_TRY(getSRVLevel(mipLevel, false, &srv));
+            ANGLE_TRY(getSRVLevel(context, mipLevel, false, &srv));
 
             const d3d11::SharedSRV *blitSRV = nullptr;
-            ANGLE_TRY(getSRVLevel(mipLevel, true, &blitSRV));
+            ANGLE_TRY(getSRVLevel(context, mipLevel, true, &blitSRV));
 
             D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
             rtvDesc.Format                = mFormatInfo.rtvFormat;
@@ -2463,12 +2448,13 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend
             rtvDesc.Texture3D.WSize       = static_cast<UINT>(-1);
 
             d3d11::RenderTargetView rtv;
-            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture, &rtv));
+            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
             rtv.setDebugName("TexStorage3D.RTV");
 
             mLevelRenderTargets[mipLevel] = new TextureRenderTarget11(
-                std::move(rtv), texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(),
-                getLevelWidth(mipLevel), getLevelHeight(mipLevel), getLevelDepth(mipLevel), 0);
+                std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat,
+                getFormatSet(), getLevelWidth(mipLevel), getLevelHeight(mipLevel),
+                getLevelDepth(mipLevel), 0);
         }
 
         ASSERT(outRT);
@@ -2481,8 +2467,8 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend
     LevelLayerKey key(mipLevel, layer);
     if (mLevelLayerRenderTargets.find(key) == mLevelLayerRenderTargets.end())
     {
-        ID3D11Resource *texture = nullptr;
-        ANGLE_TRY(getResource(&texture));
+        const TextureHelper11 *texture = nullptr;
+        ANGLE_TRY(getResource(context, &texture));
 
         // TODO, what kind of SRV is expected here?
         const d3d11::SharedSRV srv;
@@ -2496,11 +2482,11 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend
         rtvDesc.Texture3D.WSize       = 1;
 
         d3d11::RenderTargetView rtv;
-        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture, &rtv));
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
         rtv.setDebugName("TexStorage3D.LayerRTV");
 
         mLevelLayerRenderTargets[key] = new TextureRenderTarget11(
-            std::move(rtv), texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(),
+            std::move(rtv), *texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(),
             getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0);
     }
 
@@ -2509,38 +2495,30 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_3D::getSwizzleTexture(ID3D11Resource **outTexture)
+gl::Error TextureStorage11_3D::getSwizzleTexture(const TextureHelper11 **outTexture)
 {
     ASSERT(outTexture);
 
-    if (!mSwizzleTexture)
+    if (!mSwizzleTexture.valid())
     {
-        ID3D11Device *device = mRenderer->getDevice();
+        const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps());
 
         D3D11_TEXTURE3D_DESC desc;
         desc.Width          = mTextureWidth;
         desc.Height         = mTextureHeight;
         desc.Depth          = mTextureDepth;
         desc.MipLevels      = mMipLevels;
-        desc.Format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).texFormat;
+        desc.Format         = format.texFormat;
         desc.Usage          = D3D11_USAGE_DEFAULT;
         desc.BindFlags      = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
         desc.CPUAccessFlags = 0;
         desc.MiscFlags      = 0;
 
-        HRESULT result = device->CreateTexture3D(&desc, nullptr, &mSwizzleTexture);
-
-        ASSERT(result == E_OUTOFMEMORY || SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create internal swizzle texture, result: 0x%X.", result);
-        }
-
-        d3d11::SetDebugName(mSwizzleTexture, "TexStorage3D.SwizzleTexture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
+        mSwizzleTexture.setDebugName("TexStorage3D.SwizzleTexture");
     }
 
-    *outTexture = mSwizzleTexture;
+    *outTexture = &mSwizzleTexture;
     return gl::NoError();
 }
 
@@ -2552,7 +2530,7 @@ gl::Error TextureStorage11_3D::getSwizzleRenderTarget(int mipLevel,
 
     if (!mSwizzleRenderTargets[mipLevel].valid())
     {
-        ID3D11Resource *swizzleTexture = nullptr;
+        const TextureHelper11 *swizzleTexture = nullptr;
         ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
 
         D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
@@ -2563,7 +2541,7 @@ gl::Error TextureStorage11_3D::getSwizzleRenderTarget(int mipLevel,
         rtvDesc.Texture3D.FirstWSlice = 0;
         rtvDesc.Texture3D.WSize       = static_cast<UINT>(-1);
 
-        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture,
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
                                               &mSwizzleRenderTargets[mipLevel]));
         mSwizzleRenderTargets[mipLevel].setDebugName("TexStorage3D.SwizzleRTV");
     }
@@ -2588,9 +2566,6 @@ TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer11 *renderer,
                               levels),
           internalformat)
 {
-    mTexture        = nullptr;
-    mSwizzleTexture = nullptr;
-
     // adjust size if needed for compressed textures
     d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel);
 
@@ -2600,29 +2575,34 @@ TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer11 *renderer,
     mTextureDepth  = depth;
 }
 
-TextureStorage11_2DArray::~TextureStorage11_2DArray()
+gl::Error TextureStorage11_2DArray::onDestroy(const gl::Context *context)
 {
-    for (ImageMap::iterator i = mAssociatedImages.begin(); i != mAssociatedImages.end(); i++)
+    for (auto iter : mAssociatedImages)
     {
-        if (i->second)
+        if (iter.second)
         {
-            i->second->verifyAssociatedStorageValid(this);
+            iter.second->verifyAssociatedStorageValid(this);
 
             // We must let the Images recover their data before we delete it from the
             // TextureStorage.
-            i->second->recoverFromAssociatedStorage();
+            ANGLE_TRY(iter.second->recoverFromAssociatedStorage(context));
         }
     }
     mAssociatedImages.clear();
 
-    SafeRelease(mTexture);
-    SafeRelease(mSwizzleTexture);
-
-    for (RenderTargetMap::iterator i = mRenderTargets.begin(); i != mRenderTargets.end(); i++)
+    for (auto iter : mRenderTargets)
     {
-        SafeDelete(i->second);
+        SafeDelete(iter.second);
     }
     mRenderTargets.clear();
+
+    delete this;
+
+    return gl::NoError();
+}
+
+TextureStorage11_2DArray::~TextureStorage11_2DArray()
+{
 }
 
 void TextureStorage11_2DArray::associateImage(Image11 *image, const gl::ImageIndex &index)
@@ -2671,7 +2651,8 @@ void TextureStorage11_2DArray::disassociateImage(const gl::ImageIndex &index,
 
 // releaseAssociatedImage prepares the Storage for a new Image association. It lets the old Image
 // recover its data before ending the association.
-gl::Error TextureStorage11_2DArray::releaseAssociatedImage(const gl::ImageIndex &index,
+gl::Error TextureStorage11_2DArray::releaseAssociatedImage(const gl::Context *context,
+                                                           const gl::ImageIndex &index,
                                                            Image11 *incomingImage)
 {
     const GLint level       = index.mipIndex;
@@ -2688,23 +2669,22 @@ gl::Error TextureStorage11_2DArray::releaseAssociatedImage(const gl::ImageIndex
 
             // Force the image to recover from storage before its data is overwritten.
             // This will reset mAssociatedImages[level] to nullptr too.
-            ANGLE_TRY(mAssociatedImages[key]->recoverFromAssociatedStorage());
+            ANGLE_TRY(mAssociatedImages[key]->recoverFromAssociatedStorage(context));
         }
     }
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2DArray::getResource(ID3D11Resource **outResource)
+gl::Error TextureStorage11_2DArray::getResource(const gl::Context *context,
+                                                const TextureHelper11 **outResource)
 {
     // if the width, height or depth is not positive this should be treated as an incomplete texture
     // we handle that here by skipping the d3d texture creation
-    if (mTexture == nullptr && mTextureWidth > 0 && mTextureHeight > 0 && mTextureDepth > 0)
+    if (!mTexture.valid() && mTextureWidth > 0 && mTextureHeight > 0 && mTextureDepth > 0)
     {
         ASSERT(mMipLevels > 0);
 
-        ID3D11Device *device = mRenderer->getDevice();
-
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
@@ -2718,33 +2698,19 @@ gl::Error TextureStorage11_2DArray::getResource(ID3D11Resource **outResource)
         desc.CPUAccessFlags     = 0;
         desc.MiscFlags          = getMiscFlags();
 
-        HRESULT result = device->CreateTexture2D(&desc, nullptr, &mTexture);
-
-        // this can happen from windows TDR
-        if (d3d11::isDeviceLostError(result))
-        {
-            mRenderer->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create 2D array texture storage, result: 0x%X.", result);
-        }
-        else if (FAILED(result))
-        {
-            ASSERT(result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create 2D array texture storage, result: 0x%X.", result);
-        }
-
-        d3d11::SetDebugName(mTexture, "TexStorage2DArray.Texture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, mFormatInfo, &mTexture));
+        mTexture.setDebugName("TexStorage2DArray.Texture");
     }
 
-    *outResource = mTexture;
+    *outResource = &mTexture;
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2DArray::createSRV(int baseLevel,
+gl::Error TextureStorage11_2DArray::createSRV(const gl::Context *context,
+                                              int baseLevel,
                                               int mipLevels,
                                               DXGI_FORMAT format,
-                                              ID3D11Resource *texture,
+                                              const TextureHelper11 &texture,
                                               d3d11::SharedSRV *outSRV) const
 {
     D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
@@ -2755,13 +2721,13 @@ gl::Error TextureStorage11_2DArray::createSRV(int baseLevel,
     srvDesc.Texture2DArray.FirstArraySlice = 0;
     srvDesc.Texture2DArray.ArraySize       = mTextureDepth;
 
-    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture, outSRV));
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
     outSRV->setDebugName("TexStorage2DArray.SRV");
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2DArray::createRenderTargetSRV(ID3D11Resource *texture,
+gl::Error TextureStorage11_2DArray::createRenderTargetSRV(const TextureHelper11 &texture,
                                                           const gl::ImageIndex &index,
                                                           DXGI_FORMAT resourceFormat,
                                                           d3d11::SharedSRV *srv) const
@@ -2774,12 +2740,13 @@ gl::Error TextureStorage11_2DArray::createRenderTargetSRV(ID3D11Resource *textur
     srvDesc.Texture2DArray.FirstArraySlice = index.layerIndex;
     srvDesc.Texture2DArray.ArraySize       = 1;
 
-    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture, srv));
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), srv));
 
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index,
+gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::Context *context,
+                                                    const gl::ImageIndex &index,
                                                     RenderTargetD3D **outRT)
 {
     ASSERT(index.hasLayer());
@@ -2792,18 +2759,18 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index,
     LevelLayerKey key(mipLevel, layer);
     if (mRenderTargets.find(key) == mRenderTargets.end())
     {
-        ID3D11Resource *texture = nullptr;
-        ANGLE_TRY(getResource(&texture));
+        const TextureHelper11 *texture = nullptr;
+        ANGLE_TRY(getResource(context, &texture));
         d3d11::SharedSRV srv;
-        ANGLE_TRY(createRenderTargetSRV(texture, index, mFormatInfo.srvFormat, &srv));
+        ANGLE_TRY(createRenderTargetSRV(*texture, index, mFormatInfo.srvFormat, &srv));
         d3d11::SharedSRV blitSRV;
         if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat)
         {
-            ANGLE_TRY(createRenderTargetSRV(texture, index, mFormatInfo.blitSRVFormat, &blitSRV));
+            ANGLE_TRY(createRenderTargetSRV(*texture, index, mFormatInfo.blitSRVFormat, &blitSRV));
         }
         else
         {
-            blitSRV = srv;
+            blitSRV = srv.makeCopy();
         }
 
         srv.setDebugName("TexStorage2DArray.RenderTargetSRV");
@@ -2818,11 +2785,11 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index,
             rtvDesc.Texture2DArray.ArraySize       = 1;
 
             d3d11::RenderTargetView rtv;
-            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture, &rtv));
+            ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
             rtv.setDebugName("TexStorage2DArray.RenderTargetRTV");
 
             mRenderTargets[key] = new TextureRenderTarget11(
-                std::move(rtv), texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(),
+                std::move(rtv), *texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(),
                 getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0);
         }
         else
@@ -2838,11 +2805,11 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index,
             dsvDesc.Flags                          = 0;
 
             d3d11::DepthStencilView dsv;
-            ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture, &dsv));
+            ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
             dsv.setDebugName("TexStorage2DArray.RenderTargetDSV");
 
             mRenderTargets[key] = new TextureRenderTarget11(
-                std::move(dsv), texture, srv, mFormatInfo.internalFormat, getFormatSet(),
+                std::move(dsv), *texture, srv, mFormatInfo.internalFormat, getFormatSet(),
                 getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0);
         }
     }
@@ -2852,18 +2819,18 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index,
     return gl::NoError();
 }
 
-gl::Error TextureStorage11_2DArray::getSwizzleTexture(ID3D11Resource **outTexture)
+gl::Error TextureStorage11_2DArray::getSwizzleTexture(const TextureHelper11 **outTexture)
 {
-    if (!mSwizzleTexture)
+    if (!mSwizzleTexture.valid())
     {
-        ID3D11Device *device = mRenderer->getDevice();
+        const auto &format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps());
 
         D3D11_TEXTURE2D_DESC desc;
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
         desc.MipLevels          = mMipLevels;
         desc.ArraySize          = mTextureDepth;
-        desc.Format = mFormatInfo.getSwizzleFormat(mRenderer->getRenderer11DeviceCaps()).texFormat;
+        desc.Format             = format.texFormat;
         desc.SampleDesc.Count   = 1;
         desc.SampleDesc.Quality = 0;
         desc.Usage              = D3D11_USAGE_DEFAULT;
@@ -2871,19 +2838,11 @@ gl::Error TextureStorage11_2DArray::getSwizzleTexture(ID3D11Resource **outTextur
         desc.CPUAccessFlags     = 0;
         desc.MiscFlags          = 0;
 
-        HRESULT result = device->CreateTexture2D(&desc, nullptr, &mSwizzleTexture);
-
-        ASSERT(result == E_OUTOFMEMORY || SUCCEEDED(result));
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create internal swizzle texture, result: 0x%X.", result);
-        }
-
-        d3d11::SetDebugName(*outTexture, "TexStorage2DArray.SwizzleTexture");
+        ANGLE_TRY(mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
+        mSwizzleTexture.setDebugName("TexStorage2DArray.SwizzleTexture");
     }
 
-    *outTexture = mSwizzleTexture;
+    *outTexture = &mSwizzleTexture;
     return gl::NoError();
 }
 
@@ -2895,7 +2854,7 @@ gl::Error TextureStorage11_2DArray::getSwizzleRenderTarget(int mipLevel,
 
     if (!mSwizzleRenderTargets[mipLevel].valid())
     {
-        ID3D11Resource *swizzleTexture = nullptr;
+        const TextureHelper11 *swizzleTexture = nullptr;
         ANGLE_TRY(getSwizzleTexture(&swizzleTexture));
 
         D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
@@ -2906,7 +2865,7 @@ gl::Error TextureStorage11_2DArray::getSwizzleRenderTarget(int mipLevel,
         rtvDesc.Texture2DArray.FirstArraySlice = 0;
         rtvDesc.Texture2DArray.ArraySize       = mTextureDepth;
 
-        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture,
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
                                               &mSwizzleRenderTargets[mipLevel]));
     }
 
@@ -2914,10 +2873,10 @@ gl::Error TextureStorage11_2DArray::getSwizzleRenderTarget(int mipLevel,
     return gl::NoError();
 }
 
-gl::ErrorOrResult<TextureStorage11::DropStencil>
-TextureStorage11_2DArray::ensureDropStencilTexture()
+gl::ErrorOrResult<TextureStorage11::DropStencil> TextureStorage11_2DArray::ensureDropStencilTexture(
+    const gl::Context *context)
 {
-    if (mDropStencilTexture)
+    if (mDropStencilTexture.valid())
     {
         return DropStencil::ALREADY_EXISTS;
     }
@@ -2935,21 +2894,226 @@ TextureStorage11_2DArray::ensureDropStencilTexture()
     dropDesc.Usage                = D3D11_USAGE_DEFAULT;
     dropDesc.Width                = mTextureWidth;
 
-    ID3D11Device *device = mRenderer->getDevice();
-
-    HRESULT hr = device->CreateTexture2D(&dropDesc, nullptr, &mDropStencilTexture);
-    if (FAILED(hr))
-    {
-        return gl::InternalError() << "Error creating drop stencil texture.";
-    }
-    d3d11::SetDebugName(mDropStencilTexture, "TexStorage2DArray.DropStencil");
+    const auto &format =
+        d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps());
+    ANGLE_TRY(mRenderer->allocateTexture(dropDesc, format, &mDropStencilTexture));
+    mDropStencilTexture.setDebugName("TexStorage2DArray.DropStencil");
 
     std::vector<GLsizei> layerCounts(mMipLevels, mTextureDepth);
 
     ANGLE_TRY(initDropStencilTexture(
-        gl::ImageIndexIterator::Make2DArray(0, mMipLevels, layerCounts.data())));
+        context, gl::ImageIndexIterator::Make2DArray(0, mMipLevels, layerCounts.data())));
 
     return DropStencil::CREATED;
 }
 
+TextureStorage11_2DMultisample::TextureStorage11_2DMultisample(Renderer11 *renderer,
+                                                               GLenum internalformat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               int levels,
+                                                               int samples,
+                                                               GLboolean fixedSampleLocations)
+    : TextureStorage11(
+          renderer,
+          GetTextureBindFlags(internalformat, renderer->getRenderer11DeviceCaps(), true),
+          GetTextureMiscFlags(internalformat, renderer->getRenderer11DeviceCaps(), true, levels),
+          internalformat),
+      mTexture(),
+      mRenderTarget(nullptr)
+{
+    // adjust size if needed for compressed textures
+    d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel);
+
+    mMipLevels            = 1;
+    mTextureWidth         = width;
+    mTextureHeight        = height;
+    mTextureDepth         = 1;
+    mSamples              = samples;
+    mFixedSampleLocations = fixedSampleLocations;
+}
+
+gl::Error TextureStorage11_2DMultisample::onDestroy(const gl::Context *context)
+{
+    mRenderTarget.reset();
+    delete this;
+
+    return gl::NoError();
+}
+
+TextureStorage11_2DMultisample::~TextureStorage11_2DMultisample()
+{
+}
+
+gl::Error TextureStorage11_2DMultisample::copyToStorage(const gl::Context *context,
+                                                        TextureStorage *destStorage)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "copyToStorage is unimplemented";
+}
+
+void TextureStorage11_2DMultisample::associateImage(Image11 *image, const gl::ImageIndex &index)
+{
+}
+
+void TextureStorage11_2DMultisample::verifyAssociatedImageValid(const gl::ImageIndex &index,
+                                                                Image11 *expectedImage)
+{
+}
+
+void TextureStorage11_2DMultisample::disassociateImage(const gl::ImageIndex &index,
+                                                       Image11 *expectedImage)
+{
+}
+
+gl::Error TextureStorage11_2DMultisample::releaseAssociatedImage(const gl::Context *context,
+                                                                 const gl::ImageIndex &index,
+                                                                 Image11 *incomingImage)
+{
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::getResource(const gl::Context *context,
+                                                      const TextureHelper11 **outResource)
+{
+    ANGLE_TRY(ensureTextureExists(1));
+
+    *outResource = &mTexture;
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::ensureTextureExists(int mipLevels)
+{
+    // For Multisampled textures, mipLevels always equals 1.
+    ASSERT(mipLevels == 1);
+
+    // 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
+    if (!mTexture.valid() && mTextureWidth > 0 && mTextureHeight > 0)
+    {
+        D3D11_TEXTURE2D_DESC desc;
+        ZeroMemory(&desc, sizeof(desc));
+        desc.Width          = mTextureWidth;  // Compressed texture size constraints?
+        desc.Height         = mTextureHeight;
+        desc.MipLevels      = mipLevels;
+        desc.ArraySize      = 1;
+        desc.Format         = mFormatInfo.texFormat;
+        desc.Usage          = D3D11_USAGE_DEFAULT;
+        desc.BindFlags      = getBindFlags();
+        desc.CPUAccessFlags = 0;
+        desc.MiscFlags      = getMiscFlags();
+
+        const gl::TextureCaps &textureCaps =
+            mRenderer->getNativeTextureCaps().get(mFormatInfo.internalFormat);
+        GLuint supportedSamples = textureCaps.getNearestSamples(mSamples);
+        desc.SampleDesc.Count   = (supportedSamples == 0) ? 1 : supportedSamples;
+        desc.SampleDesc.Quality = 0;
+
+        ANGLE_TRY(mRenderer->allocateTexture(desc, mFormatInfo, &mTexture));
+        mTexture.setDebugName("TexStorage2DMS.Texture");
+    }
+
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::getRenderTarget(const gl::Context *context,
+                                                          const gl::ImageIndex &index,
+                                                          RenderTargetD3D **outRT)
+{
+    ASSERT(!index.hasLayer());
+
+    const int level = index.mipIndex;
+    ASSERT(level == 0);
+
+    ASSERT(outRT);
+    if (mRenderTarget)
+    {
+        *outRT = mRenderTarget.get();
+        return gl::NoError();
+    }
+
+    const TextureHelper11 *texture = nullptr;
+    ANGLE_TRY(getResource(context, &texture));
+
+    const d3d11::SharedSRV *srv = nullptr;
+    ANGLE_TRY(getSRVLevel(context, level, false, &srv));
+
+    const d3d11::SharedSRV *blitSRV = nullptr;
+    ANGLE_TRY(getSRVLevel(context, level, true, &blitSRV));
+
+    if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN)
+    {
+        D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
+        rtvDesc.Format        = mFormatInfo.rtvFormat;
+        rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
+
+        d3d11::RenderTargetView rtv;
+        ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
+
+        mRenderTarget.reset(new TextureRenderTarget11(
+            std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(),
+            getLevelWidth(level), getLevelHeight(level), 1, mSamples));
+
+        *outRT = mRenderTarget.get();
+        return gl::NoError();
+    }
+
+    ASSERT(mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN);
+
+    D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
+    dsvDesc.Format        = mFormatInfo.dsvFormat;
+    dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
+    dsvDesc.Flags         = 0;
+
+    d3d11::DepthStencilView dsv;
+    ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
+
+    mRenderTarget.reset(new TextureRenderTarget11(
+        std::move(dsv), *texture, *srv, mFormatInfo.internalFormat, getFormatSet(),
+        getLevelWidth(level), getLevelHeight(level), 1, mSamples));
+
+    *outRT = mRenderTarget.get();
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::createSRV(const gl::Context *context,
+                                                    int baseLevel,
+                                                    int mipLevels,
+                                                    DXGI_FORMAT format,
+                                                    const TextureHelper11 &texture,
+                                                    d3d11::SharedSRV *outSRV) const
+{
+    ASSERT(outSRV);
+
+    D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
+    srvDesc.Format        = format;
+    srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
+
+    ANGLE_TRY(mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
+    outSRV->setDebugName("TexStorage2DMS.SRV");
+
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11_2DMultisample::getSwizzleTexture(const TextureHelper11 **outTexture)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "getSwizzleTexture is unimplemented.";
+}
+
+gl::Error TextureStorage11_2DMultisample::getSwizzleRenderTarget(
+    int mipLevel,
+    const d3d11::RenderTargetView **outRTV)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "getSwizzleRenderTarget is unimplemented.";
+}
+
+gl::ErrorOrResult<TextureStorage11::DropStencil>
+TextureStorage11_2DMultisample::ensureDropStencilTexture(const gl::Context *context)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "Drop stencil texture not implemented.";
+}
+
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h
index 4be8988e07a..1f28f76fd06 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h
@@ -13,7 +13,7 @@
 #include "libANGLE/Error.h"
 #include "libANGLE/Texture.h"
 #include "libANGLE/renderer/d3d/TextureStorage.h"
-#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
+#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
 #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
 
 #include <array>
@@ -45,16 +45,25 @@ class TextureStorage11 : public TextureStorage
     UINT getBindFlags() const;
     UINT getMiscFlags() const;
     const d3d11::Format &getFormatSet() const;
-    gl::Error getSRVLevels(GLint baseLevel, GLint maxLevel, d3d11::SharedSRV *outSRV);
-    gl::Error generateSwizzles(const gl::SwizzleState &swizzleTarget);
+    gl::Error getSRVLevels(const gl::Context *context,
+                           GLint baseLevel,
+                           GLint maxLevel,
+                           const d3d11::SharedSRV **outSRV);
+    gl::Error generateSwizzles(const gl::Context *context, const gl::SwizzleState &swizzleTarget);
     void markLevelDirty(int mipLevel);
     void markDirty();
 
-    gl::Error updateSubresourceLevel(ID3D11Resource *texture, unsigned int sourceSubresource,
-                                     const gl::ImageIndex &index, const gl::Box &copyArea);
+    gl::Error updateSubresourceLevel(const gl::Context *context,
+                                     const TextureHelper11 &texture,
+                                     unsigned int sourceSubresource,
+                                     const gl::ImageIndex &index,
+                                     const gl::Box &copyArea);
 
-    gl::Error copySubresourceLevel(ID3D11Resource* dstTexture, unsigned int dstSubresource,
-                                   const gl::ImageIndex &index, const gl::Box &region);
+    gl::Error copySubresourceLevel(const gl::Context *context,
+                                   const TextureHelper11 &dstTexture,
+                                   unsigned int dstSubresource,
+                                   const gl::ImageIndex &index,
+                                   const gl::Box &region);
 
     // TextureStorage virtual functions
     int getTopLevel() const override;
@@ -62,24 +71,31 @@ class TextureStorage11 : public TextureStorage
     bool isManaged() const override;
     bool supportsNativeMipmapFunction() const override;
     int getLevelCount() const override;
-    gl::Error generateMipmap(const gl::ImageIndex &sourceIndex,
+    gl::Error generateMipmap(const gl::Context *context,
+                             const gl::ImageIndex &sourceIndex,
                              const gl::ImageIndex &destIndex) override;
-    gl::Error copyToStorage(TextureStorage *destStorage) override;
-    gl::Error setData(const gl::ImageIndex &index,
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
+    gl::Error setData(const gl::Context *context,
+                      const gl::ImageIndex &index,
                       ImageD3D *image,
                       const gl::Box *destBox,
                       GLenum type,
                       const gl::PixelUnpackState &unpack,
                       const uint8_t *pixelData) override;
 
-    virtual gl::Error getSRV(const gl::TextureState &textureState, d3d11::SharedSRV *outSRV);
+    virtual gl::Error getSRV(const gl::Context *context,
+                             const gl::TextureState &textureState,
+                             const d3d11::SharedSRV **outSRV);
     virtual UINT getSubresourceIndex(const gl::ImageIndex &index) const;
-    virtual gl::Error getResource(ID3D11Resource **outResource) = 0;
+    virtual gl::Error getResource(const gl::Context *context,
+                                  const TextureHelper11 **outResource) = 0;
     virtual void associateImage(Image11* image, const gl::ImageIndex &index) = 0;
     virtual void disassociateImage(const gl::ImageIndex &index, Image11* expectedImage) = 0;
     virtual void verifyAssociatedImageValid(const gl::ImageIndex &index,
                                             Image11 *expectedImage) = 0;
-    virtual gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11* incomingImage) = 0;
+    virtual gl::Error releaseAssociatedImage(const gl::Context *context,
+                                             const gl::ImageIndex &index,
+                                             Image11 *incomingImage) = 0;
 
   protected:
     TextureStorage11(Renderer11 *renderer, UINT bindFlags, UINT miscFlags, GLenum internalFormat);
@@ -88,12 +104,19 @@ class TextureStorage11 : public TextureStorage
     int getLevelDepth(int mipLevel) const;
 
     // Some classes (e.g. TextureStorage11_2D) will override getMippedResource.
-    virtual gl::Error getMippedResource(ID3D11Resource **outResource) { return getResource(outResource); }
+    virtual gl::Error getMippedResource(const gl::Context *context,
+                                        const TextureHelper11 **outResource)
+    {
+        return getResource(context, outResource);
+    }
 
-    virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture) = 0;
+    virtual gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) = 0;
     virtual gl::Error getSwizzleRenderTarget(int mipLevel,
                                              const d3d11::RenderTargetView **outRTV) = 0;
-    gl::Error getSRVLevel(int mipLevel, bool blitSRV, const d3d11::SharedSRV **outSRV);
+    gl::Error getSRVLevel(const gl::Context *context,
+                          int mipLevel,
+                          bool blitSRV,
+                          const d3d11::SharedSRV **outSRV);
 
     // Get a version of a depth texture with only depth information, not stencil.
     enum DropStencil
@@ -101,14 +124,15 @@ class TextureStorage11 : public TextureStorage
         CREATED,
         ALREADY_EXISTS
     };
-    virtual gl::ErrorOrResult<DropStencil> ensureDropStencilTexture();
-    gl::Error initDropStencilTexture(const gl::ImageIndexIterator &it);
+    virtual gl::ErrorOrResult<DropStencil> ensureDropStencilTexture(const gl::Context *context);
+    gl::Error initDropStencilTexture(const gl::Context *context, const gl::ImageIndexIterator &it);
 
     // The baseLevel parameter should *not* have mTopLevel applied.
-    virtual gl::Error createSRV(int baseLevel,
+    virtual gl::Error createSRV(const gl::Context *context,
+                                int baseLevel,
                                 int mipLevels,
                                 DXGI_FORMAT format,
-                                ID3D11Resource *texture,
+                                const TextureHelper11 &texture,
                                 d3d11::SharedSRV *outSRV) const = 0;
 
     void verifySwizzleExists(const gl::SwizzleState &swizzleState);
@@ -126,7 +150,7 @@ class TextureStorage11 : public TextureStorage
     unsigned int mTextureDepth;
 
     gl::SwizzleState mSwizzleCache[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
-    ID3D11Texture2D *mDropStencilTexture;
+    TextureHelper11 mDropStencilTexture;
 
   private:
     const UINT mBindFlags;
@@ -145,7 +169,9 @@ class TextureStorage11 : public TextureStorage
     };
     typedef std::map<SRVKey, d3d11::SharedSRV> SRVCache;
 
-    gl::Error getCachedOrCreateSRV(const SRVKey &key, d3d11::SharedSRV *outSRV);
+    gl::Error getCachedOrCreateSRV(const gl::Context *context,
+                                   const SRVKey &key,
+                                   const d3d11::SharedSRV **outSRV);
 
     SRVCache mSrvCache;
     std::array<d3d11::SharedSRV, gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS> mLevelSRVs;
@@ -159,35 +185,43 @@ class TextureStorage11_2D : public TextureStorage11
     TextureStorage11_2D(Renderer11 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels, bool hintLevelZeroOnly = false);
     ~TextureStorage11_2D() override;
 
-    gl::Error getResource(ID3D11Resource **outResource) override;
-    gl::Error getMippedResource(ID3D11Resource **outResource) override;
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
+    gl::Error getMippedResource(const gl::Context *context,
+                                const TextureHelper11 **outResource) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
-    gl::Error copyToStorage(TextureStorage *destStorage) override;
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
 
     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
-    gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11 *incomingImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
 
     gl::Error useLevelZeroWorkaroundTexture(bool useLevelZeroTexture) override;
 
   protected:
-    gl::Error getSwizzleTexture(ID3D11Resource **outTexture) override;
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
     gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
 
-    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture() override;
+    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture(const gl::Context *context) override;
 
     gl::Error ensureTextureExists(int mipLevels);
 
   private:
-    gl::Error createSRV(int baseLevel,
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
                         int mipLevels,
                         DXGI_FORMAT format,
-                        ID3D11Resource *texture,
+                        const TextureHelper11 &texture,
                         d3d11::SharedSRV *outSRV) const override;
 
-    ID3D11Texture2D *mTexture;
+    TextureHelper11 mTexture;
     RenderTarget11 *mRenderTarget[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
     bool mHasKeyedMutex;
 
@@ -200,12 +234,12 @@ class TextureStorage11_2D : public TextureStorage11
     // One example of this is an application that creates a texture, calls glGenerateMipmap, and then disables mipmaps on the texture.
     // A more likely example is an app that creates an empty texture, renders to it, and then calls glGenerateMipmap
     // TODO: In this rendering scenario, release the mLevelZeroTexture after mTexture has been created to save memory.
-    ID3D11Texture2D *mLevelZeroTexture;
+    TextureHelper11 mLevelZeroTexture;
     RenderTarget11 *mLevelZeroRenderTarget;
     bool mUseLevelZeroTexture;
 
     // Swizzle-related variables
-    ID3D11Texture2D *mSwizzleTexture;
+    TextureHelper11 mSwizzleTexture;
     d3d11::RenderTargetView mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
     Image11 *mAssociatedImages[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
@@ -219,29 +253,37 @@ class TextureStorage11_External : public TextureStorage11
                               const egl::Stream::GLTextureDescription &glDesc);
     ~TextureStorage11_External() override;
 
-    gl::Error getResource(ID3D11Resource **outResource) override;
-    gl::Error getMippedResource(ID3D11Resource **outResource) override;
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error onDestroy(const gl::Context *context) override;
 
-    gl::Error copyToStorage(TextureStorage *destStorage) override;
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
+    gl::Error getMippedResource(const gl::Context *context,
+                                const TextureHelper11 **outResource) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
+
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
 
     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
-    gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11 *incomingImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
 
   protected:
-    gl::Error getSwizzleTexture(ID3D11Resource **outTexture) override;
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
     gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
 
   private:
-    gl::Error createSRV(int baseLevel,
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
                         int mipLevels,
                         DXGI_FORMAT format,
-                        ID3D11Resource *texture,
+                        const TextureHelper11 &texture,
                         d3d11::SharedSRV *outSRV) const override;
 
-    ID3D11Texture2D *mTexture;
+    TextureHelper11 mTexture;
     int mSubresourceIndex;
     bool mHasKeyedMutex;
 
@@ -256,42 +298,50 @@ class TextureStorage11_EGLImage final : public TextureStorage11
                               RenderTarget11 *renderTarget11);
     ~TextureStorage11_EGLImage() override;
 
-    gl::Error getResource(ID3D11Resource **outResource) override;
-    gl::Error getSRV(const gl::TextureState &textureState, d3d11::SharedSRV *outSRV) override;
-    gl::Error getMippedResource(ID3D11Resource **outResource) override;
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
+    gl::Error getSRV(const gl::Context *context,
+                     const gl::TextureState &textureState,
+                     const d3d11::SharedSRV **outSRV) override;
+    gl::Error getMippedResource(const gl::Context *context,
+                                const TextureHelper11 **outResource) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
-    gl::Error copyToStorage(TextureStorage *destStorage) override;
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
 
     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
-    gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11 *incomingImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
 
     gl::Error useLevelZeroWorkaroundTexture(bool useLevelZeroTexture) override;
 
   protected:
-    gl::Error getSwizzleTexture(ID3D11Resource **outTexture) override;
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
     gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
 
   private:
     // Check if the EGL image's render target has been updated due to orphaning and delete
     // any SRVs and other resources based on the image's old render target.
-    gl::Error checkForUpdatedRenderTarget();
+    gl::Error checkForUpdatedRenderTarget(const gl::Context *context);
 
-    gl::Error createSRV(int baseLevel,
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
                         int mipLevels,
                         DXGI_FORMAT format,
-                        ID3D11Resource *texture,
+                        const TextureHelper11 &texture,
                         d3d11::SharedSRV *outSRV) const override;
 
-    gl::Error getImageRenderTarget(RenderTarget11 **outRT) const;
+    gl::Error getImageRenderTarget(const gl::Context *context, RenderTarget11 **outRT) const;
 
     EGLImageD3D *mImage;
     uintptr_t mCurrentRenderTarget;
 
     // Swizzle-related variables
-    ID3D11Texture2D *mSwizzleTexture;
+    TextureHelper11 mSwizzleTexture;
     std::vector<d3d11::RenderTargetView> mSwizzleRenderTargets;
 };
 
@@ -301,51 +351,59 @@ class TextureStorage11_Cube : public TextureStorage11
     TextureStorage11_Cube(Renderer11 *renderer, GLenum internalformat, bool renderTarget, int size, int levels, bool hintLevelZeroOnly);
     ~TextureStorage11_Cube() override;
 
+    gl::Error onDestroy(const gl::Context *context) override;
+
     UINT getSubresourceIndex(const gl::ImageIndex &index) const override;
 
-    gl::Error getResource(ID3D11Resource **outResource) override;
-    gl::Error getMippedResource(ID3D11Resource **outResource) override;
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
+    gl::Error getMippedResource(const gl::Context *context,
+                                const TextureHelper11 **outResource) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
-    gl::Error copyToStorage(TextureStorage *destStorage) override;
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
 
     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
-    gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11 *incomingImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
 
     gl::Error useLevelZeroWorkaroundTexture(bool useLevelZeroTexture) override;
 
   protected:
-    gl::Error getSwizzleTexture(ID3D11Resource **outTexture) override;
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
     gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
 
-    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture() override;
+    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture(const gl::Context *context) override;
 
     gl::Error ensureTextureExists(int mipLevels);
 
   private:
-    gl::Error createSRV(int baseLevel,
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
                         int mipLevels,
                         DXGI_FORMAT format,
-                        ID3D11Resource *texture,
+                        const TextureHelper11 &texture,
                         d3d11::SharedSRV *outSRV) const override;
-    gl::Error createRenderTargetSRV(ID3D11Resource *texture,
+    gl::Error createRenderTargetSRV(const TextureHelper11 &texture,
                                     const gl::ImageIndex &index,
                                     DXGI_FORMAT resourceFormat,
                                     d3d11::SharedSRV *srv) const;
 
     static const size_t CUBE_FACE_COUNT = 6;
 
-    ID3D11Texture2D *mTexture;
+    TextureHelper11 mTexture;
     RenderTarget11 *mRenderTarget[CUBE_FACE_COUNT][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
     // Level-zero workaround members. See TextureStorage11_2D's workaround members for a description.
-    ID3D11Texture2D *mLevelZeroTexture;
+    TextureHelper11 mLevelZeroTexture;
     RenderTarget11 *mLevelZeroRenderTarget[CUBE_FACE_COUNT];
     bool mUseLevelZeroTexture;
 
-    ID3D11Texture2D *mSwizzleTexture;
+    TextureHelper11 mSwizzleTexture;
     d3d11::RenderTargetView mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
     Image11 *mAssociatedImages[CUBE_FACE_COUNT][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
@@ -358,25 +416,32 @@ class TextureStorage11_3D : public TextureStorage11
                         GLsizei width, GLsizei height, GLsizei depth, int levels);
     ~TextureStorage11_3D() override;
 
-    gl::Error getResource(ID3D11Resource **outResource) override;
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
 
     // Handles both layer and non-layer RTs
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
-    gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11 *incomingImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
 
   protected:
-    gl::Error getSwizzleTexture(ID3D11Resource **outTexture) override;
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
     gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
 
   private:
-    gl::Error createSRV(int baseLevel,
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
                         int mipLevels,
                         DXGI_FORMAT format,
-                        ID3D11Resource *texture,
+                        const TextureHelper11 &texture,
                         d3d11::SharedSRV *outSRV) const override;
 
     typedef std::pair<int, int> LevelLayerKey;
@@ -385,8 +450,8 @@ class TextureStorage11_3D : public TextureStorage11
 
     RenderTarget11 *mLevelRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
-    ID3D11Texture3D *mTexture;
-    ID3D11Texture3D *mSwizzleTexture;
+    TextureHelper11 mTexture;
+    TextureHelper11 mSwizzleTexture;
     d3d11::RenderTargetView mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
     Image11 *mAssociatedImages[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
@@ -399,27 +464,34 @@ class TextureStorage11_2DArray : public TextureStorage11
                              GLsizei width, GLsizei height, GLsizei depth, int levels);
     ~TextureStorage11_2DArray() override;
 
-    gl::Error getResource(ID3D11Resource **outResource) override;
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
 
     void associateImage(Image11 *image, const gl::ImageIndex &index) override;
     void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
     void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
-    gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11 *incomingImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
 
   protected:
-    gl::Error getSwizzleTexture(ID3D11Resource **outTexture) override;
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
     gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
 
-    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture() override;
+    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture(const gl::Context *context) override;
 
   private:
-    gl::Error createSRV(int baseLevel,
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
                         int mipLevels,
                         DXGI_FORMAT format,
-                        ID3D11Resource *texture,
+                        const TextureHelper11 &texture,
                         d3d11::SharedSRV *outSRV) const override;
-    gl::Error createRenderTargetSRV(ID3D11Resource *texture,
+    gl::Error createRenderTargetSRV(const TextureHelper11 &texture,
                                     const gl::ImageIndex &index,
                                     DXGI_FORMAT resourceFormat,
                                     d3d11::SharedSRV *srv) const;
@@ -428,15 +500,65 @@ class TextureStorage11_2DArray : public TextureStorage11
     typedef std::map<LevelLayerKey, RenderTarget11*> RenderTargetMap;
     RenderTargetMap mRenderTargets;
 
-    ID3D11Texture2D *mTexture;
+    TextureHelper11 mTexture;
 
-    ID3D11Texture2D *mSwizzleTexture;
+    TextureHelper11 mSwizzleTexture;
     d3d11::RenderTargetView mSwizzleRenderTargets[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 
     typedef std::map<LevelLayerKey, Image11*> ImageMap;
     ImageMap mAssociatedImages;
 };
 
+class TextureStorage11_2DMultisample : public TextureStorage11
+{
+  public:
+    TextureStorage11_2DMultisample(Renderer11 *renderer,
+                                   GLenum internalformat,
+                                   GLsizei width,
+                                   GLsizei height,
+                                   int levels,
+                                   int samples,
+                                   GLboolean fixedSampleLocations);
+    ~TextureStorage11_2DMultisample() override;
+
+    gl::Error onDestroy(const gl::Context *context) override;
+
+    gl::Error getResource(const gl::Context *context, const TextureHelper11 **outResource) override;
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
+
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
+
+    void associateImage(Image11 *image, const gl::ImageIndex &index) override;
+    void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override;
+    void verifyAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override;
+    gl::Error releaseAssociatedImage(const gl::Context *context,
+                                     const gl::ImageIndex &index,
+                                     Image11 *incomingImage) override;
+
+  protected:
+    gl::Error getSwizzleTexture(const TextureHelper11 **outTexture) override;
+    gl::Error getSwizzleRenderTarget(int mipLevel, const d3d11::RenderTargetView **outRTV) override;
+
+    gl::ErrorOrResult<DropStencil> ensureDropStencilTexture(const gl::Context *context) override;
+
+    gl::Error ensureTextureExists(int mipLevels);
+
+  private:
+    gl::Error createSRV(const gl::Context *context,
+                        int baseLevel,
+                        int mipLevels,
+                        DXGI_FORMAT format,
+                        const TextureHelper11 &texture,
+                        d3d11::SharedSRV *outSRV) const override;
+
+    TextureHelper11 mTexture;
+    std::unique_ptr<RenderTarget11> mRenderTarget;
+
+    unsigned int mSamples;
+    GLboolean mFixedSampleLocations;
+};
 }
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_TEXTURESTORAGE11_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp
index 39b293f9b09..240d6d26fac 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp
@@ -31,6 +31,20 @@ TransformFeedback11::~TransformFeedback11()
 
 void TransformFeedback11::begin(GLenum primitiveMode)
 {
+    // Reset all the cached offsets to the binding offsets
+    mIsDirty = true;
+    for (size_t bindingIdx = 0; bindingIdx < mBuffers.size(); bindingIdx++)
+    {
+        const auto &binding = mState.getIndexedBuffer(bindingIdx);
+        if (binding.get() != nullptr)
+        {
+            mBufferOffsets[bindingIdx] = static_cast<UINT>(binding.getOffset());
+        }
+        else
+        {
+            mBufferOffsets[bindingIdx] = 0;
+        }
+    }
 }
 
 void TransformFeedback11::end()
@@ -49,12 +63,12 @@ void TransformFeedback11::resume()
 {
 }
 
-void TransformFeedback11::bindGenericBuffer(const BindingPointer<gl::Buffer> &binding)
+void TransformFeedback11::bindGenericBuffer(const gl::BindingPointer<gl::Buffer> &binding)
 {
 }
 
 void TransformFeedback11::bindIndexedBuffer(size_t index,
-                                            const OffsetBindingPointer<gl::Buffer> &binding)
+                                            const gl::OffsetBindingPointer<gl::Buffer> &binding)
 {
     mIsDirty              = true;
     mBufferOffsets[index] = static_cast<UINT>(binding.getOffset());
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h
index 01879d6f3af..8a7cdd19750 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h
@@ -31,8 +31,9 @@ class TransformFeedback11 : public TransformFeedbackImpl
     void pause() override;
     void resume() override;
 
-    void bindGenericBuffer(const BindingPointer<gl::Buffer> &binding) override;
-    void bindIndexedBuffer(size_t index, const OffsetBindingPointer<gl::Buffer> &binding) override;
+    void bindGenericBuffer(const gl::BindingPointer<gl::Buffer> &binding) override;
+    void bindIndexedBuffer(size_t index,
+                           const gl::OffsetBindingPointer<gl::Buffer> &binding) override;
 
     void onApply();
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp
index 73814a7aa2a..4697a87cc25 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.cpp
@@ -10,7 +10,9 @@
 #include "libANGLE/renderer/d3d/d3d11/VertexArray11.h"
 
 #include "common/bitset_utils.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/renderer/d3d/d3d11/Buffer11.h"
+#include "libANGLE/renderer/d3d/d3d11/Context11.h"
 
 using namespace angle;
 
@@ -29,34 +31,35 @@ VertexArray11::VertexArray11(const gl::VertexArrayState &data)
     }
 }
 
-VertexArray11::~VertexArray11()
+void VertexArray11::destroy(const gl::Context *context)
 {
     for (auto &buffer : mCurrentBuffers)
     {
         if (buffer.get())
         {
-            buffer.set(nullptr);
+            buffer.set(context, nullptr);
         }
     }
 }
 
-void VertexArray11::syncState(ContextImpl *contextImpl, const gl::VertexArray::DirtyBits &dirtyBits)
+void VertexArray11::syncState(const gl::Context *context,
+                              const gl::VertexArray::DirtyBits &dirtyBits)
 {
     for (auto dirtyBit : dirtyBits)
     {
         if (dirtyBit == gl::VertexArray::DIRTY_BIT_ELEMENT_ARRAY_BUFFER)
             continue;
 
-        size_t index = gl::VertexArray::GetAttribIndex(dirtyBit);
+        size_t index = gl::VertexArray::GetVertexIndexFromDirtyBit(dirtyBit);
         // TODO(jiawei.shao@intel.com): Vertex Attrib Bindings
         ASSERT(index == mData.getBindingIndexFromAttribIndex(index));
         mAttribsToUpdate.set(index);
     }
 }
 
-void VertexArray11::flushAttribUpdates(const gl::State &state)
+void VertexArray11::flushAttribUpdates(const gl::Context *context)
 {
-    const gl::Program *program  = state.getProgram();
+    const gl::Program *program  = context->getGLState().getProgram();
     const auto &activeLocations = program->getActiveAttribLocationsMask();
 
     if (mAttribsToUpdate.any())
@@ -67,12 +70,12 @@ void VertexArray11::flushAttribUpdates(const gl::State &state)
         for (auto toUpdateIndex : activeToUpdate)
         {
             mAttribsToUpdate.reset(toUpdateIndex);
-            updateVertexAttribStorage(toUpdateIndex);
+            updateVertexAttribStorage(context, toUpdateIndex);
         }
     }
 }
 
-void VertexArray11::updateVertexAttribStorage(size_t attribIndex)
+void VertexArray11::updateVertexAttribStorage(const gl::Context *context, size_t attribIndex)
 {
     const auto &attrib = mData.getVertexAttribute(attribIndex);
     const auto &binding = mData.getBindingFromAttribIndex(attribIndex);
@@ -104,7 +107,7 @@ void VertexArray11::updateVertexAttribStorage(size_t attribIndex)
     }
 
     gl::Buffer *oldBufferGL = mCurrentBuffers[attribIndex].get();
-    gl::Buffer *newBufferGL = binding.buffer.get();
+    gl::Buffer *newBufferGL = binding.getBuffer().get();
     Buffer11 *oldBuffer11   = oldBufferGL ? GetImplAs<Buffer11>(oldBufferGL) : nullptr;
     Buffer11 *newBuffer11   = newBufferGL ? GetImplAs<Buffer11>(newBufferGL) : nullptr;
 
@@ -129,25 +132,26 @@ void VertexArray11::updateVertexAttribStorage(size_t attribIndex)
             }
         }
         mOnBufferDataDirty[attribIndex].bind(newChannel);
-        mCurrentBuffers[attribIndex] = binding.buffer;
+        mCurrentBuffers[attribIndex].set(context, binding.getBuffer().get());
     }
 }
 
-bool VertexArray11::hasDynamicAttrib(const gl::State &state)
+bool VertexArray11::hasDynamicAttrib(const gl::Context *context)
 {
-    flushAttribUpdates(state);
+    flushAttribUpdates(context);
     return mDynamicAttribsMask.any();
 }
 
-gl::Error VertexArray11::updateDirtyAndDynamicAttribs(VertexDataManager *vertexDataManager,
-                                                      const gl::State &state,
+gl::Error VertexArray11::updateDirtyAndDynamicAttribs(const gl::Context *context,
+                                                      VertexDataManager *vertexDataManager,
                                                       GLint start,
                                                       GLsizei count,
                                                       GLsizei instances)
 {
-    flushAttribUpdates(state);
+    flushAttribUpdates(context);
 
-    const gl::Program *program  = state.getProgram();
+    const auto &glState         = context->getGLState();
+    const gl::Program *program  = glState.getProgram();
     const auto &activeLocations = program->getActiveAttribLocationsMask();
     const auto &attribs         = mData.getVertexAttributes();
     const auto &bindings        = mData.getVertexBindings();
@@ -162,13 +166,13 @@ gl::Error VertexArray11::updateDirtyAndDynamicAttribs(VertexDataManager *vertexD
             mAttribsToTranslate.reset(dirtyAttribIndex);
 
             auto *translatedAttrib = &mTranslatedAttribs[dirtyAttribIndex];
-            const auto &currentValue = state.getVertexAttribCurrentValue(dirtyAttribIndex);
+            const auto &currentValue = glState.getVertexAttribCurrentValue(dirtyAttribIndex);
 
             // Record basic attrib info
             translatedAttrib->attribute = &attribs[dirtyAttribIndex];
             translatedAttrib->binding   = &bindings[translatedAttrib->attribute->bindingIndex];
             translatedAttrib->currentValueType = currentValue.Type;
-            translatedAttrib->divisor          = translatedAttrib->binding->divisor;
+            translatedAttrib->divisor          = translatedAttrib->binding->getDivisor();
 
             switch (mAttributeStorageTypes[dirtyAttribIndex])
             {
@@ -197,13 +201,13 @@ gl::Error VertexArray11::updateDirtyAndDynamicAttribs(VertexDataManager *vertexD
         for (auto dynamicAttribIndex : activeDynamicAttribs)
         {
             auto *dynamicAttrib = &mTranslatedAttribs[dynamicAttribIndex];
-            const auto &currentValue = state.getVertexAttribCurrentValue(dynamicAttribIndex);
+            const auto &currentValue = glState.getVertexAttribCurrentValue(dynamicAttribIndex);
 
             // Record basic attrib info
             dynamicAttrib->attribute        = &attribs[dynamicAttribIndex];
             dynamicAttrib->binding          = &bindings[dynamicAttrib->attribute->bindingIndex];
             dynamicAttrib->currentValueType = currentValue.Type;
-            dynamicAttrib->divisor          = dynamicAttrib->binding->divisor;
+            dynamicAttrib->divisor          = dynamicAttrib->binding->getDivisor();
         }
 
         return vertexDataManager->storeDynamicAttribs(&mTranslatedAttribs, activeDynamicAttribs,
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.h
index 4fda4341920..449ca596958 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexArray11.h
@@ -22,13 +22,14 @@ class VertexArray11 : public VertexArrayImpl, public OnBufferDataDirtyReceiver
 {
   public:
     VertexArray11(const gl::VertexArrayState &data);
-    ~VertexArray11() override;
+    void destroy(const gl::Context *context) override;
 
-    void syncState(ContextImpl *contextImpl, const gl::VertexArray::DirtyBits &dirtyBits) override;
+    void syncState(const gl::Context *context,
+                   const gl::VertexArray::DirtyBits &dirtyBits) override;
     // This will flush any pending attrib updates and then check the dynamic attribs mask.
-    bool hasDynamicAttrib(const gl::State &state);
-    gl::Error updateDirtyAndDynamicAttribs(VertexDataManager *vertexDataManager,
-                                           const gl::State &state,
+    bool hasDynamicAttrib(const gl::Context *context);
+    gl::Error updateDirtyAndDynamicAttribs(const gl::Context *context,
+                                           VertexDataManager *vertexDataManager,
                                            GLint start,
                                            GLsizei count,
                                            GLsizei instances);
@@ -40,8 +41,8 @@ class VertexArray11 : public VertexArrayImpl, public OnBufferDataDirtyReceiver
     void signal(size_t channelID) override;
 
   private:
-    void updateVertexAttribStorage(size_t attribIndex);
-    void flushAttribUpdates(const gl::State &state);
+    void updateVertexAttribStorage(const gl::Context *context, size_t attribIndex);
+    void flushAttribUpdates(const gl::Context *context);
 
     std::vector<VertexStorageType> mAttributeStorageTypes;
     std::vector<TranslatedAttribute> mTranslatedAttribs;
@@ -56,7 +57,7 @@ class VertexArray11 : public VertexArrayImpl, public OnBufferDataDirtyReceiver
     gl::AttributesMask mAttribsToTranslate;
 
     // We need to keep a safe pointer to the Buffer so we can attach the correct dirty callbacks.
-    std::vector<BindingPointer<gl::Buffer>> mCurrentBuffers;
+    std::vector<gl::BindingPointer<gl::Buffer>> mCurrentBuffers;
 
     std::vector<OnBufferDataDirtyBinding> mOnBufferDataDirty;
 };
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp
index 15ca724136a..611bd0f18ba 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp
@@ -19,30 +19,27 @@
 namespace rx
 {
 
-VertexBuffer11::VertexBuffer11(Renderer11 *const renderer) : mRenderer(renderer)
+VertexBuffer11::VertexBuffer11(Renderer11 *const renderer)
+    : mRenderer(renderer),
+      mBuffer(),
+      mBufferSize(0),
+      mDynamicUsage(false),
+      mMappedResourceData(nullptr)
 {
-    mBuffer             = nullptr;
-    mBufferSize         = 0;
-    mDynamicUsage       = false;
-    mMappedResourceData = nullptr;
 }
 
 VertexBuffer11::~VertexBuffer11()
 {
     ASSERT(mMappedResourceData == nullptr);
-    SafeRelease(mBuffer);
 }
 
 gl::Error VertexBuffer11::initialize(unsigned int size, bool dynamicUsage)
 {
-    SafeRelease(mBuffer);
-
+    mBuffer.reset();
     updateSerial();
 
     if (size > 0)
     {
-        ID3D11Device *dxDevice = mRenderer->getDevice();
-
         D3D11_BUFFER_DESC bufferDesc;
         bufferDesc.ByteWidth           = size;
         bufferDesc.Usage               = D3D11_USAGE_DYNAMIC;
@@ -51,20 +48,15 @@ gl::Error VertexBuffer11::initialize(unsigned int size, bool dynamicUsage)
         bufferDesc.MiscFlags           = 0;
         bufferDesc.StructureByteStride = 0;
 
-        HRESULT result = dxDevice->CreateBuffer(&bufferDesc, nullptr, &mBuffer);
-        if (FAILED(result))
-        {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to allocate internal vertex buffer of size, %lu.", size);
-        }
+        ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &mBuffer));
 
         if (dynamicUsage)
         {
-            d3d11::SetDebugName(mBuffer, "VertexBuffer11 (dynamic)");
+            mBuffer.setDebugName("VertexBuffer11 (dynamic)");
         }
         else
         {
-            d3d11::SetDebugName(mBuffer, "VertexBuffer11 (static)");
+            mBuffer.setDebugName("VertexBuffer11 (static)");
         }
     }
 
@@ -83,11 +75,11 @@ gl::Error VertexBuffer11::mapResource()
         D3D11_MAPPED_SUBRESOURCE mappedResource;
 
         HRESULT result =
-            dxContext->Map(mBuffer, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mappedResource);
+            dxContext->Map(mBuffer.get(), 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mappedResource);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to map internal vertex buffer, HRESULT: 0x%08x.", result);
+            return gl::OutOfMemory()
+                   << "Failed to map internal vertex buffer, " << gl::FmtHR(result);
         }
 
         mMappedResourceData = reinterpret_cast<uint8_t *>(mappedResource.pData);
@@ -101,7 +93,7 @@ void VertexBuffer11::hintUnmapResource()
     if (mMappedResourceData != nullptr)
     {
         ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
-        dxContext->Unmap(mBuffer, 0);
+        dxContext->Unmap(mBuffer.get(), 0);
 
         mMappedResourceData = nullptr;
     }
@@ -116,9 +108,9 @@ gl::Error VertexBuffer11::storeVertexAttributes(const gl::VertexAttribute &attri
                                                 unsigned int offset,
                                                 const uint8_t *sourceData)
 {
-    if (!mBuffer)
+    if (!mBuffer.valid())
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal vertex buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal vertex buffer is not initialized.";
     }
 
     int inputStride = static_cast<int>(ComputeVertexAttributeStride(attrib, binding));
@@ -130,7 +122,7 @@ gl::Error VertexBuffer11::storeVertexAttributes(const gl::VertexAttribute &attri
 
     const uint8_t *input = sourceData;
 
-    if (instances == 0 || binding.divisor == 0)
+    if (instances == 0 || binding.getDivisor() == 0)
     {
         input += inputStride * start;
     }
@@ -164,27 +156,27 @@ gl::Error VertexBuffer11::setBufferSize(unsigned int size)
 
 gl::Error VertexBuffer11::discard()
 {
-    if (!mBuffer)
+    if (!mBuffer.valid())
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal vertex buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal vertex buffer is not initialized.";
     }
 
     ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
 
     D3D11_MAPPED_SUBRESOURCE mappedResource;
-    HRESULT result = dxContext->Map(mBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    HRESULT result = dxContext->Map(mBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to map internal buffer for discarding, HRESULT: 0x%08x", result);
+        return gl::OutOfMemory() << "Failed to map internal buffer for discarding, "
+                                 << gl::FmtHR(result);
     }
 
-    dxContext->Unmap(mBuffer, 0);
+    dxContext->Unmap(mBuffer.get(), 0);
 
     return gl::NoError();
 }
 
-ID3D11Buffer *VertexBuffer11::getBuffer() const
+const d3d11::Buffer &VertexBuffer11::getBuffer() const
 {
     return mBuffer;
 }
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.h
index 038ba4284c4..ab619ae5030 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.h
@@ -12,6 +12,7 @@
 #include <stdint.h>
 
 #include "libANGLE/renderer/d3d/VertexBuffer.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
 
 namespace rx
 {
@@ -41,7 +42,7 @@ class VertexBuffer11 : public VertexBuffer
 
     void hintUnmapResource() override;
 
-    ID3D11Buffer *getBuffer() const;
+    const d3d11::Buffer &getBuffer() const;
 
   private:
     ~VertexBuffer11() override;
@@ -49,7 +50,7 @@ class VertexBuffer11 : public VertexBuffer
 
     Renderer11 *const mRenderer;
 
-    ID3D11Buffer *mBuffer;
+    d3d11::Buffer mBuffer;
     unsigned int mBufferSize;
     bool mDynamicUsage;
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/dxgi_support_table.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/dxgi_support_table.h
index 1d8d68565e6..a818f376ef3 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/dxgi_support_table.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/dxgi_support_table.h
@@ -8,6 +8,9 @@
 //   version, D3D feature level, and is sometimes guaranteed or optional.
 //
 
+#ifndef LIBANGLE_RENDERER_D3D_D3D11_DXGI_SUPPORT_TABLE_H_
+#define LIBANGLE_RENDERER_D3D_D3D11_DXGI_SUPPORT_TABLE_H_
+
 #include "common/platform.h"
 
 namespace rx
@@ -42,3 +45,5 @@ const DXGISupport &GetDXGISupport(DXGI_FORMAT dxgiFormat, D3D_FEATURE_LEVEL feat
 } // namespace d3d11
 
 } // namespace rx
+
+#endif  // LIBANGLE_RENDERER_D3D_D3D11_DXGI_SUPPORT_TABLE_H_
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
index cd45b21c9c4..0b7815dfffe 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
@@ -1294,6 +1294,7 @@ void GenerateCaps(ID3D11Device *device, ID3D11DeviceContext *deviceContext, cons
 
     // Multisample limits
     caps->maxSamples = maxSamples;
+    caps->maxColorTextureSamples = maxSamples;
 
     // GL extension support
     extensions->setTextureExtensionSupport(*textureCapsMap);
@@ -1793,7 +1794,10 @@ void MakeValidSize(bool isImage, DXGI_FORMAT format, GLsizei *requestWidth, GLsi
             upsampleCount++;
         }
     }
-    *levelOffset = upsampleCount;
+    if (levelOffset)
+    {
+        *levelOffset = upsampleCount;
+    }
 }
 
 void GenerateInitialTextureData(GLint internalFormat,
@@ -1856,6 +1860,36 @@ void SetPositionLayerTexCoord3DVertex(PositionLayerTexCoord3DVertex* vertex, flo
     vertex->s = s;
 }
 
+BlendStateKey::BlendStateKey()
+{
+    memset(this, 0, sizeof(BlendStateKey));
+}
+
+bool operator==(const BlendStateKey &a, const BlendStateKey &b)
+{
+    return memcmp(&a, &b, sizeof(BlendStateKey)) == 0;
+}
+
+bool operator!=(const BlendStateKey &a, const BlendStateKey &b)
+{
+    return !(a == b);
+}
+
+RasterizerStateKey::RasterizerStateKey()
+{
+    memset(this, 0, sizeof(RasterizerStateKey));
+}
+
+bool operator==(const RasterizerStateKey &a, const RasterizerStateKey &b)
+{
+    return memcmp(&a, &b, sizeof(RasterizerStateKey)) == 0;
+}
+
+bool operator!=(const RasterizerStateKey &a, const RasterizerStateKey &b)
+{
+    return !(a == b);
+}
+
 HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name)
 {
 #if defined(_DEBUG)
@@ -1894,36 +1928,9 @@ HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name)
 #endif
 }
 
-LazyInputLayout::LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
-                                 size_t inputDescLen,
-                                 const BYTE *byteCode,
-                                 size_t byteCodeLen,
-                                 const char *debugName)
-    : mInputDesc(inputDescLen),
-      mByteCodeLen(byteCodeLen),
-      mByteCode(byteCode),
-      mDebugName(debugName)
+gl::Error LazyInputLayout::resolve(Renderer11 *renderer)
 {
-    if (inputDesc)
-    {
-        memcpy(&mInputDesc[0], inputDesc, sizeof(D3D11_INPUT_ELEMENT_DESC) * inputDescLen);
-    }
-}
-
-ID3D11InputLayout *LazyInputLayout::resolve(ID3D11Device *device)
-{
-    checkAssociatedDevice(device);
-
-    if (mResource == nullptr && mByteCode != nullptr)
-    {
-        HRESULT result =
-            device->CreateInputLayout(&mInputDesc[0], static_cast<UINT>(mInputDesc.size()),
-                                      mByteCode, mByteCodeLen, &mResource);
-        ASSERT(SUCCEEDED(result));
-        d3d11::SetDebugName(mResource, mDebugName);
-    }
-
-    return mResource;
+    return resolveImpl(renderer, mInputDesc, &mByteCode, mDebugName);
 }
 
 LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName)
@@ -1931,18 +1938,9 @@ LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugNa
 {
 }
 
-ID3D11BlendState *LazyBlendState::resolve(ID3D11Device *device)
+gl::Error LazyBlendState::resolve(Renderer11 *renderer)
 {
-    checkAssociatedDevice(device);
-
-    if (mResource == nullptr)
-    {
-        HRESULT result = device->CreateBlendState(&mDesc, &mResource);
-        ASSERT(SUCCEEDED(result));
-        d3d11::SetDebugName(mResource, mDebugName);
-    }
-
-    return mResource;
+    return resolveImpl(renderer, mDesc, nullptr, mDebugName);
 }
 
 angle::WorkaroundsD3D GenerateWorkarounds(const Renderer11DeviceCaps &deviceCaps,
@@ -2031,136 +2029,80 @@ void InitConstantBufferDesc(D3D11_BUFFER_DESC *constantBufferDescription, size_t
 
 }  // namespace d3d11
 
-TextureHelper11::TextureHelper11()
-    : mTextureType(GL_NONE),
-      mFormat(DXGI_FORMAT_UNKNOWN),
-      mFormatSet(nullptr),
-      mSampleCount(0),
-      mTexture2D(nullptr),
-      mTexture3D(nullptr)
+// TextureHelper11 implementation.
+TextureHelper11::TextureHelper11() : mFormatSet(nullptr), mSampleCount(0)
 {
 }
 
-TextureHelper11::TextureHelper11(TextureHelper11 &&toCopy)
-    : mTextureType(toCopy.mTextureType),
-      mExtents(toCopy.mExtents),
-      mFormat(toCopy.mFormat),
-      mFormatSet(toCopy.mFormatSet),
-      mSampleCount(toCopy.mSampleCount),
-      mTexture2D(toCopy.mTexture2D),
-      mTexture3D(toCopy.mTexture3D)
+TextureHelper11::TextureHelper11(TextureHelper11 &&toCopy) : TextureHelper11()
 {
-    toCopy.reset();
+    *this = std::move(toCopy);
 }
 
-// static
-TextureHelper11 TextureHelper11::MakeAndReference(ID3D11Resource *genericResource,
-                                                  const d3d11::Format &formatSet)
+TextureHelper11::TextureHelper11(const TextureHelper11 &other)
+    : mFormatSet(other.mFormatSet), mExtents(other.mExtents), mSampleCount(other.mSampleCount)
 {
-    TextureHelper11 newHelper;
-    newHelper.mFormatSet   = &formatSet;
-    newHelper.mTexture2D   = d3d11::DynamicCastComObject<ID3D11Texture2D>(genericResource);
-    newHelper.mTexture3D   = d3d11::DynamicCastComObject<ID3D11Texture3D>(genericResource);
-    newHelper.mTextureType = newHelper.mTexture2D ? GL_TEXTURE_2D : GL_TEXTURE_3D;
-    newHelper.initDesc();
-    return newHelper;
+    mData = other.mData;
 }
 
-// static
-TextureHelper11 TextureHelper11::MakeAndPossess2D(ID3D11Texture2D *texToOwn,
-                                                  const d3d11::Format &formatSet)
+TextureHelper11::~TextureHelper11()
 {
-    TextureHelper11 newHelper;
-    newHelper.mFormatSet   = &formatSet;
-    newHelper.mTexture2D   = texToOwn;
-    newHelper.mTextureType = GL_TEXTURE_2D;
-    newHelper.initDesc();
-    return newHelper;
 }
 
-// static
-TextureHelper11 TextureHelper11::MakeAndPossess3D(ID3D11Texture3D *texToOwn,
-                                                  const d3d11::Format &formatSet)
+void TextureHelper11::getDesc(D3D11_TEXTURE2D_DESC *desc) const
 {
-    TextureHelper11 newHelper;
-    newHelper.mFormatSet   = &formatSet;
-    newHelper.mTexture3D   = texToOwn;
-    newHelper.mTextureType = GL_TEXTURE_3D;
-    newHelper.initDesc();
-    return newHelper;
+    static_cast<ID3D11Texture2D *>(mData->object)->GetDesc(desc);
 }
 
-void TextureHelper11::initDesc()
+void TextureHelper11::getDesc(D3D11_TEXTURE3D_DESC *desc) const
 {
-    if (mTextureType == GL_TEXTURE_2D)
-    {
-        ASSERT(!mTexture3D);
-        D3D11_TEXTURE2D_DESC desc2D;
-        mTexture2D->GetDesc(&desc2D);
-
-        mExtents.width  = static_cast<int>(desc2D.Width);
-        mExtents.height = static_cast<int>(desc2D.Height);
-        mExtents.depth  = 1;
-        mFormat         = desc2D.Format;
-        mSampleCount    = desc2D.SampleDesc.Count;
-    }
-    else
-    {
-        ASSERT(mTexture3D && mTextureType == GL_TEXTURE_3D);
-        D3D11_TEXTURE3D_DESC desc3D;
-        mTexture3D->GetDesc(&desc3D);
-
-        mExtents.width  = static_cast<int>(desc3D.Width);
-        mExtents.height = static_cast<int>(desc3D.Height);
-        mExtents.depth  = static_cast<int>(desc3D.Depth);
-        mFormat         = desc3D.Format;
-        mSampleCount    = 1;
-    }
-    ASSERT(mFormatSet && mFormat == mFormatSet->texFormat);
+    static_cast<ID3D11Texture3D *>(mData->object)->GetDesc(desc);
 }
 
-TextureHelper11::~TextureHelper11()
+void TextureHelper11::initDesc(const D3D11_TEXTURE2D_DESC &desc2D)
 {
-    SafeRelease(mTexture2D);
-    SafeRelease(mTexture3D);
+    mData->resourceType = ResourceType::Texture2D;
+    mExtents.width      = static_cast<int>(desc2D.Width);
+    mExtents.height     = static_cast<int>(desc2D.Height);
+    mExtents.depth      = 1;
+    mSampleCount        = desc2D.SampleDesc.Count;
 }
 
-ID3D11Resource *TextureHelper11::getResource() const
+void TextureHelper11::initDesc(const D3D11_TEXTURE3D_DESC &desc3D)
 {
-    return mTexture2D ? static_cast<ID3D11Resource *>(mTexture2D)
-                      : static_cast<ID3D11Resource *>(mTexture3D);
+    mData->resourceType = ResourceType::Texture3D;
+    mExtents.width      = static_cast<int>(desc3D.Width);
+    mExtents.height     = static_cast<int>(desc3D.Height);
+    mExtents.depth      = static_cast<int>(desc3D.Depth);
+    mSampleCount        = 1;
 }
 
-TextureHelper11 &TextureHelper11::operator=(TextureHelper11 &&texture)
+TextureHelper11 &TextureHelper11::operator=(TextureHelper11 &&other)
 {
-    SafeRelease(mTexture2D);
-    SafeRelease(mTexture3D);
+    std::swap(mData, other.mData);
+    std::swap(mExtents, other.mExtents);
+    std::swap(mFormatSet, other.mFormatSet);
+    std::swap(mSampleCount, other.mSampleCount);
+    return *this;
+}
 
-    mTextureType = texture.mTextureType;
-    mExtents     = texture.mExtents;
-    mFormat      = texture.mFormat;
-    mFormatSet   = texture.mFormatSet;
-    mSampleCount = texture.mSampleCount;
-    mTexture2D   = texture.mTexture2D;
-    mTexture3D   = texture.mTexture3D;
-    texture.reset();
+TextureHelper11 &TextureHelper11::operator=(const TextureHelper11 &other)
+{
+    mData        = other.mData;
+    mExtents     = other.mExtents;
+    mFormatSet   = other.mFormatSet;
+    mSampleCount = other.mSampleCount;
     return *this;
 }
 
-void TextureHelper11::reset()
+bool TextureHelper11::operator==(const TextureHelper11 &other) const
 {
-    mTextureType = GL_NONE;
-    mExtents     = gl::Extents();
-    mFormat      = DXGI_FORMAT_UNKNOWN;
-    mFormatSet   = nullptr;
-    mSampleCount = 0;
-    mTexture2D   = nullptr;
-    mTexture3D   = nullptr;
+    return mData->object == other.mData->object;
 }
 
-bool TextureHelper11::valid() const
+bool TextureHelper11::operator!=(const TextureHelper11 &other) const
 {
-    return (mTextureType != GL_NONE);
+    return mData->object != other.mData->object;
 }
 
 bool UsePresentPathFast(const Renderer11 *renderer,
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
index 071ebb3c20b..d83839c37f7 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
@@ -18,8 +18,9 @@
 
 #include "libANGLE/Caps.h"
 #include "libANGLE/Error.h"
-#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
+#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
 
 namespace gl
 {
@@ -119,20 +120,30 @@ struct PositionVertex
     float x, y, z, w;
 };
 
-struct BlendStateKey
+struct BlendStateKey final
 {
+    // This will zero-initialize the struct, including padding.
+    BlendStateKey();
+
     gl::BlendState blendState;
     bool mrt;
     uint8_t rtvMasks[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
 };
 
-HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name);
+bool operator==(const BlendStateKey &a, const BlendStateKey &b);
+bool operator!=(const BlendStateKey &a, const BlendStateKey &b);
 
-template <typename T>
-HRESULT SetDebugName(angle::ComPtr<T> &resource, const char *name)
+struct RasterizerStateKey final
 {
-    return SetDebugName(resource.Get(), name);
-}
+    // This will zero-initialize the struct, including padding.
+    RasterizerStateKey();
+
+    gl::RasterizerState rasterizerState;
+    bool scissorEnabled;
+};
+
+bool operator==(const RasterizerStateKey &a, const RasterizerStateKey &b);
+bool operator!=(const RasterizerStateKey &a, const RasterizerStateKey &b);
 
 template <typename outType>
 outType* DynamicCastComObject(IUnknown* object)
@@ -165,166 +176,88 @@ inline bool isDeviceLostError(HRESULT errorCode)
     }
 }
 
-inline ID3D11VertexShader *CompileVS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
-{
-    ID3D11VertexShader *vs = nullptr;
-    HRESULT result = device->CreateVertexShader(byteCode, N, nullptr, &vs);
-    ASSERT(SUCCEEDED(result));
-    if (SUCCEEDED(result))
-    {
-        SetDebugName(vs, name);
-        return vs;
-    }
-    return nullptr;
-}
-
-template <unsigned int N>
-ID3D11VertexShader *CompileVS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
+template <ResourceType ResourceT>
+class LazyResource : angle::NonCopyable
 {
-    return CompileVS(device, byteCode, N, name);
-}
+  public:
+    constexpr LazyResource() : mResource() {}
+    virtual ~LazyResource() {}
 
-inline ID3D11GeometryShader *CompileGS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
-{
-    ID3D11GeometryShader *gs = nullptr;
-    HRESULT result = device->CreateGeometryShader(byteCode, N, nullptr, &gs);
-    ASSERT(SUCCEEDED(result));
-    if (SUCCEEDED(result))
+    virtual gl::Error resolve(Renderer11 *renderer) = 0;
+    void reset() { mResource.reset(); }
+    GetD3D11Type<ResourceT> *get() const
     {
-        SetDebugName(gs, name);
-        return gs;
+        ASSERT(mResource.valid());
+        return mResource.get();
     }
-    return nullptr;
-}
 
-template <unsigned int N>
-ID3D11GeometryShader *CompileGS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
-{
-    return CompileGS(device, byteCode, N, name);
-}
+    const Resource11<GetD3D11Type<ResourceT>> &getObj() const { return mResource; }
 
-inline ID3D11PixelShader *CompilePS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
-{
-    ID3D11PixelShader *ps = nullptr;
-    HRESULT result = device->CreatePixelShader(byteCode, N, nullptr, &ps);
-    ASSERT(SUCCEEDED(result));
-    if (SUCCEEDED(result))
+  protected:
+    gl::Error resolveImpl(Renderer11 *renderer,
+                          const GetDescType<ResourceT> &desc,
+                          GetInitDataType<ResourceT> *initData,
+                          const char *name)
     {
-        SetDebugName(ps, name);
-        return ps;
+        if (!mResource.valid())
+        {
+            ANGLE_TRY(renderer->allocateResource(desc, initData, &mResource));
+            mResource.setDebugName(name);
+        }
+        return gl::NoError();
     }
-    return nullptr;
-}
 
-template <unsigned int N>
-ID3D11PixelShader *CompilePS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
-{
-    return CompilePS(device, byteCode, N, name);
-}
-
-template <typename ResourceType>
-class LazyResource : angle::NonCopyable
-{
-  public:
-    LazyResource() : mResource(nullptr), mAssociatedDevice(nullptr) {}
-    virtual ~LazyResource() { release(); }
-
-    virtual ResourceType *resolve(ID3D11Device *device) = 0;
-    void release() { SafeRelease(mResource); }
-
-  protected:
-    void checkAssociatedDevice(ID3D11Device *device);
-
-    ResourceType *mResource;
-    ID3D11Device *mAssociatedDevice;
+    Resource11<GetD3D11Type<ResourceT>> mResource;
 };
 
-template <typename ResourceType>
-void LazyResource<ResourceType>::checkAssociatedDevice(ID3D11Device *device)
-{
-    ASSERT(mAssociatedDevice == nullptr || device == mAssociatedDevice);
-    mAssociatedDevice = device;
-}
-
 template <typename D3D11ShaderType>
-class LazyShader final : public LazyResource<D3D11ShaderType>
+class LazyShader final : public LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>
 {
   public:
     // All parameters must be constexpr. Not supported in VS2013.
-    LazyShader(const BYTE *byteCode,
-               size_t byteCodeSize,
-               const char *name)
-        : mByteCode(byteCode),
-          mByteCodeSize(byteCodeSize),
-          mName(name)
+    constexpr LazyShader(const BYTE *byteCode, size_t byteCodeSize, const char *name)
+        : mByteCode(byteCode, byteCodeSize), mName(name)
     {
     }
 
-    D3D11ShaderType *resolve(ID3D11Device *device) override;
+    gl::Error resolve(Renderer11 *renderer) override
+    {
+        return this->resolveImpl(renderer, mByteCode, nullptr, mName);
+    }
 
   private:
-    const BYTE *mByteCode;
-    size_t mByteCodeSize;
+    ShaderData mByteCode;
     const char *mName;
 };
 
-template <>
-inline ID3D11VertexShader *LazyShader<ID3D11VertexShader>::resolve(ID3D11Device *device)
-{
-    checkAssociatedDevice(device);
-    if (mResource == nullptr)
-    {
-        mResource = CompileVS(device, mByteCode, mByteCodeSize, mName);
-    }
-    return mResource;
-}
-
-template <>
-inline ID3D11GeometryShader *LazyShader<ID3D11GeometryShader>::resolve(ID3D11Device *device)
+class LazyInputLayout final : public LazyResource<ResourceType::InputLayout>
 {
-    checkAssociatedDevice(device);
-    if (mResource == nullptr)
-    {
-        mResource = CompileGS(device, mByteCode, mByteCodeSize, mName);
-    }
-    return mResource;
-}
-
-template <>
-inline ID3D11PixelShader *LazyShader<ID3D11PixelShader>::resolve(ID3D11Device *device)
-{
-    checkAssociatedDevice(device);
-    if (mResource == nullptr)
+  public:
+    constexpr LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
+                              size_t inputDescLen,
+                              const BYTE *byteCode,
+                              size_t byteCodeLen,
+                              const char *debugName)
+        : mInputDesc(inputDesc, inputDescLen),
+          mByteCode(byteCode, byteCodeLen),
+          mDebugName(debugName)
     {
-        mResource = CompilePS(device, mByteCode, mByteCodeSize, mName);
     }
-    return mResource;
-}
-
-class LazyInputLayout final : public LazyResource<ID3D11InputLayout>
-{
-  public:
-    LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
-                    size_t inputDescLen,
-                    const BYTE *byteCode,
-                    size_t byteCodeLen,
-                    const char *debugName);
 
-    ID3D11InputLayout *resolve(ID3D11Device *device) override;
+    gl::Error resolve(Renderer11 *renderer) override;
 
   private:
-    std::vector<D3D11_INPUT_ELEMENT_DESC> mInputDesc;
-    size_t mByteCodeLen;
-    const BYTE *mByteCode;
+    InputElementArray mInputDesc;
+    ShaderData mByteCode;
     const char *mDebugName;
 };
 
-class LazyBlendState final : public LazyResource<ID3D11BlendState>
+class LazyBlendState final : public LazyResource<ResourceType::BlendState>
 {
   public:
     LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName);
 
-    ID3D11BlendState *resolve(ID3D11Device *device) override;
+    gl::Error resolve(Renderer11 *renderer);
 
   private:
     D3D11_BLEND_DESC mDesc;
@@ -360,43 +293,88 @@ enum ReservedConstantBufferSlot
 void InitConstantBufferDesc(D3D11_BUFFER_DESC *constantBufferDescription, size_t byteWidth);
 }  // namespace d3d11
 
+struct GenericData
+{
+    GenericData() {}
+    ~GenericData()
+    {
+        if (object)
+        {
+            // We can have a nullptr factory when holding passed-in resources.
+            if (manager)
+            {
+                manager->onReleaseGeneric(resourceType, object);
+                manager = nullptr;
+            }
+            object->Release();
+            object = nullptr;
+        }
+    }
+
+    ResourceType resourceType  = ResourceType::Last;
+    ID3D11Resource *object     = nullptr;
+    ResourceManager11 *manager = nullptr;
+};
+
 // A helper class which wraps a 2D or 3D texture.
-class TextureHelper11 : angle::NonCopyable
+class TextureHelper11 : public Resource11Base<ID3D11Resource, std::shared_ptr, GenericData>
 {
   public:
     TextureHelper11();
-    TextureHelper11(TextureHelper11 &&toCopy);
+    TextureHelper11(TextureHelper11 &&other);
+    TextureHelper11(const TextureHelper11 &other);
     ~TextureHelper11();
-    TextureHelper11 &operator=(TextureHelper11 &&texture);
-
-    static TextureHelper11 MakeAndReference(ID3D11Resource *genericResource,
-                                            const d3d11::Format &formatSet);
-    static TextureHelper11 MakeAndPossess2D(ID3D11Texture2D *texToOwn,
-                                            const d3d11::Format &formatSet);
-    static TextureHelper11 MakeAndPossess3D(ID3D11Texture3D *texToOwn,
-                                            const d3d11::Format &formatSet);
+    TextureHelper11 &operator=(TextureHelper11 &&other);
+    TextureHelper11 &operator=(const TextureHelper11 &other);
 
-    GLenum getTextureType() const { return mTextureType; }
+    bool is2D() const { return mData->resourceType == ResourceType::Texture2D; }
+    bool is3D() const { return mData->resourceType == ResourceType::Texture3D; }
+    ResourceType getTextureType() const { return mData->resourceType; }
     gl::Extents getExtents() const { return mExtents; }
-    DXGI_FORMAT getFormat() const { return mFormat; }
+    DXGI_FORMAT getFormat() const { return mFormatSet->texFormat; }
     const d3d11::Format &getFormatSet() const { return *mFormatSet; }
     int getSampleCount() const { return mSampleCount; }
-    ID3D11Texture2D *getTexture2D() const { return mTexture2D; }
-    ID3D11Texture3D *getTexture3D() const { return mTexture3D; }
-    ID3D11Resource *getResource() const;
-    bool valid() const;
+
+    template <typename DescT, typename ResourceT>
+    void init(Resource11<ResourceT> &&texture, const DescT &desc, const d3d11::Format &format)
+    {
+        std::swap(mData->manager, texture.mData->manager);
+
+        // Can't use std::swap because texture is typed, and here we use ID3D11Resource.
+        auto temp             = mData->object;
+        mData->object         = texture.mData->object;
+        texture.mData->object = static_cast<ResourceT *>(temp);
+
+        mFormatSet = &format;
+        initDesc(desc);
+    }
+
+    template <typename ResourceT>
+    void set(ResourceT *object, const d3d11::Format &format)
+    {
+        ASSERT(!valid());
+        mFormatSet     = &format;
+        mData->object  = object;
+        mData->manager = nullptr;
+
+        GetDescFromD3D11<ResourceT> desc;
+        getDesc(&desc);
+        initDesc(desc);
+    }
+
+    bool operator==(const TextureHelper11 &other) const;
+    bool operator!=(const TextureHelper11 &other) const;
+
+    void getDesc(D3D11_TEXTURE2D_DESC *desc) const;
+    void getDesc(D3D11_TEXTURE3D_DESC *desc) const;
 
   private:
-    void reset();
-    void initDesc();
+    void initDesc(const D3D11_TEXTURE2D_DESC &desc2D);
+    void initDesc(const D3D11_TEXTURE3D_DESC &desc3D);
 
-    GLenum mTextureType;
-    gl::Extents mExtents;
-    DXGI_FORMAT mFormat;
     const d3d11::Format *mFormatSet;
+    gl::Extents mExtents;
     int mSampleCount;
-    ID3D11Texture2D *mTexture2D;
-    ID3D11Texture3D *mTexture3D;
 };
 
 enum class StagingAccess
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/MultiplyAlpha.hlsl b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/MultiplyAlpha.hlsl
index b788e1794be..0d10b8eafa7 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/MultiplyAlpha.hlsl
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/MultiplyAlpha.hlsl
@@ -7,6 +7,43 @@ SamplerState Sampler        : register(s0);
 // PM: premultiply, UM: unmulitply, PT: passthrough
 // F: float, U: uint
 
+// Float to float LUMA
+float4 PS_FtoF_PM_LUMA(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0
+{
+    float4 color = TextureF.Sample(Sampler, inTexCoord).rgba;
+    color.rgb = color.r * color.a;
+    color.a = 1.0f;
+    return color;
+}
+float4 PS_FtoF_UM_LUMA(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0
+{
+    float4 color = TextureF.Sample(Sampler, inTexCoord).rgba;
+    if (color.a > 0.0f)
+    {
+        color.rgb = color.r / color.a;
+    }
+    color.a = 1.0f;
+    return color;
+}
+
+// Float to float LUMAALPHA
+float4 PS_FtoF_PM_LUMAALPHA(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0
+{
+    float4 color = TextureF.Sample(Sampler, inTexCoord).rgba;
+    color.rgb = color.r * color.a;
+    return color;
+}
+
+float4 PS_FtoF_UM_LUMAALPHA(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0
+{
+    float4 color = TextureF.Sample(Sampler, inTexCoord).rgba;
+    if (color.a > 0.0f)
+    {
+        color.rgb = color.r / color.a;
+    }
+    return color;
+}
+
 // Float to float RGBA
 float4 PS_FtoF_PM_RGBA(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0
 {
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_ps.h
new file mode 100644
index 00000000000..bd63ef33b0a
--- /dev/null
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_luma_ps.h
@@ -0,0 +1,77 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim Slot Elements
+// ------------------------------ ---------- ------- ----------- ---- --------
+// Sampler                           sampler      NA          NA    0        1
+// TextureF                          texture  float4          2d    0        1
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float
+// TEXCOORD                 0   xy          1     NONE   float   xy
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_TARGET                0   xyzw        0   TARGET   float   xyzw
+//
+ps_4_0
+dcl_sampler s0, mode_default
+dcl_resource_texture2d (float,float,float,float) t0
+dcl_input_ps linear v1.xy
+dcl_output o0.xyzw
+dcl_temps 1
+sample r0.xyzw, v1.xyxx, t0.xyzw, s0
+mul o0.xyz, r0.wwww, r0.xxxx
+mov o0.w, l(1.000000)
+ret
+// Approximately 4 instruction slots used
+#endif
+
+const BYTE g_PS_FtoF_PM_LUMA[] = {
+    68, 88,  66,  67,  61,  193, 4,   85,  218, 250, 183, 199, 231, 187, 141, 93,  80,  186, 200,
+    74, 1,   0,   0,   0,   136, 2,   0,   0,   5,   0,   0,   0,   52,  0,   0,   0,   220, 0,
+    0,  0,   52,  1,   0,   0,   104, 1,   0,   0,   12,  2,   0,   0,   82,  68,  69,  70,  160,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   2,   0,   0,   0,   28,  0,   0,   0,
+    0,  4,   255, 255, 0,   1,   0,   0,   109, 0,   0,   0,   92,  0,   0,   0,   3,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,
+    0,  0,   1,   0,   0,   0,   100, 0,   0,   0,   2,   0,   0,   0,   5,   0,   0,   0,   4,
+    0,  0,   0,   255, 255, 255, 255, 0,   0,   0,   0,   1,   0,   0,   0,   13,  0,   0,   0,
+    83, 97,  109, 112, 108, 101, 114, 0,   84,  101, 120, 116, 117, 114, 101, 70,  0,   77,  105,
+    99, 114, 111, 115, 111, 102, 116, 32,  40,  82,  41,  32,  72,  76,  83,  76,  32,  83,  104,
+    97, 100, 101, 114, 32,  67,  111, 109, 112, 105, 108, 101, 114, 32,  54,  46,  51,  46,  57,
+    54, 48,  48,  46,  49,  54,  51,  56,  52,  0,   171, 73,  83,  71,  78,  80,  0,   0,   0,
+    2,  0,   0,   0,   8,   0,   0,   0,   56,  0,   0,   0,   0,   0,   0,   0,   1,   0,   0,
+    0,  3,   0,   0,   0,   0,   0,   0,   0,   15,  0,   0,   0,   68,  0,   0,   0,   0,   0,
+    0,  0,   0,   0,   0,   0,   3,   0,   0,   0,   1,   0,   0,   0,   3,   3,   0,   0,   83,
+    86, 95,  80,  79,  83,  73,  84,  73,  79,  78,  0,   84,  69,  88,  67,  79,  79,  82,  68,
+    0,  171, 171, 171, 79,  83,  71,  78,  44,  0,   0,   0,   1,   0,   0,   0,   8,   0,   0,
+    0,  32,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,   0,   0,   0,   0,   0,
+    0,  0,   15,  0,   0,   0,   83,  86,  95,  84,  65,  82,  71,  69,  84,  0,   171, 171, 83,
+    72, 68,  82,  156, 0,   0,   0,   64,  0,   0,   0,   39,  0,   0,   0,   90,  0,   0,   3,
+    0,  96,  16,  0,   0,   0,   0,   0,   88,  24,  0,   4,   0,   112, 16,  0,   0,   0,   0,
+    0,  85,  85,  0,   0,   98,  16,  0,   3,   50,  16,  16,  0,   1,   0,   0,   0,   101, 0,
+    0,  3,   242, 32,  16,  0,   0,   0,   0,   0,   104, 0,   0,   2,   1,   0,   0,   0,   69,
+    0,  0,   9,   242, 0,   16,  0,   0,   0,   0,   0,   70,  16,  16,  0,   1,   0,   0,   0,
+    70, 126, 16,  0,   0,   0,   0,   0,   0,   96,  16,  0,   0,   0,   0,   0,   56,  0,   0,
+    7,  114, 32,  16,  0,   0,   0,   0,   0,   246, 15,  16,  0,   0,   0,   0,   0,   6,   0,
+    16, 0,   0,   0,   0,   0,   54,  0,   0,   5,   130, 32,  16,  0,   0,   0,   0,   0,   1,
+    64, 0,   0,   0,   0,   128, 63,  62,  0,   0,   1,   83,  84,  65,  84,  116, 0,   0,   0,
+    4,  0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,   2,   0,   0,   0,   1,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    1,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,  0};
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_ps.h
new file mode 100644
index 00000000000..435f5783e9e
--- /dev/null
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_pm_lumaalpha_ps.h
@@ -0,0 +1,77 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim Slot Elements
+// ------------------------------ ---------- ------- ----------- ---- --------
+// Sampler                           sampler      NA          NA    0        1
+// TextureF                          texture  float4          2d    0        1
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float
+// TEXCOORD                 0   xy          1     NONE   float   xy
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_TARGET                0   xyzw        0   TARGET   float   xyzw
+//
+ps_4_0
+dcl_sampler s0, mode_default
+dcl_resource_texture2d (float,float,float,float) t0
+dcl_input_ps linear v1.xy
+dcl_output o0.xyzw
+dcl_temps 1
+sample r0.xyzw, v1.xyxx, t0.xyzw, s0
+mul o0.xyz, r0.wwww, r0.xxxx
+mov o0.w, r0.w
+ret
+// Approximately 4 instruction slots used
+#endif
+
+const BYTE g_PS_FtoF_PM_LUMAALPHA[] = {
+    68, 88,  66,  67,  16,  240, 62,  171, 253, 134, 187, 96,  66,  174, 101, 13,  101, 43,  164,
+    23, 1,   0,   0,   0,   136, 2,   0,   0,   5,   0,   0,   0,   52,  0,   0,   0,   220, 0,
+    0,  0,   52,  1,   0,   0,   104, 1,   0,   0,   12,  2,   0,   0,   82,  68,  69,  70,  160,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   2,   0,   0,   0,   28,  0,   0,   0,
+    0,  4,   255, 255, 0,   1,   0,   0,   109, 0,   0,   0,   92,  0,   0,   0,   3,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,
+    0,  0,   1,   0,   0,   0,   100, 0,   0,   0,   2,   0,   0,   0,   5,   0,   0,   0,   4,
+    0,  0,   0,   255, 255, 255, 255, 0,   0,   0,   0,   1,   0,   0,   0,   13,  0,   0,   0,
+    83, 97,  109, 112, 108, 101, 114, 0,   84,  101, 120, 116, 117, 114, 101, 70,  0,   77,  105,
+    99, 114, 111, 115, 111, 102, 116, 32,  40,  82,  41,  32,  72,  76,  83,  76,  32,  83,  104,
+    97, 100, 101, 114, 32,  67,  111, 109, 112, 105, 108, 101, 114, 32,  54,  46,  51,  46,  57,
+    54, 48,  48,  46,  49,  54,  51,  56,  52,  0,   171, 73,  83,  71,  78,  80,  0,   0,   0,
+    2,  0,   0,   0,   8,   0,   0,   0,   56,  0,   0,   0,   0,   0,   0,   0,   1,   0,   0,
+    0,  3,   0,   0,   0,   0,   0,   0,   0,   15,  0,   0,   0,   68,  0,   0,   0,   0,   0,
+    0,  0,   0,   0,   0,   0,   3,   0,   0,   0,   1,   0,   0,   0,   3,   3,   0,   0,   83,
+    86, 95,  80,  79,  83,  73,  84,  73,  79,  78,  0,   84,  69,  88,  67,  79,  79,  82,  68,
+    0,  171, 171, 171, 79,  83,  71,  78,  44,  0,   0,   0,   1,   0,   0,   0,   8,   0,   0,
+    0,  32,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,   0,   0,   0,   0,   0,
+    0,  0,   15,  0,   0,   0,   83,  86,  95,  84,  65,  82,  71,  69,  84,  0,   171, 171, 83,
+    72, 68,  82,  156, 0,   0,   0,   64,  0,   0,   0,   39,  0,   0,   0,   90,  0,   0,   3,
+    0,  96,  16,  0,   0,   0,   0,   0,   88,  24,  0,   4,   0,   112, 16,  0,   0,   0,   0,
+    0,  85,  85,  0,   0,   98,  16,  0,   3,   50,  16,  16,  0,   1,   0,   0,   0,   101, 0,
+    0,  3,   242, 32,  16,  0,   0,   0,   0,   0,   104, 0,   0,   2,   1,   0,   0,   0,   69,
+    0,  0,   9,   242, 0,   16,  0,   0,   0,   0,   0,   70,  16,  16,  0,   1,   0,   0,   0,
+    70, 126, 16,  0,   0,   0,   0,   0,   0,   96,  16,  0,   0,   0,   0,   0,   56,  0,   0,
+    7,  114, 32,  16,  0,   0,   0,   0,   0,   246, 15,  16,  0,   0,   0,   0,   0,   6,   0,
+    16, 0,   0,   0,   0,   0,   54,  0,   0,   5,   130, 32,  16,  0,   0,   0,   0,   0,   58,
+    0,  16,  0,   0,   0,   0,   0,   62,  0,   0,   1,   83,  84,  65,  84,  116, 0,   0,   0,
+    4,  0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,   2,   0,   0,   0,   1,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    1,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,  0};
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_ps.h
new file mode 100644
index 00000000000..333fa69e0ab
--- /dev/null
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_luma_ps.h
@@ -0,0 +1,82 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim Slot Elements
+// ------------------------------ ---------- ------- ----------- ---- --------
+// Sampler                           sampler      NA          NA    0        1
+// TextureF                          texture  float4          2d    0        1
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float
+// TEXCOORD                 0   xy          1     NONE   float   xy
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_TARGET                0   xyzw        0   TARGET   float   xyzw
+//
+ps_4_0
+dcl_sampler s0, mode_default
+dcl_resource_texture2d (float,float,float,float) t0
+dcl_input_ps linear v1.xy
+dcl_output o0.xyzw
+dcl_temps 2
+sample r0.xyzw, v1.xyxx, t0.xyzw, s0
+lt r1.x, l(0.000000), r0.w
+div r0.w, r0.x, r0.w
+movc o0.xyz, r1.xxxx, r0.wwww, r0.xyzx
+mov o0.w, l(1.000000)
+ret
+// Approximately 6 instruction slots used
+#endif
+
+const BYTE g_PS_FtoF_UM_LUMA[] = {
+    68,  88,  66,  67,  64,  125, 110, 227, 139, 187, 78,  166, 27,  154, 215, 226, 168, 30,  14,
+    98,  1,   0,   0,   0,   200, 2,   0,   0,   5,   0,   0,   0,   52,  0,   0,   0,   220, 0,
+    0,   0,   52,  1,   0,   0,   104, 1,   0,   0,   76,  2,   0,   0,   82,  68,  69,  70,  160,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   2,   0,   0,   0,   28,  0,   0,   0,
+    0,   4,   255, 255, 0,   1,   0,   0,   109, 0,   0,   0,   92,  0,   0,   0,   3,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,
+    0,   0,   1,   0,   0,   0,   100, 0,   0,   0,   2,   0,   0,   0,   5,   0,   0,   0,   4,
+    0,   0,   0,   255, 255, 255, 255, 0,   0,   0,   0,   1,   0,   0,   0,   13,  0,   0,   0,
+    83,  97,  109, 112, 108, 101, 114, 0,   84,  101, 120, 116, 117, 114, 101, 70,  0,   77,  105,
+    99,  114, 111, 115, 111, 102, 116, 32,  40,  82,  41,  32,  72,  76,  83,  76,  32,  83,  104,
+    97,  100, 101, 114, 32,  67,  111, 109, 112, 105, 108, 101, 114, 32,  54,  46,  51,  46,  57,
+    54,  48,  48,  46,  49,  54,  51,  56,  52,  0,   171, 73,  83,  71,  78,  80,  0,   0,   0,
+    2,   0,   0,   0,   8,   0,   0,   0,   56,  0,   0,   0,   0,   0,   0,   0,   1,   0,   0,
+    0,   3,   0,   0,   0,   0,   0,   0,   0,   15,  0,   0,   0,   68,  0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   3,   0,   0,   0,   1,   0,   0,   0,   3,   3,   0,   0,   83,
+    86,  95,  80,  79,  83,  73,  84,  73,  79,  78,  0,   84,  69,  88,  67,  79,  79,  82,  68,
+    0,   171, 171, 171, 79,  83,  71,  78,  44,  0,   0,   0,   1,   0,   0,   0,   8,   0,   0,
+    0,   32,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,   0,   0,   0,   0,   0,
+    0,   0,   15,  0,   0,   0,   83,  86,  95,  84,  65,  82,  71,  69,  84,  0,   171, 171, 83,
+    72,  68,  82,  220, 0,   0,   0,   64,  0,   0,   0,   55,  0,   0,   0,   90,  0,   0,   3,
+    0,   96,  16,  0,   0,   0,   0,   0,   88,  24,  0,   4,   0,   112, 16,  0,   0,   0,   0,
+    0,   85,  85,  0,   0,   98,  16,  0,   3,   50,  16,  16,  0,   1,   0,   0,   0,   101, 0,
+    0,   3,   242, 32,  16,  0,   0,   0,   0,   0,   104, 0,   0,   2,   2,   0,   0,   0,   69,
+    0,   0,   9,   242, 0,   16,  0,   0,   0,   0,   0,   70,  16,  16,  0,   1,   0,   0,   0,
+    70,  126, 16,  0,   0,   0,   0,   0,   0,   96,  16,  0,   0,   0,   0,   0,   49,  0,   0,
+    7,   18,  0,   16,  0,   1,   0,   0,   0,   1,   64,  0,   0,   0,   0,   0,   0,   58,  0,
+    16,  0,   0,   0,   0,   0,   14,  0,   0,   7,   130, 0,   16,  0,   0,   0,   0,   0,   10,
+    0,   16,  0,   0,   0,   0,   0,   58,  0,   16,  0,   0,   0,   0,   0,   55,  0,   0,   9,
+    114, 32,  16,  0,   0,   0,   0,   0,   6,   0,   16,  0,   1,   0,   0,   0,   246, 15,  16,
+    0,   0,   0,   0,   0,   70,  2,   16,  0,   0,   0,   0,   0,   54,  0,   0,   5,   130, 32,
+    16,  0,   0,   0,   0,   0,   1,   64,  0,   0,   0,   0,   128, 63,  62,  0,   0,   1,   83,
+    84,  65,  84,  116, 0,   0,   0,   6,   0,   0,   0,   2,   0,   0,   0,   0,   0,   0,   0,
+    2,   0,   0,   0,   2,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   1,   0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0};
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_ps.h
new file mode 100644
index 00000000000..64aeb9ae1fc
--- /dev/null
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/multiplyalpha_ftof_um_lumaalpha_ps.h
@@ -0,0 +1,82 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim Slot Elements
+// ------------------------------ ---------- ------- ----------- ---- --------
+// Sampler                           sampler      NA          NA    0        1
+// TextureF                          texture  float4          2d    0        1
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float
+// TEXCOORD                 0   xy          1     NONE   float   xy
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_TARGET                0   xyzw        0   TARGET   float   xyzw
+//
+ps_4_0
+dcl_sampler s0, mode_default
+dcl_resource_texture2d (float,float,float,float) t0
+dcl_input_ps linear v1.xy
+dcl_output o0.xyzw
+dcl_temps 2
+sample r0.xyzw, v1.xyxx, t0.xyzw, s0
+lt r1.x, l(0.000000), r0.w
+div r1.y, r0.x, r0.w
+movc o0.xyz, r1.xxxx, r1.yyyy, r0.xyzx
+mov o0.w, r0.w
+ret
+// Approximately 6 instruction slots used
+#endif
+
+const BYTE g_PS_FtoF_UM_LUMAALPHA[] = {
+    68,  88,  66,  67,  108, 4,   157, 10,  254, 47,  42,  8,   219, 0,   94,  160, 25,  199, 73,
+    60,  1,   0,   0,   0,   200, 2,   0,   0,   5,   0,   0,   0,   52,  0,   0,   0,   220, 0,
+    0,   0,   52,  1,   0,   0,   104, 1,   0,   0,   76,  2,   0,   0,   82,  68,  69,  70,  160,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   2,   0,   0,   0,   28,  0,   0,   0,
+    0,   4,   255, 255, 0,   1,   0,   0,   109, 0,   0,   0,   92,  0,   0,   0,   3,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,
+    0,   0,   1,   0,   0,   0,   100, 0,   0,   0,   2,   0,   0,   0,   5,   0,   0,   0,   4,
+    0,   0,   0,   255, 255, 255, 255, 0,   0,   0,   0,   1,   0,   0,   0,   13,  0,   0,   0,
+    83,  97,  109, 112, 108, 101, 114, 0,   84,  101, 120, 116, 117, 114, 101, 70,  0,   77,  105,
+    99,  114, 111, 115, 111, 102, 116, 32,  40,  82,  41,  32,  72,  76,  83,  76,  32,  83,  104,
+    97,  100, 101, 114, 32,  67,  111, 109, 112, 105, 108, 101, 114, 32,  54,  46,  51,  46,  57,
+    54,  48,  48,  46,  49,  54,  51,  56,  52,  0,   171, 73,  83,  71,  78,  80,  0,   0,   0,
+    2,   0,   0,   0,   8,   0,   0,   0,   56,  0,   0,   0,   0,   0,   0,   0,   1,   0,   0,
+    0,   3,   0,   0,   0,   0,   0,   0,   0,   15,  0,   0,   0,   68,  0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   3,   0,   0,   0,   1,   0,   0,   0,   3,   3,   0,   0,   83,
+    86,  95,  80,  79,  83,  73,  84,  73,  79,  78,  0,   84,  69,  88,  67,  79,  79,  82,  68,
+    0,   171, 171, 171, 79,  83,  71,  78,  44,  0,   0,   0,   1,   0,   0,   0,   8,   0,   0,
+    0,   32,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,   0,   0,   0,   0,   0,
+    0,   0,   15,  0,   0,   0,   83,  86,  95,  84,  65,  82,  71,  69,  84,  0,   171, 171, 83,
+    72,  68,  82,  220, 0,   0,   0,   64,  0,   0,   0,   55,  0,   0,   0,   90,  0,   0,   3,
+    0,   96,  16,  0,   0,   0,   0,   0,   88,  24,  0,   4,   0,   112, 16,  0,   0,   0,   0,
+    0,   85,  85,  0,   0,   98,  16,  0,   3,   50,  16,  16,  0,   1,   0,   0,   0,   101, 0,
+    0,   3,   242, 32,  16,  0,   0,   0,   0,   0,   104, 0,   0,   2,   2,   0,   0,   0,   69,
+    0,   0,   9,   242, 0,   16,  0,   0,   0,   0,   0,   70,  16,  16,  0,   1,   0,   0,   0,
+    70,  126, 16,  0,   0,   0,   0,   0,   0,   96,  16,  0,   0,   0,   0,   0,   49,  0,   0,
+    7,   18,  0,   16,  0,   1,   0,   0,   0,   1,   64,  0,   0,   0,   0,   0,   0,   58,  0,
+    16,  0,   0,   0,   0,   0,   14,  0,   0,   7,   34,  0,   16,  0,   1,   0,   0,   0,   10,
+    0,   16,  0,   0,   0,   0,   0,   58,  0,   16,  0,   0,   0,   0,   0,   55,  0,   0,   9,
+    114, 32,  16,  0,   0,   0,   0,   0,   6,   0,   16,  0,   1,   0,   0,   0,   86,  5,   16,
+    0,   1,   0,   0,   0,   70,  2,   16,  0,   0,   0,   0,   0,   54,  0,   0,   5,   130, 32,
+    16,  0,   0,   0,   0,   0,   58,  0,   16,  0,   0,   0,   0,   0,   62,  0,   0,   1,   83,
+    84,  65,  84,  116, 0,   0,   0,   6,   0,   0,   0,   2,   0,   0,   0,   0,   0,   0,   0,
+    2,   0,   0,   0,   2,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   1,   0,   0,   0,   1,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0};
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat
index 6aad63d3c52..def2082434c 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat
@@ -40,6 +40,10 @@ call:BuildShader MultiplyAlpha.hlsl PS_FtoU_UM_RGBA ps_4_0 compiled\multiplyalph
 call:BuildShader MultiplyAlpha.hlsl PS_FtoU_PT_RGB  ps_4_0 compiled\multiplyalpha_ftou_pt_rgb_ps.h  %debug%
 call:BuildShader MultiplyAlpha.hlsl PS_FtoU_PM_RGB  ps_4_0 compiled\multiplyalpha_ftou_pm_rgb_ps.h  %debug%
 call:BuildShader MultiplyAlpha.hlsl PS_FtoU_UM_RGB  ps_4_0 compiled\multiplyalpha_ftou_um_rgb_ps.h  %debug%
+call:BuildShader MultiplyAlpha.hlsl PS_FtoF_PM_LUMA ps_4_0 compiled\multiplyalpha_ftof_pm_luma_ps.h  %debug%
+call:BuildShader MultiplyAlpha.hlsl PS_FtoF_UM_LUMA ps_4_0 compiled\multiplyalpha_ftof_um_luma_ps.h  %debug%
+call:BuildShader MultiplyAlpha.hlsl PS_FtoF_PM_LUMAALPHA   ps_4_0 compiled\multiplyalpha_ftof_pm_lumaalpha_ps.h  %debug%
+call:BuildShader MultiplyAlpha.hlsl PS_FtoF_UM_LUMAALPHA   ps_4_0 compiled\multiplyalpha_ftof_um_lumaalpha_ps.h  %debug%
 
 call:BuildShader Clear11.hlsl           VS_Clear_FL9             vs_4_0_level_9_3  compiled\clear11_fl9vs.h             %debug%
 call:BuildShader Clear11.hlsl           PS_ClearFloat_FL9        ps_4_0_level_9_3  compiled\clearfloat11_fl9ps.h        %debug%
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.cpp
index 6648a75fda0..dc1ae4c6530 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.cpp
@@ -103,7 +103,8 @@ gl::Error Blit9::initialize()
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal blit vertex shader, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to create internal blit vertex shader, "
+                                 << gl::FmtHR(result);
     }
 
     void *lockPtr = nullptr;
@@ -113,7 +114,8 @@ gl::Error Blit9::initialize()
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         SafeRelease(mQuadVertexBuffer);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal blit vertex shader, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to lock internal blit vertex shader, "
+                                 << gl::FmtHR(result);
     }
 
     memcpy(lockPtr, quad, sizeof(quad));
@@ -131,7 +133,8 @@ gl::Error Blit9::initialize()
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         SafeRelease(mQuadVertexBuffer);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal blit vertex declaration, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to lock internal blit vertex declaration, "
+                                 << gl::FmtHR(result);
     }
 
     mGeometryLoaded = true;
@@ -162,7 +165,7 @@ gl::Error Blit9::setShader(ShaderId source, const char *profile,
     HRESULT hr = (device->*setShader)(shader);
     if (FAILED(hr))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to set shader for blit operation, result: 0x%X.", hr);
+        return gl::OutOfMemory() << "Failed to set shader for blit operation, " << gl::FmtHR(hr);
     }
 
     return gl::NoError();
@@ -233,7 +236,13 @@ gl::Error Blit9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
     return gl::NoError();
 }
 
-gl::Error Blit9::copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, const gl::Offset &destOffset, TextureStorage *storage, GLint level)
+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_TRY(initialize());
 
@@ -241,7 +250,7 @@ gl::Error Blit9::copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRe
     ASSERT(colorbuffer);
 
     RenderTarget9 *renderTarget9 = nullptr;
-    ANGLE_TRY(colorbuffer->getRenderTarget(&renderTarget9));
+    ANGLE_TRY(colorbuffer->getRenderTarget(context, &renderTarget9));
     ASSERT(renderTarget9);
 
     IDirect3DSurface9 *source = renderTarget9->getSurface();
@@ -249,7 +258,7 @@ gl::Error Blit9::copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRe
 
     IDirect3DSurface9 *destSurface = nullptr;
     TextureStorage9 *storage9      = GetAs<TextureStorage9>(storage);
-    gl::Error error = storage9->getSurfaceLevel(GL_TEXTURE_2D, level, true, &destSurface);
+    gl::Error error = storage9->getSurfaceLevel(context, GL_TEXTURE_2D, level, true, &destSurface);
     if (error.isError())
     {
         SafeRelease(source);
@@ -266,7 +275,14 @@ gl::Error Blit9::copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRe
     return result;
 }
 
-gl::Error Blit9::copyCube(const gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, const gl::Offset &destOffset, TextureStorage *storage, GLenum target, GLint level)
+gl::Error Blit9::copyCube(const gl::Context *context,
+                          const gl::Framebuffer *framebuffer,
+                          const RECT &sourceRect,
+                          GLenum destFormat,
+                          const gl::Offset &destOffset,
+                          TextureStorage *storage,
+                          GLenum target,
+                          GLint level)
 {
     gl::Error error = initialize();
     if (error.isError())
@@ -278,7 +294,7 @@ gl::Error Blit9::copyCube(const gl::Framebuffer *framebuffer, const RECT &source
     ASSERT(colorbuffer);
 
     RenderTarget9 *renderTarget9 = nullptr;
-    error = colorbuffer->getRenderTarget(&renderTarget9);
+    error                        = colorbuffer->getRenderTarget(context, &renderTarget9);
     if (error.isError())
     {
         return error;
@@ -290,7 +306,7 @@ gl::Error Blit9::copyCube(const gl::Framebuffer *framebuffer, const RECT &source
 
     IDirect3DSurface9 *destSurface = nullptr;
     TextureStorage9 *storage9      = GetAs<TextureStorage9>(storage);
-    error = storage9->getSurfaceLevel(target, level, true, &destSurface);
+    error = storage9->getSurfaceLevel(context, target, level, true, &destSurface);
     if (error.isError())
     {
         SafeRelease(source);
@@ -307,7 +323,8 @@ gl::Error Blit9::copyCube(const gl::Framebuffer *framebuffer, const RECT &source
     return result;
 }
 
-gl::Error Blit9::copyTexture(const gl::Texture *source,
+gl::Error Blit9::copyTexture(const gl::Context *context,
+                             const gl::Texture *source,
                              GLint sourceLevel,
                              const RECT &sourceRect,
                              GLenum destFormat,
@@ -324,7 +341,7 @@ gl::Error Blit9::copyTexture(const gl::Texture *source,
     const TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source);
 
     TextureStorage *sourceStorage = nullptr;
-    ANGLE_TRY(const_cast<TextureD3D *>(sourceD3D)->getNativeTexture(&sourceStorage));
+    ANGLE_TRY(const_cast<TextureD3D *>(sourceD3D)->getNativeTexture(context, &sourceStorage));
 
     TextureStorage9_2D *sourceStorage9 = GetAs<TextureStorage9_2D>(sourceStorage);
     ASSERT(sourceStorage9);
@@ -334,13 +351,15 @@ gl::Error Blit9::copyTexture(const gl::Texture *source,
 
     ASSERT(sourceLevel == 0);
     IDirect3DBaseTexture9 *sourceTexture = nullptr;
-    ANGLE_TRY(sourceStorage9->getBaseTexture(&sourceTexture));
+    ANGLE_TRY(sourceStorage9->getBaseTexture(context, &sourceTexture));
 
     IDirect3DSurface9 *sourceSurface = nullptr;
-    ANGLE_TRY(sourceStorage9->getSurfaceLevel(GL_TEXTURE_2D, sourceLevel, true, &sourceSurface));
+    ANGLE_TRY(
+        sourceStorage9->getSurfaceLevel(context, GL_TEXTURE_2D, sourceLevel, true, &sourceSurface));
 
     IDirect3DSurface9 *destSurface = nullptr;
-    gl::Error error = destStorage9->getSurfaceLevel(destTarget, destLevel, true, &destSurface);
+    gl::Error error =
+        destStorage9->getSurfaceLevel(context, destTarget, destLevel, true, &destSurface);
     if (error.isError())
     {
         SafeRelease(sourceSurface);
@@ -386,7 +405,8 @@ gl::Error Blit9::copy(IDirect3DSurface9 *source,
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to blit between textures, StretchRect result: 0x%X.", result);
+            return gl::OutOfMemory()
+                   << "Failed to blit between textures, StretchRect " << gl::FmtHR(result);
         }
 
         return gl::NoError();
@@ -632,7 +652,8 @@ gl::Error Blit9::copySurfaceToTexture(IDirect3DSurface9 *surface,
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal texture for blit, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to allocate internal texture for blit, "
+                                 << gl::FmtHR(result);
     }
 
     IDirect3DSurface9 *textureSurface;
@@ -642,7 +663,8 @@ gl::Error Blit9::copySurfaceToTexture(IDirect3DSurface9 *surface,
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         SafeRelease(texture);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to query surface of internal blit texture, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to query surface of internal blit texture, "
+                                 << gl::FmtHR(result);
     }
 
     mRenderer->endScene();
@@ -654,7 +676,8 @@ gl::Error Blit9::copySurfaceToTexture(IDirect3DSurface9 *surface,
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         SafeRelease(texture);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to copy between internal blit textures, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to copy between internal blit textures, "
+                                 << gl::FmtHR(result);
     }
 
     *outTexture = texture;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.h
index 926c591a633..026874f8ae3 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Blit9.h
@@ -16,6 +16,7 @@
 
 namespace gl
 {
+class Context;
 class Framebuffer;
 class Texture;
 struct Extents;
@@ -37,15 +38,23 @@ class Blit9 : angle::NonCopyable
 
     // Copy from source surface to dest surface.
     // sourceRect, xoffset, yoffset are in D3D coordinates (0,0 in upper-left)
-    gl::Error copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, const gl::Offset &destOffset, TextureStorage *storage, GLint level);
-    gl::Error copyCube(const gl::Framebuffer *framebuffer,
+    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,
                        GLenum target,
                        GLint level);
-    gl::Error copyTexture(const gl::Texture *source,
+    gl::Error copyTexture(const gl::Context *context,
+                          const gl::Texture *source,
                           GLint sourceLevel,
                           const RECT &sourceRect,
                           GLenum destFormat,
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp
index 534a2524a96..5cadcdc5092 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp
@@ -22,7 +22,7 @@ Buffer9::~Buffer9()
     mSize = 0;
 }
 
-gl::Error Buffer9::setData(ContextImpl * /*context*/,
+gl::Error Buffer9::setData(const gl::Context * /*context*/,
                            GLenum /*target*/,
                            const void *data,
                            size_t size,
@@ -32,7 +32,7 @@ gl::Error Buffer9::setData(ContextImpl * /*context*/,
     {
         if (!mMemory.resize(size))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to resize internal buffer.");
+            return gl::OutOfMemory() << "Failed to resize internal buffer.";
         }
     }
 
@@ -55,7 +55,7 @@ gl::Error Buffer9::getData(const uint8_t **outData)
     return gl::NoError();
 }
 
-gl::Error Buffer9::setSubData(ContextImpl * /*context*/,
+gl::Error Buffer9::setSubData(const gl::Context * /*context*/,
                               GLenum /*target*/,
                               const void *data,
                               size_t size,
@@ -65,7 +65,7 @@ gl::Error Buffer9::setSubData(ContextImpl * /*context*/,
     {
         if (!mMemory.resize(offset + size))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to resize internal buffer.");
+            return gl::OutOfMemory() << "Failed to resize internal buffer.";
         }
     }
 
@@ -80,7 +80,7 @@ gl::Error Buffer9::setSubData(ContextImpl * /*context*/,
     return gl::NoError();
 }
 
-gl::Error Buffer9::copySubData(ContextImpl *context,
+gl::Error Buffer9::copySubData(const gl::Context *context,
                                BufferImpl *source,
                                GLintptr sourceOffset,
                                GLintptr destOffset,
@@ -98,32 +98,32 @@ gl::Error Buffer9::copySubData(ContextImpl *context,
 }
 
 // We do not support buffer mapping in D3D9
-gl::Error Buffer9::map(ContextImpl *context, GLenum access, void **mapPtr)
+gl::Error Buffer9::map(const gl::Context *context, GLenum access, void **mapPtr)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error Buffer9::mapRange(ContextImpl *context,
+gl::Error Buffer9::mapRange(const gl::Context *context,
                             size_t offset,
                             size_t length,
                             GLbitfield access,
                             void **mapPtr)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error Buffer9::unmap(ContextImpl *context, GLboolean *result)
+gl::Error Buffer9::unmap(const gl::Context *context, GLboolean *result)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
 gl::Error Buffer9::markTransformFeedbackUsage()
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.h
index a0a6ccc977c..6173afa09e1 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Buffer9.h
@@ -29,28 +29,28 @@ class Buffer9 : public BufferD3D
     gl::Error getData(const uint8_t **outData) override;
 
     // BufferImpl implementation
-    gl::Error setData(ContextImpl *context,
+    gl::Error setData(const gl::Context *context,
                       GLenum target,
                       const void *data,
                       size_t size,
                       GLenum usage) override;
-    gl::Error setSubData(ContextImpl *context,
+    gl::Error setSubData(const gl::Context *context,
                          GLenum target,
                          const void *data,
                          size_t size,
                          size_t offset) override;
-    gl::Error copySubData(ContextImpl *context,
+    gl::Error copySubData(const gl::Context *context,
                           BufferImpl *source,
                           GLintptr sourceOffset,
                           GLintptr destOffset,
                           GLsizeiptr size) override;
-    gl::Error map(ContextImpl *context, GLenum access, void **mapPtr) override;
-    gl::Error mapRange(ContextImpl *context,
+    gl::Error map(const gl::Context *context, GLenum access, void **mapPtr) override;
+    gl::Error mapRange(const gl::Context *context,
                        size_t offset,
                        size_t length,
                        GLbitfield access,
                        void **mapPtr) override;
-    gl::Error unmap(ContextImpl *context, GLboolean *result) override;
+    gl::Error unmap(const gl::Context *context, GLboolean *result) override;
     gl::Error markTransformFeedbackUsage() override;
 
   private:
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.cpp
index 326398076fb..6d89ad747d1 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.cpp
@@ -135,39 +135,44 @@ gl::Error Context9::finish()
     return mRenderer->finish();
 }
 
-gl::Error Context9::drawArrays(GLenum mode, GLint first, GLsizei count)
+gl::Error Context9::drawArrays(const gl::Context *context, GLenum mode, GLint first, GLsizei count)
 {
-    return mRenderer->genericDrawArrays(this, mode, first, count, 0);
+    return mRenderer->genericDrawArrays(context, mode, first, count, 0);
 }
 
-gl::Error Context9::drawArraysInstanced(GLenum mode,
+gl::Error Context9::drawArraysInstanced(const gl::Context *context,
+                                        GLenum mode,
                                         GLint first,
                                         GLsizei count,
                                         GLsizei instanceCount)
 {
-    return mRenderer->genericDrawArrays(this, mode, first, count, instanceCount);
+    return mRenderer->genericDrawArrays(context, mode, first, count, instanceCount);
 }
 
-gl::Error Context9::drawElements(GLenum mode,
+gl::Error Context9::drawElements(const gl::Context *context,
+                                 GLenum mode,
                                  GLsizei count,
                                  GLenum type,
                                  const void *indices,
                                  const gl::IndexRange &indexRange)
 {
-    return mRenderer->genericDrawElements(this, mode, count, type, indices, 0, indexRange);
+    return mRenderer->genericDrawElements(context, mode, count, type, indices, 0, indexRange);
 }
 
-gl::Error Context9::drawElementsInstanced(GLenum mode,
+gl::Error Context9::drawElementsInstanced(const gl::Context *context,
+                                          GLenum mode,
                                           GLsizei count,
                                           GLenum type,
                                           const void *indices,
                                           GLsizei instances,
                                           const gl::IndexRange &indexRange)
 {
-    return mRenderer->genericDrawElements(this, mode, count, type, indices, instances, indexRange);
+    return mRenderer->genericDrawElements(context, mode, count, type, indices, instances,
+                                          indexRange);
 }
 
-gl::Error Context9::drawRangeElements(GLenum mode,
+gl::Error Context9::drawRangeElements(const gl::Context *context,
+                                      GLenum mode,
                                       GLuint start,
                                       GLuint end,
                                       GLsizei count,
@@ -175,16 +180,21 @@ gl::Error Context9::drawRangeElements(GLenum mode,
                                       const void *indices,
                                       const gl::IndexRange &indexRange)
 {
-    return mRenderer->genericDrawElements(this, mode, count, type, indices, 0, indexRange);
+    return mRenderer->genericDrawElements(context, mode, count, type, indices, 0, indexRange);
 }
 
-gl::Error Context9::drawArraysIndirect(GLenum mode, const void *indirect)
+gl::Error Context9::drawArraysIndirect(const gl::Context *context,
+                                       GLenum mode,
+                                       const void *indirect)
 {
     UNREACHABLE();
     return gl::InternalError() << "D3D9 doesn't support ES 3.1 DrawArraysIndirect API";
 }
 
-gl::Error Context9::drawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
+gl::Error Context9::drawElementsIndirect(const gl::Context *context,
+                                         GLenum mode,
+                                         GLenum type,
+                                         const void *indirect)
 {
     UNREACHABLE();
     return gl::InternalError() << "D3D9 doesn't support ES 3.1 DrawElementsIndirect API";
@@ -228,7 +238,7 @@ void Context9::popGroupMarker()
     mRenderer->getAnnotator()->endEvent();
 }
 
-void Context9::syncState(const gl::State::DirtyBits &dirtyBits)
+void Context9::syncState(const gl::Context *context, const gl::State::DirtyBits &dirtyBits)
 {
     mRenderer->getStateManager()->syncState(mState.getState(), dirtyBits);
 }
@@ -243,7 +253,7 @@ GLint64 Context9::getTimestamp()
     return mRenderer->getTimestamp();
 }
 
-void Context9::onMakeCurrent(const gl::ContextState &data)
+void Context9::onMakeCurrent(const gl::Context *context)
 {
 }
 
@@ -267,7 +277,10 @@ const gl::Limitations &Context9::getNativeLimitations() const
     return mRenderer->getNativeLimitations();
 }
 
-gl::Error Context9::dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ)
+gl::Error Context9::dispatchCompute(const gl::Context *context,
+                                    GLuint numGroupsX,
+                                    GLuint numGroupsY,
+                                    GLuint numGroupsZ)
 {
     UNREACHABLE();
     return gl::InternalError() << "D3D9 doesn't support ES 3.1 DispatchCompute API";
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.h
index f69ed97d26f..f71275f4ef6 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Context9.h
@@ -64,32 +64,44 @@ class Context9 : public ContextImpl
     gl::Error finish() override;
 
     // Drawing methods.
-    gl::Error drawArrays(GLenum mode, GLint first, GLsizei count) override;
-    gl::Error drawArraysInstanced(GLenum mode,
+    gl::Error drawArrays(const gl::Context *context,
+                         GLenum mode,
+                         GLint first,
+                         GLsizei count) override;
+    gl::Error drawArraysInstanced(const gl::Context *context,
+                                  GLenum mode,
                                   GLint first,
                                   GLsizei count,
                                   GLsizei instanceCount) override;
 
-    gl::Error drawElements(GLenum mode,
+    gl::Error drawElements(const gl::Context *context,
+                           GLenum mode,
                            GLsizei count,
                            GLenum type,
                            const void *indices,
                            const gl::IndexRange &indexRange) override;
-    gl::Error drawElementsInstanced(GLenum mode,
+    gl::Error drawElementsInstanced(const gl::Context *context,
+                                    GLenum mode,
                                     GLsizei count,
                                     GLenum type,
                                     const void *indices,
                                     GLsizei instances,
                                     const gl::IndexRange &indexRange) override;
-    gl::Error drawRangeElements(GLenum mode,
+    gl::Error drawRangeElements(const gl::Context *context,
+                                GLenum mode,
                                 GLuint start,
                                 GLuint end,
                                 GLsizei count,
                                 GLenum type,
                                 const void *indices,
                                 const gl::IndexRange &indexRange) override;
-    gl::Error drawArraysIndirect(GLenum mode, const void *indirect) override;
-    gl::Error drawElementsIndirect(GLenum mode, GLenum type, const void *indirect) override;
+    gl::Error drawArraysIndirect(const gl::Context *context,
+                                 GLenum mode,
+                                 const void *indirect) override;
+    gl::Error drawElementsIndirect(const gl::Context *context,
+                                   GLenum mode,
+                                   GLenum type,
+                                   const void *indirect) override;
 
     // Device loss
     GLenum getResetStatus() override;
@@ -104,14 +116,14 @@ class Context9 : public ContextImpl
     void popGroupMarker() override;
 
     // State sync with dirty bits.
-    void syncState(const gl::State::DirtyBits &dirtyBits) override;
+    void syncState(const gl::Context *context, const gl::State::DirtyBits &dirtyBits) override;
 
     // Disjoint timer queries
     GLint getGPUDisjoint() override;
     GLint64 getTimestamp() override;
 
     // Context switching
-    void onMakeCurrent(const gl::ContextState &data) override;
+    void onMakeCurrent(const gl::Context *context) override;
 
     // Caps queries
     const gl::Caps &getNativeCaps() const override;
@@ -119,7 +131,10 @@ class Context9 : public ContextImpl
     const gl::Extensions &getNativeExtensions() const override;
     const gl::Limitations &getNativeLimitations() const override;
 
-    gl::Error dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ) override;
+    gl::Error dispatchCompute(const gl::Context *context,
+                              GLuint numGroupsX,
+                              GLuint numGroupsY,
+                              GLuint numGroupsZ) override;
 
   private:
     Renderer9 *mRenderer;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Fence9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Fence9.cpp
index 6779f56f2d8..bff38816555 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Fence9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Fence9.cpp
@@ -38,7 +38,7 @@ gl::Error FenceNV9::set(GLenum condition)
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         SafeRelease(mQuery);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to end event query, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to end event query, " << gl::FmtHR(result);
     }
 
     return gl::NoError();
@@ -76,11 +76,11 @@ gl::Error FenceNV9::testHelper(bool flushCommandBuffer, GLboolean *outFinished)
     if (d3d9::isDeviceLostError(result))
     {
         mRenderer->notifyDeviceLost();
-        return gl::Error(GL_OUT_OF_MEMORY, "Device was lost while querying result of an event query.");
+        return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
     }
     else if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to get query data, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to get query data, " << gl::FmtHR(result);
     }
 
     ASSERT(result == S_OK || result == S_FALSE);
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp
index 9155c98cd1e..97ecd6cc151 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp
@@ -8,18 +8,19 @@
 
 #include "libANGLE/renderer/d3d/d3d9/Framebuffer9.h"
 
+#include "libANGLE/Context.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/Texture.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/ContextImpl.h"
-#include "libANGLE/renderer/renderer_utils.h"
 #include "libANGLE/renderer/d3d/TextureD3D.h"
-#include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
 #include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h"
+#include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
 #include "libANGLE/renderer/d3d/d3d9/TextureStorage9.h"
 #include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
 #include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h"
+#include "libANGLE/renderer/renderer_utils.h"
 
 namespace rx
 {
@@ -34,38 +35,36 @@ Framebuffer9::~Framebuffer9()
 {
 }
 
-gl::Error Framebuffer9::discard(size_t, const GLenum *)
+gl::Error Framebuffer9::discard(const gl::Context *context, size_t, const GLenum *)
 {
     // Extension not implemented in D3D9 renderer
     UNREACHABLE();
     return gl::NoError();
 }
 
-gl::Error Framebuffer9::invalidate(size_t, const GLenum *)
+gl::Error Framebuffer9::invalidate(const gl::Context *context, size_t, const GLenum *)
 {
     // Shouldn't ever reach here in D3D9
     UNREACHABLE();
     return gl::NoError();
 }
 
-gl::Error Framebuffer9::invalidateSub(size_t, const GLenum *, const gl::Rectangle &)
+gl::Error Framebuffer9::invalidateSub(const gl::Context *context,
+                                      size_t,
+                                      const GLenum *,
+                                      const gl::Rectangle &)
 {
     // Shouldn't ever reach here in D3D9
     UNREACHABLE();
     return gl::NoError();
 }
 
-gl::Error Framebuffer9::clearImpl(ContextImpl *context, const ClearParameters &clearParams)
+gl::Error Framebuffer9::clearImpl(const gl::Context *context, const ClearParameters &clearParams)
 {
     const gl::FramebufferAttachment *colorAttachment        = mState.getColorAttachment(0);
     const gl::FramebufferAttachment *depthStencilAttachment = mState.getDepthOrStencilAttachment();
 
-    gl::Error error =
-        mRenderer->applyRenderTarget(context, colorAttachment, depthStencilAttachment);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(mRenderer->applyRenderTarget(context, colorAttachment, depthStencilAttachment));
 
     const gl::State &glState = context->getGLState();
     float nearZ              = glState.getNearPlane();
@@ -75,10 +74,11 @@ gl::Error Framebuffer9::clearImpl(ContextImpl *context, const ClearParameters &c
 
     mRenderer->setScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled());
 
-    return mRenderer->clear(clearParams, colorAttachment, depthStencilAttachment);
+    return mRenderer->clear(context, clearParams, colorAttachment, depthStencilAttachment);
 }
 
-gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
+gl::Error Framebuffer9::readPixelsImpl(const gl::Context *context,
+                                       const gl::Rectangle &area,
                                        GLenum format,
                                        GLenum type,
                                        size_t outputPitch,
@@ -91,11 +91,7 @@ gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
     ASSERT(colorbuffer);
 
     RenderTarget9 *renderTarget = nullptr;
-    gl::Error error = colorbuffer->getRenderTarget(&renderTarget);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(colorbuffer->getRenderTarget(context, &renderTarget));
     ASSERT(renderTarget);
 
     IDirect3DSurface9 *surface = renderTarget->getSurface();
@@ -108,7 +104,8 @@ gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
     {
         UNIMPLEMENTED();   // FIXME: Requires resolve using StretchRect into non-multisampled render target
         SafeRelease(surface);
-        return gl::Error(GL_OUT_OF_MEMORY, "ReadPixels is unimplemented for multisampled framebuffer attachments.");
+        return gl::OutOfMemory()
+               << "ReadPixels is unimplemented for multisampled framebuffer attachments.";
     }
 
     IDirect3DDevice9 *device = mRenderer->getDevice();
@@ -140,7 +137,7 @@ gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
             SafeRelease(surface);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal texture for ReadPixels.");
+            return gl::OutOfMemory() << "Failed to allocate internal texture for ReadPixels.";
         }
     }
 
@@ -162,7 +159,7 @@ gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
             UNREACHABLE();
         }
 
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to read internal render target data.");
+        return gl::OutOfMemory() << "Failed to read internal render target data.";
     }
 
     if (directToPixels)
@@ -185,7 +182,7 @@ gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
         UNREACHABLE();
         SafeRelease(systemSurface);
 
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal render target.");
+        return gl::OutOfMemory() << "Failed to lock internal render target.";
     }
 
     uint8_t *source = reinterpret_cast<uint8_t *>(lock.pBits);
@@ -203,7 +200,7 @@ gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
     packParams.format      = format;
     packParams.type        = type;
     packParams.outputPitch = static_cast<GLuint>(outputPitch);
-    packParams.pack        = pack;
+    packParams.pack.copyFrom(context, pack);
 
     PackPixels(packParams, d3dFormatInfo.info(), inputPitch, source, pixels);
 
@@ -213,7 +210,8 @@ gl::Error Framebuffer9::readPixelsImpl(const gl::Rectangle &area,
     return gl::NoError();
 }
 
-gl::Error Framebuffer9::blitImpl(const gl::Rectangle &sourceArea,
+gl::Error Framebuffer9::blitImpl(const gl::Context *context,
+                                 const gl::Rectangle &sourceArea,
                                  const gl::Rectangle &destArea,
                                  const gl::Rectangle *scissor,
                                  bool blitRenderTarget,
@@ -235,7 +233,7 @@ gl::Error Framebuffer9::blitImpl(const gl::Rectangle &sourceArea,
         ASSERT(readBuffer);
 
         RenderTarget9 *readRenderTarget = nullptr;
-        gl::Error error = readBuffer->getRenderTarget(&readRenderTarget);
+        gl::Error error                 = readBuffer->getRenderTarget(context, &readRenderTarget);
         if (error.isError())
         {
             return error;
@@ -246,7 +244,7 @@ gl::Error Framebuffer9::blitImpl(const gl::Rectangle &sourceArea,
         ASSERT(drawBuffer);
 
         RenderTarget9 *drawRenderTarget = nullptr;
-        error = drawBuffer->getRenderTarget(&drawRenderTarget);
+        error                           = drawBuffer->getRenderTarget(context, &drawRenderTarget);
         if (error.isError())
         {
             return error;
@@ -351,7 +349,7 @@ gl::Error Framebuffer9::blitImpl(const gl::Rectangle &sourceArea,
 
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Internal blit failed, StretchRect returned 0x%X.", result);
+            return gl::OutOfMemory() << "Internal blit failed, StretchRect " << gl::FmtHR(result);
         }
     }
 
@@ -361,7 +359,7 @@ gl::Error Framebuffer9::blitImpl(const gl::Rectangle &sourceArea,
         ASSERT(readBuffer);
 
         RenderTarget9 *readDepthStencil = nullptr;
-        gl::Error error = readBuffer->getRenderTarget(&readDepthStencil);
+        gl::Error error                 = readBuffer->getRenderTarget(context, &readDepthStencil);
         if (error.isError())
         {
             return error;
@@ -372,7 +370,7 @@ gl::Error Framebuffer9::blitImpl(const gl::Rectangle &sourceArea,
         ASSERT(drawBuffer);
 
         RenderTarget9 *drawDepthStencil = nullptr;
-        error = drawBuffer->getRenderTarget(&drawDepthStencil);
+        error                           = drawBuffer->getRenderTarget(context, &drawDepthStencil);
         if (error.isError())
         {
             return error;
@@ -393,7 +391,7 @@ gl::Error Framebuffer9::blitImpl(const gl::Rectangle &sourceArea,
 
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Internal blit failed, StretchRect returned 0x%X.", result);
+            return gl::OutOfMemory() << "Internal blit failed, StretchRect " << gl::FmtHR(result);
         }
     }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.h
index 8401350b3d9..9d8d5e176b0 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Framebuffer9.h
@@ -21,21 +21,28 @@ class Framebuffer9 : public FramebufferD3D
     Framebuffer9(const gl::FramebufferState &data, Renderer9 *renderer);
     virtual ~Framebuffer9();
 
-    gl::Error discard(size_t count, const GLenum *attachments) override;
-    gl::Error invalidate(size_t count, const GLenum *attachments) override;
-    gl::Error invalidateSub(size_t count, const GLenum *attachments, const gl::Rectangle &area) override;
+    gl::Error discard(const gl::Context *context, size_t count, const GLenum *attachments) override;
+    gl::Error invalidate(const gl::Context *context,
+                         size_t count,
+                         const GLenum *attachments) override;
+    gl::Error invalidateSub(const gl::Context *context,
+                            size_t count,
+                            const GLenum *attachments,
+                            const gl::Rectangle &area) override;
 
   private:
-    gl::Error clearImpl(ContextImpl *context, const ClearParameters &clearParams) override;
+    gl::Error clearImpl(const gl::Context *context, const ClearParameters &clearParams) override;
 
-    gl::Error readPixelsImpl(const gl::Rectangle &area,
+    gl::Error readPixelsImpl(const gl::Context *context,
+                             const gl::Rectangle &area,
                              GLenum format,
                              GLenum type,
                              size_t outputPitch,
                              const gl::PixelPackState &pack,
                              uint8_t *pixels) const override;
 
-    gl::Error blitImpl(const gl::Rectangle &sourceArea,
+    gl::Error blitImpl(const gl::Context *context,
+                       const gl::Rectangle &sourceArea,
                        const gl::Rectangle &destArea,
                        const gl::Rectangle *scissor,
                        bool blitRenderTarget,
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.cpp
index d3b4dc25aa0..089414b5c2e 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.cpp
@@ -45,7 +45,9 @@ gl::Error Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9
     ASSERT(SUCCEEDED(result));
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to query the source surface description for mipmap generation, result: 0x%X.", result);
+        return gl::OutOfMemory()
+               << "Failed to query the source surface description for mipmap generation, "
+               << gl::FmtHR(result);
     }
 
     D3DSURFACE_DESC sourceDesc;
@@ -53,7 +55,9 @@ gl::Error Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9
     ASSERT(SUCCEEDED(result));
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to query the destination surface description for mipmap generation, result: 0x%X.", result);
+        return gl::OutOfMemory()
+               << "Failed to query the destination surface description for mipmap generation, "
+               << gl::FmtHR(result);
     }
 
     ASSERT(sourceDesc.Format == destDesc.Format);
@@ -68,7 +72,8 @@ gl::Error Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9
     ASSERT(SUCCEEDED(result));
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock the source surface for mipmap generation, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to lock the source surface for mipmap generation, "
+                                 << gl::FmtHR(result);
     }
 
     D3DLOCKED_RECT destLocked = {0};
@@ -77,7 +82,8 @@ gl::Error Image9::generateMip(IDirect3DSurface9 *destSurface, IDirect3DSurface9
     if (FAILED(result))
     {
         sourceSurface->UnlockRect();
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock the destination surface for mipmap generation, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to lock the destination surface for mipmap generation, "
+                                 << gl::FmtHR(result);
     }
 
     const uint8_t *sourceData = reinterpret_cast<const uint8_t*>(sourceLocked.pBits);
@@ -132,14 +138,14 @@ gl::Error Image9::copyLockableSurfaces(IDirect3DSurface9 *dest, IDirect3DSurface
     result = source->LockRect(&sourceLock, nullptr, 0);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock source surface for copy, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to lock source surface for copy, " << gl::FmtHR(result);
     }
 
     result = dest->LockRect(&destLock, nullptr, 0);
     if (FAILED(result))
     {
         source->UnlockRect();
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock source surface for copy, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to lock source surface for copy, " << gl::FmtHR(result);
     }
 
     ASSERT(sourceLock.pBits && destLock.pBits);
@@ -225,7 +231,7 @@ gl::Error Image9::createSurface()
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create image surface, result: 0x%X.", result);
+            return gl::OutOfMemory() << "Failed to create image surface, " << gl::FmtHR(result);
         }
 
         newTexture->GetSurfaceLevel(levelToFetch, &newSurface);
@@ -245,7 +251,7 @@ gl::Error Image9::createSurface()
             ASSERT(SUCCEEDED(result));
             if (FAILED(result))
             {
-                return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock image surface, result: 0x%X.", result);
+                return gl::OutOfMemory() << "Failed to lock image surface, " << gl::FmtHR(result);
             }
 
             d3dFormatInfo.dataInitializerFunction(mWidth, mHeight, 1, reinterpret_cast<uint8_t*>(lockedRect.pBits),
@@ -255,7 +261,7 @@ gl::Error Image9::createSurface()
             ASSERT(SUCCEEDED(result));
             if (FAILED(result))
             {
-                return gl::Error(GL_OUT_OF_MEMORY, "Failed to unlock image surface, result: 0x%X.", result);
+                return gl::OutOfMemory() << "Failed to unlock image surface, " << gl::FmtHR(result);
             }
         }
     }
@@ -281,7 +287,7 @@ gl::Error Image9::lock(D3DLOCKED_RECT *lockedRect, const RECT &rect)
         ASSERT(SUCCEEDED(result));
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock image surface, result: 0x%X.", result);
+            return gl::OutOfMemory() << "Failed to lock image surface, " << gl::FmtHR(result);
         }
 
         mDirty = true;
@@ -329,11 +335,13 @@ gl::Error Image9::getSurface(IDirect3DSurface9 **outSurface)
     return gl::NoError();
 }
 
-gl::Error Image9::setManagedSurface2D(TextureStorage *storage, int level)
+gl::Error Image9::setManagedSurface2D(const gl::Context *context,
+                                      TextureStorage *storage,
+                                      int level)
 {
     IDirect3DSurface9 *surface = nullptr;
     TextureStorage9 *storage9  = GetAs<TextureStorage9>(storage);
-    gl::Error error = storage9->getSurfaceLevel(GL_TEXTURE_2D, level, false, &surface);
+    gl::Error error = storage9->getSurfaceLevel(context, GL_TEXTURE_2D, level, false, &surface);
     if (error.isError())
     {
         return error;
@@ -341,12 +349,15 @@ gl::Error Image9::setManagedSurface2D(TextureStorage *storage, int level)
     return setManagedSurface(surface);
 }
 
-gl::Error Image9::setManagedSurfaceCube(TextureStorage *storage, int face, int level)
+gl::Error Image9::setManagedSurfaceCube(const gl::Context *context,
+                                        TextureStorage *storage,
+                                        int face,
+                                        int level)
 {
     IDirect3DSurface9 *surface = nullptr;
     TextureStorage9 *storage9 = GetAs<TextureStorage9>(storage);
-    gl::Error error =
-        storage9->getSurfaceLevel(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, false, &surface);
+    gl::Error error = storage9->getSurfaceLevel(context, GL_TEXTURE_CUBE_MAP_POSITIVE_X + face,
+                                                level, false, &surface);
     if (error.isError())
     {
         return error;
@@ -379,7 +390,10 @@ gl::Error Image9::setManagedSurface(IDirect3DSurface9 *surface)
     return gl::NoError();
 }
 
-gl::Error Image9::copyToStorage(TextureStorage *storage, const gl::ImageIndex &index, const gl::Box &region)
+gl::Error Image9::copyToStorage(const gl::Context *context,
+                                TextureStorage *storage,
+                                const gl::ImageIndex &index,
+                                const gl::Box &region)
 {
     gl::Error error = createSurface();
     if (error.isError())
@@ -393,7 +407,8 @@ gl::Error Image9::copyToStorage(TextureStorage *storage, const gl::ImageIndex &i
 
     if (index.type == GL_TEXTURE_2D)
     {
-        error = storage9->getSurfaceLevel(GL_TEXTURE_2D, index.mipIndex, true, &destSurface);
+        error =
+            storage9->getSurfaceLevel(context, GL_TEXTURE_2D, index.mipIndex, true, &destSurface);
         if (error.isError())
         {
             return error;
@@ -402,7 +417,7 @@ gl::Error Image9::copyToStorage(TextureStorage *storage, const gl::ImageIndex &i
     else
     {
         ASSERT(gl::IsCubeMapTextureTarget(index.type));
-        error = storage9->getSurfaceLevel(index.type, index.mipIndex, true, &destSurface);
+        error = storage9->getSurfaceLevel(context, index.type, index.mipIndex, true, &destSurface);
         if (error.isError())
         {
             return error;
@@ -448,7 +463,8 @@ gl::Error Image9::copyToSurface(IDirect3DSurface9 *destSurface, const gl::Box &a
                                                              D3DPOOL_SYSTEMMEM, &surf, nullptr);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Internal CreateOffscreenPlainSurface call failed, result: 0x%X.", result);
+            return gl::OutOfMemory()
+                   << "Internal CreateOffscreenPlainSurface call failed, " << gl::FmtHR(result);
         }
 
         copyLockableSurfaces(surf, sourceSurface);
@@ -457,7 +473,7 @@ gl::Error Image9::copyToSurface(IDirect3DSurface9 *destSurface, const gl::Box &a
         ASSERT(SUCCEEDED(result));
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Internal UpdateSurface call failed, result: 0x%X.", result);
+            return gl::OutOfMemory() << "Internal UpdateSurface call failed, " << gl::FmtHR(result);
         }
     }
     else
@@ -467,7 +483,7 @@ gl::Error Image9::copyToSurface(IDirect3DSurface9 *destSurface, const gl::Box &a
         ASSERT(SUCCEEDED(result));
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Internal UpdateSurface call failed, result: 0x%X.", result);
+            return gl::OutOfMemory() << "Internal UpdateSurface call failed, " << gl::FmtHR(result);
         }
     }
 
@@ -476,7 +492,8 @@ gl::Error Image9::copyToSurface(IDirect3DSurface9 *destSurface, const gl::Box &a
 
 // Store the pixel rectangle designated by xoffset,yoffset,width,height with pixels stored as format/type at input
 // into the target pixel rectangle.
-gl::Error Image9::loadData(const gl::Box &area,
+gl::Error Image9::loadData(const gl::Context *context,
+                           const gl::Box &area,
                            const gl::PixelUnpackState &unpack,
                            GLenum type,
                            const void *input,
@@ -519,7 +536,9 @@ gl::Error Image9::loadData(const gl::Box &area,
     return gl::NoError();
 }
 
-gl::Error Image9::loadCompressedData(const gl::Box &area, const void *input)
+gl::Error Image9::loadCompressedData(const gl::Context *context,
+                                     const gl::Box &area,
+                                     const void *input)
 {
     // 3D textures are not supported by the D3D9 backend.
     ASSERT(area.z == 0 && area.depth == 1);
@@ -588,7 +607,8 @@ gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
     if (FAILED(result))
     {
         SafeRelease(surface);
-        return gl::Error(GL_OUT_OF_MEMORY, "Could not create matching destination surface, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Could not create matching destination surface, "
+                                 << gl::FmtHR(result);
     }
 
     result = device->GetRenderTargetData(surface, renderTargetData);
@@ -597,7 +617,8 @@ gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
     {
         SafeRelease(renderTargetData);
         SafeRelease(surface);
-        return gl::Error(GL_OUT_OF_MEMORY, "GetRenderTargetData unexpectedly failed, result: 0x%X.", result);
+        return gl::OutOfMemory() << "GetRenderTargetData unexpectedly failed, "
+                                 << gl::FmtHR(result);
     }
 
     int width = sourceArea.width;
@@ -613,7 +634,9 @@ gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
     {
         SafeRelease(renderTargetData);
         SafeRelease(surface);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock the source surface (rectangle might be invalid), result: 0x%X.", result);
+        return gl::OutOfMemory()
+               << "Failed to lock the source surface (rectangle might be invalid), "
+               << gl::FmtHR(result);
     }
 
     D3DLOCKED_RECT destLock = {0};
@@ -793,10 +816,12 @@ gl::Error Image9::copyFromRTInternal(const gl::Offset &destOffset,
     return gl::NoError();
 }
 
-gl::Error Image9::copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureStorage *source)
+gl::Error Image9::copyFromTexStorage(const gl::Context *context,
+                                     const gl::ImageIndex &imageIndex,
+                                     TextureStorage *source)
 {
     RenderTargetD3D *renderTarget = nullptr;
-    gl::Error error = source->getRenderTarget(imageIndex, &renderTarget);
+    gl::Error error               = source->getRenderTarget(context, imageIndex, &renderTarget);
     if (error.isError())
     {
         return error;
@@ -806,7 +831,8 @@ gl::Error Image9::copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureSt
     return copyFromRTInternal(gl::Offset(), sourceArea, renderTarget);
 }
 
-gl::Error Image9::copyFromFramebuffer(const gl::Offset &destOffset,
+gl::Error Image9::copyFromFramebuffer(const gl::Context *context,
+                                      const gl::Offset &destOffset,
                                       const gl::Rectangle &sourceArea,
                                       const gl::Framebuffer *source)
 {
@@ -814,7 +840,7 @@ gl::Error Image9::copyFromFramebuffer(const gl::Offset &destOffset,
     ASSERT(srcAttachment);
 
     RenderTargetD3D *renderTarget = nullptr;
-    gl::Error error = srcAttachment->getRenderTarget(&renderTarget);
+    gl::Error error               = srcAttachment->getRenderTarget(context, &renderTarget);
     if (error.isError())
     {
         return error;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.h
index 068a67fc942..7ece2aa96e9 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Image9.h
@@ -38,19 +38,33 @@ class Image9 : public ImageD3D
 
     virtual bool isDirty() const;
 
-    virtual gl::Error setManagedSurface2D(TextureStorage *storage, int level);
-    virtual gl::Error setManagedSurfaceCube(TextureStorage *storage, int face, int level);
-    virtual gl::Error copyToStorage(TextureStorage *storage, const gl::ImageIndex &index, const gl::Box &region);
-
-    gl::Error loadData(const gl::Box &area,
+    gl::Error setManagedSurface2D(const gl::Context *context,
+                                  TextureStorage *storage,
+                                  int level) override;
+    gl::Error setManagedSurfaceCube(const gl::Context *context,
+                                    TextureStorage *storage,
+                                    int face,
+                                    int level) override;
+    gl::Error copyToStorage(const gl::Context *context,
+                            TextureStorage *storage,
+                            const gl::ImageIndex &index,
+                            const gl::Box &region) override;
+
+    gl::Error loadData(const gl::Context *context,
+                       const gl::Box &area,
                        const gl::PixelUnpackState &unpack,
                        GLenum type,
                        const void *input,
                        bool applySkipImages) override;
-    gl::Error loadCompressedData(const gl::Box &area, const void *input) override;
-
-    gl::Error copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureStorage *source) override;
-    gl::Error copyFromFramebuffer(const gl::Offset &destOffset,
+    gl::Error loadCompressedData(const gl::Context *context,
+                                 const gl::Box &area,
+                                 const void *input) override;
+
+    gl::Error copyFromTexStorage(const gl::Context *context,
+                                 const gl::ImageIndex &imageIndex,
+                                 TextureStorage *source) override;
+    gl::Error copyFromFramebuffer(const gl::Context *context,
+                                  const gl::Offset &destOffset,
                                   const gl::Rectangle &sourceArea,
                                   const gl::Framebuffer *source) override;
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.cpp
index 378ceebe3a8..df86331766b 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/IndexBuffer9.cpp
@@ -54,7 +54,8 @@ gl::Error IndexBuffer9::initialize(unsigned int bufferSize, GLenum indexType, bo
         HRESULT result = mRenderer->createIndexBuffer(bufferSize, usageFlags, format, &mIndexBuffer);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal index buffer of size, %lu.", bufferSize);
+            return gl::OutOfMemory()
+                   << "Failed to allocate internal index buffer of size " << bufferSize;
         }
     }
 
@@ -69,7 +70,7 @@ gl::Error IndexBuffer9::mapBuffer(unsigned int offset, unsigned int size, void**
 {
     if (!mIndexBuffer)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal index buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal index buffer is not initialized.";
     }
 
     DWORD lockFlags = mDynamic ? D3DLOCK_NOOVERWRITE : 0;
@@ -78,7 +79,7 @@ gl::Error IndexBuffer9::mapBuffer(unsigned int offset, unsigned int size, void**
     HRESULT result = mIndexBuffer->Lock(offset, size, &mapPtr, lockFlags);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal index buffer, HRESULT: 0x%08x.", result);
+        return gl::OutOfMemory() << "Failed to lock internal index buffer, " << gl::FmtHR(result);
     }
 
     *outMappedMemory = mapPtr;
@@ -89,13 +90,13 @@ gl::Error IndexBuffer9::unmapBuffer()
 {
     if (!mIndexBuffer)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal index buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal index buffer is not initialized.";
     }
 
     HRESULT result = mIndexBuffer->Unlock();
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to unlock internal index buffer, HRESULT: 0x%08x.", result);
+        return gl::OutOfMemory() << "Failed to unlock internal index buffer, " << gl::FmtHR(result);
     }
 
     return gl::NoError();
@@ -127,7 +128,7 @@ gl::Error IndexBuffer9::discard()
 {
     if (!mIndexBuffer)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal index buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal index buffer is not initialized.";
     }
 
     void *dummy;
@@ -136,13 +137,13 @@ gl::Error IndexBuffer9::discard()
     result = mIndexBuffer->Lock(0, 1, &dummy, D3DLOCK_DISCARD);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal index buffer, HRESULT: 0x%08x.", result);
+        return gl::OutOfMemory() << "Failed to lock internal index buffer, " << gl::FmtHR(result);
     }
 
     result = mIndexBuffer->Unlock();
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to unlock internal index buffer, HRESULT: 0x%08x.", result);
+        return gl::OutOfMemory() << "Failed to unlock internal index buffer, " << gl::FmtHR(result);
     }
 
     return gl::NoError();
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Query9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Query9.cpp
index 0305720a4f7..4ba053e6bd6 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Query9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Query9.cpp
@@ -36,7 +36,7 @@ gl::Error Query9::begin()
         HRESULT result = mRenderer->getDevice()->CreateQuery(d3dQueryType, &mQuery);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Internal query creation failed, result: 0x%X.", result);
+            return gl::OutOfMemory() << "Internal query creation failed, " << gl::FmtHR(result);
         }
     }
 
@@ -46,8 +46,7 @@ gl::Error Query9::begin()
         ASSERT(SUCCEEDED(result));
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to begin internal query, result: 0x%X.",
-                             result);
+            return gl::OutOfMemory() << "Failed to begin internal query, " << gl::FmtHR(result);
         }
     }
 
@@ -62,7 +61,7 @@ gl::Error Query9::end()
     ASSERT(SUCCEEDED(result));
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to end internal query, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to end internal query, " << gl::FmtHR(result);
     }
 
     mQueryFinished = false;
@@ -74,7 +73,7 @@ gl::Error Query9::end()
 gl::Error Query9::queryCounter()
 {
     UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION, "Unimplemented");
+    return gl::InternalError() << "Unimplemented";
 }
 
 template <typename T>
@@ -174,12 +173,12 @@ gl::Error Query9::testQuery()
         if (d3d9::isDeviceLostError(result))
         {
             mRenderer->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to test get query result, device is lost.");
+            return gl::OutOfMemory() << "Failed to test get query result, device is lost.";
         }
         else if (mRenderer->testDeviceLost())
         {
             mRenderer->notifyDeviceLost();
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to test get query result, device is lost.");
+            return gl::OutOfMemory() << "Failed to test get query result, device is lost.";
         }
     }
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
index 4d0d284841e..b8b75c857aa 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
@@ -13,6 +13,7 @@
 
 #include "common/utilities.h"
 #include "libANGLE/Buffer.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Display.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
@@ -183,7 +184,7 @@ egl::Error Renderer9::initialize()
 
     if (mD3d9Module == nullptr)
     {
-        return egl::Error(EGL_NOT_INITIALIZED, D3D9_INIT_MISSING_DEP, "No D3D9 module found.");
+        return egl::EglNotInitialized(D3D9_INIT_MISSING_DEP) << "No D3D9 module found.";
     }
 
     typedef HRESULT(WINAPI * Direct3DCreate9ExFunc)(UINT, IDirect3D9Ex **);
@@ -210,8 +211,7 @@ egl::Error Renderer9::initialize()
 
     if (!mD3d9)
     {
-        return egl::Error(EGL_NOT_INITIALIZED, D3D9_INIT_MISSING_DEP,
-                          "Could not create D3D9 device.");
+        return egl::EglNotInitialized(D3D9_INIT_MISSING_DEP) << "Could not create D3D9 device.";
     }
 
     if (mDisplay->getNativeDisplayId() != nullptr)
@@ -240,8 +240,8 @@ egl::Error Renderer9::initialize()
                                       // D3DERR_INVALIDDEVICE, or another error we can't recover
                                       // from
             {
-                return egl::Error(EGL_NOT_INITIALIZED, D3D9_INIT_OTHER_ERROR,
-                                  "Failed to get device caps: Error code 0x%x\n", result);
+                return egl::EglNotInitialized(D3D9_INIT_OTHER_ERROR)
+                       << "Failed to get device caps, " << gl::FmtHR(result);
             }
         }
     }
@@ -254,8 +254,8 @@ egl::Error Renderer9::initialize()
 
     if (mDeviceCaps.PixelShaderVersion < D3DPS_VERSION(minShaderModel, 0))
     {
-        return egl::Error(EGL_NOT_INITIALIZED, D3D9_INIT_UNSUPPORTED_VERSION,
-                          "Renderer does not support PS %u.%u.aborting!", minShaderModel, 0);
+        return egl::EglNotInitialized(D3D9_INIT_UNSUPPORTED_VERSION)
+               << "Renderer does not support PS " << minShaderModel << ".0, aborting!";
     }
 
     // When DirectX9 is running with an older DirectX8 driver, a StretchRect from a regular texture
@@ -263,8 +263,8 @@ egl::Error Renderer9::initialize()
     // Texture2D::ensureRenderTarget.
     if ((mDeviceCaps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES) == 0)
     {
-        return egl::Error(EGL_NOT_INITIALIZED, D3D9_INIT_UNSUPPORTED_STRETCHRECT,
-                          "Renderer does not support StretctRect from textures.");
+        return egl::EglNotInitialized(D3D9_INIT_UNSUPPORTED_STRETCHRECT)
+               << "Renderer does not support StretctRect from textures.";
     }
 
     {
@@ -295,8 +295,8 @@ egl::Error Renderer9::initialize()
     }
     if (result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY || result == D3DERR_DEVICELOST)
     {
-        return egl::Error(EGL_BAD_ALLOC, D3D9_INIT_OUT_OF_MEMORY,
-                          "CreateDevice failed: device lost of out of memory");
+        return egl::EglBadAlloc(D3D9_INIT_OUT_OF_MEMORY)
+               << "CreateDevice failed: device lost of out of memory";
     }
 
     if (FAILED(result))
@@ -310,9 +310,8 @@ egl::Error Renderer9::initialize()
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY ||
                    result == D3DERR_NOTAVAILABLE || result == D3DERR_DEVICELOST);
-            return egl::Error(
-                EGL_BAD_ALLOC, D3D9_INIT_OUT_OF_MEMORY,
-                "CreateDevice2 failed: device lost, not available, or of out of memory");
+            return egl::EglBadAlloc(D3D9_INIT_OUT_OF_MEMORY)
+                   << "CreateDevice2 failed: device lost, not available, or of out of memory";
         }
     }
 
@@ -342,7 +341,7 @@ egl::Error Renderer9::initialize()
 
     initializeDevice();
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 // do any one-time device initialization
@@ -568,6 +567,9 @@ void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions)
 
     // Contexts are virtualized so textures can be shared globally
     outExtensions->displayTextureShareGroup = true;
+
+    // D3D9 can be used without an output surface
+    outExtensions->surfacelessContext = true;
 }
 
 void Renderer9::startScene()
@@ -608,7 +610,7 @@ gl::Error Renderer9::flush()
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to issue event query, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to issue event query, " << gl::FmtHR(result);
     }
 
     // Grab the query data once
@@ -621,7 +623,7 @@ gl::Error Renderer9::flush()
             notifyDeviceLost();
         }
 
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
     }
 
     return gl::NoError();
@@ -640,7 +642,7 @@ gl::Error Renderer9::finish()
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to issue event query, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to issue event query, " << gl::FmtHR(result);
     }
 
     // Grab the query data once
@@ -653,7 +655,7 @@ gl::Error Renderer9::finish()
         }
 
         freeEventQuery(query);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
     }
 
     // Loop until the query completes
@@ -680,8 +682,7 @@ gl::Error Renderer9::finish()
             }
 
             freeEventQuery(query);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.",
-                             result);
+            return gl::OutOfMemory() << "Failed to get event query data, " << gl::FmtHR(result);
         }
     }
 
@@ -723,7 +724,7 @@ egl::Error Renderer9::getD3DTextureInfo(const egl::Config *config,
     IDirect3DTexture9 *texture = nullptr;
     if (FAILED(d3dTexture->QueryInterface(&texture)))
     {
-        return egl::Error(EGL_BAD_PARAMETER, "client buffer is not a IDirect3DTexture9");
+        return egl::EglBadParameter() << "Client buffer is not a IDirect3DTexture9";
     }
 
     IDirect3DDevice9 *textureDevice = nullptr;
@@ -731,7 +732,7 @@ egl::Error Renderer9::getD3DTextureInfo(const egl::Config *config,
     if (textureDevice != mDevice)
     {
         SafeRelease(texture);
-        return egl::Error(EGL_BAD_PARAMETER, "Texture's device does not match.");
+        return egl::EglBadParameter() << "Texture's device does not match.";
     }
     SafeRelease(textureDevice);
 
@@ -758,8 +759,8 @@ egl::Error Renderer9::getD3DTextureInfo(const egl::Config *config,
             break;
 
         default:
-            return egl::Error(EGL_BAD_PARAMETER, "Unknown client buffer texture format: %u.",
-                              desc.Format);
+            return egl::EglBadParameter()
+                   << "Unknown client buffer texture format: " << desc.Format;
     }
 
     if (fboFormat)
@@ -769,7 +770,7 @@ egl::Error Renderer9::getD3DTextureInfo(const egl::Config *config,
         *fboFormat = d3dFormatInfo.info().fboImplementationInternalFormat;
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 egl::Error Renderer9::validateShareHandle(const egl::Config *config,
@@ -778,7 +779,7 @@ egl::Error Renderer9::validateShareHandle(const egl::Config *config,
 {
     if (shareHandle == nullptr)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "NULL share handle.");
+        return egl::EglBadParameter() << "NULL share handle.";
     }
 
     EGLint width  = attribs.getAsInt(EGL_WIDTH, 0);
@@ -794,7 +795,7 @@ egl::Error Renderer9::validateShareHandle(const egl::Config *config,
                                             &texture, &shareHandle);
     if (FAILED(result))
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Failed to open share handle, result: 0x%X.", result);
+        return egl::EglBadParameter() << "Failed to open share handle, " << gl::FmtHR(result);
     }
 
     DWORD levelCount = texture->GetLevelCount();
@@ -807,10 +808,10 @@ egl::Error Renderer9::validateShareHandle(const egl::Config *config,
         desc.Height != static_cast<UINT>(height) ||
         desc.Format != backBufferd3dFormatInfo.texFormat)
     {
-        return egl::Error(EGL_BAD_PARAMETER, "Invalid texture parameters in share handle texture.");
+        return egl::EglBadParameter() << "Invalid texture parameters in share handle texture.";
     }
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 ContextImpl *Renderer9::createContext(const gl::ContextState &state)
@@ -831,8 +832,7 @@ gl::Error Renderer9::allocateEventQuery(IDirect3DQuery9 **outQuery)
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate event query, result: 0x%X.",
-                             result);
+            return gl::OutOfMemory() << "Failed to allocate event query, " << gl::FmtHR(result);
         }
     }
     else
@@ -912,7 +912,8 @@ bool Renderer9::supportsFastCopyBufferToTexture(GLenum internalFormat) const
     return false;
 }
 
-gl::Error Renderer9::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack,
+gl::Error Renderer9::fastCopyBufferToTexture(const gl::Context *context,
+                                             const gl::PixelUnpackState &unpack,
                                              unsigned int offset,
                                              RenderTargetD3D *destRenderTarget,
                                              GLenum destinationFormat,
@@ -921,10 +922,11 @@ gl::Error Renderer9::fastCopyBufferToTexture(const gl::PixelUnpackState &unpack,
 {
     // Pixel buffer objects are not supported in D3D9, since D3D9 is ES2-only and PBOs are ES3.
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error Renderer9::setSamplerState(gl::SamplerType type,
+gl::Error Renderer9::setSamplerState(const gl::Context *context,
+                                     gl::SamplerType type,
                                      int index,
                                      gl::Texture *texture,
                                      const gl::SamplerState &samplerState)
@@ -936,11 +938,7 @@ gl::Error Renderer9::setSamplerState(gl::SamplerType type,
     TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
 
     TextureStorage *storage = nullptr;
-    gl::Error error         = textureD3D->getNativeTexture(&storage);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(textureD3D->getNativeTexture(context, &storage));
 
     // Storage should exist, texture should be complete
     ASSERT(storage);
@@ -985,7 +983,10 @@ gl::Error Renderer9::setSamplerState(gl::SamplerType type,
     return gl::NoError();
 }
 
-gl::Error Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *texture)
+gl::Error Renderer9::setTexture(const gl::Context *context,
+                                gl::SamplerType type,
+                                int index,
+                                gl::Texture *texture)
 {
     int d3dSamplerOffset              = (type == gl::SAMPLER_PIXEL) ? 0 : D3DVERTEXTEXTURESAMPLER0;
     int d3dSampler                    = index + d3dSamplerOffset;
@@ -1000,21 +1001,13 @@ gl::Error Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *te
         TextureD3D *textureImpl = GetImplAs<TextureD3D>(texture);
 
         TextureStorage *texStorage = nullptr;
-        gl::Error error            = textureImpl->getNativeTexture(&texStorage);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(textureImpl->getNativeTexture(context, &texStorage));
 
         // Texture should be complete and have a storage
         ASSERT(texStorage);
 
         TextureStorage9 *storage9 = GetAs<TextureStorage9>(texStorage);
-        error                     = storage9->getBaseTexture(&d3dTexture);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(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
@@ -1042,7 +1035,7 @@ gl::Error Renderer9::setUniformBuffers(const gl::ContextState & /*data*/,
     return gl::NoError();
 }
 
-gl::Error Renderer9::updateState(Context9 *context, GLenum drawMode)
+gl::Error Renderer9::updateState(const gl::Context *context, GLenum drawMode)
 {
     const auto &data    = context->getContextState();
     const auto &glState = data.getState();
@@ -1071,7 +1064,7 @@ gl::Error Renderer9::updateState(Context9 *context, GLenum drawMode)
     {
         ASSERT(firstColorAttachment->isAttached());
         RenderTarget9 *renderTarget = nullptr;
-        ANGLE_TRY(firstColorAttachment->getRenderTarget(&renderTarget));
+        ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
         samples = renderTarget->getSamples();
     }
     gl::RasterizerState rasterizer = glState.getRasterizerState();
@@ -1079,7 +1072,7 @@ gl::Error Renderer9::updateState(Context9 *context, GLenum drawMode)
     rasterizer.multiSample         = (samples != 0);
 
     unsigned int mask = GetBlendSampleMask(data, samples);
-    ANGLE_TRY(setBlendDepthRasterStates(data, mask));
+    ANGLE_TRY(setBlendDepthRasterStates(context, mask));
 
     mStateManager.resetDirtyBits();
 
@@ -1091,9 +1084,9 @@ void Renderer9::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
     mStateManager.setScissorState(scissor, enabled);
 }
 
-gl::Error Renderer9::setBlendDepthRasterStates(const gl::ContextState &glData, GLenum drawMode)
+gl::Error Renderer9::setBlendDepthRasterStates(const gl::Context *context, GLenum drawMode)
 {
-    const auto &glState  = glData.getState();
+    const auto &glState  = context->getGLState();
     auto drawFramebuffer = glState.getDrawFramebuffer();
     ASSERT(!drawFramebuffer->hasAnyDirtyBit());
     // Since framebuffer->getSamples will return the original samples which may be different with
@@ -1105,14 +1098,14 @@ gl::Error Renderer9::setBlendDepthRasterStates(const gl::ContextState &glData, G
     {
         ASSERT(firstColorAttachment->isAttached());
         RenderTarget9 *renderTarget = nullptr;
-        ANGLE_TRY(firstColorAttachment->getRenderTarget(&renderTarget));
+        ANGLE_TRY(firstColorAttachment->getRenderTarget(context, &renderTarget));
         samples = renderTarget->getSamples();
     }
     gl::RasterizerState rasterizer = glState.getRasterizerState();
     rasterizer.pointDrawMode       = (drawMode == GL_POINTS);
     rasterizer.multiSample         = (samples != 0);
 
-    unsigned int mask = GetBlendSampleMask(glData, samples);
+    unsigned int mask = GetBlendSampleMask(context->getContextState(), samples);
     return mStateManager.setBlendDepthRasterStates(glState, mask);
 }
 
@@ -1167,7 +1160,7 @@ bool Renderer9::applyPrimitiveType(GLenum mode, GLsizei count, bool usesPointSiz
     return mPrimitiveCount > 0;
 }
 
-gl::Error Renderer9::getNullColorbuffer(GLImplFactory *implFactory,
+gl::Error Renderer9::getNullColorbuffer(const gl::Context *context,
                                         const gl::FramebufferAttachment *depthbuffer,
                                         const gl::FramebufferAttachment **outColorBuffer)
 {
@@ -1188,8 +1181,10 @@ gl::Error Renderer9::getNullColorbuffer(GLImplFactory *implFactory,
         }
     }
 
+    auto *implFactory = context->getImplementation();
+
     gl::Renderbuffer *nullRenderbuffer = new gl::Renderbuffer(implFactory->createRenderbuffer(), 0);
-    gl::Error error = nullRenderbuffer->setStorage(GL_NONE, size.width, size.height);
+    gl::Error error = nullRenderbuffer->setStorage(context, GL_NONE, size.width, size.height);
     if (error.isError())
     {
         SafeDelete(nullRenderbuffer);
@@ -1197,7 +1192,7 @@ gl::Error Renderer9::getNullColorbuffer(GLImplFactory *implFactory,
     }
 
     gl::FramebufferAttachment *nullbuffer = new gl::FramebufferAttachment(
-        GL_RENDERBUFFER, GL_NONE, gl::ImageIndex::MakeInvalid(), nullRenderbuffer);
+        context, GL_RENDERBUFFER, GL_NONE, gl::ImageIndex::MakeInvalid(), nullRenderbuffer);
 
     // add nullbuffer to the cache
     NullColorbufferCacheEntry *oldest = &mNullColorbufferCache[0];
@@ -1219,22 +1214,17 @@ gl::Error Renderer9::getNullColorbuffer(GLImplFactory *implFactory,
     return gl::NoError();
 }
 
-gl::Error Renderer9::applyRenderTarget(GLImplFactory *implFactory,
+gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
                                        const gl::FramebufferAttachment *colorAttachment,
                                        const gl::FramebufferAttachment *depthStencilAttachment)
 {
     const gl::FramebufferAttachment *renderAttachment = colorAttachment;
-    gl::Error error(GL_NO_ERROR);
 
     // 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.
     if (renderAttachment == nullptr)
     {
-        error = getNullColorbuffer(implFactory, depthStencilAttachment, &renderAttachment);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(getNullColorbuffer(context, depthStencilAttachment, &renderAttachment));
     }
     ASSERT(renderAttachment != nullptr);
 
@@ -1243,11 +1233,7 @@ gl::Error Renderer9::applyRenderTarget(GLImplFactory *implFactory,
     D3DFORMAT renderTargetFormat = D3DFMT_UNKNOWN;
 
     RenderTarget9 *renderTarget = nullptr;
-    error                       = renderAttachment->getRenderTarget(&renderTarget);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(renderAttachment->getRenderTarget(context, &renderTarget));
     ASSERT(renderTarget);
 
     bool renderTargetChanged        = false;
@@ -1274,11 +1260,7 @@ gl::Error Renderer9::applyRenderTarget(GLImplFactory *implFactory,
 
     if (depthStencilAttachment != nullptr)
     {
-        error = depthStencilAttachment->getRenderTarget(&depthStencilRenderTarget);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(depthStencilAttachment->getRenderTarget(context, &depthStencilRenderTarget));
         ASSERT(depthStencilRenderTarget);
 
         depthStencilSerial = depthStencilRenderTarget->getSerial();
@@ -1324,10 +1306,10 @@ gl::Error Renderer9::applyRenderTarget(GLImplFactory *implFactory,
     return gl::NoError();
 }
 
-gl::Error Renderer9::applyRenderTarget(GLImplFactory *implFactory,
+gl::Error Renderer9::applyRenderTarget(const gl::Context *context,
                                        const gl::Framebuffer *framebuffer)
 {
-    return applyRenderTarget(implFactory, framebuffer->getColorbuffer(0),
+    return applyRenderTarget(context, framebuffer->getColorbuffer(0),
                              framebuffer->getDepthOrStencilbuffer());
 }
 
@@ -1509,9 +1491,8 @@ gl::Error Renderer9::drawLineLoop(GLsizei count,
         if (static_cast<unsigned int>(count) + 1 >
             (std::numeric_limits<unsigned int>::max() / sizeof(unsigned int)))
         {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create a 32-bit looping index buffer for GL_LINE_LOOP, too "
-                             "many indices required.");
+            return gl::OutOfMemory() << "Failed to create a 32-bit looping index buffer for "
+                                        "GL_LINE_LOOP, too many indices required.";
         }
 
         const unsigned int spaceNeeded =
@@ -1593,9 +1574,8 @@ gl::Error Renderer9::drawLineLoop(GLsizei count,
         if (static_cast<unsigned int>(count) + 1 >
             (std::numeric_limits<unsigned short>::max() / sizeof(unsigned short)))
         {
-            return gl::Error(GL_OUT_OF_MEMORY,
-                             "Failed to create a 16-bit looping index buffer for GL_LINE_LOOP, too "
-                             "many indices required.");
+            return gl::OutOfMemory() << "Failed to create a 16-bit looping index buffer for "
+                                        "GL_LINE_LOOP, too many indices required.";
         }
 
         const unsigned int spaceNeeded =
@@ -1721,7 +1701,7 @@ gl::Error Renderer9::drawIndexedPoints(GLsizei count,
             return drawPoints<GLuint>(mDevice, count, indices, minIndex);
         default:
             UNREACHABLE();
-            return gl::Error(GL_INVALID_OPERATION);
+            return gl::InternalError();
     }
 }
 
@@ -1790,30 +1770,31 @@ gl::Error Renderer9::getCountingIB(size_t count, StaticIndexBufferInterface **ou
     }
     else
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Could not create a counting index buffer for glDrawArraysInstanced.");
+        return gl::OutOfMemory()
+               << "Could not create a counting index buffer for glDrawArraysInstanced.";
     }
 
     *outIB = mCountingIB;
     return gl::NoError();
 }
 
-gl::Error Renderer9::applyShaders(const gl::ContextState &data, GLenum drawMode)
+gl::Error Renderer9::applyShaders(const gl::Context *context, GLenum drawMode)
 {
+    const gl::State &state = context->getContextState().getState();
     // This method is called single-threaded.
     ANGLE_TRY(ensureHLSLCompilerInitialized());
 
-    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.getState().getProgram());
-    programD3D->updateCachedInputLayout(data.getState());
+    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(state.getProgram());
+    programD3D->updateCachedInputLayout(state);
 
     const auto &inputLayout = programD3D->getCachedInputLayout();
 
     ShaderExecutableD3D *vertexExe = nullptr;
     ANGLE_TRY(programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr));
 
-    const gl::Framebuffer *drawFramebuffer = data.getState().getDrawFramebuffer();
+    const gl::Framebuffer *drawFramebuffer = state.getDrawFramebuffer();
     ShaderExecutableD3D *pixelExe          = nullptr;
-    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(drawFramebuffer, &pixelExe));
+    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(context, drawFramebuffer, &pixelExe));
 
     IDirect3DVertexShader9 *vertexShader =
         (vertexExe ? GetAs<ShaderExecutable9>(vertexExe)->getVertexShader() : nullptr);
@@ -1945,7 +1926,8 @@ void Renderer9::applyUniformnbv(const D3DUniform *targetUniform, const GLint *v)
     applyUniformnfv(targetUniform, (GLfloat *)vector);
 }
 
-gl::Error Renderer9::clear(const ClearParameters &clearParams,
+gl::Error Renderer9::clear(const gl::Context *context,
+                           const ClearParameters &clearParams,
                            const gl::FramebufferAttachment *colorBuffer,
                            const gl::FramebufferAttachment *depthStencilBuffer)
 {
@@ -1953,7 +1935,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
     {
         // Clearing buffers with non-float values is not supported by Renderer9 and ES 2.0
         UNREACHABLE();
-        return gl::Error(GL_INVALID_OPERATION);
+        return gl::InternalError();
     }
 
     bool clearColor = clearParams.clearColor[0];
@@ -1964,7 +1946,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
             // Clearing individual buffers other than buffer zero is not supported by Renderer9 and
             // ES 2.0
             UNREACHABLE();
-            return gl::Error(GL_INVALID_OPERATION);
+            return gl::InternalError();
         }
     }
 
@@ -1977,7 +1959,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
         ASSERT(depthStencilBuffer != nullptr);
 
         RenderTargetD3D *stencilRenderTarget = nullptr;
-        gl::Error error = depthStencilBuffer->getRenderTarget(&stencilRenderTarget);
+        gl::Error error = depthStencilBuffer->getRenderTarget(context, &stencilRenderTarget);
         if (error.isError())
         {
             return error;
@@ -2002,7 +1984,7 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
         ASSERT(colorBuffer != nullptr);
 
         RenderTargetD3D *colorRenderTarget = nullptr;
-        gl::Error error                    = colorBuffer->getRenderTarget(&colorRenderTarget);
+        gl::Error error = colorBuffer->getRenderTarget(context, &colorRenderTarget);
         if (error.isError())
         {
             return error;
@@ -2259,6 +2241,10 @@ void Renderer9::releaseDeviceResources()
 
     for (int i = 0; i < NUM_NULL_COLORBUFFER_CACHE_ENTRIES; i++)
     {
+        if (mNullColorbufferCache[i].buffer)
+        {
+            mNullColorbufferCache[i].buffer->detach(mDisplay->getProxyContext());
+        }
         SafeDelete(mNullColorbufferCache[i].buffer);
     }
 }
@@ -2510,7 +2496,8 @@ D3DPOOL Renderer9::getBufferPool(DWORD usage) const
     return D3DPOOL_DEFAULT;
 }
 
-gl::Error Renderer9::copyImage2D(const gl::Framebuffer *framebuffer,
+gl::Error Renderer9::copyImage2D(const gl::Context *context,
+                                 const gl::Framebuffer *framebuffer,
                                  const gl::Rectangle &sourceRect,
                                  GLenum destFormat,
                                  const gl::Offset &destOffset,
@@ -2523,10 +2510,11 @@ gl::Error Renderer9::copyImage2D(const gl::Framebuffer *framebuffer,
     rect.right  = sourceRect.x + sourceRect.width;
     rect.bottom = sourceRect.y + sourceRect.height;
 
-    return mBlit->copy2D(framebuffer, rect, destFormat, destOffset, storage, level);
+    return mBlit->copy2D(context, framebuffer, rect, destFormat, destOffset, storage, level);
 }
 
-gl::Error Renderer9::copyImageCube(const gl::Framebuffer *framebuffer,
+gl::Error Renderer9::copyImageCube(const gl::Context *context,
+                                   const gl::Framebuffer *framebuffer,
                                    const gl::Rectangle &sourceRect,
                                    GLenum destFormat,
                                    const gl::Offset &destOffset,
@@ -2540,10 +2528,12 @@ gl::Error Renderer9::copyImageCube(const gl::Framebuffer *framebuffer,
     rect.right  = sourceRect.x + sourceRect.width;
     rect.bottom = sourceRect.y + sourceRect.height;
 
-    return mBlit->copyCube(framebuffer, rect, destFormat, destOffset, storage, target, level);
+    return mBlit->copyCube(context, framebuffer, rect, destFormat, destOffset, storage, target,
+                           level);
 }
 
-gl::Error Renderer9::copyImage3D(const gl::Framebuffer *framebuffer,
+gl::Error Renderer9::copyImage3D(const gl::Context *context,
+                                 const gl::Framebuffer *framebuffer,
                                  const gl::Rectangle &sourceRect,
                                  GLenum destFormat,
                                  const gl::Offset &destOffset,
@@ -2552,10 +2542,11 @@ gl::Error Renderer9::copyImage3D(const gl::Framebuffer *framebuffer,
 {
     // 3D textures are not available in the D3D9 backend.
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error Renderer9::copyImage2DArray(const gl::Framebuffer *framebuffer,
+gl::Error Renderer9::copyImage2DArray(const gl::Context *context,
+                                      const gl::Framebuffer *framebuffer,
                                       const gl::Rectangle &sourceRect,
                                       GLenum destFormat,
                                       const gl::Offset &destOffset,
@@ -2564,10 +2555,11 @@ gl::Error Renderer9::copyImage2DArray(const gl::Framebuffer *framebuffer,
 {
     // 2D array textures are not available in the D3D9 backend.
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error Renderer9::copyTexture(const gl::Texture *source,
+gl::Error Renderer9::copyTexture(const gl::Context *context,
+                                 const gl::Texture *source,
                                  GLint sourceLevel,
                                  const gl::Rectangle &sourceRect,
                                  GLenum destFormat,
@@ -2585,18 +2577,19 @@ gl::Error Renderer9::copyTexture(const gl::Texture *source,
     rect.right  = sourceRect.x + sourceRect.width;
     rect.bottom = sourceRect.y + sourceRect.height;
 
-    return mBlit->copyTexture(source, sourceLevel, rect, destFormat, destOffset, storage,
+    return mBlit->copyTexture(context, source, sourceLevel, rect, destFormat, destOffset, storage,
                               destTarget, destLevel, unpackFlipY, unpackPremultiplyAlpha,
                               unpackUnmultiplyAlpha);
 }
 
-gl::Error Renderer9::copyCompressedTexture(const gl::Texture *source,
+gl::Error Renderer9::copyCompressedTexture(const gl::Context *context,
+                                           const gl::Texture *source,
                                            GLint sourceLevel,
                                            TextureStorage *storage,
                                            GLint destLevel)
 {
     UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
 gl::Error Renderer9::createRenderTarget(int width,
@@ -2648,8 +2641,7 @@ gl::Error Renderer9::createRenderTarget(int width,
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create render target, result: 0x%X.",
-                             result);
+            return gl::OutOfMemory() << "Failed to create render target, " << gl::FmtHR(result);
         }
 
         if (requiresInitialization)
@@ -2690,14 +2682,14 @@ gl::Error Renderer9::createRenderTargetCopy(RenderTargetD3D *source, RenderTarge
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to copy render target, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to copy render target, " << gl::FmtHR(result);
     }
 
     *outRT = newRT;
     return gl::NoError();
 }
 
-gl::Error Renderer9::loadExecutable(const void *function,
+gl::Error Renderer9::loadExecutable(const uint8_t *function,
                                     size_t length,
                                     ShaderType type,
                                     const std::vector<D3DVarying> &streamOutVaryings,
@@ -2733,7 +2725,7 @@ gl::Error Renderer9::loadExecutable(const void *function,
         break;
         default:
             UNREACHABLE();
-            return gl::Error(GL_INVALID_OPERATION);
+            return gl::InternalError();
     }
 
     return gl::NoError();
@@ -2762,7 +2754,7 @@ gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
             break;
         default:
             UNREACHABLE();
-            return gl::Error(GL_INVALID_OPERATION);
+            return gl::InternalError();
     }
 
     profileStream << "_" << ((getMajorShaderModel() >= 3) ? 3 : 2);
@@ -2817,8 +2809,9 @@ gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
         return gl::NoError();
     }
 
-    error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
-                           streamOutVaryings, separatedOutputBuffers, outExectuable);
+    error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
+                           binary->GetBufferSize(), type, streamOutVaryings, separatedOutputBuffers,
+                           outExectuable);
 
     SafeRelease(binary);
     if (error.isError())
@@ -2899,8 +2892,7 @@ gl::Error Renderer9::copyToRenderTarget(IDirect3DSurface9 *dest,
     if (FAILED(result))
     {
         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to blit internal texture, result: 0x%X.",
-                         result);
+        return gl::OutOfMemory() << "Failed to blit internal texture, " << gl::FmtHR(result);
     }
 
     return gl::NoError();
@@ -2911,20 +2903,34 @@ ImageD3D *Renderer9::createImage()
     return new Image9(this);
 }
 
-gl::Error Renderer9::generateMipmap(ImageD3D *dest, ImageD3D *src)
+gl::Error Renderer9::generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *src)
 {
     Image9 *src9 = GetAs<Image9>(src);
     Image9 *dst9 = GetAs<Image9>(dest);
     return Image9::generateMipmap(dst9, src9);
 }
 
-gl::Error Renderer9::generateMipmapUsingD3D(TextureStorage *storage,
+gl::Error Renderer9::generateMipmapUsingD3D(const gl::Context *context,
+                                            TextureStorage *storage,
                                             const gl::TextureState &textureState)
 {
     UNREACHABLE();
     return gl::NoError();
 }
 
+gl::Error Renderer9::copyImage(const gl::Context *context,
+                               ImageD3D *dest,
+                               ImageD3D *source,
+                               const gl::Rectangle &sourceRect,
+                               const gl::Offset &destOffset,
+                               bool unpackFlipY,
+                               bool unpackPremultiplyAlpha,
+                               bool unpackUnmultiplyAlpha)
+{
+    UNREACHABLE();
+    return gl::NoError();
+}
+
 TextureStorage *Renderer9::createTextureStorage2D(SwapChainD3D *swapChain)
 {
     SwapChain9 *swapChain9 = GetAs<SwapChain9>(swapChain);
@@ -2991,6 +2997,19 @@ TextureStorage *Renderer9::createTextureStorage2DArray(GLenum internalformat,
     return nullptr;
 }
 
+TextureStorage *Renderer9::createTextureStorage2DMultisample(GLenum internalformat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             int levels,
+                                                             int samples,
+                                                             GLboolean fixedSampleLocations)
+{
+    // 2D multisampled textures are not supported by the D3D9 backend.
+    UNREACHABLE();
+
+    return NULL;
+}
+
 bool Renderer9::getLUID(LUID *adapterLuid) const
 {
     adapterLuid->HighPart = 0;
@@ -3029,20 +3048,21 @@ gl::ErrorOrResult<unsigned int> Renderer9::getVertexSpaceRequired(const gl::Vert
     const d3d9::VertexFormat &d3d9VertexInfo =
         d3d9::GetVertexFormatInfo(getCapsDeclTypes(), vertexFormatType);
 
-    unsigned int elementCount = 0;
-    if (instances == 0 || binding.divisor == 0)
+    unsigned int elementCount  = 0;
+    const unsigned int divisor = binding.getDivisor();
+    if (instances == 0 || divisor == 0)
     {
         elementCount = static_cast<unsigned int>(count);
     }
     else
     {
         // Round up to divisor, if possible
-        elementCount = UnsignedCeilDivide(static_cast<unsigned int>(instances), binding.divisor);
+        elementCount = UnsignedCeilDivide(static_cast<unsigned int>(instances), divisor);
     }
 
     if (d3d9VertexInfo.outputElementSize > std::numeric_limits<unsigned int>::max() / elementCount)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "New vertex buffer size would result in an overflow.");
+        return gl::OutOfMemory() << "New vertex buffer size would result in an overflow.";
     }
 
     return static_cast<unsigned int>(d3d9VertexInfo.outputElementSize) * elementCount;
@@ -3062,16 +3082,15 @@ angle::WorkaroundsD3D Renderer9::generateWorkarounds() const
     return d3d9::GenerateWorkarounds();
 }
 
-gl::Error Renderer9::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd)
+gl::Error Renderer9::clearTextures(const gl::Context *context,
+                                   gl::SamplerType samplerType,
+                                   size_t rangeStart,
+                                   size_t rangeEnd)
 {
     // TODO(jmadill): faster way?
     for (size_t samplerIndex = rangeStart; samplerIndex < rangeEnd; samplerIndex++)
     {
-        gl::Error error = setTexture(samplerType, static_cast<int>(samplerIndex), nullptr);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(setTexture(context, samplerType, static_cast<int>(samplerIndex), nullptr));
     }
 
     return gl::NoError();
@@ -3094,7 +3113,7 @@ egl::Error Renderer9::getEGLDevice(DeviceImpl **device)
     }
 
     *device = static_cast<DeviceImpl *>(mEGLDevice);
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 Renderer9::CurSamplerState::CurSamplerState()
@@ -3102,7 +3121,7 @@ Renderer9::CurSamplerState::CurSamplerState()
 {
 }
 
-gl::Error Renderer9::genericDrawElements(Context9 *context,
+gl::Error Renderer9::genericDrawElements(const gl::Context *context,
                                          GLenum mode,
                                          GLsizei count,
                                          GLenum type,
@@ -3140,8 +3159,8 @@ gl::Error Renderer9::genericDrawElements(Context9 *context,
     ANGLE_TRY(applyVertexBuffer(data.getState(), mode,
                                 static_cast<GLsizei>(indexInfo.indexRange.start),
                                 static_cast<GLsizei>(vertexCount), instances, &indexInfo));
-    ANGLE_TRY(applyTextures(context, data));
-    ANGLE_TRY(applyShaders(data, mode));
+    ANGLE_TRY(applyTextures(context));
+    ANGLE_TRY(applyShaders(context, mode));
     ANGLE_TRY(programD3D->applyUniformBuffers(data));
 
     if (!skipDraw(data, mode))
@@ -3152,7 +3171,7 @@ gl::Error Renderer9::genericDrawElements(Context9 *context,
     return gl::NoError();
 }
 
-gl::Error Renderer9::genericDrawArrays(Context9 *context,
+gl::Error Renderer9::genericDrawArrays(const gl::Context *context,
                                        GLenum mode,
                                        GLint first,
                                        GLsizei count,
@@ -3174,8 +3193,8 @@ gl::Error Renderer9::genericDrawArrays(Context9 *context,
     ANGLE_TRY(updateState(context, mode));
     ANGLE_TRY(applyTransformFeedbackBuffers(data.getState()));
     ANGLE_TRY(applyVertexBuffer(data.getState(), mode, first, count, instances, nullptr));
-    ANGLE_TRY(applyTextures(context, data));
-    ANGLE_TRY(applyShaders(data, mode));
+    ANGLE_TRY(applyTextures(context));
+    ANGLE_TRY(applyShaders(context, mode));
     ANGLE_TRY(programD3D->applyUniformBuffers(data));
 
     if (!skipDraw(data, mode))
@@ -3208,4 +3227,10 @@ gl::Error Renderer9::applyComputeUniforms(const ProgramD3D &programD3D,
     return gl::InternalError() << "Compute shader is not implemented on D3D9";
 }
 
+gl::Error Renderer9::clearRenderTarget(RenderTargetD3D *renderTarget, const gl::ColorF &clearValues)
+{
+    UNIMPLEMENTED();
+    return gl::InternalError() << "clearRenderTarget is not implemented on D3D9";
+}
+
 }  // namespace rx
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.h
index ce7fb7117b1..e22239ce2fb 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/Renderer9.h
@@ -119,17 +119,21 @@ class Renderer9 : public RendererD3D
                               DWORD Usage,
                               D3DFORMAT Format,
                               IDirect3DIndexBuffer9 **ppIndexBuffer);
-    gl::Error setSamplerState(gl::SamplerType type,
+    gl::Error setSamplerState(const gl::Context *context,
+                              gl::SamplerType type,
                               int index,
                               gl::Texture *texture,
                               const gl::SamplerState &sampler) override;
-    gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture) override;
+    gl::Error setTexture(const gl::Context *context,
+                         gl::SamplerType type,
+                         int index,
+                         gl::Texture *texture) override;
 
     gl::Error setUniformBuffers(const gl::ContextState &data,
                                 const std::vector<GLint> &vertexUniformBuffers,
                                 const std::vector<GLint> &fragmentUniformBuffers) override;
 
-    gl::Error updateState(Context9 *context, GLenum drawMode);
+    gl::Error updateState(const gl::Context *context, GLenum drawMode);
 
     void setScissorRectangle(const gl::Rectangle &scissor, bool enabled);
     void setViewport(const gl::Rectangle &viewport,
@@ -139,8 +143,8 @@ class Renderer9 : public RendererD3D
                      GLenum frontFace,
                      bool ignoreViewport);
 
-    gl::Error applyRenderTarget(GLImplFactory *implFactory, const gl::Framebuffer *frameBuffer);
-    gl::Error applyRenderTarget(GLImplFactory *implFactory,
+    gl::Error applyRenderTarget(const gl::Context *context, const gl::Framebuffer *frameBuffer);
+    gl::Error applyRenderTarget(const gl::Context *context,
                                 const gl::FramebufferAttachment *colorAttachment,
                                 const gl::FramebufferAttachment *depthStencilAttachment);
     gl::Error applyUniforms(const ProgramD3D &programD3D,
@@ -162,7 +166,8 @@ class Renderer9 : public RendererD3D
 
     gl::Error applyTransformFeedbackBuffers(const gl::State &state);
 
-    gl::Error clear(const ClearParameters &clearParams,
+    gl::Error clear(const gl::Context *context,
+                    const ClearParameters &clearParams,
                     const gl::FramebufferAttachment *colorBuffer,
                     const gl::FramebufferAttachment *depthStencilBuffer);
 
@@ -193,33 +198,38 @@ class Renderer9 : public RendererD3D
     DWORD getCapsDeclTypes() const;
 
     // Pixel operations
-    gl::Error copyImage2D(const gl::Framebuffer *framebuffer,
+    gl::Error copyImage2D(const gl::Context *context,
+                          const gl::Framebuffer *framebuffer,
                           const gl::Rectangle &sourceRect,
                           GLenum destFormat,
                           const gl::Offset &destOffset,
                           TextureStorage *storage,
                           GLint level) override;
-    gl::Error copyImageCube(const gl::Framebuffer *framebuffer,
+    gl::Error copyImageCube(const gl::Context *context,
+                            const gl::Framebuffer *framebuffer,
                             const gl::Rectangle &sourceRect,
                             GLenum destFormat,
                             const gl::Offset &destOffset,
                             TextureStorage *storage,
                             GLenum target,
                             GLint level) override;
-    gl::Error copyImage3D(const gl::Framebuffer *framebuffer,
+    gl::Error copyImage3D(const gl::Context *context,
+                          const gl::Framebuffer *framebuffer,
                           const gl::Rectangle &sourceRect,
                           GLenum destFormat,
                           const gl::Offset &destOffset,
                           TextureStorage *storage,
                           GLint level) override;
-    gl::Error copyImage2DArray(const gl::Framebuffer *framebuffer,
+    gl::Error copyImage2DArray(const gl::Context *context,
+                               const gl::Framebuffer *framebuffer,
                                const gl::Rectangle &sourceRect,
                                GLenum destFormat,
                                const gl::Offset &destOffset,
                                TextureStorage *storage,
                                GLint level) override;
 
-    gl::Error copyTexture(const gl::Texture *source,
+    gl::Error copyTexture(const gl::Context *context,
+                          const gl::Texture *source,
                           GLint sourceLevel,
                           const gl::Rectangle &sourceRect,
                           GLenum destFormat,
@@ -230,7 +240,8 @@ class Renderer9 : public RendererD3D
                           bool unpackFlipY,
                           bool unpackPremultiplyAlpha,
                           bool unpackUnmultiplyAlpha) override;
-    gl::Error copyCompressedTexture(const gl::Texture *source,
+    gl::Error copyCompressedTexture(const gl::Context *context,
+                                    const gl::Texture *source,
                                     GLint sourceLevel,
                                     TextureStorage *storage,
                                     GLint destLevel) override;
@@ -244,7 +255,7 @@ class Renderer9 : public RendererD3D
     gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) override;
 
     // Shader operations
-    gl::Error loadExecutable(const void *function,
+    gl::Error loadExecutable(const uint8_t *function,
                              size_t length,
                              ShaderType type,
                              const std::vector<D3DVarying> &streamOutVaryings,
@@ -263,9 +274,18 @@ class Renderer9 : public RendererD3D
 
     // Image operations
     ImageD3D *createImage() override;
-    gl::Error generateMipmap(ImageD3D *dest, ImageD3D *source) override;
-    gl::Error generateMipmapUsingD3D(TextureStorage *storage,
+    gl::Error generateMipmap(const gl::Context *context, ImageD3D *dest, ImageD3D *source) override;
+    gl::Error generateMipmapUsingD3D(const gl::Context *context,
+                                     TextureStorage *storage,
                                      const gl::TextureState &textureState) override;
+    gl::Error copyImage(const gl::Context *context,
+                        ImageD3D *dest,
+                        ImageD3D *source,
+                        const gl::Rectangle &sourceRect,
+                        const gl::Offset &destOffset,
+                        bool unpackFlipY,
+                        bool unpackPremultiplyAlpha,
+                        bool unpackUnmultiplyAlpha) override;
     TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain) override;
     TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage,
                                                  RenderTargetD3D *renderTargetD3D) override;
@@ -296,6 +316,13 @@ class Renderer9 : public RendererD3D
                                                 GLsizei depth,
                                                 int levels) override;
 
+    TextureStorage *createTextureStorage2DMultisample(GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      int levels,
+                                                      int samples,
+                                                      GLboolean fixedSampleLocations) override;
+
     // Buffer creation
     VertexBuffer *createVertexBuffer() override;
     IndexBuffer *createIndexBuffer() override;
@@ -307,7 +334,8 @@ class Renderer9 : public RendererD3D
 
     // Buffer-to-texture and Texture-to-buffer copies
     bool supportsFastCopyBufferToTexture(GLenum internalFormat) const override;
-    gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack,
+    gl::Error fastCopyBufferToTexture(const gl::Context *context,
+                                      const gl::PixelUnpackState &unpack,
                                       unsigned int offset,
                                       RenderTargetD3D *destRenderTarget,
                                       GLenum destinationFormat,
@@ -343,13 +371,13 @@ class Renderer9 : public RendererD3D
 
     StateManager9 *getStateManager() { return &mStateManager; }
 
-    gl::Error genericDrawArrays(Context9 *context,
+    gl::Error genericDrawArrays(const gl::Context *context,
                                 GLenum mode,
                                 GLint first,
                                 GLsizei count,
                                 GLsizei instances);
 
-    gl::Error genericDrawElements(Context9 *context,
+    gl::Error genericDrawElements(const gl::Context *context,
                                   GLenum mode,
                                   GLsizei count,
                                   GLenum type,
@@ -367,8 +395,12 @@ class Renderer9 : public RendererD3D
     gl::Error applyComputeUniforms(const ProgramD3D &programD3D,
                                    const std::vector<D3DUniform *> &uniformArray) override;
 
+    gl::Error clearRenderTarget(RenderTargetD3D *renderTarget,
+                                const gl::ColorF &clearValues) override;
+
   protected:
-    gl::Error clearTextures(gl::SamplerType samplerType,
+    gl::Error clearTextures(const gl::Context *context,
+                            gl::SamplerType samplerType,
                             size_t rangeStart,
                             size_t rangeEnd) override;
 
@@ -386,7 +418,7 @@ class Renderer9 : public RendererD3D
                                const void *indices,
                                GLsizei instances);
 
-    gl::Error applyShaders(const gl::ContextState &data, GLenum drawMode);
+    gl::Error applyShaders(const gl::Context *context, GLenum drawMode);
 
     void generateCaps(gl::Caps *outCaps,
                       gl::TextureCapsMap *outTextureCaps,
@@ -395,7 +427,7 @@ class Renderer9 : public RendererD3D
 
     angle::WorkaroundsD3D generateWorkarounds() const override;
 
-    gl::Error setBlendDepthRasterStates(const gl::ContextState &glData, GLenum drawMode);
+    gl::Error setBlendDepthRasterStates(const gl::Context *context, GLenum drawMode);
 
     void release();
 
@@ -416,7 +448,7 @@ class Renderer9 : public RendererD3D
 
     gl::Error getCountingIB(size_t count, StaticIndexBufferInterface **outIB);
 
-    gl::Error getNullColorbuffer(GLImplFactory *implFactory,
+    gl::Error getNullColorbuffer(const gl::Context *context,
                                  const gl::FramebufferAttachment *depthbuffer,
                                  const gl::FramebufferAttachment **outColorBuffer);
 
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/ShaderCache.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/ShaderCache.h
index 079e5f0e127..399770dd8d1 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/ShaderCache.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/ShaderCache.h
@@ -52,7 +52,7 @@ class ShaderCache : angle::NonCopyable
         HRESULT result = createShader(function, &shader);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create shader, result: 0x%X.", result);
+            return gl::OutOfMemory() << "Failed to create shader, " << gl::FmtHR(result);
         }
 
         // Random eviction policy.
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp
index 65566674d7d..f9323ab6871 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.cpp
@@ -79,13 +79,16 @@ static DWORD convertInterval(EGLint interval)
 #endif
 }
 
-EGLint SwapChain9::resize(int backbufferWidth, int backbufferHeight)
+EGLint SwapChain9::resize(const gl::Context *context, int backbufferWidth, int backbufferHeight)
 {
     // D3D9 does not support resizing swap chains without recreating them
-    return reset(backbufferWidth, backbufferHeight, mSwapInterval);
+    return reset(context, backbufferWidth, backbufferHeight, mSwapInterval);
 }
 
-EGLint SwapChain9::reset(int backbufferWidth, int backbufferHeight, EGLint swapInterval)
+EGLint SwapChain9::reset(const gl::Context *context,
+                         int backbufferWidth,
+                         int backbufferHeight,
+                         EGLint swapInterval)
 {
     IDirect3DDevice9 *device = mRenderer->getDevice();
 
@@ -265,7 +268,11 @@ EGLint SwapChain9::reset(int backbufferWidth, int backbufferHeight, EGLint swapI
 }
 
 // parameters should be validated/clamped by caller
-EGLint SwapChain9::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+EGLint SwapChain9::swapRect(const gl::Context *context,
+                            EGLint x,
+                            EGLint y,
+                            EGLint width,
+                            EGLint height)
 {
     if (!mSwapChain)
     {
@@ -413,7 +420,7 @@ void *SwapChain9::getKeyedMutex()
 egl::Error SwapChain9::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc)
 {
     UNREACHABLE();
-    return egl::Error(EGL_BAD_SURFACE);
+    return egl::EglBadSurface();
 }
 
 void SwapChain9::recreate()
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.h
index 11fde1a5403..6b12fa3967a 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/SwapChain9.h
@@ -30,9 +30,16 @@ class SwapChain9 : public SwapChainD3D
                EGLint orientation);
     virtual ~SwapChain9();
 
-    EGLint resize(EGLint backbufferWidth, EGLint backbufferHeight);
-    virtual EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval);
-    virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height);
+    EGLint resize(const gl::Context *context, EGLint backbufferWidth, EGLint backbufferHeight);
+    virtual EGLint reset(const gl::Context *context,
+                         EGLint backbufferWidth,
+                         EGLint backbufferHeight,
+                         EGLint swapInterval);
+    virtual EGLint swapRect(const gl::Context *context,
+                            EGLint x,
+                            EGLint y,
+                            EGLint width,
+                            EGLint height);
     virtual void recreate();
 
     RenderTargetD3D *getColorRenderTarget() override { return &mColorRenderTarget; }
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp
index fd3e2c83846..9bcaeb6a6f7 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp
@@ -93,11 +93,16 @@ int TextureStorage9::getLevelCount() const
     return static_cast<int>(mMipLevels) - mTopLevel;
 }
 
-gl::Error TextureStorage9::setData(const gl::ImageIndex &index, ImageD3D *image, const gl::Box *destBox, GLenum type,
-                                   const gl::PixelUnpackState &unpack, const uint8_t *pixelData)
+gl::Error TextureStorage9::setData(const gl::Context *context,
+                                   const gl::ImageIndex &index,
+                                   ImageD3D *image,
+                                   const gl::Box *destBox,
+                                   GLenum type,
+                                   const gl::PixelUnpackState &unpack,
+                                   const uint8_t *pixelData)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
 TextureStorage9_2D::TextureStorage9_2D(Renderer9 *renderer, SwapChain9 *swapchain)
@@ -147,7 +152,8 @@ TextureStorage9_2D::~TextureStorage9_2D()
 
 // Increments refcount on surface.
 // caller must Release() the returned surface
-gl::Error TextureStorage9_2D::getSurfaceLevel(GLenum target,
+gl::Error TextureStorage9_2D::getSurfaceLevel(const gl::Context *context,
+                                              GLenum target,
                                               int level,
                                               bool dirty,
                                               IDirect3DSurface9 **outSurface)
@@ -155,7 +161,7 @@ gl::Error TextureStorage9_2D::getSurfaceLevel(GLenum target,
     ASSERT(target == GL_TEXTURE_2D);
 
     IDirect3DBaseTexture9 *baseTexture = nullptr;
-    gl::Error error = getBaseTexture(&baseTexture);
+    gl::Error error                    = getBaseTexture(context, &baseTexture);
     if (error.isError())
     {
         return error;
@@ -168,7 +174,8 @@ gl::Error TextureStorage9_2D::getSurfaceLevel(GLenum target,
     ASSERT(SUCCEEDED(result));
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to get the surface from a texture, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to get the surface from a texture, "
+                                 << gl::FmtHR(result);
     }
 
     // With managed textures the driver needs to be informed of updates to the lower mipmap levels
@@ -180,21 +187,23 @@ gl::Error TextureStorage9_2D::getSurfaceLevel(GLenum target,
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_2D::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureStorage9_2D::getRenderTarget(const gl::Context *context,
+                                              const gl::ImageIndex &index,
+                                              RenderTargetD3D **outRT)
 {
     ASSERT(index.mipIndex < getLevelCount());
 
     if (!mRenderTargets[index.mipIndex] && isRenderTarget())
     {
         IDirect3DBaseTexture9 *baseTexture = nullptr;
-        gl::Error error = getBaseTexture(&baseTexture);
+        gl::Error error                    = getBaseTexture(context, &baseTexture);
         if (error.isError())
         {
             return error;
         }
 
         IDirect3DSurface9 *surface = nullptr;
-        error = getSurfaceLevel(GL_TEXTURE_2D, index.mipIndex, false, &surface);
+        error = getSurfaceLevel(context, GL_TEXTURE_2D, index.mipIndex, false, &surface);
         if (error.isError())
         {
             return error;
@@ -215,17 +224,19 @@ gl::Error TextureStorage9_2D::getRenderTarget(const gl::ImageIndex &index, Rende
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_2D::generateMipmap(const gl::ImageIndex &sourceIndex, const gl::ImageIndex &destIndex)
+gl::Error TextureStorage9_2D::generateMipmap(const gl::Context *context,
+                                             const gl::ImageIndex &sourceIndex,
+                                             const gl::ImageIndex &destIndex)
 {
     IDirect3DSurface9 *upper = nullptr;
-    gl::Error error = getSurfaceLevel(GL_TEXTURE_2D, sourceIndex.mipIndex, false, &upper);
+    gl::Error error = getSurfaceLevel(context, GL_TEXTURE_2D, sourceIndex.mipIndex, false, &upper);
     if (error.isError())
     {
         return error;
     }
 
     IDirect3DSurface9 *lower = nullptr;
-    error = getSurfaceLevel(GL_TEXTURE_2D, destIndex.mipIndex, true, &lower);
+    error = getSurfaceLevel(context, GL_TEXTURE_2D, destIndex.mipIndex, true, &lower);
     if (error.isError())
     {
         SafeRelease(upper);
@@ -241,7 +252,8 @@ gl::Error TextureStorage9_2D::generateMipmap(const gl::ImageIndex &sourceIndex,
     return error;
 }
 
-gl::Error TextureStorage9_2D::getBaseTexture(IDirect3DBaseTexture9 **outTexture)
+gl::Error 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
@@ -258,7 +270,8 @@ gl::Error TextureStorage9_2D::getBaseTexture(IDirect3DBaseTexture9 **outTexture)
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create 2D storage texture, result: 0x%X.", result);
+            return gl::OutOfMemory()
+                   << "Failed to create 2D storage texture, " << gl::FmtHR(result);
         }
     }
 
@@ -266,7 +279,7 @@ gl::Error TextureStorage9_2D::getBaseTexture(IDirect3DBaseTexture9 **outTexture)
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_2D::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage9_2D::copyToStorage(const gl::Context *context, TextureStorage *destStorage)
 {
     ASSERT(destStorage);
 
@@ -276,14 +289,14 @@ gl::Error TextureStorage9_2D::copyToStorage(TextureStorage *destStorage)
     for (int i = 0; i < levels; ++i)
     {
         IDirect3DSurface9 *srcSurf = nullptr;
-        gl::Error error = getSurfaceLevel(GL_TEXTURE_2D, i, false, &srcSurf);
+        gl::Error error            = getSurfaceLevel(context, GL_TEXTURE_2D, i, false, &srcSurf);
         if (error.isError())
         {
             return error;
         }
 
         IDirect3DSurface9 *dstSurf = nullptr;
-        error = dest9->getSurfaceLevel(GL_TEXTURE_2D, i, true, &dstSurf);
+        error = dest9->getSurfaceLevel(context, GL_TEXTURE_2D, i, true, &dstSurf);
         if (error.isError())
         {
             SafeRelease(srcSurf);
@@ -321,7 +334,8 @@ TextureStorage9_EGLImage::~TextureStorage9_EGLImage()
 {
 }
 
-gl::Error TextureStorage9_EGLImage::getSurfaceLevel(GLenum target,
+gl::Error TextureStorage9_EGLImage::getSurfaceLevel(const gl::Context *context,
+                                                    GLenum target,
                                                     int level,
                                                     bool,
                                                     IDirect3DSurface9 **outSurface)
@@ -330,7 +344,7 @@ gl::Error TextureStorage9_EGLImage::getSurfaceLevel(GLenum target,
     ASSERT(level == 0);
 
     RenderTargetD3D *renderTargetD3D = nullptr;
-    gl::Error error = mImage->getRenderTarget(&renderTargetD3D);
+    gl::Error error                  = mImage->getRenderTarget(context, &renderTargetD3D);
     if (error.isError())
     {
         return error;
@@ -342,19 +356,21 @@ gl::Error TextureStorage9_EGLImage::getSurfaceLevel(GLenum target,
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_EGLImage::getRenderTarget(const gl::ImageIndex &index,
+gl::Error TextureStorage9_EGLImage::getRenderTarget(const gl::Context *context,
+                                                    const gl::ImageIndex &index,
                                                     RenderTargetD3D **outRT)
 {
     ASSERT(!index.hasLayer());
     ASSERT(index.mipIndex == 0);
 
-    return mImage->getRenderTarget(outRT);
+    return mImage->getRenderTarget(context, outRT);
 }
 
-gl::Error TextureStorage9_EGLImage::getBaseTexture(IDirect3DBaseTexture9 **outTexture)
+gl::Error TextureStorage9_EGLImage::getBaseTexture(const gl::Context *context,
+                                                   IDirect3DBaseTexture9 **outTexture)
 {
     RenderTargetD3D *renderTargetD3D = nullptr;
-    gl::Error error = mImage->getRenderTarget(&renderTargetD3D);
+    gl::Error error                  = mImage->getRenderTarget(context, &renderTargetD3D);
     if (error.isError())
     {
         return error;
@@ -367,13 +383,16 @@ gl::Error TextureStorage9_EGLImage::getBaseTexture(IDirect3DBaseTexture9 **outTe
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_EGLImage::generateMipmap(const gl::ImageIndex &, const gl::ImageIndex &)
+gl::Error TextureStorage9_EGLImage::generateMipmap(const gl::Context *context,
+                                                   const gl::ImageIndex &,
+                                                   const gl::ImageIndex &)
 {
     UNREACHABLE();
-    return gl::Error(GL_INVALID_OPERATION);
+    return gl::InternalError();
 }
 
-gl::Error TextureStorage9_EGLImage::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage9_EGLImage::copyToStorage(const gl::Context *context,
+                                                  TextureStorage *destStorage)
 {
     ASSERT(destStorage);
     ASSERT(getLevelCount() == 1);
@@ -381,7 +400,7 @@ gl::Error TextureStorage9_EGLImage::copyToStorage(TextureStorage *destStorage)
     TextureStorage9 *dest9 = GetAs<TextureStorage9>(destStorage);
 
     IDirect3DBaseTexture9 *destBaseTexture9 = nullptr;
-    gl::Error error = dest9->getBaseTexture(&destBaseTexture9);
+    gl::Error error                         = dest9->getBaseTexture(context, &destBaseTexture9);
     if (error.isError())
     {
         return error;
@@ -393,12 +412,12 @@ gl::Error TextureStorage9_EGLImage::copyToStorage(TextureStorage *destStorage)
     HRESULT result = destTexture9->GetSurfaceLevel(destStorage->getTopLevel(), &destSurface);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY,
-                         "Failed to get the surface from a texture, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to get the surface from a texture, "
+                                 << gl::FmtHR(result);
     }
 
     RenderTargetD3D *sourceRenderTarget = nullptr;
-    error = mImage->getRenderTarget(&sourceRenderTarget);
+    error                               = mImage->getRenderTarget(context, &sourceRenderTarget);
     if (error.isError())
     {
         SafeRelease(destSurface);
@@ -456,13 +475,14 @@ TextureStorage9_Cube::~TextureStorage9_Cube()
 
 // Increments refcount on surface.
 // caller must Release() the returned surface
-gl::Error TextureStorage9_Cube::getSurfaceLevel(GLenum target,
+gl::Error TextureStorage9_Cube::getSurfaceLevel(const gl::Context *context,
+                                                GLenum target,
                                                 int level,
                                                 bool dirty,
                                                 IDirect3DSurface9 **outSurface)
 {
     IDirect3DBaseTexture9 *baseTexture = nullptr;
-    gl::Error error = getBaseTexture(&baseTexture);
+    gl::Error error                    = getBaseTexture(context, &baseTexture);
     if (error.isError())
     {
         return error;
@@ -476,7 +496,8 @@ gl::Error TextureStorage9_Cube::getSurfaceLevel(GLenum target,
     ASSERT(SUCCEEDED(result));
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to get the surface from a texture, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to get the surface from a texture, "
+                                 << gl::FmtHR(result);
     }
 
     // With managed textures the driver needs to be informed of updates to the lower mipmap levels
@@ -488,7 +509,9 @@ gl::Error TextureStorage9_Cube::getSurfaceLevel(GLenum target,
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_Cube::getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT)
+gl::Error TextureStorage9_Cube::getRenderTarget(const gl::Context *context,
+                                                const gl::ImageIndex &index,
+                                                RenderTargetD3D **outRT)
 {
     ASSERT(outRT);
     ASSERT(index.mipIndex == 0);
@@ -497,14 +520,14 @@ gl::Error TextureStorage9_Cube::getRenderTarget(const gl::ImageIndex &index, Ren
     if (mRenderTarget[index.layerIndex] == nullptr && isRenderTarget())
     {
         IDirect3DBaseTexture9 *baseTexture = nullptr;
-        gl::Error error = getBaseTexture(&baseTexture);
+        gl::Error error                    = getBaseTexture(context, &baseTexture);
         if (error.isError())
         {
             return error;
         }
 
         IDirect3DSurface9 *surface = nullptr;
-        error = getSurfaceLevel(GL_TEXTURE_CUBE_MAP_POSITIVE_X + index.layerIndex,
+        error = getSurfaceLevel(context, GL_TEXTURE_CUBE_MAP_POSITIVE_X + index.layerIndex,
                                 mTopLevel + index.mipIndex, false, &surface);
         if (error.isError())
         {
@@ -521,17 +544,20 @@ gl::Error TextureStorage9_Cube::getRenderTarget(const gl::ImageIndex &index, Ren
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_Cube::generateMipmap(const gl::ImageIndex &sourceIndex, const gl::ImageIndex &destIndex)
+gl::Error TextureStorage9_Cube::generateMipmap(const gl::Context *context,
+                                               const gl::ImageIndex &sourceIndex,
+                                               const gl::ImageIndex &destIndex)
 {
     IDirect3DSurface9 *upper = nullptr;
-    gl::Error error = getSurfaceLevel(sourceIndex.type, sourceIndex.mipIndex, false, &upper);
+    gl::Error error =
+        getSurfaceLevel(context, sourceIndex.type, sourceIndex.mipIndex, false, &upper);
     if (error.isError())
     {
         return error;
     }
 
     IDirect3DSurface9 *lower = nullptr;
-    error = getSurfaceLevel(destIndex.type, destIndex.mipIndex, true, &lower);
+    error = getSurfaceLevel(context, destIndex.type, destIndex.mipIndex, true, &lower);
     if (error.isError())
     {
         SafeRelease(upper);
@@ -547,7 +573,8 @@ gl::Error TextureStorage9_Cube::generateMipmap(const gl::ImageIndex &sourceIndex
     return error;
 }
 
-gl::Error TextureStorage9_Cube::getBaseTexture(IDirect3DBaseTexture9 **outTexture)
+gl::Error 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
@@ -564,7 +591,8 @@ gl::Error TextureStorage9_Cube::getBaseTexture(IDirect3DBaseTexture9 **outTextur
         if (FAILED(result))
         {
             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create cube storage texture, result: 0x%X.", result);
+            return gl::OutOfMemory()
+                   << "Failed to create cube storage texture, " << gl::FmtHR(result);
         }
     }
 
@@ -572,7 +600,8 @@ gl::Error TextureStorage9_Cube::getBaseTexture(IDirect3DBaseTexture9 **outTextur
     return gl::NoError();
 }
 
-gl::Error TextureStorage9_Cube::copyToStorage(TextureStorage *destStorage)
+gl::Error TextureStorage9_Cube::copyToStorage(const gl::Context *context,
+                                              TextureStorage *destStorage)
 {
     ASSERT(destStorage);
 
@@ -585,14 +614,15 @@ gl::Error TextureStorage9_Cube::copyToStorage(TextureStorage *destStorage)
         {
             IDirect3DSurface9 *srcSurf = nullptr;
             gl::Error error =
-                getSurfaceLevel(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, false, &srcSurf);
+                getSurfaceLevel(context, GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, false, &srcSurf);
             if (error.isError())
             {
                 return error;
             }
 
             IDirect3DSurface9 *dstSurf = nullptr;
-            error = dest9->getSurfaceLevel(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, true, &dstSurf);
+            error = dest9->getSurfaceLevel(context, GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, true,
+                                           &dstSurf);
             if (error.isError())
             {
                 SafeRelease(srcSurf);
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h
index f0455a9b710..a33d096ee96 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h
@@ -32,12 +32,16 @@ class TextureStorage9 : public TextureStorage
     D3DPOOL getPool() const;
     DWORD getUsage() const;
 
-    virtual gl::Error getSurfaceLevel(GLenum target,
+    virtual gl::Error getSurfaceLevel(const gl::Context *context,
+                                      GLenum target,
                                       int level,
                                       bool dirty,
                                       IDirect3DSurface9 **outSurface) = 0;
-    virtual gl::Error getBaseTexture(IDirect3DBaseTexture9 **outTexture) = 0;
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) = 0;
+    virtual gl::Error getBaseTexture(const gl::Context *context,
+                                     IDirect3DBaseTexture9 **outTexture) = 0;
+    virtual gl::Error getRenderTarget(const gl::Context *context,
+                                      const gl::ImageIndex &index,
+                                      RenderTargetD3D **outRT) = 0;
 
     virtual int getTopLevel() const;
     virtual bool isRenderTarget() const;
@@ -45,8 +49,13 @@ class TextureStorage9 : public TextureStorage
     bool supportsNativeMipmapFunction() const override;
     virtual int getLevelCount() const;
 
-    virtual gl::Error setData(const gl::ImageIndex &index, ImageD3D *image, const gl::Box *destBox, GLenum type,
-                              const gl::PixelUnpackState &unpack, const uint8_t *pixelData);
+    gl::Error setData(const gl::Context *context,
+                      const gl::ImageIndex &index,
+                      ImageD3D *image,
+                      const gl::Box *destBox,
+                      GLenum type,
+                      const gl::PixelUnpackState &unpack,
+                      const uint8_t *pixelData) override;
 
   protected:
     int mTopLevel;
@@ -70,16 +79,22 @@ class TextureStorage9_2D : public TextureStorage9
   public:
     TextureStorage9_2D(Renderer9 *renderer, SwapChain9 *swapchain);
     TextureStorage9_2D(Renderer9 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels);
-    virtual ~TextureStorage9_2D();
+    ~TextureStorage9_2D() override;
 
-    gl::Error getSurfaceLevel(GLenum target,
+    gl::Error getSurfaceLevel(const gl::Context *context,
+                              GLenum target,
                               int level,
                               bool dirty,
                               IDirect3DSurface9 **outSurface) override;
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT);
-    virtual gl::Error getBaseTexture(IDirect3DBaseTexture9 **outTexture);
-    virtual gl::Error generateMipmap(const gl::ImageIndex &sourceIndex, const gl::ImageIndex &destIndex);
-    virtual gl::Error copyToStorage(TextureStorage *destStorage);
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
+    gl::Error getBaseTexture(const gl::Context *context,
+                             IDirect3DBaseTexture9 **outTexture) override;
+    gl::Error generateMipmap(const gl::Context *context,
+                             const gl::ImageIndex &sourceIndex,
+                             const gl::ImageIndex &destIndex) override;
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
 
   private:
     IDirect3DTexture9 *mTexture;
@@ -92,15 +107,20 @@ class TextureStorage9_EGLImage final : public TextureStorage9
     TextureStorage9_EGLImage(Renderer9 *renderer, EGLImageD3D *image, RenderTarget9 *renderTarget9);
     ~TextureStorage9_EGLImage() override;
 
-    gl::Error getSurfaceLevel(GLenum target,
+    gl::Error getSurfaceLevel(const gl::Context *context,
+                              GLenum target,
                               int level,
                               bool dirty,
                               IDirect3DSurface9 **outSurface) override;
-    gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override;
-    gl::Error getBaseTexture(IDirect3DBaseTexture9 **outTexture) override;
-    gl::Error generateMipmap(const gl::ImageIndex &sourceIndex,
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
+    gl::Error getBaseTexture(const gl::Context *context,
+                             IDirect3DBaseTexture9 **outTexture) override;
+    gl::Error generateMipmap(const gl::Context *context,
+                             const gl::ImageIndex &sourceIndex,
                              const gl::ImageIndex &destIndex) override;
-    gl::Error copyToStorage(TextureStorage *destStorage) override;
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
 
   private:
     EGLImageD3D *mImage;
@@ -112,14 +132,20 @@ class TextureStorage9_Cube : public TextureStorage9
     TextureStorage9_Cube(Renderer9 *renderer, GLenum internalformat, bool renderTarget, int size, int levels, bool hintLevelZeroOnly);
     virtual ~TextureStorage9_Cube();
 
-    gl::Error getSurfaceLevel(GLenum target,
+    gl::Error getSurfaceLevel(const gl::Context *context,
+                              GLenum target,
                               int level,
                               bool dirty,
                               IDirect3DSurface9 **outSurface) override;
-    virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT);
-    virtual gl::Error getBaseTexture(IDirect3DBaseTexture9 **outTexture);
-    virtual gl::Error generateMipmap(const gl::ImageIndex &sourceIndex, const gl::ImageIndex &destIndex);
-    virtual gl::Error copyToStorage(TextureStorage *destStorage);
+    gl::Error getRenderTarget(const gl::Context *context,
+                              const gl::ImageIndex &index,
+                              RenderTargetD3D **outRT) override;
+    gl::Error getBaseTexture(const gl::Context *context,
+                             IDirect3DBaseTexture9 **outTexture) override;
+    gl::Error generateMipmap(const gl::Context *context,
+                             const gl::ImageIndex &sourceIndex,
+                             const gl::ImageIndex &destIndex) override;
+    gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) override;
 
   private:
     static const size_t CUBE_FACE_COUNT = 6;
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp
index e9c69304bd0..c0b80a847c3 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexBuffer9.cpp
@@ -47,7 +47,8 @@ gl::Error VertexBuffer9::initialize(unsigned int size, bool dynamicUsage)
 
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal vertex buffer of size, %lu.", size);
+            return gl::OutOfMemory()
+                   << "Failed to allocate internal vertex buffer of size " << size;
         }
     }
 
@@ -67,7 +68,7 @@ gl::Error VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib
 {
     if (!mVertexBuffer)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal vertex buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal vertex buffer is not initialized.";
     }
 
     int inputStride = static_cast<int>(gl::ComputeVertexAttributeStride(attrib, binding));
@@ -88,12 +89,12 @@ gl::Error VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib
     HRESULT result = mVertexBuffer->Lock(offset, mapSize, reinterpret_cast<void**>(&mapPtr), lockFlags);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal vertex buffer, HRESULT: 0x%08x.", result);
+        return gl::OutOfMemory() << "Failed to lock internal vertex buffer, " << gl::FmtHR(result);
     }
 
     const uint8_t *input = sourceData;
 
-    if (instances == 0 || binding.divisor == 0)
+    if (instances == 0 || binding.getDivisor() == 0)
     {
         input += inputStride * start;
     }
@@ -138,7 +139,7 @@ gl::Error VertexBuffer9::discard()
 {
     if (!mVertexBuffer)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Internal vertex buffer is not initialized.");
+        return gl::OutOfMemory() << "Internal vertex buffer is not initialized.";
     }
 
     void *dummy;
@@ -147,13 +148,15 @@ gl::Error VertexBuffer9::discard()
     result = mVertexBuffer->Lock(0, 1, &dummy, D3DLOCK_DISCARD);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to lock internal buffer for discarding, HRESULT: 0x%08x", result);
+        return gl::OutOfMemory() << "Failed to lock internal buffer for discarding, "
+                                 << gl::FmtHR(result);
     }
 
     result = mVertexBuffer->Unlock();
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to unlock internal buffer for discarding, HRESULT: 0x%08x", result);
+        return gl::OutOfMemory() << "Failed to unlock internal buffer for discarding, "
+                                 << gl::FmtHR(result);
     }
 
     return gl::NoError();
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp
index c9555d4fe1d..abadf5c0b54 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.cpp
@@ -232,7 +232,8 @@ gl::Error VertexDeclarationCache::applyDeclaration(
     HRESULT result = device->CreateVertexDeclaration(elements, &lastCache->vertexDeclaration);
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal vertex declaration, result: 0x%X.", result);
+        return gl::OutOfMemory() << "Failed to create internal vertex declaration, "
+                                 << gl::FmtHR(result);
     }
 
     device->SetVertexDeclaration(lastCache->vertexDeclaration);