D3D11: Consolidate InputLayout allocation.

src/common/angleutils.h

@@ -47,6 +47,27 @@ constexpr inline size_t ArraySize(T (&)[N])
     return N;
 }
 
+template <typename T>
+class WrappedArray final : angle::NonCopyable
+{
+  public:
+    template <size_t N>
+    constexpr WrappedArray(const T (&data)[N]) : mArray(&data[0]), mSize(N)
+    {
+    }
+
+    constexpr WrappedArray() : mArray(nullptr), mSize(0) {}
+    constexpr WrappedArray(const T *data, size_t size) : mArray(data), mSize(size) {}
+    ~WrappedArray() {}
+
+    constexpr const T *get() const { return mArray; }
+    constexpr size_t size() const { return mSize; }
+
+  private:
+    const T *mArray;
+    size_t mSize;
+};
+
 template <typename T, unsigned int N>
 void SafeRelease(T (&resourceBlock)[N])
 {

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

@@ -597,11 +597,9 @@ Blit11::Blit11(Renderer11 *renderer)
 
 Blit11::~Blit11()
 {
-    mQuad2DIL.release();
     mQuad2DVS.release();
     mDepthPS.release();
 
-    mQuad3DIL.release();
     mQuad3DVS.release();
     mQuad3DGS.release();
 
@@ -955,28 +953,29 @@ 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));
+        supportOut->inputLayout         = mQuad2DIL.get();
+        supportOut->vertexShader        = mQuad2DVS.resolve(device);
+        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));
+        supportOut->inputLayout         = mQuad2DIL.get();
+        supportOut->vertexShader        = mQuad3DVS.resolve(device);
+        supportOut->geometryShader      = mQuad3DGS.resolve(device);
+        supportOut->vertexWriteFunction = Write3DVertices;
     }
 
-    return support;
+    return gl::NoError();
 }
 
 gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
@@ -1041,7 +1040,8 @@ gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
         return gl::OutOfMemory() << "Failed to map internal vertex buffer for swizzle, " << result;
     }
 
-    const ShaderSupport &support = getShaderSupport(*shader);
+    ShaderSupport support;
+    ANGLE_TRY(getShaderSupport(*shader, &support));
 
     UINT stride    = 0;
     UINT startIdx  = 0;
@@ -1167,7 +1167,8 @@ 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;
@@ -1361,7 +1362,8 @@ gl::Error Blit11::copyDepth(const d3d11::SharedSRV &source,
     }
 
     // Apply shaders
-    deviceContext->IASetInputLayout(mQuad2DIL.resolve(device));
+    ANGLE_TRY(mQuad2DIL.resolve(mRenderer));
+    deviceContext->IASetInputLayout(mQuad2DIL.get());
     deviceContext->IASetPrimitiveTopology(topology);
     deviceContext->VSSetShader(quad2DVS, nullptr, 0);
 

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

@@ -195,7 +195,7 @@ class Blit11 : angle::NonCopyable
 
     gl::Error initResources();
 
-    ShaderSupport getShaderSupport(const Shader &shader);
+    gl::Error getShaderSupport(const Shader &shader, ShaderSupport *supportOut);
 
     static BlitShaderType GetBlitShaderType(GLenum destinationFormat,
                                             GLenum sourceFormat,

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"),
@@ -102,31 +102,35 @@ Clear11::ShaderManager::~ShaderManager()
     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,
+                                                      ID3D11InputLayout **il,
+                                                      ID3D11VertexShader **vs,
+                                                      ID3D11PixelShader **ps)
 {
+    auto featureLevel = renderer->getRenderer11DeviceCaps().featureLevel;
+    auto device       = renderer->getDevice();
+
     if (featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
         ASSERT(clearType == GL_FLOAT);
 
         *vs = mVs9.resolve(device);
 
-        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}};
+
+            InputElementArray ilDescArray(ilDesc);
+            ShaderData vertexShader(g_VS_Clear_FL9);
 
-            device->CreateInputLayout(&ilDesc, 1, g_VS_Clear_FL9, ArraySize(g_PS_ClearFloat_FL9),
-                                      mIl9.GetAddressOf());
+            ANGLE_TRY(renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
         }
 
-        *il = mIl9.Get();
+        *il = mIl9.get();
         *ps = mPsFloat9.resolve(device);
-        return;
+        return gl::NoError();
     }
 
     *vs = mVs.resolve(device);
@@ -147,6 +151,8 @@ void Clear11::ShaderManager::getShadersAndLayout(ID3D11Device *device,
             UNREACHABLE();
             break;
     }
+
+    return gl::NoError();
 }
 
 Clear11::Clear11(Renderer11 *renderer)
@@ -692,13 +698,11 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
     }
 
     // Get Shaders
-    const D3D_FEATURE_LEVEL fl = mRenderer->getRenderer11DeviceCaps().featureLevel;
-    ID3D11Device *device = mRenderer->getDevice();
-    ID3D11VertexShader *vs;
-    ID3D11InputLayout *il;
-    ID3D11PixelShader *ps;
+    ID3D11VertexShader *vs = nullptr;
+    ID3D11InputLayout *il  = nullptr;
+    ID3D11PixelShader *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);

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

@@ -47,15 +47,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,
+                                      ID3D11InputLayout **il,
+                                      ID3D11VertexShader **vs,
+                                      ID3D11PixelShader **ps);
 
       private:
-        angle::ComPtr<ID3D11InputLayout> mIl9;
+        d3d11::InputLayout mIl9;
         d3d11::LazyShader<ID3D11VertexShader> mVs9;
         d3d11::LazyShader<ID3D11PixelShader> mPsFloat9;
         d3d11::LazyShader<ID3D11VertexShader> mVs;

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

@@ -195,10 +195,6 @@ void InputLayoutCache::initialize()
 
 void InputLayoutCache::clear()
 {
-    for (auto &layout : mLayoutMap)
-    {
-        SafeRelease(layout.second);
-    }
     mLayoutMap.clear();
     mPointSpriteVertexBuffer.reset();
     mPointSpriteIndexBuffer.reset();
@@ -504,12 +500,13 @@ gl::Error InputLayoutCache::updateInputLayout(Renderer11 *renderer,
         auto layoutMapIt = mLayoutMap.find(layout);
         if (layoutMapIt != mLayoutMap.end())
         {
-            inputLayout = layoutMapIt->second;
+            inputLayout = layoutMapIt->second.get();
         }
         else
         {
+            d3d11::InputLayout newInputLayout;
             ANGLE_TRY(createInputLayout(renderer, sortedSemanticIndices, mode, program,
-                                        numIndicesPerInstance, &inputLayout));
+                                        numIndicesPerInstance, &newInputLayout));
             if (mLayoutMap.size() >= mCacheSize)
             {
                 WARN() << "Overflowed the limit of " << mCacheSize
@@ -523,13 +520,13 @@ gl::Error InputLayoutCache::updateInputLayout(Renderer11 *renderer,
                     if (it != mLayoutMap.end())
                     {
                         // c++11 erase allows us to easily delete the current iterator.
-                        SafeRelease(it->second);
                         it = mLayoutMap.erase(it);
                     }
                 }
             }
 
-            mLayoutMap[layout] = inputLayout;
+            inputLayout        = newInputLayout.get();
+            mLayoutMap[layout] = std::move(newInputLayout);
         }
     }
 
@@ -548,7 +545,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;
@@ -638,15 +635,10 @@ 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();
 }
 

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

@@ -101,9 +101,9 @@ class InputLayoutCache : angle::NonCopyable
                                 GLenum mode,
                                 gl::Program *program,
                                 GLsizei numIndicesPerInstance,
-                                ID3D11InputLayout **inputLayoutOut);
+                                d3d11::InputLayout *inputLayoutOut);
 
-    std::map<PackedAttributeLayout, ID3D11InputLayout *> mLayoutMap;
+    std::map<PackedAttributeLayout, d3d11::InputLayout> mLayoutMap;
 
     uintptr_t mCurrentIL;
     std::array<ID3D11Buffer *, gl::MAX_VERTEX_ATTRIBS> mCurrentBuffers;

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

@@ -121,6 +121,15 @@ HRESULT CreateResource(ID3D11Device *device,
 }
 
 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 D3D11_RASTERIZER_DESC *desc,
                        void * /*initData*/,
                        ID3D11RasterizerState **rasterizerState)
@@ -337,30 +346,13 @@ void ResourceManager11::decrResource(ResourceType resourceType, size_t memorySiz
     mAllocatedResourceDeviceMemory[ResourceTypeIndex(resourceType)] -= memorySize;
 }
 
-void ResourceManager11::onReleaseResource(ResourceType resourceType, ID3D11Resource *resource)
+void ResourceManager11::onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource)
 {
     ASSERT(resource);
     decrResource(resourceType, ComputeGenericMemoryUsage(resourceType, resource));
 }
 
 template <>
-void ResourceManager11::onRelease(ID3D11Resource *resource)
-{
-    // For untyped ID3D11Resource, they must call onReleaseResource.
-    UNREACHABLE();
-}
-
-template <typename T>
-void ResourceManager11::onRelease(T *resource)
-{
-    ASSERT(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)
 {
@@ -456,21 +448,12 @@ GetInitDataFromD3D11<T> *ResourceManager11::createInitDataIfNeeded(const GetDesc
     return nullptr;
 }
 
-#define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \
-    \
-template gl::Error                                                             \
-    ResourceManager11::allocate(\
-Renderer11 *,                                                                  \
-                                \
-const DESCTYPE *,                                                              \
-                                \
-INITDATATYPE *,                                                                \
-                                \
-Resource11<D3D11TYPE> *);                                                      \
+#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

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

@@ -25,6 +25,9 @@ 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, BlendState, ID3D11BlendState, D3D11_BLEND_DESC, void)                           \
@@ -32,6 +35,7 @@ class TextureHelper11;
     OP(NAME, DepthStencilState, ID3D11DepthStencilState, D3D11_DEPTH_STENCIL_DESC, void)     \
     OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC,        \
        ID3D11Resource)                                                                       \
+    OP(NAME, InputLayout, ID3D11InputLayout, InputElementArray, const ShaderData)            \
     OP(NAME, RasterizerState, ID3D11RasterizerState, D3D11_RASTERIZER_DESC, void)            \
     OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC,        \
        ID3D11Resource)                                                                       \
@@ -277,8 +281,12 @@ class ResourceManager11 final : angle::NonCopyable
     }
 
     template <typename T>
-    void onRelease(T *resource);
-    void onReleaseResource(ResourceType resourceType, ID3D11Resource *resource);
+    void onRelease(T *resource)
+    {
+        onReleaseGeneric(GetResourceTypeFromD3D11<T>(), resource);
+    }
+
+    void onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource);
 
   private:
     void incrResource(ResourceType resourceType, size_t memorySize);

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

@@ -82,7 +82,7 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
       mDepthStencilSRView(),
       mQuadVB(),
       mPassThroughSampler(),
-      mPassThroughIL(nullptr),
+      mPassThroughIL(),
       mPassThroughVS(nullptr),
       mPassThroughPS(nullptr),
       mPassThroughRS(),
@@ -122,7 +122,7 @@ void SwapChain11::release()
     mDepthStencilSRView.reset();
     mQuadVB.reset();
     mPassThroughSampler.reset();
-    SafeRelease(mPassThroughIL);
+    mPassThroughIL.reset();
     SafeRelease(mPassThroughVS);
     SafeRelease(mPassThroughPS);
     mPassThroughRS.reset();
@@ -612,7 +612,7 @@ void SwapChain11::initPassThroughResources()
 
     // Make sure our resources are all not allocated, when we create
     ASSERT(!mQuadVB.valid() && !mPassThroughSampler.valid());
-    ASSERT(mPassThroughIL == nullptr && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
+    ASSERT(!mPassThroughIL.valid() && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
 
     D3D11_BUFFER_DESC vbDesc;
     vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
@@ -651,13 +651,15 @@ void SwapChain11::initPassThroughResources()
         { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
     };
 
-    HRESULT 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);
+
+    err = mRenderer->allocateResource(quadElements, &vertexShaderData, &mPassThroughIL);
+    ASSERT(!err.isError());
+    mPassThroughIL.setDebugName("Swap chain pass through layout");
 
-    result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), nullptr,
-                                        &mPassThroughVS);
+    HRESULT result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D),
+                                                nullptr, &mPassThroughVS);
     ASSERT(SUCCEEDED(result));
     d3d11::SetDebugName(mPassThroughVS, "Swap chain pass through vertex shader");
 
@@ -782,7 +784,7 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
     deviceContext->RSSetState(mPassThroughRS.get());
 
     // Apply shaders
-    deviceContext->IASetInputLayout(mPassThroughIL);
+    deviceContext->IASetInputLayout(mPassThroughIL.get());
     deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
     deviceContext->VSSetShader(mPassThroughVS, nullptr, 0);
     deviceContext->PSSetShader(mPassThroughPS, nullptr, 0);

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

@@ -100,7 +100,7 @@ class SwapChain11 final : public SwapChainD3D
 
     d3d11::Buffer mQuadVB;
     d3d11::SamplerState mPassThroughSampler;
-    ID3D11InputLayout *mPassThroughIL;
+    d3d11::InputLayout mPassThroughIL;
     ID3D11VertexShader *mPassThroughVS;
     ID3D11PixelShader *mPassThroughPS;
     d3d11::RasterizerState mPassThroughRS;

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

@@ -1940,36 +1940,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)
@@ -1979,7 +1952,7 @@ LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugNa
 
 gl::Error LazyBlendState::resolve(Renderer11 *renderer)
 {
-    return resolveImpl(renderer, mDesc, mDebugName);
+    return resolveImpl(renderer, mDesc, nullptr, mDebugName);
 }
 
 angle::WorkaroundsD3D GenerateWorkarounds(const Renderer11DeviceCaps &deviceCaps,

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

@@ -262,7 +262,7 @@ template <ResourceType ResourceT>
 class LazyResource2 : angle::NonCopyable
 {
   public:
-    LazyResource2() : mResource() {}
+    constexpr LazyResource2() : mResource() {}
     virtual ~LazyResource2() {}
 
     virtual gl::Error resolve(Renderer11 *renderer) = 0;
@@ -276,11 +276,12 @@ class LazyResource2 : angle::NonCopyable
   protected:
     gl::Error resolveImpl(Renderer11 *renderer,
                           const GetDescType<ResourceT> &desc,
+                          GetInitDataType<ResourceT> *initData,
                           const char *name)
     {
         if (!mResource.valid())
         {
-            ANGLE_TRY(renderer->allocateResource(desc, &mResource));
+            ANGLE_TRY(renderer->allocateResource(desc, initData, &mResource));
             mResource.setDebugName(name);
         }
         return gl::NoError();
@@ -351,21 +352,25 @@ inline ID3D11PixelShader *LazyShader<ID3D11PixelShader>::resolve(ID3D11Device *d
     return mResource;
 }
 
-class LazyInputLayout final : public LazyResource<ID3D11InputLayout>
+class LazyInputLayout final : public LazyResource2<ResourceType::InputLayout>
 {
   public:
-    LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
-                    size_t inputDescLen,
-                    const BYTE *byteCode,
-                    size_t byteCodeLen,
-                    const char *debugName);
+    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)
+    {
+    }
 
-    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;
 };
 
@@ -420,7 +425,7 @@ struct GenericData
             // We can have a nullptr factory when holding passed-in resources.
             if (manager)
             {
-                manager->onReleaseResource(resourceType, object);
+                manager->onReleaseGeneric(resourceType, object);
                 manager = nullptr;
             }
             object->Release();