Clean up GrVkImage::setLayout()

src/gpu/vk/GrVkGpu.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 250 matching lines @@
         //                                       height);
     } else {
         bool linearTiling = vkTex->isLinearTiled();
         if (linearTiling) {
             if (texels.count() > 1) {
                 SkDebugf("Can't upload mipmap data to linear tiled texture");
                 return false;
             }
             if (VK_IMAGE_LAYOUT_PREINITIALIZED != vkTex->currentLayout()) {
                 // Need to change the layout to general in order to perform a host write
-                VkImageLayout layout = vkTex->currentLayout();
-                VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
-                VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_HOST_BIT;
-                VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
-                VkAccessFlags dstAccessMask = VK_ACCESS_HOST_WRITE_BIT;
                 vkTex->setImageLayout(this,
                                       VK_IMAGE_LAYOUT_GENERAL,
-                                      srcAccessMask,
-                                      dstAccessMask,
-                                      srcStageMask,
-                                      dstStageMask,
+                                      VK_ACCESS_HOST_WRITE_BIT,
+                                      VK_PIPELINE_STAGE_HOST_BIT,
                                       false);
                 this->submitCommandBuffer(kForce_SyncQueue);
             }
             success = this->uploadTexDataLinear(vkTex, left, top, width, height, config,
                                                 texels.begin()->fPixels, texels.begin()->fRowBytes);
         } else {
             int newMipLevels = texels.count();
             int currentMipLevels = vkTex->texturePriv().maxMipMapLevel() + 1;
             if (newMipLevels != currentMipLevels) {
                 if (!vkTex->reallocForMipmap(this, newMipLevels)) {
@@ skipping 190 matching lines @@
 
     // make sure the unmap has finished
     transferBuffer->addMemoryBarrier(this,
                                      VK_ACCESS_HOST_WRITE_BIT,
                                      VK_ACCESS_TRANSFER_READ_BIT,
                                      VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                      VK_PIPELINE_STAGE_TRANSFER_BIT,
                                      false);
 
     // Change layout of our target so it can be copied to
-    VkImageLayout layout = tex->currentLayout();
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
-    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
     tex->setImageLayout(this,
                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                        srcAccessMask,
-                        dstAccessMask,
-                        srcStageMask,
-                        dstStageMask,
+                        VK_ACCESS_TRANSFER_WRITE_BIT,
+                        VK_PIPELINE_STAGE_TRANSFER_BIT,
                         false);
 
     // Copy the buffer to the image
     fCurrentCmdBuffer->copyBufferToImage(this,
                                          transferBuffer,
                                          tex,
                                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                          regions.count(),
                                          regions.begin());
 
@@ skipping 200 matching lines @@
     }
 
     // determine if we can blit to and from this format
     const GrVkCaps& caps = this->vkCaps();
     if (!caps.configCanBeDstofBlit(tex->config(), false) ||
         !caps.configCanBeSrcofBlit(tex->config(), false)) {
         return;
     }
 
     // change the original image's layout
-    VkImageLayout origSrcLayout = tex->currentLayout();
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origSrcLayout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origSrcLayout);
-    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-
     tex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                        srcAccessMask, dstAccessMask, srcStageMask, dstStageMask, false);
+                        VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, false);
 
     // grab handle to the original image resource
     const GrVkImage::Resource* oldResource = tex->resource();
     oldResource->ref();
 
     // SkMipMap doesn't include the base level in the level count so we have to add 1
     uint32_t levelCount = SkMipMap::ComputeLevelCount(tex->width(), tex->height()) + 1;
     if (!tex->reallocForMipmap(this, levelCount)) {
         oldResource->unref(this);
         return;
     }
 
     // change the new image's layout
-    VkImageLayout origDstLayout = tex->currentLayout();
-
-    srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-    dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-    srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
-    dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-
-    tex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                        srcAccessMask, dstAccessMask, srcStageMask, dstStageMask, false);
+    tex->setImageLayout(this, VK_IMAGE_LAYOUT_GENERAL,
+                        VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, false);
 
     // Blit original image
     int width = tex->width();
     int height = tex->height();
 
     VkImageBlit blitRegion;
     memset(&blitRegion, 0, sizeof(VkImageBlit));
     blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
     blitRegion.srcOffsets[0] = { 0, 0, 0 };
     blitRegion.srcOffsets[1] = { width, height, 0 };
     blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
     blitRegion.dstOffsets[0] = { 0, 0, 0 };
     blitRegion.dstOffsets[1] = { width, height, 0 };
 
     fCurrentCmdBuffer->blitImage(this,
                                  oldResource,
                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                  tex->resource(),
-                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                 VK_IMAGE_LAYOUT_GENERAL,
                                  1,
                                  &blitRegion,
                                  VK_FILTER_LINEAR);
+
+    // setup memory barrier
+    SkASSERT(GrVkFormatToPixelConfig(tex->resource()->fFormat, nullptr));
+    VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
+    VkImageMemoryBarrier imageMemoryBarrier = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,          // sType
+        NULL,                                            // pNext
+        VK_ACCESS_TRANSFER_WRITE_BIT,                    // outputMask
+        VK_ACCESS_TRANSFER_READ_BIT,                     // inputMask
+        VK_IMAGE_LAYOUT_GENERAL,                         // oldLayout
+        VK_IMAGE_LAYOUT_GENERAL,                         // newLayout
+        VK_QUEUE_FAMILY_IGNORED,                         // srcQueueFamilyIndex
+        VK_QUEUE_FAMILY_IGNORED,                         // dstQueueFamilyIndex
+        tex->resource()->fImage,                         // image
+        { aspectFlags, 0, 1, 0, 1 }                      // subresourceRange
+    };
+
     // Blit the miplevels
     uint32_t mipLevel = 1;
     while (mipLevel < levelCount) {
         int prevWidth = width;
         int prevHeight = height;
         width = SkTMax(1, width / 2);
         height = SkTMax(1, height / 2);
 
-        blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel-1, 0, 1 };
+        imageMemoryBarrier.subresourceRange.baseMipLevel = mipLevel - 1;
+        this->addImageMemoryBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                    false, &imageMemoryBarrier);
+
+        blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel - 1, 0, 1 };
         blitRegion.srcOffsets[0] = { 0, 0, 0 };
         blitRegion.srcOffsets[1] = { prevWidth, prevHeight, 0 };
         blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel, 0, 1 };
         blitRegion.dstOffsets[0] = { 0, 0, 0 };
         blitRegion.dstOffsets[1] = { width, height, 0 };
-
-        tex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                            srcAccessMask, dstAccessMask, srcStageMask, dstStageMask, 
-                            mipLevel-1, 1, false);
-
         fCurrentCmdBuffer->blitImage(this,
                                      tex->resource(),
-                                     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                                     VK_IMAGE_LAYOUT_GENERAL,
                                      tex->resource(),
-                                     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                     VK_IMAGE_LAYOUT_GENERAL,
                                      1,
                                      &blitRegion,
                                      VK_FILTER_LINEAR);
         ++mipLevel;
     }
 
     oldResource->unref(this);
 }
 
 
@@ skipping 242 matching lines @@
     if (nullptr == target) {
         return;
     }
     GrStencilAttachment* stencil = target->renderTargetPriv().getStencilAttachment();
     GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
 
 
     VkClearDepthStencilValue vkStencilColor;
     memset(&vkStencilColor, 0, sizeof(VkClearDepthStencilValue));
 
-    VkImageLayout origDstLayout = vkStencil->currentLayout();
-
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);;
-    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-
     vkStencil->setImageLayout(this,
                               VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                              srcAccessMask,
-                              dstAccessMask,
-                              srcStageMask,
-                              dstStageMask,
+                              VK_ACCESS_TRANSFER_WRITE_BIT,
+                              VK_PIPELINE_STAGE_TRANSFER_BIT,
                               false);
 
-
     VkImageSubresourceRange subRange;
     memset(&subRange, 0, sizeof(VkImageSubresourceRange));
     subRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
     subRange.baseMipLevel = 0;
     subRange.levelCount = 1;
     subRange.baseArrayLayer = 0;
     subRange.layerCount = 1;
 
     // TODO: I imagine that most times we want to clear a stencil it will be at the beginning of a
     // draw. Thus we should look into using the load op functions on the render pass to clear out
@@ skipping 17 matching lines @@
     // during this clear. Thus we will clear the entire stencil to the desired value.
 
     VkClearDepthStencilValue vkStencilColor;
     memset(&vkStencilColor, 0, sizeof(VkClearDepthStencilValue));
     if (insideClip) {
         vkStencilColor.stencil = (1 << (stencilBitCount - 1));
     } else {
         vkStencilColor.stencil = 0;
     }
 
-    VkImageLayout origDstLayout = vkStencil->currentLayout();
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
-    VkAccessFlags dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
     vkStencil->setImageLayout(this,
                               VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-                              srcAccessMask,
-                              dstAccessMask,
-                              srcStageMask,
-                              dstStageMask,
+                              VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                              VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                               false);
 
     // Change layout of our render target so it can be used as the color attachment. This is what
     // the render pass expects when it begins.
-    VkImageLayout layout = vkRT->currentLayout();
-    srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
-    dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-    srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
-    dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
     vkRT->setImageLayout(this,
                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-                         srcAccessMask,
-                         dstAccessMask,
-                         srcStageMask,
-                         dstStageMask,
+                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                          false);
 
     VkClearRect clearRect;
     // Flip rect if necessary
     SkIRect vkRect = rect;
 
     if (kBottomLeft_GrSurfaceOrigin == vkRT->origin()) {
         vkRect.fTop = vkRT->height() - rect.fBottom;
         vkRect.fBottom = vkRT->height() - rect.fTop;
     }
@@ skipping 23 matching lines @@
 }
 
 void GrVkGpu::onClear(GrRenderTarget* target, const SkIRect& rect, GrColor color) {
     // parent class should never let us get here with no RT
     SkASSERT(target);
 
     VkClearColorValue vkColor;
     GrColorToRGBAFloat(color, vkColor.float32);
 
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(target);
-    VkImageLayout origDstLayout = vkRT->currentLayout();
 
     if (rect.width() != target->width() || rect.height() != target->height()) {
-        VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
-        VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-        VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-        VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
         vkRT->setImageLayout(this,
                              VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-                             srcAccessMask,
-                             dstAccessMask,
-                             srcStageMask,
-                             dstStageMask,
+                             VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                              false);
 
         // If we are using a stencil attachment we also need to change its layout to what the render
         // pass is expecting.
         if (GrStencilAttachment* stencil = vkRT->renderTargetPriv().getStencilAttachment()) {
             GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
-            origDstLayout = vkStencil->currentLayout();
-            srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
-            dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
-                            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-            srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-            dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
             vkStencil->setImageLayout(this,
                                       VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-                                      srcAccessMask,
-                                      dstAccessMask,
-                                      srcStageMask,
-                                      dstStageMask,
+                                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+                                      VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                       false);
         }
 
         VkClearRect clearRect;
         // Flip rect if necessary
         SkIRect vkRect = rect;
         if (kBottomLeft_GrSurfaceOrigin == vkRT->origin()) {
             vkRect.fTop = vkRT->height() - rect.fBottom;
             vkRect.fBottom = vkRT->height() - rect.fTop;
         }
@@ skipping 12 matching lines @@
         VkClearAttachment attachment;
         attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
         attachment.colorAttachment = colorIndex;
         attachment.clearValue.color = vkColor;
 
         fCurrentCmdBuffer->clearAttachments(this, 1, &attachment, 1, &clearRect);
         fCurrentCmdBuffer->endRenderPass(this);
         return;
     }
 
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);;
-    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-
     vkRT->setImageLayout(this,
                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                         srcAccessMask,
-                         dstAccessMask,
-                         srcStageMask,
-                         dstStageMask,
+                         VK_ACCESS_TRANSFER_WRITE_BIT,
+                         VK_PIPELINE_STAGE_TRANSFER_BIT,
                          false);
 
-
     VkImageSubresourceRange subRange;
     memset(&subRange, 0, sizeof(VkImageSubresourceRange));
     subRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     subRange.baseMipLevel = 0;
     subRange.levelCount = 1;
     subRange.baseArrayLayer = 0;
     subRange.layerCount = 1;
 
     // In the future we may not actually be doing this type of clear at all. If we are inside a
     // render pass or doing a non full clear then we will use CmdClearColorAttachment. The more
@@ skipping 28 matching lines @@
 }
 
 void GrVkGpu::copySurfaceAsCopyImage(GrSurface* dst,
                                      GrSurface* src,
                                      GrVkImage* dstImage,
                                      GrVkImage* srcImage,
                                      const SkIRect& srcRect,
                                      const SkIPoint& dstPoint) {
     SkASSERT(can_copy_image(dst, src, this));
 
-    VkImageLayout origDstLayout = dstImage->currentLayout();
-    VkImageLayout origSrcLayout = srcImage->currentLayout();
-
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
     // These flags are for flushing/invalidating caches and for the dst image it doesn't matter if
     // the cache is flushed since it is only being written to.
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);;
-    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-
     dstImage->setImageLayout(this,
-                            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                            srcAccessMask,
-                            dstAccessMask,
-                            srcStageMask,
-                            dstStageMask,
-                            false);
-
-    srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origSrcLayout);
-    dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-    srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origSrcLayout);
-    dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+                             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                             VK_ACCESS_TRANSFER_WRITE_BIT,
+                             VK_PIPELINE_STAGE_TRANSFER_BIT,
+                             false);
 
     srcImage->setImageLayout(this,
                              VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                             srcAccessMask,
-                             dstAccessMask,
-                             srcStageMask,
-                             dstStageMask,
+                             VK_ACCESS_TRANSFER_READ_BIT,
+                             VK_PIPELINE_STAGE_TRANSFER_BIT,
                              false);
 
     // Flip rect if necessary
     SkIRect srcVkRect = srcRect;
     int32_t dstY = dstPoint.fY;
 
     if (kBottomLeft_GrSurfaceOrigin == src->origin()) {
         SkASSERT(kBottomLeft_GrSurfaceOrigin == dst->origin());
         srcVkRect.fTop = src->height() - srcRect.fBottom;
         srcVkRect.fBottom =  src->height() - srcRect.fTop;
@@ skipping 48 matching lines @@
 }
 
 void GrVkGpu::copySurfaceAsBlit(GrSurface* dst,
                                 GrSurface* src,
                                 GrVkImage* dstImage,
                                 GrVkImage* srcImage,
                                 const SkIRect& srcRect,
                                 const SkIPoint& dstPoint) {
     SkASSERT(can_copy_as_blit(dst, src, dstImage, srcImage, this));
 
-    VkImageLayout origDstLayout = dstImage->currentLayout();
-    VkImageLayout origSrcLayout = srcImage->currentLayout();
-
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);;
-    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-
     dstImage->setImageLayout(this,
                              VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                             srcAccessMask,
-                             dstAccessMask,
-                             srcStageMask,
-                             dstStageMask,
+                             VK_ACCESS_TRANSFER_WRITE_BIT,
+                             VK_PIPELINE_STAGE_TRANSFER_BIT,
                              false);
 
-    srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origSrcLayout);
-    dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-    srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origSrcLayout);
-    dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
-
     srcImage->setImageLayout(this,
                              VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                             srcAccessMask,
-                             dstAccessMask,
-                             srcStageMask,
-                             dstStageMask,
+                             VK_ACCESS_TRANSFER_READ_BIT,
+                             VK_PIPELINE_STAGE_TRANSFER_BIT,
                              false);
 
     // Flip rect if necessary
     SkIRect srcVkRect;
     srcVkRect.fLeft = srcRect.fLeft;
     srcVkRect.fRight = srcRect.fRight;
     SkIRect dstRect;
     dstRect.fLeft = dstPoint.fX;
     dstRect.fRight = dstPoint.fX + srcRect.width();
 
@@ skipping 136 matching lines @@
     if (!GrPixelConfigToVkFormat(config, &pixelFormat)) {
         return false;
     }
 
     GrVkTexture* tgt = static_cast<GrVkTexture*>(surface->asTexture());
     if (!tgt) {
         return false;
     }
 
     // Change layout of our target so it can be used as copy
-    VkImageLayout layout = tgt->currentLayout();
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
-    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
     tgt->setImageLayout(this,
                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                        srcAccessMask,
-                        dstAccessMask,
-                        srcStageMask,
-                        dstStageMask,
+                        VK_ACCESS_TRANSFER_READ_BIT,
+                        VK_PIPELINE_STAGE_TRANSFER_BIT,
                         false);
 
     GrVkTransferBuffer* transferBuffer =
         static_cast<GrVkTransferBuffer*>(this->createBuffer(rowBytes * height,
                                                             kXferGpuToCpu_GrBufferType,
                                                             kStream_GrAccessPattern));
 
     bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
     VkOffset3D offset = {
         left,
@@ skipping 94 matching lines @@
     GrPrimitiveType primitiveType = meshes[0].primitiveType();
     sk_sp<GrVkPipelineState> pipelineState = this->prepareDrawState(pipeline,
                                                                     primProc,
                                                                     primitiveType,
                                                                     *renderPass);
     if (!pipelineState) {
         return;
     }
 
     // Change layout of our render target so it can be used as the color attachment
-    VkImageLayout layout = vkRT->currentLayout();
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
-    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
-    VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
     vkRT->setImageLayout(this,
                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-                         srcAccessMask,
-                         dstAccessMask,
-                         srcStageMask,
-                         dstStageMask,
+                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                          false);
 
     // If we are using a stencil attachment we also need to update its layout
     if (GrStencilAttachment* stencil = vkRT->renderTargetPriv().getStencilAttachment()) {
         GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
-        VkImageLayout origDstLayout = vkStencil->currentLayout();
-        VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
-        VkAccessFlags dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
-            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-        VkPipelineStageFlags srcStageMask =
-            GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
-        VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
         vkStencil->setImageLayout(this,
                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-                                  srcAccessMask,
-                                  dstAccessMask,
-                                  srcStageMask,
-                                  dstStageMask,
+                                  VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                  VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
+                                  VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                   false);
     }
 
     fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
 
     for (int i = 0; i < meshCount; ++i) {
         const GrMesh& mesh = meshes[i];
         GrMesh::Iterator iter;
         const GrNonInstancedMesh* nonIdxMesh = iter.init(mesh);
         do {
@@ skipping 47 matching lines @@
     aglSwapBuffers(aglGetCurrentContext());
     int set_a_break_pt_here = 9;
     aglSwapBuffers(aglGetCurrentContext());
 #elif defined(SK_BUILD_FOR_WIN32)
     SwapBuf();
     int set_a_break_pt_here = 9;
     SwapBuf();
 #endif
 #endif
 }