Clean up TextureStorage11_2DMultisample

This de-duplicates functionality from TextureStorage11_EGLImage and
TextureStorage11_2DMultisample. Neither of those supports changing the
associated images or image access in shaders.

Multisampled textures also cannot be compressed, so the size doesn't
need to be adjusted according to block size.

BUG=angleproject:2275
TEST=angle_end2end_tests

Change-Id: I45bc573584065bf4f528f883435fadfbd7281077
Reviewed-on: https://chromium-review.googlesource.com/1216002
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
diff --git a/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp b/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
index 5519bcd..22934bf 100644
--- a/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
+++ b/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
@@ -1602,13 +1602,62 @@
     return angle::Result::Stop();
 }
 
+TextureStorage11ImmutableBase::TextureStorage11ImmutableBase(Renderer11 *renderer,
+                                                             UINT bindFlags,
+                                                             UINT miscFlags,
+                                                             GLenum internalFormat)
+    : TextureStorage11(renderer, bindFlags, miscFlags, internalFormat)
+{
+}
+
+void TextureStorage11ImmutableBase::associateImage(Image11 *, const gl::ImageIndex &)
+{
+}
+
+void TextureStorage11ImmutableBase::disassociateImage(const gl::ImageIndex &, Image11 *)
+{
+}
+
+void TextureStorage11ImmutableBase::verifyAssociatedImageValid(const gl::ImageIndex &, Image11 *)
+{
+}
+
+angle::Result TextureStorage11ImmutableBase::releaseAssociatedImage(const gl::Context *context,
+                                                                    const gl::ImageIndex &,
+                                                                    Image11 *)
+{
+    return angle::Result::Continue();
+}
+
+angle::Result TextureStorage11ImmutableBase::createSRVForImage(const gl::Context *context,
+                                                               int level,
+                                                               DXGI_FORMAT format,
+                                                               const TextureHelper11 &texture,
+                                                               d3d11::SharedSRV *outSRV)
+{
+    UNREACHABLE();
+    context->handleError(gl::InternalError() << "createSRVForImage is unimplemented.");
+    return angle::Result::Stop();
+}
+
+angle::Result TextureStorage11ImmutableBase::createUAVForImage(const gl::Context *context,
+                                                               int level,
+                                                               DXGI_FORMAT format,
+                                                               const TextureHelper11 &texture,
+                                                               d3d11::SharedUAV *outUAV)
+{
+    UNREACHABLE();
+    context->handleError(gl::InternalError() << "createUAVForImage is unimplemented.");
+    return angle::Result::Stop();
+}
+
 TextureStorage11_EGLImage::TextureStorage11_EGLImage(Renderer11 *renderer,
                                                      EGLImageD3D *eglImage,
                                                      RenderTarget11 *renderTarget11)
-    : TextureStorage11(renderer,
-                       D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE,
-                       0,
-                       renderTarget11->getInternalFormat()),
+    : TextureStorage11ImmutableBase(renderer,
+                                    D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE,
+                                    0,
+                                    renderTarget11->getInternalFormat()),
       mImage(eglImage),
       mCurrentRenderTarget(0),
       mSwizzleTexture(),
@@ -1687,25 +1736,6 @@
     return angle::Result::Continue();
 }
 
-void TextureStorage11_EGLImage::associateImage(Image11 *, const gl::ImageIndex &)
-{
-}
-
-void TextureStorage11_EGLImage::disassociateImage(const gl::ImageIndex &, Image11 *)
-{
-}
-
-void TextureStorage11_EGLImage::verifyAssociatedImageValid(const gl::ImageIndex &, Image11 *)
-{
-}
-
-angle::Result TextureStorage11_EGLImage::releaseAssociatedImage(const gl::Context *context,
-                                                                const gl::ImageIndex &,
-                                                                Image11 *)
-{
-    return angle::Result::Continue();
-}
-
 angle::Result TextureStorage11_EGLImage::useLevelZeroWorkaroundTexture(const gl::Context *context,
                                                                        bool)
 {
@@ -1824,28 +1854,6 @@
     return angle::Result::Continue();
 }
 
-angle::Result TextureStorage11_EGLImage::createSRVForImage(const gl::Context *context,
-                                                           int level,
-                                                           DXGI_FORMAT format,
-                                                           const TextureHelper11 &texture,
-                                                           d3d11::SharedSRV *outSRV)
-{
-    UNREACHABLE();
-    context->handleError(gl::InternalError());
-    return angle::Result::Stop();
-}
-
-angle::Result TextureStorage11_EGLImage::createUAVForImage(const gl::Context *context,
-                                                           int level,
-                                                           DXGI_FORMAT format,
-                                                           const TextureHelper11 &texture,
-                                                           d3d11::SharedUAV *outUAV)
-{
-    UNREACHABLE();
-    context->handleError(gl::InternalError());
-    return angle::Result::Stop();
-}
-
 angle::Result TextureStorage11_EGLImage::getImageRenderTarget(const gl::Context *context,
                                                               RenderTarget11 **outRT) const
 {
@@ -3263,7 +3271,7 @@
                                                                int levels,
                                                                int samples,
                                                                bool fixedSampleLocations)
-    : TextureStorage11(
+    : TextureStorage11ImmutableBase(
           renderer,
           GetTextureBindFlags(internalformat, renderer->getRenderer11DeviceCaps(), true),
           GetTextureMiscFlags(internalformat, renderer->getRenderer11DeviceCaps(), true, levels),
@@ -3271,8 +3279,10 @@
       mTexture(),
       mRenderTarget(nullptr)
 {
-    // adjust size if needed for compressed textures
-    d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel);
+    // There are no multisampled compressed formats, so there's no need to adjust texture size
+    // according to block size.
+    ASSERT(d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat).blockWidth <= 1);
+    ASSERT(d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat).blockHeight <= 1);
 
     mMipLevels            = 1;
     mTextureWidth         = width;
@@ -3299,27 +3309,6 @@
     return angle::Result::Stop();
 }
 
-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)
-{
-}
-
-angle::Result TextureStorage11_2DMultisample::releaseAssociatedImage(const gl::Context *context,
-                                                                     const gl::ImageIndex &index,
-                                                                     Image11 *incomingImage)
-{
-    return angle::Result::Continue();
-}
-
 angle::Result TextureStorage11_2DMultisample::getResource(const gl::Context *context,
                                                           const TextureHelper11 **outResource)
 {
@@ -3446,28 +3435,6 @@
     return angle::Result::Continue();
 }
 
-angle::Result TextureStorage11_2DMultisample::createSRVForImage(const gl::Context *context,
-                                                                int level,
-                                                                DXGI_FORMAT format,
-                                                                const TextureHelper11 &texture,
-                                                                d3d11::SharedSRV *outSRV)
-{
-    UNREACHABLE();
-    context->handleError(gl::InternalError() << "createSRVForImage is unimplemented.");
-    return angle::Result::Stop();
-}
-
-angle::Result TextureStorage11_2DMultisample::createUAVForImage(const gl::Context *context,
-                                                                int level,
-                                                                DXGI_FORMAT format,
-                                                                const TextureHelper11 &texture,
-                                                                d3d11::SharedUAV *outUAV)
-{
-    UNREACHABLE();
-    context->handleError(gl::InternalError() << "createUAVForImage is unimplemented.");
-    return angle::Result::Stop();
-}
-
 angle::Result TextureStorage11_2DMultisample::getSwizzleTexture(const gl::Context *context,
                                                                 const TextureHelper11 **outTexture)
 {
diff --git a/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h b/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h
index eb58aff..892a1b6 100644
--- a/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h
+++ b/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h
@@ -382,7 +382,36 @@
     Image11 *mAssociatedImage;
 };
 
-class TextureStorage11_EGLImage final : public TextureStorage11
+// A base class for texture storage classes where the associated images are not changed, nor are
+// they accessible as images in GLES3.1+ shaders.
+class TextureStorage11ImmutableBase : public TextureStorage11
+{
+  public:
+    TextureStorage11ImmutableBase(Renderer11 *renderer,
+                                  UINT bindFlags,
+                                  UINT miscFlags,
+                                  GLenum internalFormat);
+
+    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;
+    angle::Result releaseAssociatedImage(const gl::Context *context,
+                                         const gl::ImageIndex &index,
+                                         Image11 *incomingImage) override;
+
+    angle::Result createSRVForImage(const gl::Context *context,
+                                    int level,
+                                    DXGI_FORMAT format,
+                                    const TextureHelper11 &texture,
+                                    d3d11::SharedSRV *outSRV) override;
+    angle::Result createUAVForImage(const gl::Context *context,
+                                    int level,
+                                    DXGI_FORMAT format,
+                                    const TextureHelper11 &texture,
+                                    d3d11::SharedUAV *outUAV) override;
+};
+
+class TextureStorage11_EGLImage final : public TextureStorage11ImmutableBase
 {
   public:
     TextureStorage11_EGLImage(Renderer11 *renderer,
@@ -404,13 +433,6 @@
 
     angle::Result 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;
-    angle::Result releaseAssociatedImage(const gl::Context *context,
-                                         const gl::ImageIndex &index,
-                                         Image11 *incomingImage) override;
-
     angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context,
                                                 bool useLevelZeroTexture) override;
 
@@ -432,16 +454,6 @@
                                       DXGI_FORMAT format,
                                       const TextureHelper11 &texture,
                                       d3d11::SharedSRV *outSRV) override;
-    angle::Result createSRVForImage(const gl::Context *context,
-                                    int level,
-                                    DXGI_FORMAT format,
-                                    const TextureHelper11 &texture,
-                                    d3d11::SharedSRV *outSRV) override;
-    angle::Result createUAVForImage(const gl::Context *context,
-                                    int level,
-                                    DXGI_FORMAT format,
-                                    const TextureHelper11 &texture,
-                                    d3d11::SharedUAV *outUAV) override;
 
     angle::Result getImageRenderTarget(const gl::Context *context, RenderTarget11 **outRT) const;
 
@@ -699,7 +711,7 @@
     ImageMap mAssociatedImages;
 };
 
-class TextureStorage11_2DMultisample : public TextureStorage11
+class TextureStorage11_2DMultisample final : public TextureStorage11ImmutableBase
 {
   public:
     TextureStorage11_2DMultisample(Renderer11 *renderer,
@@ -721,13 +733,6 @@
 
     angle::Result 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;
-    angle::Result releaseAssociatedImage(const gl::Context *context,
-                                         const gl::ImageIndex &index,
-                                         Image11 *incomingImage) override;
-
   protected:
     angle::Result getSwizzleTexture(const gl::Context *context,
                                     const TextureHelper11 **outTexture) override;
@@ -747,16 +752,6 @@
                                       DXGI_FORMAT format,
                                       const TextureHelper11 &texture,
                                       d3d11::SharedSRV *outSRV) override;
-    angle::Result createSRVForImage(const gl::Context *context,
-                                    int level,
-                                    DXGI_FORMAT format,
-                                    const TextureHelper11 &texture,
-                                    d3d11::SharedSRV *outSRV) override;
-    angle::Result createUAVForImage(const gl::Context *context,
-                                    int level,
-                                    DXGI_FORMAT format,
-                                    const TextureHelper11 &texture,
-                                    d3d11::SharedUAV *outUAV) override;
 
     TextureHelper11 mTexture;
     std::unique_ptr<RenderTarget11> mRenderTarget;