Bug 1407289 Move classes from renderer11_utils.h r=jgilbert,Lenzak

It's illegal to use a method of a forward declared class

libANGLE/renderer/d3d/d3d11/renderer11_utils.h:207:31: error: invalid use of incomplete type 'class rx::Renderer11'
               ANGLE_TRY(renderer->allocateResource(desc, initData, &mResource));

However we cannot simply include Renderer11.h because Renderer11.h includes renderer11_utils.h

If we put the LazyX classes into Renderer11.h however, we can
change the include on the few places they are used with minimal impact.

MozReview-Commit-ID: 8Wf4Xbi7vAP

--HG--
extra : rebase_source : 984601e08f88342c8f5b75f9d43af3e666598855

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

@@ -13,7 +13,7 @@
 #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>
 

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

@@ -15,7 +15,7 @@
 #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
 {

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

@@ -569,5 +569,122 @@ class Renderer11 : public RendererD3D
     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_

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

@@ -2026,21 +2026,6 @@ HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name)
 #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)
 {

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

@@ -178,101 +178,6 @@ inline bool isDeviceLostError(HRESULT errorCode)
     }
 }
 
-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.