--- a/gfx/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h
+++ b/gfx/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h
@@ -8,17 +8,17 @@
 
 #ifndef LIBANGLE_RENDERER_D3D_D3D11_BLIT11_H_
 #define LIBANGLE_RENDERER_D3D_D3D11_BLIT11_H_
 
 #include "common/angleutils.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
-#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
+#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
 
 #include <map>
 
 namespace rx
 {
 class Renderer11;
 
 class Blit11 : angle::NonCopyable

--- a/gfx/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.h
+++ b/gfx/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.h
@@ -10,17 +10,17 @@
 #define LIBANGLE_RENDERER_D3D_D3D11_CLEAR11_H_
 
 #include <map>
 #include <vector>
 
 #include "libANGLE/angletypes.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/Framebuffer.h"
-#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
+#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
 
 namespace rx
 {
 class Renderer11;
 class RenderTarget11;
 struct ClearParameters;
 
 template <typename T>

--- a/gfx/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
+++ b/gfx/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h
@@ -564,10 +564,127 @@ class Renderer11 : public RendererD3D
     gl::DebugAnnotator *mAnnotator;
 
     mutable Optional<bool> mSupportsShareHandles;
     ResourceManager11 mResourceManager11;
 
     TextureHelper11 mCachedResolveTexture;
 };
 
+namespace d3d11
+{
+
+template <ResourceType ResourceT>
+class LazyResource : angle::NonCopyable
+{
+  public:
+    constexpr LazyResource() : mResource() {}
+    virtual ~LazyResource() {}
+
+    virtual gl::Error resolve(Renderer11 *renderer) = 0;
+    void reset() { mResource.reset(); }
+    GetD3D11Type<ResourceT> *get() const
+    {
+        ASSERT(mResource.valid());
+        return mResource.get();
+    }
+
+    const Resource11<GetD3D11Type<ResourceT>> &getObj() const { return mResource; }
+
+  protected:
+    LazyResource(LazyResource &&other) : mResource(std::move(other.mResource)) {}
+    gl::Error resolveImpl(Renderer11 *renderer,
+                          const GetDescType<ResourceT> &desc,
+                          GetInitDataType<ResourceT> *initData,
+                          const char *name)
+    {
+        if (!mResource.valid())
+        {
+            ANGLE_TRY(renderer->allocateResource(desc, initData, &mResource));
+            mResource.setDebugName(name);
+        }
+        return gl::NoError();
+    }
+
+    Resource11<GetD3D11Type<ResourceT>> mResource;
+};
+
+template <typename D3D11ShaderType>
+class LazyShader final : public LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>
+{
+  public:
+    // All parameters must be constexpr. Not supported in VS2013.
+    constexpr LazyShader(const BYTE *byteCode, size_t byteCodeSize, const char *name)
+        : mByteCode(byteCode, byteCodeSize), mName(name)
+    {
+    }
+
+    constexpr LazyShader(LazyShader &&shader)
+        : LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>(std::move(shader)),
+          mByteCode(std::move(shader.mByteCode)),
+          mName(shader.mName)
+    {
+    }
+
+    gl::Error resolve(Renderer11 *renderer) override
+    {
+        return this->resolveImpl(renderer, mByteCode, nullptr, mName);
+    }
+
+  private:
+    ShaderData mByteCode;
+    const char *mName;
+};
+
+class LazyInputLayout final : public LazyResource<ResourceType::InputLayout>
+{
+  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)
+    {
+    }
+
+    gl::Error resolve(Renderer11 *renderer) override
+    {
+        return resolveImpl(renderer, mInputDesc, &mByteCode, mDebugName);
+    }
+
+  private:
+    InputElementArray mInputDesc;
+    ShaderData mByteCode;
+    const char *mDebugName;
+};
+
+class LazyBlendState final : public LazyResource<ResourceType::BlendState>
+{
+  public:
+    LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName)
+        : mDesc(desc), mDebugName(debugName)
+    {
+    }
+
+
+    gl::Error resolve(Renderer11 *renderer)
+    {
+        return resolveImpl(renderer, mDesc, nullptr, mDebugName);
+    }
+
+
+  private:
+    D3D11_BLEND_DESC mDesc;
+    const char *mDebugName;
+};
+
+
+
+
+
+
+}  // namespace d3d11
+
 }  // namespace rx
 #endif  // LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_

--- a/gfx/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
+++ b/gfx/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
@@ -2021,31 +2021,16 @@ HRESULT SetDebugName(ID3D11DeviceChild *
         return resource->SetPrivateData(WKPDID_D3DDebugObjectName,
                                         static_cast<unsigned int>(strlen(name)), name);
     }
 #else
     return S_OK;
 #endif
 }
 
-gl::Error LazyInputLayout::resolve(Renderer11 *renderer)
-{
-    return resolveImpl(renderer, mInputDesc, &mByteCode, mDebugName);
-}
-
-LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName)
-    : mDesc(desc), mDebugName(debugName)
-{
-}
-
-gl::Error LazyBlendState::resolve(Renderer11 *renderer)
-{
-    return resolveImpl(renderer, mDesc, nullptr, mDebugName);
-}
-
 angle::WorkaroundsD3D GenerateWorkarounds(const Renderer11DeviceCaps &deviceCaps,
                                           const DXGI_ADAPTER_DESC &adapterDesc)
 {
     bool is9_3 = (deviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3);
 
     angle::WorkaroundsD3D workarounds;
     workarounds.mrtPerfWorkaround = true;
     workarounds.setDataFasterThanImageUpload = true;

--- a/gfx/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
+++ b/gfx/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
@@ -173,111 +173,16 @@ inline bool isDeviceLostError(HRESULT er
       case DXGI_ERROR_DRIVER_INTERNAL_ERROR:
       case DXGI_ERROR_NOT_CURRENTLY_AVAILABLE:
         return true;
       default:
         return false;
     }
 }
 
-template <ResourceType ResourceT>
-class LazyResource : angle::NonCopyable
-{
-  public:
-    constexpr LazyResource() : mResource() {}
-    virtual ~LazyResource() {}
-
-    virtual gl::Error resolve(Renderer11 *renderer) = 0;
-    void reset() { mResource.reset(); }
-    GetD3D11Type<ResourceT> *get() const
-    {
-        ASSERT(mResource.valid());
-        return mResource.get();
-    }
-
-    const Resource11<GetD3D11Type<ResourceT>> &getObj() const { return mResource; }
-
-  protected:
-    LazyResource(LazyResource &&other) : mResource(std::move(other.mResource)) {}
-    gl::Error resolveImpl(Renderer11 *renderer,
-                          const GetDescType<ResourceT> &desc,
-                          GetInitDataType<ResourceT> *initData,
-                          const char *name)
-    {
-        if (!mResource.valid())
-        {
-            ANGLE_TRY(renderer->allocateResource(desc, initData, &mResource));
-            mResource.setDebugName(name);
-        }
-        return gl::NoError();
-    }
-
-    Resource11<GetD3D11Type<ResourceT>> mResource;
-};
-
-template <typename D3D11ShaderType>
-class LazyShader final : public LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>
-{
-  public:
-    // All parameters must be constexpr. Not supported in VS2013.
-    constexpr LazyShader(const BYTE *byteCode, size_t byteCodeSize, const char *name)
-        : mByteCode(byteCode, byteCodeSize), mName(name)
-    {
-    }
-
-    constexpr LazyShader(LazyShader &&shader)
-        : LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>(std::move(shader)),
-          mByteCode(std::move(shader.mByteCode)),
-          mName(shader.mName)
-    {
-    }
-
-    gl::Error resolve(Renderer11 *renderer) override
-    {
-        return this->resolveImpl(renderer, mByteCode, nullptr, mName);
-    }
-
-  private:
-    ShaderData mByteCode;
-    const char *mName;
-};
-
-class LazyInputLayout final : public LazyResource<ResourceType::InputLayout>
-{
-  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)
-    {
-    }
-
-    gl::Error resolve(Renderer11 *renderer) override;
-
-  private:
-    InputElementArray mInputDesc;
-    ShaderData mByteCode;
-    const char *mDebugName;
-};
-
-class LazyBlendState final : public LazyResource<ResourceType::BlendState>
-{
-  public:
-    LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName);
-
-    gl::Error resolve(Renderer11 *renderer);
-
-  private:
-    D3D11_BLEND_DESC mDesc;
-    const char *mDebugName;
-};
 
 // Copy data to small D3D11 buffers, such as for small constant buffers, which use one struct to
 // represent an entire buffer.
 template <class T>
 void SetBufferData(ID3D11DeviceContext *context, ID3D11Buffer *constantBuffer, const T &value)
 {
     D3D11_MAPPED_SUBRESOURCE mappedResource = {};
     HRESULT result = context->Map(constantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);