D3D11: Consolidate Buffer allocation.

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -248,18 +248,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;
 

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

@@ -556,7 +556,7 @@ DXGI_FORMAT GetStencilSRVFormat(const d3d11::Format &formatSet)
 Blit11::Blit11(Renderer11 *renderer)
     : mRenderer(renderer),
       mResourcesInitialized(false),
-      mVertexBuffer(nullptr),
+      mVertexBuffer(),
       mPointSampler(nullptr),
       mLinearSampler(nullptr),
       mScissorEnabledRasterizerState(nullptr),
@@ -579,7 +579,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"),
@@ -632,13 +632,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;
@@ -751,13 +746,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;
 
@@ -1076,7 +1066,7 @@ 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;
@@ -1093,10 +1083,10 @@ 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, "
@@ -1109,13 +1099,15 @@ 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);
 
     // Apply vertex buffer
-    deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &startIdx);
+    ID3D11Buffer *vertexBuffer = mVertexBuffer.get();
+    deviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &startIdx);
 
     // 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);
@@ -1210,7 +1202,7 @@ gl::Error Blit11::copyTexture(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, "
@@ -1225,10 +1217,11 @@ gl::Error Blit11::copyTexture(const d3d11::SharedSRV &source,
     support.vertexWriteFunction(sourceArea, sourceSize, destArea, destSize, mappedResource.pData,
                                 &stride, &drawCount, &topology);
 
-    deviceContext->Unmap(mVertexBuffer.Get(), 0);
+    deviceContext->Unmap(mVertexBuffer.get(), 0);
 
     // Apply vertex buffer
-    deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &startIdx);
+    ID3D11Buffer *vertexBuffer = mVertexBuffer.get();
+    deviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &startIdx);
 
     // Apply state
     if (maskOffAlpha)
@@ -1349,7 +1342,7 @@ 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, "
@@ -1364,10 +1357,11 @@ gl::Error Blit11::copyDepth(const d3d11::SharedSRV &source,
     Write2DVertices(sourceArea, sourceSize, destArea, destSize, mappedResource.pData, &stride,
                     &drawCount, &topology);
 
-    deviceContext->Unmap(mVertexBuffer.Get(), 0);
+    deviceContext->Unmap(mVertexBuffer.get(), 0);
 
     // Apply vertex buffer
-    deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &startIdx);
+    ID3D11Buffer *vertexBuffer = mVertexBuffer.get();
+    deviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &startIdx);
 
     // Apply state
     deviceContext->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF);

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

@@ -277,7 +277,7 @@ class Blit11 : angle::NonCopyable
     std::map<SwizzleShaderType, Shader> mSwizzleShaderMap;
 
     bool mResourcesInitialized;
-    angle::ComPtr<ID3D11Buffer> mVertexBuffer;
+    d3d11::Buffer mVertexBuffer;
     angle::ComPtr<ID3D11SamplerState> mPointSampler;
     angle::ComPtr<ID3D11SamplerState> mLinearSampler;
     angle::ComPtr<ID3D11RasterizerState> mScissorEnabledRasterizerState;
@@ -294,7 +294,7 @@ class Blit11 : angle::NonCopyable
 
     d3d11::LazyBlendState mAlphaMaskBlendState;
 
-    angle::ComPtr<ID3D11Buffer> mSwizzleCB;
+    d3d11::Buffer mSwizzleCB;
 
     d3d11::LazyShader<ID3D11VertexShader> mResolveDepthStencilVS;
     d3d11::LazyShader<ID3D11PixelShader> mResolveDepthPS;

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

@@ -154,8 +154,8 @@ Clear11::Clear11(Renderer11 *renderer)
       mScissorEnabledRasterizerState(nullptr),
       mScissorDisabledRasterizerState(nullptr),
       mShaderManager(),
-      mConstantBuffer(nullptr),
-      mVertexBuffer(nullptr),
+      mConstantBuffer(),
+      mVertexBuffer(),
       mShaderData({})
 {
     TRACE_EVENT0("gpu.angle", "Clear11::Clear11");
@@ -173,55 +173,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;
@@ -282,6 +233,75 @@ 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,
                                     const gl::FramebufferState &fboData)
 {
@@ -619,12 +639,14 @@ 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))
         {
@@ -632,7 +654,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
         }
 
         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
@@ -674,17 +696,19 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
     deviceContext->VSSetShader(vs, nullptr, 0);
     deviceContext->GSSetShader(nullptr, nullptr, 0);
     deviceContext->PSSetShader(ps, nullptr, 0);
-    deviceContext->PSSetConstantBuffers(0, 1, mConstantBuffer.GetAddressOf());
+    ID3D11Buffer *constantBuffer = mConstantBuffer.get();
+    deviceContext->PSSetConstantBuffers(0, 1, &constantBuffer);
 
     // Bind IL & VB if needed
     deviceContext->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0);
     deviceContext->IASetInputLayout(il);
 
-    if (mVertexBuffer.Get())
+    if (useVertexBuffer())
     {
+        ANGLE_TRY(ensureVertexBufferCreated());
         const UINT offset = 0;
-        deviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &g_VertexSize,
-                                          &offset);
+        ID3D11Buffer *vertexBuffer = mVertexBuffer.get();
+        deviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &g_VertexSize, &offset);
     }
     else
     {

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

@@ -64,6 +64,10 @@ class Clear11 : angle::NonCopyable
         d3d11::LazyShader<ID3D11PixelShader> mPsSInt;
     };
 
+    bool useVertexBuffer() const;
+    gl::Error ensureConstantBufferCreated();
+    gl::Error ensureVertexBufferCreated();
+
     Renderer11 *mRenderer;
 
     // States
@@ -74,13 +78,13 @@ class Clear11 : angle::NonCopyable
 
     // 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_

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,7 +60,7 @@ 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.");
     }
@@ -83,7 +74,8 @@ gl::Error IndexBuffer11::mapBuffer(unsigned int offset, unsigned int size, void*
     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);
@@ -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.");
     }
 
     ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
-    dxContext->Unmap(mBuffer, 0);
+    dxContext->Unmap(mBuffer.get(), 0);
     return gl::NoError();
 }
 
@@ -129,7 +121,7 @@ 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.");
     }
@@ -137,13 +129,13 @@ gl::Error IndexBuffer11::discard()
     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);
     }
 
-    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

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_

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

@@ -173,8 +173,8 @@ bool InputLayoutCache::PackedAttributeLayout::operator<(const PackedAttributeLay
 
 InputLayoutCache::InputLayoutCache()
     : mCurrentIL(angle::DirtyPointer),
-      mPointSpriteVertexBuffer(nullptr),
-      mPointSpriteIndexBuffer(nullptr),
+      mPointSpriteVertexBuffer(),
+      mPointSpriteIndexBuffer(),
       mCacheSize(kDefaultCacheSize)
 {
     mCurrentBuffers.fill(nullptr);
@@ -200,8 +200,8 @@ void InputLayoutCache::clear()
         SafeRelease(layout.second);
     }
     mLayoutMap.clear();
-    SafeRelease(mPointSpriteVertexBuffer);
-    SafeRelease(mPointSpriteIndexBuffer);
+    mPointSpriteVertexBuffer.reset();
+    mPointSpriteIndexBuffer.reset();
     markDirty();
 }
 
@@ -227,7 +227,6 @@ gl::Error InputLayoutCache::applyVertexBuffers(
     GLsizei numIndicesPerInstance)
 {
     ID3D11DeviceContext *deviceContext = renderer->getDeviceContext();
-    ID3D11Device *device               = renderer->getDevice();
 
     gl::Program *program   = state.getProgram();
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
@@ -285,7 +284,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))
             {
@@ -342,7 +341,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(
     {
         const UINT pointSpriteVertexStride = sizeof(float) * 5;
 
-        if (!mPointSpriteVertexBuffer)
+        if (!mPointSpriteVertexBuffer.valid())
         {
             static const float pointSpriteVertices[] =
             {
@@ -364,15 +363,11 @@ 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;
+        mCurrentBuffers[0] = mPointSpriteVertexBuffer.get();
         // 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;
@@ -383,7 +378,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(
         minDiff = 0;
         maxDiff = std::max(maxDiff, static_cast<size_t>(0));
 
-        if (!mPointSpriteIndexBuffer)
+        if (!mPointSpriteIndexBuffer.valid())
         {
             // Create an index buffer and set it for pointsprite rendering
             static const unsigned short pointSpriteIndices[] =
@@ -400,13 +395,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,7 +405,7 @@ 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);
         }
     }
 

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

@@ -22,6 +22,7 @@
 #include "libANGLE/Error.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
+#include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
 
 namespace gl
 {
@@ -110,8 +111,8 @@ class InputLayoutCache : angle::NonCopyable
     std::array<UINT, gl::MAX_VERTEX_ATTRIBS> mCurrentVertexOffsets;
     std::vector<const TranslatedAttribute *> mCurrentAttributes;
 
-    ID3D11Buffer *mPointSpriteVertexBuffer;
-    ID3D11Buffer *mPointSpriteIndexBuffer;
+    d3d11::Buffer mPointSpriteVertexBuffer;
+    d3d11::Buffer mPointSpriteIndexBuffer;
 
     unsigned int mCacheSize;
 };

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

@@ -38,7 +38,7 @@ PixelTransfer11::PixelTransfer11(Renderer11 *renderer)
       mResourcesLoaded(false),
       mBufferToTextureVS(nullptr),
       mBufferToTextureGS(nullptr),
-      mParamsConstantBuffer(nullptr),
+      mParamsConstantBuffer(),
       mCopyRasterizerState(nullptr),
       mCopyDepthStencilState(nullptr)
 {
@@ -55,7 +55,6 @@ PixelTransfer11::~PixelTransfer11()
 
     SafeRelease(mBufferToTextureVS);
     SafeRelease(mBufferToTextureGS);
-    SafeRelease(mParamsConstantBuffer);
     SafeRelease(mCopyRasterizerState);
     SafeRelease(mCopyDepthStencilState);
 }
@@ -120,13 +119,8 @@ 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");
@@ -239,11 +233,12 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
 
     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;

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
 {
 
@@ -76,7 +76,7 @@ class PixelTransfer11
     std::map<GLenum, ID3D11PixelShader *> mBufferToTexturePSMap;
     ID3D11VertexShader *mBufferToTextureVS;
     ID3D11GeometryShader *mBufferToTextureGS;
-    ID3D11Buffer *mParamsConstantBuffer;
+    d3d11::Buffer mParamsConstantBuffer;
     CopyShaderParams mParamsData;
 
     ID3D11RasterizerState *mCopyRasterizerState;

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

@@ -541,7 +541,7 @@ 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,
                                 const gl::Rectangle &sourceRect,
@@ -603,27 +603,27 @@ class Renderer11 : public RendererD3D
     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;

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

@@ -51,6 +51,12 @@ size_t ComputeMemoryUsage(const D3D11_TEXTURE3D_DESC *desc)
                                     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)
 {
@@ -74,6 +80,8 @@ size_t ComputeGenericMemoryUsage(ResourceType resourceType, ID3D11DeviceChild *r
             return ComputeGenericMemoryUsage<ResourceType::Texture2D>(resource);
         case ResourceType::Texture3D:
             return ComputeGenericMemoryUsage<ResourceType::Texture3D>(resource);
+        case ResourceType::Buffer:
+            return ComputeGenericMemoryUsage<ResourceType::Buffer>(resource);
 
         default:
             return 0;
@@ -81,6 +89,14 @@ size_t ComputeGenericMemoryUsage(ResourceType resourceType, ID3D11DeviceChild *r
 }
 
 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 D3D11_DEPTH_STENCIL_VIEW_DESC *desc,
                        ID3D11Resource *resource,
                        ID3D11DepthStencilView **resourceOut)

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

@@ -26,6 +26,7 @@ class TextureHelper11;
 
 // Format: ResourceType, D3D11 type, DESC type, init data type.
 #define ANGLE_RESOURCE_TYPE_OP(NAME, OP)                                                     \
+    OP(NAME, Buffer, ID3D11Buffer, D3D11_BUFFER_DESC, const D3D11_SUBRESOURCE_DATA)          \
     OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC,        \
        ID3D11Resource)                                                                       \
     OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC,        \

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

@@ -89,30 +89,33 @@ ID3D11ComputeShader *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();
+}
+
+UniformStorage11::~UniformStorage11()
+{
+}
 
-    if (initialSize > 0)
+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

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
 {
@@ -44,15 +45,15 @@ class ShaderExecutable11 : public ShaderExecutableD3D
 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_

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

@@ -80,7 +80,7 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
       mDepthStencilTexture(),
       mDepthStencilDSView(),
       mDepthStencilSRView(),
-      mQuadVB(nullptr),
+      mQuadVB(),
       mPassThroughSampler(nullptr),
       mPassThroughIL(nullptr),
       mPassThroughVS(nullptr),
@@ -120,7 +120,7 @@ void SwapChain11::release()
     mDepthStencilTexture.reset();
     mDepthStencilDSView.reset();
     mDepthStencilSRView.reset();
-    SafeRelease(mQuadVB);
+    mQuadVB.reset();
     SafeRelease(mPassThroughSampler);
     SafeRelease(mPassThroughIL);
     SafeRelease(mPassThroughVS);
@@ -611,7 +611,7 @@ void SwapChain11::initPassThroughResources()
     ASSERT(device != nullptr);
 
     // Make sure our resources are all not allocated, when we create
-    ASSERT(mQuadVB == nullptr && mPassThroughSampler == nullptr);
+    ASSERT(!mQuadVB.valid() && mPassThroughSampler == nullptr);
     ASSERT(mPassThroughIL == nullptr && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
 
     D3D11_BUFFER_DESC vbDesc;
@@ -622,9 +622,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;
@@ -641,7 +641,7 @@ void SwapChain11::initPassThroughResources()
     samplerDesc.MinLOD = 0;
     samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
-    result = device->CreateSamplerState(&samplerDesc, &mPassThroughSampler);
+    HRESULT result = device->CreateSamplerState(&samplerDesc, &mPassThroughSampler);
     ASSERT(SUCCEEDED(result));
     d3d11::SetDebugName(mPassThroughSampler, "Swap chain pass through sampler");
 
@@ -729,7 +729,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;
@@ -763,11 +764,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);
 
     static UINT stride = sizeof(d3d11::PositionTexCoordVertex);
     static UINT startIdx = 0;
-    deviceContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &startIdx);
+    ID3D11Buffer *vertexBuffer = mQuadVB.get();
+    deviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &startIdx);
 
     // Apply state
     deviceContext->OMSetDepthStencilState(nullptr, 0xFFFFFFFF);

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

@@ -98,7 +98,7 @@ class SwapChain11 final : public SwapChainD3D
     d3d11::DepthStencilView mDepthStencilDSView;
     d3d11::SharedSRV mDepthStencilSRView;
 
-    ID3D11Buffer *mQuadVB;
+    d3d11::Buffer mQuadVB;
     ID3D11SamplerState *mPassThroughSampler;
     ID3D11InputLayout *mPassThroughIL;
     ID3D11VertexShader *mPassThroughVS;

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,7 +75,7 @@ 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,
@@ -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,7 +108,7 @@ 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.");
     }
@@ -164,7 +156,7 @@ 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.");
     }
@@ -172,19 +164,19 @@ gl::Error VertexBuffer11::discard()
     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);
     }
 
-    dxContext->Unmap(mBuffer, 0);
+    dxContext->Unmap(mBuffer.get(), 0);
 
     return gl::NoError();
 }
 
-ID3D11Buffer *VertexBuffer11::getBuffer() const
+const d3d11::Buffer &VertexBuffer11::getBuffer() const
 {
     return mBuffer;
 }

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;