Revert 4 Vulkan content defined CLs.

src/libANGLE/angletypes.cpp

@@ -14,23 +14,6 @@
 
 namespace gl
 {
-namespace
-{
-bool IsStencilNoOp(GLenum stencilFunc,
-                   GLenum stencilFail,
-                   GLenum stencilPassDepthFail,
-                   GLenum stencilPassDepthPass)
-{
-    const bool isNeverAndKeep           = stencilFunc == GL_NEVER && stencilFail == GL_KEEP;
-    const bool isAlwaysAndKeepOrAllKeep = (stencilFunc == GL_ALWAYS || stencilFail == GL_KEEP) &&
-                                          stencilPassDepthFail == GL_KEEP &&
-                                          stencilPassDepthPass == GL_KEEP;
-
-    return isNeverAndKeep || isAlwaysAndKeepOrAllKeep;
-}
-
-}  // anonymous namespace
-
 RasterizerState::RasterizerState()
 {
     memset(this, 0, sizeof(RasterizerState));
@@ -131,20 +114,6 @@ bool DepthStencilState::isStencilMaskedOut() const
     return (stencilMask & stencilWritemask) == 0;
 }
 
-bool DepthStencilState::isStencilNoOp() const
-{
-    return isStencilMaskedOut() ||
-           IsStencilNoOp(stencilFunc, stencilFail, stencilPassDepthFail, stencilPassDepthPass);
-}
-
-bool DepthStencilState::isStencilBackNoOp() const
-{
-    const bool isStencilBackMaskedOut = (stencilBackMask & stencilBackWritemask) == 0;
-    return isStencilBackMaskedOut ||
-           IsStencilNoOp(stencilBackFunc, stencilBackFail, stencilBackPassDepthFail,
-                         stencilBackPassDepthPass);
-}
-
 bool operator==(const DepthStencilState &a, const DepthStencilState &b)
 {
     return memcmp(&a, &b, sizeof(DepthStencilState)) == 0;

src/libANGLE/angletypes.h

@@ -199,8 +199,6 @@ struct DepthStencilState final
 
     bool isDepthMaskedOut() const;
     bool isStencilMaskedOut() const;
-    bool isStencilNoOp() const;
-    bool isStencilBackNoOp() const;
 
     bool depthTest;
     GLenum depthFunc;

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -300,7 +300,7 @@ vk::ResourceAccess GetDepthAccess(const gl::DepthStencilState &dsState)
     {
         return vk::ResourceAccess::Unused;
     }
-    return dsState.isDepthMaskedOut() ? vk::ResourceAccess::ReadOnly : vk::ResourceAccess::Write;
+    return dsState.depthMask ? vk::ResourceAccess::Write : vk::ResourceAccess::ReadOnly;
 }
 
 vk::ResourceAccess GetStencilAccess(const gl::DepthStencilState &dsState)
@@ -309,9 +309,8 @@ vk::ResourceAccess GetStencilAccess(const gl::DepthStencilState &dsState)
     {
         return vk::ResourceAccess::Unused;
     }
-
-    return dsState.isStencilNoOp() && dsState.isStencilBackNoOp() ? vk::ResourceAccess::ReadOnly
-                                                                  : vk::ResourceAccess::Write;
+    // Simplify this check by returning write instead of checking the mask.
+    return vk::ResourceAccess::Write;
 }
 }  // anonymous namespace
 
@@ -2568,8 +2567,7 @@ void ContextVk::optimizeRenderPassForPresent(VkFramebuffer framebufferHandle)
         mRenderPassCommands->invalidateRenderPassStencilAttachment(dsState);
         mRenderPassCommands->invalidateRenderPassDepthAttachment(dsState);
         // Mark content as invalid so that we will not load them in next renderpass
-        depthStencilRenderTarget->invalidateEntireContent(this);
-        depthStencilRenderTarget->invalidateEntireStencilContent(this);
+        depthStencilRenderTarget->invalidateEntireContent();
     }
 
     // Use finalLayout instead of extra barrier for layout change to present
@@ -4204,17 +4202,8 @@ angle::Result ContextVk::updateActiveImages(const gl::Context *context,
         }
         VkImageAspectFlags aspectFlags = image->getAspectFlags();
 
-        uint32_t layerStart = 0;
-        uint32_t layerCount = image->getLayerCount();
-        if (imageUnit.layered)
-        {
-            layerStart = imageUnit.layered;
-            layerCount = 1;
-        }
-
-        commandBufferHelper->imageWrite(
-            &mResourceUseList, gl::LevelIndex(static_cast<uint32_t>(imageUnit.level)), layerStart,
-            layerCount, aspectFlags, imageLayout, vk::AliasingMode::Allowed, image);
+        commandBufferHelper->imageWrite(&mResourceUseList, aspectFlags, imageLayout,
+                                        vk::AliasingMode::Allowed, image);
     }
 
     return angle::Result::Continue;
@@ -4646,11 +4635,7 @@ angle::Result ContextVk::onImageRead(VkImageAspectFlags aspectFlags,
     return angle::Result::Continue;
 }
 
-angle::Result ContextVk::onImageWrite(gl::LevelIndex levelStart,
-                                      uint32_t levelCount,
-                                      uint32_t layerStart,
-                                      uint32_t layerCount,
-                                      VkImageAspectFlags aspectFlags,
+angle::Result ContextVk::onImageWrite(VkImageAspectFlags aspectFlags,
                                       vk::ImageLayout imageLayout,
                                       vk::ImageHelper *image)
 {
@@ -4662,7 +4647,7 @@ angle::Result ContextVk::onImageWrite(gl::LevelIndex levelStart,
     image->recordWriteBarrier(aspectFlags, imageLayout,
                               &mOutsideRenderPassCommands->getCommandBuffer());
     image->retain(&mResourceUseList);
-    image->onWrite(levelStart, levelCount, layerStart, layerCount, aspectFlags);
+    image->onWrite();
 
     return angle::Result::Continue;
 }
@@ -5130,8 +5115,16 @@ angle::Result ContextVk::updateRenderPassDepthStencilAccess()
         }
         else
         {
-            mRenderPassCommands->onDepthAccess(depthAccess);
-            mRenderPassCommands->onStencilAccess(stencilAccess);
+            if (mRenderPassCommands->onDepthAccess(depthAccess))
+            {
+                // The attachment is no longer invalidated, so set mContentDefined to true
+                mDrawFramebuffer->restoreDepthStencilDefinedContents();
+            }
+            if (mRenderPassCommands->onStencilAccess(stencilAccess))
+            {
+                // The attachment is no longer invalidated, so set mContentDefined to true
+                mDrawFramebuffer->restoreDepthStencilDefinedContents();
+            }
 
             mDrawFramebuffer->updateRenderPassReadOnlyDepthMode(this, mRenderPassCommands);
         }

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -511,29 +511,17 @@ class ContextVk : public ContextImpl, public vk::Context
     {
         return onImageRead(aspectFlags, vk::ImageLayout::TransferSrc, image);
     }
-    angle::Result onImageTransferWrite(gl::LevelIndex levelStart,
-                                       uint32_t levelCount,
-                                       uint32_t layerStart,
-                                       uint32_t layerCount,
-                                       VkImageAspectFlags aspectFlags,
-                                       vk::ImageHelper *image)
+    angle::Result onImageTransferWrite(VkImageAspectFlags aspectFlags, vk::ImageHelper *image)
     {
-        return onImageWrite(levelStart, levelCount, layerStart, layerCount, aspectFlags,
-                            vk::ImageLayout::TransferDst, image);
+        return onImageWrite(aspectFlags, vk::ImageLayout::TransferDst, image);
     }
     angle::Result onImageComputeShaderRead(VkImageAspectFlags aspectFlags, vk::ImageHelper *image)
     {
         return onImageRead(aspectFlags, vk::ImageLayout::ComputeShaderReadOnly, image);
     }
-    angle::Result onImageComputeShaderWrite(gl::LevelIndex levelStart,
-                                            uint32_t levelCount,
-                                            uint32_t layerStart,
-                                            uint32_t layerCount,
-                                            VkImageAspectFlags aspectFlags,
-                                            vk::ImageHelper *image)
+    angle::Result onImageComputeShaderWrite(VkImageAspectFlags aspectFlags, vk::ImageHelper *image)
     {
-        return onImageWrite(levelStart, levelCount, layerStart, layerCount, aspectFlags,
-                            vk::ImageLayout::ComputeShaderWrite, image);
+        return onImageWrite(aspectFlags, vk::ImageLayout::ComputeShaderWrite, image);
     }
 
     void onImageRenderPassRead(VkImageAspectFlags aspectFlags,
@@ -544,26 +532,19 @@ class ContextVk : public ContextImpl, public vk::Context
         mRenderPassCommands->imageRead(&mResourceUseList, aspectFlags, imageLayout, image);
     }
 
-    void onImageRenderPassWrite(gl::LevelIndex level,
-                                uint32_t layerStart,
-                                uint32_t layerCount,
-                                VkImageAspectFlags aspectFlags,
+    void onImageRenderPassWrite(VkImageAspectFlags aspectFlags,
                                 vk::ImageLayout imageLayout,
                                 vk::ImageHelper *image)
     {
         ASSERT(mRenderPassCommands->started());
-        mRenderPassCommands->imageWrite(&mResourceUseList, level, layerStart, layerCount,
-                                        aspectFlags, imageLayout, vk::AliasingMode::Allowed, image);
+        mRenderPassCommands->imageWrite(&mResourceUseList, aspectFlags, imageLayout,
+                                        vk::AliasingMode::Allowed, image);
     }
 
-    void onDepthStencilDraw(gl::LevelIndex level,
-                            uint32_t layer,
-                            vk::ImageHelper *image,
-                            vk::ImageHelper *resolveImage)
+    void onDepthStencilDraw(vk::ImageHelper *image, vk::ImageHelper *resolveImage)
     {
         ASSERT(mRenderPassCommands->started());
-        mRenderPassCommands->depthStencilImagesDraw(&mResourceUseList, level, layer, image,
-                                                    resolveImage);
+        mRenderPassCommands->depthStencilImagesDraw(&mResourceUseList, image, resolveImage);
     }
 
     void onImageHelperRelease(const vk::ImageHelper *image)
@@ -949,11 +930,7 @@ class ContextVk : public ContextImpl, public vk::Context
     angle::Result onImageRead(VkImageAspectFlags aspectFlags,
                               vk::ImageLayout imageLayout,
                               vk::ImageHelper *image);
-    angle::Result onImageWrite(gl::LevelIndex levelStart,
-                               uint32_t levelCount,
-                               uint32_t layerStart,
-                               uint32_t layerCount,
-                               VkImageAspectFlags aspectFlags,
+    angle::Result onImageWrite(VkImageAspectFlags aspectFlags,
                                vk::ImageLayout imageLayout,
                                vk::ImageHelper *image);
 

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -824,9 +824,7 @@ angle::Result FramebufferVk::blitWithCommand(ContextVk *contextVk,
     }
 
     ANGLE_TRY(contextVk->onImageTransferRead(imageAspectMask, srcImage));
-    ANGLE_TRY(contextVk->onImageTransferWrite(drawRenderTarget->getLevelIndex(), 1,
-                                              drawRenderTarget->getLayerIndex(), 1, imageAspectMask,
-                                              dstImage));
+    ANGLE_TRY(contextVk->onImageTransferWrite(imageAspectMask, dstImage));
     vk::CommandBuffer &commandBuffer = contextVk->getOutsideRenderPassCommandBuffer();
 
     VkImageBlit blit               = {};
@@ -1362,9 +1360,8 @@ angle::Result FramebufferVk::resolveColorWithCommand(ContextVk *contextVk,
     for (size_t colorIndexGL : mState.getEnabledDrawBuffers())
     {
         RenderTargetVk *drawRenderTarget = mRenderTargetCache.getColors()[colorIndexGL];
-        ANGLE_TRY(contextVk->onImageTransferWrite(
-            drawRenderTarget->getLevelIndex(), 1, drawRenderTarget->getLayerIndex(), 1,
-            VK_IMAGE_ASPECT_COLOR_BIT, &drawRenderTarget->getImageForWrite()));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT,
+                                                  &drawRenderTarget->getImageForWrite()));
 
         vk::CommandBuffer &commandBuffer = contextVk->getOutsideRenderPassCommandBuffer();
 
@@ -1518,21 +1515,15 @@ angle::Result FramebufferVk::invalidateImpl(ContextVk *contextVk,
             {
                 RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndexGL];
                 ASSERT(colorRenderTarget);
-                colorRenderTarget->invalidateEntireContent(contextVk);
+                colorRenderTarget->invalidateEntireContent();
             }
         }
 
-        // If we have a depth / stencil render target, invalidate its aspects.
-        if (depthStencilRenderTarget)
+        // If we have a depth / stencil render target AND we invalidate both we'll mark it as
+        // invalid. Maybe in the future add separate depth & stencil invalid flags.
+        if (depthStencilRenderTarget && invalidateDepthBuffer && invalidateStencilBuffer)
         {
-            if (invalidateDepthBuffer)
-            {
-                depthStencilRenderTarget->invalidateEntireContent(contextVk);
-            }
-            if (invalidateStencilBuffer)
-            {
-                depthStencilRenderTarget->invalidateEntireStencilContent(contextVk);
-            }
+            depthStencilRenderTarget->invalidateEntireContent();
         }
     }
 
@@ -2198,7 +2189,11 @@ angle::Result FramebufferVk::clearWithCommand(
         dsAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
         dsClearValue.depthStencil = clearDepthStencilValue;
         // Explicitly mark a depth write because we are clearing the depth buffer.
-        renderpassCommands->onDepthAccess(vk::ResourceAccess::Write);
+        if (renderpassCommands->onDepthAccess(vk::ResourceAccess::Write))
+        {
+            // The attachment is no longer invalidated, so set mContentDefined to true
+            restoreDepthStencilDefinedContents();
+        }
     }
 
     if (clearStencil)
@@ -2206,7 +2201,11 @@ angle::Result FramebufferVk::clearWithCommand(
         dsAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
         dsClearValue.depthStencil = clearDepthStencilValue;
         // Explicitly mark a stencil write because we are clearing the stencil buffer.
-        renderpassCommands->onStencilAccess(vk::ResourceAccess::Write);
+        if (renderpassCommands->onStencilAccess(vk::ResourceAccess::Write))
+        {
+            // The attachment is no longer invalidated, so set mContentDefined to true
+            restoreDepthStencilDefinedContents();
+        }
     }
 
     if (dsAspectFlags != 0)
@@ -2345,11 +2344,7 @@ angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
         if (!depthStencilRenderTarget->hasDefinedContent() ||
             depthStencilRenderTarget->isEntirelyTransient())
         {
-            depthLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-        }
-        if (!depthStencilRenderTarget->hasDefinedStencilContent() ||
-            depthStencilRenderTarget->isEntirelyTransient())
-        {
+            depthLoadOp   = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
             stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
         }
 
@@ -2484,7 +2479,7 @@ angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
 
     if (depthStencilRenderTarget)
     {
-        // This must be called after hasDefined*Content() since it will set content to valid. We are
+        // This must be called after hasDefinedContent() since it will set content to valid. We are
         // tracking content valid very loosely here that as long as it is attached, it assumes will
         // have valid content. The only time it has undefined content is between swap and
         // startNewRenderPass
@@ -2509,6 +2504,18 @@ angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
     return angle::Result::Continue;
 }
 
+void FramebufferVk::restoreDepthStencilDefinedContents()
+{
+    // If the depthStencilRenderTarget does not have "defined content" (i.e. meaning that a future
+    // render pass should use a loadOp of DONT_CARE), we should restore it (i.e. so that a future
+    // render pass uses a loadOp of LOAD).
+    RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
+    if (depthStencilRenderTarget)
+    {
+        depthStencilRenderTarget->restoreEntireContent();
+    }
+}
+
 void FramebufferVk::updateActiveColorMasks(size_t colorIndexGL, bool r, bool g, bool b, bool a)
 {
     gl::BlendStateExt::ColorMaskStorage::SetValueIndexed(

src/libANGLE/renderer/vulkan/FramebufferVk.h

@@ -118,6 +118,7 @@ class FramebufferVk : public FramebufferImpl
     angle::Result startNewRenderPass(ContextVk *contextVk,
                                      const gl::Rectangle &renderArea,
                                      vk::CommandBuffer **commandBufferOut);
+    void restoreDepthStencilDefinedContents();
 
     RenderTargetVk *getFirstRenderTarget() const;
     GLint getSamples() const;

src/libANGLE/renderer/vulkan/OverlayVk.cpp

@@ -120,8 +120,7 @@ angle::Result OverlayVk::createFont(ContextVk *contextVk)
 
     // Copy font data from staging buffer.
     ANGLE_TRY(contextVk->onBufferTransferRead(&fontDataBuffer.get()));
-    ANGLE_TRY(contextVk->onImageTransferWrite(gl::LevelIndex(0), 1, 0, gl::overlay::kFontCount,
-                                              VK_IMAGE_ASPECT_COLOR_BIT, &mFontImage));
+    ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, &mFontImage));
     vk::CommandBuffer &fontDataUpload = contextVk->getOutsideRenderPassCommandBuffer();
 
     VkBufferImageCopy copy           = {};

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -1221,6 +1221,9 @@ angle::Result ProgramExecutableVk::updateImagesDescriptorSet(
 
             // Note: binding.access is unused because it is implied by the shader.
 
+            // TODO(syoussefi): Support image data reinterpretation by using binding.format.
+            // http://anglebug.com/3563
+
             // Lazily allocate the descriptor set, since we may not need one if all of the image
             // uniforms are inactive.
             if (descriptorSet == VK_NULL_HANDLE)

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -31,7 +31,8 @@ RenderTargetVk::RenderTargetVk(RenderTargetVk &&other)
       mResolveImage(other.mResolveImage),
       mResolveImageViews(other.mResolveImageViews),
       mLevelIndexGL(other.mLevelIndexGL),
-      mLayerIndex(other.mLayerIndex)
+      mLayerIndex(other.mLayerIndex),
+      mContentDefined(other.mContentDefined)
 {
     other.reset();
 }
@@ -51,6 +52,9 @@ void RenderTargetVk::init(vk::ImageHelper *image,
     mLevelIndexGL      = levelIndexGL;
     mLayerIndex        = layerIndex;
 
+    // Conservatively assume the content is defined.
+    mContentDefined = true;
+
     mTransience = transience;
 }
 
@@ -62,6 +66,7 @@ void RenderTargetVk::reset()
     mResolveImageViews = nullptr;
     mLevelIndexGL      = gl::LevelIndex(0);
     mLayerIndex        = 0;
+    mContentDefined    = false;
 }
 
 vk::ImageViewSubresourceSerial RenderTargetVk::getSubresourceSerialImpl(
@@ -90,14 +95,16 @@ void RenderTargetVk::onColorDraw(ContextVk *contextVk)
 {
     ASSERT(!mImage->getFormat().actualImageFormat().hasDepthOrStencilBits());
 
-    contextVk->onImageRenderPassWrite(mLevelIndexGL, mLayerIndex, 1, VK_IMAGE_ASPECT_COLOR_BIT,
-                                      vk::ImageLayout::ColorAttachment, mImage);
+    contextVk->onImageRenderPassWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::ColorAttachment,
+                                      mImage);
     if (mResolveImage)
     {
-        contextVk->onImageRenderPassWrite(mLevelIndexGL, mLayerIndex, 1, VK_IMAGE_ASPECT_COLOR_BIT,
+        contextVk->onImageRenderPassWrite(VK_IMAGE_ASPECT_COLOR_BIT,
                                           vk::ImageLayout::ColorAttachment, mResolveImage);
     }
     retainImageViews(contextVk);
+
+    mContentDefined = true;
 }
 
 void RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk)
@@ -105,8 +112,10 @@ void RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk)
     const angle::Format &format = mImage->getFormat().actualImageFormat();
     ASSERT(format.hasDepthOrStencilBits());
 
-    contextVk->onDepthStencilDraw(mLevelIndexGL, mLayerIndex, mImage, mResolveImage);
+    contextVk->onDepthStencilDraw(mImage, mResolveImage);
     retainImageViews(contextVk);
+
+    mContentDefined = true;
 }
 
 vk::ImageHelper &RenderTargetVk::getImageForRenderPass()
@@ -166,11 +175,6 @@ bool RenderTargetVk::isResolveImageOwnerOfData() const
     return isImageTransient();
 }
 
-vk::ImageHelper *RenderTargetVk::getOwnerOfData() const
-{
-    return isResolveImageOwnerOfData() ? mResolveImage : mImage;
-}
-
 angle::Result RenderTargetVk::getAndRetainCopyImageView(ContextVk *contextVk,
                                                         const vk::ImageView **imageViewOut) const
 {
@@ -222,19 +226,23 @@ void RenderTargetVk::updateSwapchainImage(vk::ImageHelper *image,
 vk::ImageHelper &RenderTargetVk::getImageForCopy() const
 {
     ASSERT(mImage && mImage->valid() && (mResolveImage == nullptr || mResolveImage->valid()));
-    return *getOwnerOfData();
+    return isResolveImageOwnerOfData() ? *mResolveImage : *mImage;
 }
 
 vk::ImageHelper &RenderTargetVk::getImageForWrite() const
 {
     ASSERT(mImage && mImage->valid() && (mResolveImage == nullptr || mResolveImage->valid()));
-    return *getOwnerOfData();
+    return isResolveImageOwnerOfData() ? *mResolveImage : *mImage;
 }
 
 angle::Result RenderTargetVk::flushStagedUpdates(ContextVk *contextVk,
                                                  vk::ClearValuesArray *deferredClears,
                                                  uint32_t deferredClearIndex)
 {
+    // This function is called when the framebuffer is notified of an update to the attachment's
+    // contents.  Therefore, set mContentDefined so that the next render pass will have loadOp=LOAD.
+    mContentDefined = true;
+
     ASSERT(mImage->valid() && (!isResolveImageOwnerOfData() || mResolveImage->valid()));
 
     // Note that the layer index for 3D textures is always zero according to Vulkan.
@@ -244,7 +252,7 @@ angle::Result RenderTargetVk::flushStagedUpdates(ContextVk *contextVk,
         layerIndex = 0;
     }
 
-    vk::ImageHelper *image = getOwnerOfData();
+    vk::ImageHelper *image = isResolveImageOwnerOfData() ? mResolveImage : mImage;
 
     // All updates should be staged on the image that owns the data as the source of truth.  With
     // multisampled-render-to-texture framebuffers, that is the resolve image.  In that case, even
@@ -275,42 +283,6 @@ void RenderTargetVk::retainImageViews(ContextVk *contextVk) const
     }
 }
 
-bool RenderTargetVk::hasDefinedContent() const
-{
-    vk::ImageHelper *image = getOwnerOfData();
-    return image->hasSubresourceDefinedContent(mLevelIndexGL, mLayerIndex);
-}
-
-bool RenderTargetVk::hasDefinedStencilContent() const
-{
-    vk::ImageHelper *image = getOwnerOfData();
-    return image->hasSubresourceDefinedStencilContent(mLevelIndexGL, mLayerIndex);
-}
-
-void RenderTargetVk::invalidateEntireContent(ContextVk *contextVk)
-{
-    vk::ImageHelper *image = getOwnerOfData();
-    image->invalidateSubresourceContent(contextVk, mLevelIndexGL, mLayerIndex);
-}
-
-void RenderTargetVk::invalidateEntireStencilContent(ContextVk *contextVk)
-{
-    vk::ImageHelper *image = getOwnerOfData();
-    image->invalidateSubresourceStencilContent(contextVk, mLevelIndexGL, mLayerIndex);
-}
-
-void RenderTargetVk::restoreEntireContent()
-{
-    vk::ImageHelper *image = getOwnerOfData();
-    image->restoreSubresourceContent(mLevelIndexGL, mLayerIndex);
-}
-
-void RenderTargetVk::restoreEntireStencilContent()
-{
-    vk::ImageHelper *image = getOwnerOfData();
-    image->restoreSubresourceStencilContent(mLevelIndexGL, mLayerIndex);
-}
-
 gl::ImageIndex RenderTargetVk::getImageIndex() const
 {
     // Determine the GL type from the Vk Image properties.

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -108,14 +108,11 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     void retainImageViews(ContextVk *contextVk) const;
 
-    bool hasDefinedContent() const;
-    bool hasDefinedStencilContent() const;
+    bool hasDefinedContent() const { return mContentDefined; }
     // Mark content as undefined so that certain optimizations are possible such as using DONT_CARE
     // as loadOp of the render target in the next renderpass.
-    void invalidateEntireContent(ContextVk *contextVk);
-    void invalidateEntireStencilContent(ContextVk *contextVk);
-    void restoreEntireContent();
-    void restoreEntireStencilContent();
+    void invalidateEntireContent() { mContentDefined = false; }
+    void restoreEntireContent() { mContentDefined = true; }
 
     // See the description of mTransience for details of how the following two can interact.
     bool hasResolveAttachment() const { return mResolveImage != nullptr && !isEntirelyTransient(); }
@@ -134,7 +131,6 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     vk::ImageViewSubresourceSerial getSubresourceSerialImpl(vk::ImageViewHelper *imageViews) const;
 
     bool isResolveImageOwnerOfData() const;
-    vk::ImageHelper *getOwnerOfData() const;
 
     // The color or depth/stencil attachment of the framebuffer and its view.
     vk::ImageHelper *mImage;
@@ -144,7 +140,7 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     // implement GL_EXT_multisampled_render_to_texture, so while the rendering is done on mImage
     // during the renderpass, the resolved image is the one that actually holds the data.  This
     // means that data uploads and blit are done on this image, copies are done out of this image
-    // etc.  This means that if there is no clear, and hasDefined*Content(), the contents of
+    // etc.  This means that if there is no clear, and hasDefinedContent(), the contents of
     // mResolveImage must be copied to mImage since the loadOp of the attachment must be set to
     // LOAD.
     vk::ImageHelper *mResolveImage;
@@ -154,6 +150,10 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     gl::LevelIndex mLevelIndexGL;
     uint32_t mLayerIndex;
 
+    // Whether the render target has been invalidated.  If so, DONT_CARE is used instead of LOAD for
+    // loadOp of this attachment.
+    bool mContentDefined;
+
     // If resolve attachment exists, |mTransience| could be *Transient if the multisampled results
     // need to be discarded.
     //

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -1197,8 +1197,7 @@ angle::Result WindowSurfaceVk::present(ContextVk *contextVk,
     {
         // Transition the multisampled image to TRANSFER_SRC for resolve.
         ANGLE_TRY(contextVk->onImageTransferRead(VK_IMAGE_ASPECT_COLOR_BIT, &mColorImageMS));
-        ANGLE_TRY(contextVk->onImageTransferWrite(gl::LevelIndex(0), 1, 0, 1,
-                                                  VK_IMAGE_ASPECT_COLOR_BIT, &image.image));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, &image.image));
         commandBuffer = &contextVk->getOutsideRenderPassCommandBuffer();
 
         VkImageResolve resolveRegion                = {};

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -842,8 +842,7 @@ angle::Result TextureVk::copySubImageImplWithTransfer(ContextVk *contextVk,
         // Make sure any updates to the image are already flushed.
         ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::EnabledLevels));
 
-        ANGLE_TRY(contextVk->onImageTransferWrite(level, 1, baseLayer, layerCount,
-                                                  VK_IMAGE_ASPECT_COLOR_BIT, mImage));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, mImage));
         vk::CommandBuffer &commandBuffer = contextVk->getOutsideRenderPassCommandBuffer();
 
         VkImageSubresourceLayers destSubresource = srcSubresource;
@@ -876,8 +875,7 @@ angle::Result TextureVk::copySubImageImplWithTransfer(ContextVk *contextVk,
                                               gl::Extents(sourceBox.width, sourceBox.height, 1),
                                               destFormat, kTransferStagingImageFlags, layerCount));
 
-        ANGLE_TRY(contextVk->onImageTransferWrite(gl::LevelIndex(0), 1, 0, layerCount,
-                                                  VK_IMAGE_ASPECT_COLOR_BIT, stagingImage.get()));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, stagingImage.get()));
         vk::CommandBuffer &commandBuffer = contextVk->getOutsideRenderPassCommandBuffer();
 
         VkImageSubresourceLayers destSubresource = srcSubresource;
@@ -963,8 +961,6 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
             break;
     }
 
-    gl::LevelIndex level(index.getLevelIndex());
-
     UtilsVk::CopyImageParameters params;
     params.srcOffset[0]        = rotatedSourceBox.x;
     params.srcOffset[1]        = rotatedSourceBox.y;
@@ -974,13 +970,13 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
     params.destOffset[1]       = destOffset.y;
     params.srcMip              = srcImage->toVkLevel(sourceLevelGL).get();
     params.srcHeight           = srcExtents.height;
-    params.dstMip              = level;
     params.srcPremultiplyAlpha = unpackPremultiplyAlpha && !unpackUnmultiplyAlpha;
     params.srcUnmultiplyAlpha  = unpackUnmultiplyAlpha && !unpackPremultiplyAlpha;
     params.srcFlipY            = isSrcFlipY;
     params.destFlipY           = unpackFlipY;
     params.srcRotation         = srcFramebufferRotation;
 
+    gl::LevelIndex level(index.getLevelIndex());
     uint32_t baseLayer  = index.hasLayer() ? index.getLayerIndex() : destOffset.z;
     uint32_t layerCount = sourceBox.depth;
 
@@ -1005,7 +1001,6 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
         for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
         {
             params.srcLayer = layerIndex + sourceBox.z;
-            params.dstLayer = baseLayer + layerIndex;
 
             const vk::ImageView *destView;
             ANGLE_TRY(getLevelLayerImageView(contextVk, level, baseLayer + layerIndex, &destView));
@@ -1033,7 +1028,6 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
         for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
         {
             params.srcLayer = layerIndex + sourceBox.z;
-            params.dstLayer = layerIndex;
 
             // Create a temporary view for this layer.
             vk::ImageView stagingView;
@@ -1453,24 +1447,15 @@ angle::Result TextureVk::copyBufferDataToImage(ContextVk *contextVk,
     // Vulkan Spec requires the bufferOffset to be a multiple of 4 for vkCmdCopyBufferToImage.
     ASSERT((offset & (kBufferOffsetMultiple - 1)) == 0);
 
-    gl::LevelIndex level = gl::LevelIndex(index.getLevelIndex());
-    GLuint layerCount    = 0;
-    GLuint layerIndex    = 0;
+    GLuint layerCount = 0;
+    GLuint layerIndex = 0;
     GetRenderTargetLayerCountAndIndex(mImage, index, &layerCount, &layerIndex);
 
-    GLuint depth = sourceArea.depth;
-    if (index.getType() == gl::TextureType::_2DArray)
-    {
-        layerCount = depth;
-        depth      = 1;
-    }
-
     // Make sure the source is initialized and its images are flushed.
     ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::EnabledLevels));
 
     ANGLE_TRY(contextVk->onBufferTransferRead(srcBuffer));
-    ANGLE_TRY(contextVk->onImageTransferWrite(level, 1, layerIndex, layerCount,
-                                              VK_IMAGE_ASPECT_COLOR_BIT, mImage));
+    ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, mImage));
 
     vk::CommandBuffer &commandBuffer = contextVk->getOutsideRenderPassCommandBuffer();
 
@@ -1480,14 +1465,21 @@ angle::Result TextureVk::copyBufferDataToImage(ContextVk *contextVk,
     region.bufferImageHeight               = imageHeight;
     region.imageExtent.width               = sourceArea.width;
     region.imageExtent.height              = sourceArea.height;
-    region.imageExtent.depth               = depth;
+    region.imageExtent.depth               = sourceArea.depth;
     region.imageOffset.x                   = sourceArea.x;
     region.imageOffset.y                   = sourceArea.y;
     region.imageOffset.z                   = sourceArea.z;
     region.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
     region.imageSubresource.baseArrayLayer = layerIndex;
-    region.imageSubresource.layerCount     = layerCount;
-    region.imageSubresource.mipLevel       = mImage->toVkLevel(level).get();
+    region.imageSubresource.layerCount     = 1;
+    region.imageSubresource.mipLevel =
+        mImage->toVkLevel(gl::LevelIndex(index.getLevelIndex())).get();
+
+    if (index.getType() == gl::TextureType::_2DArray)
+    {
+        region.imageExtent.depth           = 1;
+        region.imageSubresource.layerCount = sourceArea.depth;
+    }
 
     commandBuffer.copyBufferToImage(srcBuffer->getBuffer().getHandle(), mImage->getImage(),
                                     mImage->getCurrentLayout(), 1, &region);
@@ -1537,11 +1529,7 @@ angle::Result TextureVk::generateMipmapsWithCompute(ContextVk *contextVk)
          destBaseLevelVk < vk::LevelIndex(mImage->getLevelCount());
          destBaseLevelVk = destBaseLevelVk + maxGenerateLevels.get())
     {
-        uint32_t writeLevelCount =
-            std::min(maxGenerateLevels.get(), mImage->getLevelCount() - destBaseLevelVk.get());
-        ANGLE_TRY(contextVk->onImageComputeShaderWrite(mImage->toGLLevel(destBaseLevelVk),
-                                                       writeLevelCount, 0, mImage->getLayerCount(),
-                                                       VK_IMAGE_ASPECT_COLOR_BIT, mImage));
+        ANGLE_TRY(contextVk->onImageComputeShaderWrite(VK_IMAGE_ASPECT_COLOR_BIT, mImage));
 
         // Generate mipmaps for every layer separately.
         for (uint32_t layer = 0; layer < mImage->getLayerCount(); ++layer)

src/libANGLE/renderer/vulkan/UtilsVk.cpp

@@ -1893,9 +1893,8 @@ angle::Result UtilsVk::stencilBlitResolveNoShaderExport(ContextVk *contextVk,
 
     // Change source layout prior to computation.
     ANGLE_TRY(contextVk->onImageComputeShaderRead(src->getAspectFlags(), src));
-    ANGLE_TRY(contextVk->onImageTransferWrite(
-        depthStencilRenderTarget->getLevelIndex(), 1, depthStencilRenderTarget->getLayerIndex(), 1,
-        depthStencilImage->getAspectFlags(), depthStencilImage));
+    ANGLE_TRY(
+        contextVk->onImageTransferWrite(depthStencilImage->getAspectFlags(), depthStencilImage));
 
     vk::CommandBuffer &commandBuffer = contextVk->getOutsideRenderPassCommandBuffer();
 
@@ -2126,8 +2125,8 @@ angle::Result UtilsVk::copyImage(ContextVk *contextVk,
     // Change source layout inside render pass.
     contextVk->onImageRenderPassRead(VK_IMAGE_ASPECT_COLOR_BIT,
                                      vk::ImageLayout::FragmentShaderReadOnly, src);
-    contextVk->onImageRenderPassWrite(params.dstMip, params.dstLayer, 1, VK_IMAGE_ASPECT_COLOR_BIT,
-                                      vk::ImageLayout::ColorAttachment, dest);
+    contextVk->onImageRenderPassWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::ColorAttachment,
+                                      dest);
 
     VkDescriptorImageInfo imageInfo = {};
     imageInfo.imageView             = srcView->getHandle();
@@ -2439,11 +2438,8 @@ angle::Result UtilsVk::cullOverlayWidgets(ContextVk *contextVk,
     ANGLE_TRY(allocateDescriptorSet(contextVk, Function::OverlayCull, &descriptorPoolBinding,
                                     &descriptorSet));
 
-    ASSERT(dest->getLevelCount() == 1 && dest->getLayerCount() == 1 &&
-           dest->getBaseLevel() == gl::LevelIndex(0));
     ANGLE_TRY(contextVk->onBufferComputeShaderRead(enabledWidgetsBuffer));
-    ANGLE_TRY(contextVk->onImageComputeShaderWrite(gl::LevelIndex(0), 1, 0, 1,
-                                                   VK_IMAGE_ASPECT_COLOR_BIT, dest));
+    ANGLE_TRY(contextVk->onImageComputeShaderWrite(VK_IMAGE_ASPECT_COLOR_BIT, dest));
 
     vk::CommandBuffer &commandBuffer = contextVk->getOutsideRenderPassCommandBuffer();
 
@@ -2512,10 +2508,7 @@ angle::Result UtilsVk::drawOverlay(ContextVk *contextVk,
     ANGLE_TRY(allocateDescriptorSet(contextVk, Function::OverlayDraw, &descriptorPoolBinding,
                                     &descriptorSet));
 
-    ASSERT(dest->getLevelCount() == 1 && dest->getLayerCount() == 1 &&
-           dest->getBaseLevel() == gl::LevelIndex(0));
-    ANGLE_TRY(contextVk->onImageComputeShaderWrite(gl::LevelIndex(0), 1, 0, 1,
-                                                   VK_IMAGE_ASPECT_COLOR_BIT, dest));
+    ANGLE_TRY(contextVk->onImageComputeShaderWrite(VK_IMAGE_ASPECT_COLOR_BIT, dest));
     ANGLE_TRY(contextVk->onImageComputeShaderRead(VK_IMAGE_ASPECT_COLOR_BIT, culledWidgets));
     ANGLE_TRY(contextVk->onImageComputeShaderRead(VK_IMAGE_ASPECT_COLOR_BIT, font));
     ANGLE_TRY(contextVk->onBufferComputeShaderRead(textWidgetsBuffer));

src/libANGLE/renderer/vulkan/UtilsVk.h

@@ -132,8 +132,6 @@ class UtilsVk : angle::NonCopyable
         int srcMip;
         int srcLayer;
         int srcHeight;
-        gl::LevelIndex dstMip;
-        int dstLayer;
         bool srcPremultiplyAlpha;
         bool srcUnmultiplyAlpha;
         bool srcFlipY;

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -945,17 +945,12 @@ class CommandBufferHelper : angle::NonCopyable
                    ImageLayout imageLayout,
                    ImageHelper *image);
     void imageWrite(ResourceUseList *resourceUseList,
-                    gl::LevelIndex level,
-                    uint32_t layerStart,
-                    uint32_t layerCount,
                     VkImageAspectFlags aspectFlags,
                     ImageLayout imageLayout,
                     AliasingMode aliasingMode,
                     ImageHelper *image);
 
     void depthStencilImagesDraw(ResourceUseList *resourceUseList,
-                                gl::LevelIndex level,
-                                uint32_t layer,
                                 ImageHelper *image,
                                 ImageHelper *resolveImage);
 
@@ -1034,10 +1029,9 @@ class CommandBufferHelper : angle::NonCopyable
         // Keep track of the size of commands in the command buffer.  If the size grows in the
         // future, that implies that drawing occured since invalidated.
         mDepthCmdSizeInvalidated = mCommandBuffer.getCommandSize();
-
         // Also track the size if the attachment is currently disabled.
-        const bool isDepthWriteEnabled = dsState.depthTest && dsState.depthMask;
-        mDepthCmdSizeDisabled = isDepthWriteEnabled ? kInfiniteCmdSize : mDepthCmdSizeInvalidated;
+        mDepthCmdSizeDisabled =
+            (dsState.depthTest && dsState.depthMask) ? kInfiniteCmdSize : mDepthCmdSizeInvalidated;
     }
 
     void invalidateRenderPassStencilAttachment(const gl::DepthStencilState &dsState)
@@ -1046,12 +1040,9 @@ class CommandBufferHelper : angle::NonCopyable
         // Keep track of the size of commands in the command buffer.  If the size grows in the
         // future, that implies that drawing occured since invalidated.
         mStencilCmdSizeInvalidated = mCommandBuffer.getCommandSize();
-
         // Also track the size if the attachment is currently disabled.
-        const bool isStencilWriteEnabled =
-            dsState.stencilTest && (!dsState.isStencilNoOp() || !dsState.isStencilBackNoOp());
         mStencilCmdSizeDisabled =
-            isStencilWriteEnabled ? kInfiniteCmdSize : mStencilCmdSizeInvalidated;
+            dsState.stencilTest ? kInfiniteCmdSize : mStencilCmdSizeInvalidated;
     }
 
     bool hasWriteAfterInvalidate(uint32_t cmdCountInvalidated, uint32_t cmdCountDisabled)
@@ -1112,8 +1103,8 @@ class CommandBufferHelper : angle::NonCopyable
     // Dumping the command stream is disabled by default.
     static constexpr bool kEnableCommandStreamDiagnostics = false;
 
-    void onDepthAccess(ResourceAccess access);
-    void onStencilAccess(ResourceAccess access);
+    bool onDepthAccess(ResourceAccess access);
+    bool onStencilAccess(ResourceAccess access);
 
     void updateRenderPassForResolve(vk::Framebuffer *newFramebuffer,
                                     const vk::RenderPassDesc &renderPassDesc);
@@ -1134,8 +1125,6 @@ class CommandBufferHelper : angle::NonCopyable
     bool onDepthStencilAccess(ResourceAccess access,
                               uint32_t *cmdCountInvalidated,
                               uint32_t *cmdCountDisabled);
-    void restoreDepthContent();
-    void restoreStencilContent();
 
     void finalizeDepthStencilImageLayout();
     void finalizeDepthStencilResolveImageLayout();
@@ -1192,8 +1181,6 @@ class CommandBufferHelper : angle::NonCopyable
 
     ImageHelper *mDepthStencilImage;
     ImageHelper *mDepthStencilResolveImage;
-    gl::LevelIndex mDepthStencilLevelIndex;
-    uint32_t mDepthStencilLayerIndex;
 };
 
 // Imagine an image going through a few layout transitions:
@@ -1643,29 +1630,10 @@ class ImageHelper final : public Resource, public angle::Subject
                                       GLuint *inputDepthPitch,
                                       GLuint *inputSkipBytes);
 
-    // Mark a given subresource as written to.  The subresource is identified by [levelStart,
-    // levelStart + levelCount) and [layerStart, layerStart + layerCount).
-    void onWrite(gl::LevelIndex levelStart,
-                 uint32_t levelCount,
-                 uint32_t layerStart,
-                 uint32_t layerCount,
-                 VkImageAspectFlags aspectFlags);
+    void onWrite() { mCurrentSingleClearValue.reset(); }
     bool hasImmutableSampler() { return mExternalFormat != 0; }
     uint64_t getExternalFormat() const { return mExternalFormat; }
 
-    // Used by framebuffer and render pass functions to decide loadOps and invalidate/un-invalidate
-    // render target contents.
-    bool hasSubresourceDefinedContent(gl::LevelIndex level, uint32_t layerIndex) const;
-    bool hasSubresourceDefinedStencilContent(gl::LevelIndex level, uint32_t layerIndex) const;
-    void invalidateSubresourceContent(ContextVk *contextVk,
-                                      gl::LevelIndex level,
-                                      uint32_t layerIndex);
-    void invalidateSubresourceStencilContent(ContextVk *contextVk,
-                                             gl::LevelIndex level,
-                                             uint32_t layerIndex);
-    void restoreSubresourceContent(gl::LevelIndex level, uint32_t layerIndex);
-    void restoreSubresourceStencilContent(gl::LevelIndex level, uint32_t layerIndex);
-
   private:
     enum class UpdateSource
     {
@@ -1769,31 +1737,6 @@ class ImageHelper final : public Resource, public angle::Subject
     void appendSubresourceUpdate(SubresourceUpdate &&update);
     void prependSubresourceUpdate(SubresourceUpdate &&update);
     void resetCachedProperties();
-    void setEntireContentUndefined();
-    void setContentDefined(LevelIndex levelStart,
-                           uint32_t levelCount,
-                           uint32_t layerStart,
-                           uint32_t layerCount,
-                           VkImageAspectFlags aspectFlags);
-
-    // Up to 8 layers are tracked per level for whether contents are defined, above which the
-    // contents are considered unconditionally defined.  This handles the more likely scenarios of:
-    //
-    // - Single layer framebuffer attachments,
-    // - Cube map framebuffer attachments,
-    // - Multi-view rendering.
-    //
-    // If there arises a need to optimize an application that invalidates layer >= 8, an additional
-    // hash map can be used to track such subresources.
-    static constexpr uint32_t kMaxContentDefinedLayerCount = 8;
-    using LevelContentDefinedMask = angle::BitSet8<kMaxContentDefinedLayerCount>;
-
-    // Use the following functions to access m*ContentDefined to make sure the correct level index
-    // is used (i.e. vk::LevelIndex and not gl::LevelIndex).
-    LevelContentDefinedMask &getLevelContentDefined(LevelIndex level);
-    LevelContentDefinedMask &getLevelStencilContentDefined(LevelIndex level);
-    const LevelContentDefinedMask &getLevelContentDefined(LevelIndex level) const;
-    const LevelContentDefinedMask &getLevelStencilContentDefined(LevelIndex level) const;
 
     angle::Result initLayerImageViewImpl(
         Context *context,
@@ -1846,11 +1789,6 @@ class ImageHelper final : public Resource, public angle::Subject
     // image it has been cleared to the specified clear value. If another clear call is made with
     // the exact same clear value, we will detect and skip the clear call.
     Optional<ClearUpdate> mCurrentSingleClearValue;
-
-    // Track whether each subresource has defined contents.  Up to 8 layers are tracked per level,
-    // above which the contents are considered unconditionally defined.
-    gl::TexLevelArray<LevelContentDefinedMask> mContentDefined;
-    gl::TexLevelArray<LevelContentDefinedMask> mStencilContentDefined;
 };
 
 // A vector of image views, such as one per level or one per layer.

src/tests/gl_tests/CopyTextureTest.cpp

@@ -576,10 +576,7 @@ class CopyTextureTestWebGL : public CopyTextureTest
 };
 
 class CopyTextureTestES3 : public CopyTextureTest
-{
-  protected:
-    void invalidateBlitThenBlendCommon(GLsizei layerCount);
-};
+{};
 
 // Test that CopyTexture cannot redefine an immutable texture and CopySubTexture can copy data to
 // immutable textures
@@ -2371,148 +2368,6 @@ TEST_P(CopyTextureTestES3, SwizzleOnSource)
     EXPECT_PIXEL_COLOR_EQ(0, 0, kSourceColor);
 }
 
-// Test that copy after invalidate works
-TEST_P(CopyTextureTestES3, InvalidateCopyThenBlend)
-{
-    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
-
-    // http://anglebug.com/5155
-    ANGLE_SKIP_TEST_IF(IsOSX() && IsIntel() && IsOpenGL());
-
-    // http://anglebug.com/5156
-    ANGLE_SKIP_TEST_IF(IsWindows() && IsIntel() && IsOpenGL());
-
-    constexpr GLsizei kSize = 4;
-
-    GLTexture texture;
-    glBindTexture(GL_TEXTURE_2D, texture);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kSize * 2, kSize * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 nullptr);
-    glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, kSize * 2, kSize * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 nullptr);
-    glTexImage2D(GL_TEXTURE_2D, 2, GL_RGBA8, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-    glTexImage2D(GL_TEXTURE_2D, 3, GL_RGBA8, kSize / 2, kSize / 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 nullptr);
-    glTexImage2D(GL_TEXTURE_2D, 4, GL_RGBA8, kSize / 4, kSize / 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 nullptr);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 1);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);
-
-    GLFramebuffer framebuffer;
-    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 2);
-    EXPECT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);
-
-    // Invalidate the framebuffer.
-    const GLenum discards[] = {GL_COLOR_ATTACHMENT0};
-    glInvalidateFramebuffer(GL_FRAMEBUFFER, 1, discards);
-    ASSERT_GL_NO_ERROR();
-
-    // Copy into the framebuffer attachment.
-    const std::vector<GLColor> kSourceColor(kSize * kSize, GLColor::green);
-    GLTexture sourceTexture;
-    glBindTexture(GL_TEXTURE_2D, sourceTexture);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 kSourceColor.data());
-    // Note: flipY is used to avoid direct transfer between textures and force a draw-based path.
-    glCopyTextureCHROMIUM(sourceTexture, 0, GL_TEXTURE_2D, texture, 2, GL_RGBA8, GL_UNSIGNED_BYTE,
-                          true, false, false);
-    ASSERT_GL_NO_ERROR();
-
-    // Draw and blend, making sure both the copy and draw happen correctly.
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ONE, GL_ONE);
-    drawQuad(program, essl1_shaders::PositionAttrib(), 0.0f);
-    ASSERT_GL_NO_ERROR();
-
-    // Make sure the blend was correctly done.
-    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::yellow);
-    EXPECT_PIXEL_COLOR_EQ(kSize - 1, 0, GLColor::yellow);
-    EXPECT_PIXEL_COLOR_EQ(0, kSize - 1, GLColor::yellow);
-    EXPECT_PIXEL_COLOR_EQ(kSize - 1, kSize - 1, GLColor::yellow);
-}
-
-void CopyTextureTestES3::invalidateBlitThenBlendCommon(GLsizei layerCount)
-{
-    // http://anglebug.com/5152
-    ANGLE_SKIP_TEST_IF(IsAndroid() && IsOpenGL());
-
-    // http://anglebug.com/5155
-    ANGLE_SKIP_TEST_IF(IsOSX() && IsIntel() && IsOpenGL());
-
-    // http://anglebug.com/5156
-    ANGLE_SKIP_TEST_IF(IsWindows() && IsIntel() && IsOpenGL());
-
-    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Red());
-
-    constexpr GLsizei kSize = 4;
-
-    GLTexture texture;
-    glBindTexture(GL_TEXTURE_2D_ARRAY, texture);
-    glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, kSize * 2, kSize * 2, layerCount, 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, nullptr);
-    glTexImage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, kSize * 2, kSize * 2, layerCount, 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, nullptr);
-    glTexImage3D(GL_TEXTURE_2D_ARRAY, 2, GL_RGBA8, kSize, kSize, layerCount, 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, nullptr);
-    glTexImage3D(GL_TEXTURE_2D_ARRAY, 3, GL_RGBA8, kSize / 2, kSize / 2, layerCount, 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, nullptr);
-    glTexImage3D(GL_TEXTURE_2D_ARRAY, 4, GL_RGBA8, kSize / 4, kSize / 4, layerCount, 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, nullptr);
-    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 1);
-    glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 4);
-
-    GLFramebuffer framebuffer;
-    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture, 2, layerCount / 2);
-    EXPECT_GL_FRAMEBUFFER_COMPLETE(GL_FRAMEBUFFER);
-
-    // Invalidate the framebuffer.
-    const GLenum discards[] = {GL_COLOR_ATTACHMENT0};
-    glInvalidateFramebuffer(GL_FRAMEBUFFER, 1, discards);
-    ASSERT_GL_NO_ERROR();
-
-    // Blit into the framebuffer attachment.
-    const std::vector<GLColor> kSourceColor(kSize * kSize, GLColor::green);
-    GLTexture sourceTexture;
-    glBindTexture(GL_TEXTURE_2D, sourceTexture);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kSize, kSize, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 kSourceColor.data());
-    GLFramebuffer sourceFramebuffer;
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, sourceFramebuffer);
-    glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sourceTexture,
-                           0);
-    EXPECT_GL_FRAMEBUFFER_COMPLETE(GL_READ_FRAMEBUFFER);
-
-    glBlitFramebuffer(0, 0, kSize, kSize, 0, 0, kSize, kSize, GL_COLOR_BUFFER_BIT, GL_NEAREST);
-    ASSERT_GL_NO_ERROR();
-
-    // Draw and blend, making sure both the blit and draw happen correctly.
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ONE, GL_ONE);
-    drawQuad(program, essl1_shaders::PositionAttrib(), 0.0f);
-    ASSERT_GL_NO_ERROR();
-
-    // Make sure the blend was correctly done.
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
-    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::yellow);
-    EXPECT_PIXEL_COLOR_EQ(kSize - 1, 0, GLColor::yellow);
-    EXPECT_PIXEL_COLOR_EQ(0, kSize - 1, GLColor::yellow);
-    EXPECT_PIXEL_COLOR_EQ(kSize - 1, kSize - 1, GLColor::yellow);
-}
-
-// Test that blit after invalidate works with non-zero layer
-TEST_P(CopyTextureTestES3, InvalidateBlitThenBlend3Layers)
-{
-    invalidateBlitThenBlendCommon(3);
-}
-
-// Test that blit after invalidate works with non-zero layer that is very large
-TEST_P(CopyTextureTestES3, InvalidateBlitThenBlend1000Layers)
-{
-    invalidateBlitThenBlendCommon(1000);
-}
-
 #ifdef Bool
 // X11 craziness.
 #    undef Bool