Update min Vulkan version to 1.0.8.0, and fix various bugs

src/gpu/vk/GrVkCommandBuffer.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 "GrVkCommandBuffer.h"
 
 #include "GrVkFramebuffer.h"
@@ skipping 123 matching lines @@
     err = GR_VK_CALL(gpu->vkInterface(), CreateFence(gpu->device(), &fenceInfo, nullptr,
                                                      &fSubmitFence));
     SkASSERT(!err);
 
     VkSubmitInfo submitInfo;
     memset(&submitInfo, 0, sizeof(VkSubmitInfo));
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.pNext = nullptr;
     submitInfo.waitSemaphoreCount = 0;
     submitInfo.pWaitSemaphores = nullptr;
+    submitInfo.pWaitDstStageMask = 0;
     submitInfo.commandBufferCount = 1;
     submitInfo.pCommandBuffers = &fCmdBuffer;
     submitInfo.signalSemaphoreCount = 0;
     submitInfo.pSignalSemaphores = nullptr;
     GR_VK_CALL_ERRCHECK(gpu->vkInterface(), QueueSubmit(queue, 1, &submitInfo, fSubmitFence));
 
     if (GrVkGpu::kForce_SyncQueue == sync) {
         err = GR_VK_CALL(gpu->vkInterface(),
                          WaitForFences(gpu->device(), 1, &fSubmitFence, true, UINT64_MAX));
         if (VK_TIMEOUT == err) {
@@ skipping 34 matching lines @@
 // CommandBuffer commands
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrVkCommandBuffer::pipelineBarrier(const GrVkGpu* gpu,
                                         VkPipelineStageFlags srcStageMask,
                                         VkPipelineStageFlags dstStageMask,
                                         bool byRegion,
                                         BarrierType barrierType,
                                         void* barrier) const {
     SkASSERT(fIsActive);
+    // For images we can have barriers inside of render passes but they require us to add more
+    // support in subpasses which need self dependencies to have barriers inside them. Also, we can
+    // never have buffer barriers inside of a render pass. For now we will just assert that we are
+    // not in a render pass.
+    SkASSERT(!fActiveRenderPass);
     VkDependencyFlags dependencyFlags = byRegion ? VK_DEPENDENCY_BY_REGION_BIT : 0;
 
     switch (barrierType) {
         case kMemory_BarrierType: {
             const VkMemoryBarrier* barrierPtr = reinterpret_cast<VkMemoryBarrier*>(barrier);
             GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(fCmdBuffer, srcStageMask,
                                                               dstStageMask, dependencyFlags,
                                                               1, barrierPtr,
                                                               0, nullptr,
                                                               0, nullptr));
@@ skipping 175 matching lines @@
                                                          firstSet,
                                                          setCount,
                                                          descriptorSets,
                                                          dynamicOffsetCount,
                                                          dynamicOffsets));
     pipelineState->addUniformResources(*this);
 }
 
 void GrVkCommandBuffer::bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pipeline) {
     SkASSERT(fIsActive);
-    SkASSERT(fActiveRenderPass);
     GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer,
                                                    VK_PIPELINE_BIND_POINT_GRAPHICS,
                                                    pipeline->pipeline()));
     addResource(pipeline);
 }
 
 void GrVkCommandBuffer::drawIndexed(const GrVkGpu* gpu,
                                     uint32_t indexCount,
                                     uint32_t instanceCount,
                                     uint32_t firstIndex,
@@ skipping 54 matching lines @@
 }
 
 void GrVkCommandBuffer::setBlendConstants(const GrVkGpu* gpu,
                                           const float blendConstants[4]) {
     SkASSERT(fIsActive);
     if (memcmp(blendConstants, fCachedBlendConstant, 4 * sizeof(float))) {
         GR_VK_CALL(gpu->vkInterface(), CmdSetBlendConstants(fCmdBuffer, blendConstants));
         memcpy(fCachedBlendConstant, blendConstants, 4 * sizeof(float));
     }
 }