Always initialize testing textures in vulkan with some data

BUG=skia:

Change-Id: I0fb99df77496835446f13d886ba29a5ea579ff54
Reviewed-on: https://skia-review.googlesource.com/10281
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>

1 files changed, 171 insertions, 159 deletions

diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index b634116841..7419f15f35 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -980,9 +980,23 @@ bool copy_testing_data(GrVkGpu* gpu, void* srcData, const GrVkAlloc& alloc,
         return false;
     }
 
-    // If there is no padding on dst we can do a single memcopy.
-    // This assumes the srcData comes in with no padding.
-    SkRectMemcpy(mapPtr, static_cast<size_t>(dstRowBytes), srcData, srcRowBytes, srcRowBytes, h);
+    if (srcData) {
+        // If there is no padding on dst we can do a single memcopy.
+        // This assumes the srcData comes in with no padding.
+        SkRectMemcpy(mapPtr, static_cast<size_t>(dstRowBytes),
+                     srcData, srcRowBytes, srcRowBytes, h);
+    } else {
+        // If there is no srcdata we always copy 0's into the textures so that it is initialized
+        // with some data.
+        if (srcRowBytes == static_cast<size_t>(dstRowBytes)) {
+            memset(mapPtr, 0, srcRowBytes * h);
+        } else {
+            for (int i = 0; i < h; ++i) {
+                memset(mapPtr, 0, srcRowBytes);
+                mapPtr = SkTAddOffset<void>(mapPtr, static_cast<size_t>(dstRowBytes));
+            }
+        }
+    }
     GrVkMemory::FlushMappedAlloc(gpu, alloc);
     GR_VK_CALL(gpu->vkInterface(), UnmapMemory(gpu->device(), alloc.fMemory));
     return true;
@@ -1057,172 +1071,170 @@ GrBackendObject GrVkGpu::createTestingOnlyBackendTexture(void* srcData, int w, i
         return 0;
     }
 
-    if (srcData) {
-        size_t bpp = GrBytesPerPixel(config);
-        size_t rowCopyBytes = bpp * w;
-        if (linearTiling) {
-            const VkImageSubresource subres = {
-                VK_IMAGE_ASPECT_COLOR_BIT,
-                0,  // mipLevel
-                0,  // arraySlice
-            };
-            VkSubresourceLayout layout;
-
-            VK_CALL(GetImageSubresourceLayout(fDevice, image, &subres, &layout));
-
-            if (!copy_testing_data(this, srcData, alloc, rowCopyBytes,
-                                   static_cast<size_t>(layout.rowPitch), h)) {
-                GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
-                VK_CALL(DestroyImage(fDevice, image, nullptr));
-                return 0;
-            }
-        } else {
-            SkASSERT(w && h);
-
-            VkBuffer buffer;
-            VkBufferCreateInfo bufInfo;
-            memset(&bufInfo, 0, sizeof(VkBufferCreateInfo));
-            bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-            bufInfo.flags = 0;
-            bufInfo.size = rowCopyBytes * h;
-            bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-            bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-            bufInfo.queueFamilyIndexCount = 0;
-            bufInfo.pQueueFamilyIndices = nullptr;
-            VkResult err;
-            err = VK_CALL(CreateBuffer(fDevice, &bufInfo, nullptr, &buffer));
-
-            if (err) {
-                GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
-                VK_CALL(DestroyImage(fDevice, image, nullptr));
-                return 0;
-            }
+    size_t bpp = GrBytesPerPixel(config);
+    size_t rowCopyBytes = bpp * w;
+    if (linearTiling) {
+        const VkImageSubresource subres = {
+            VK_IMAGE_ASPECT_COLOR_BIT,
+            0,  // mipLevel
+            0,  // arraySlice
+        };
+        VkSubresourceLayout layout;
 
-            GrVkAlloc bufferAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
-            if (!GrVkMemory::AllocAndBindBufferMemory(this, buffer, GrVkBuffer::kCopyRead_Type,
-                                                      true, &bufferAlloc)) {
-                GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
-                VK_CALL(DestroyImage(fDevice, image, nullptr));
-                VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
-                return 0;
-            }
+        VK_CALL(GetImageSubresourceLayout(fDevice, image, &subres, &layout));
 
-            if (!copy_testing_data(this, srcData, bufferAlloc, rowCopyBytes, rowCopyBytes, h)) {
-                GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
-                VK_CALL(DestroyImage(fDevice, image, nullptr));
-                GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
-                VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
-                return 0;
-            }
+        if (!copy_testing_data(this, srcData, alloc, rowCopyBytes,
+                               static_cast<size_t>(layout.rowPitch), h)) {
+            GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
+            VK_CALL(DestroyImage(fDevice, image, nullptr));
+            return 0;
+        }
+    } else {
+        SkASSERT(w && h);
+
+        VkBuffer buffer;
+        VkBufferCreateInfo bufInfo;
+        memset(&bufInfo, 0, sizeof(VkBufferCreateInfo));
+        bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+        bufInfo.flags = 0;
+        bufInfo.size = rowCopyBytes * h;
+        bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+        bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+        bufInfo.queueFamilyIndexCount = 0;
+        bufInfo.pQueueFamilyIndices = nullptr;
+        VkResult err;
+        err = VK_CALL(CreateBuffer(fDevice, &bufInfo, nullptr, &buffer));
+
+        if (err) {
+            GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
+            VK_CALL(DestroyImage(fDevice, image, nullptr));
+            return 0;
+        }
 
-            const VkCommandBufferAllocateInfo cmdInfo = {
-                VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
-                NULL,                                             // pNext
-                fCmdPool,                                         // commandPool
-                VK_COMMAND_BUFFER_LEVEL_PRIMARY,                  // level
-                1                                                 // bufferCount
-            };
-
-            VkCommandBuffer cmdBuffer;
-            err = VK_CALL(AllocateCommandBuffers(fDevice, &cmdInfo, &cmdBuffer));
-            if (err) {
-                GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
-                VK_CALL(DestroyImage(fDevice, image, nullptr));
-                GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
-                VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
-                return 0;
-            }
+        GrVkAlloc bufferAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
+        if (!GrVkMemory::AllocAndBindBufferMemory(this, buffer, GrVkBuffer::kCopyRead_Type,
+                                                  true, &bufferAlloc)) {
+            GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
+            VK_CALL(DestroyImage(fDevice, image, nullptr));
+            VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
+            return 0;
+        }
 
-            VkCommandBufferBeginInfo cmdBufferBeginInfo;
-            memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
-            cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-            cmdBufferBeginInfo.pNext = nullptr;
-            cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-            cmdBufferBeginInfo.pInheritanceInfo = nullptr;
-
-            err = VK_CALL(BeginCommandBuffer(cmdBuffer, &cmdBufferBeginInfo));
-            SkASSERT(!err);
-
-            // Set image layout and add barrier
-            VkImageMemoryBarrier barrier;
-            memset(&barrier, 0, sizeof(VkImageMemoryBarrier));
-            barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-            barrier.pNext = nullptr;
-            barrier.srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(initialLayout);
-            barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-            barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-            barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-            barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-            barrier.image = image;
-            barrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0 , 1};
-
-            VK_CALL(CmdPipelineBarrier(cmdBuffer,
-                                       GrVkMemory::LayoutToPipelineStageFlags(initialLayout),
-                                       VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                       0,
-                                       0, nullptr,
-                                       0, nullptr,
-                                       1, &barrier));
-            initialLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-
-            // Submit copy command
-            VkBufferImageCopy region;
-            memset(&region, 0, sizeof(VkBufferImageCopy));
-            region.bufferOffset = 0;
-            region.bufferRowLength = w;
-            region.bufferImageHeight = h;
-            region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
-            region.imageOffset = { 0, 0, 0 };
-            region.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
-
-            VK_CALL(CmdCopyBufferToImage(cmdBuffer, buffer, image, initialLayout, 1, &region));
-
-            // End CommandBuffer
-            err = VK_CALL(EndCommandBuffer(cmdBuffer));
-            SkASSERT(!err);
-
-            // Create Fence for queue
-            VkFence fence;
-            VkFenceCreateInfo fenceInfo;
-            memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
-            fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-
-            err = VK_CALL(CreateFence(fDevice, &fenceInfo, nullptr, &fence));
-            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 = &cmdBuffer;
-            submitInfo.signalSemaphoreCount = 0;
-            submitInfo.pSignalSemaphores = nullptr;
-            err = VK_CALL(QueueSubmit(this->queue(), 1, &submitInfo, fence));
-            SkASSERT(!err);
-
-            err = VK_CALL(WaitForFences(fDevice, 1, &fence, true, UINT64_MAX));
-            if (VK_TIMEOUT == err) {
-                GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
-                VK_CALL(DestroyImage(fDevice, image, nullptr));
-                GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
-                VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
-                VK_CALL(FreeCommandBuffers(fDevice, fCmdPool, 1, &cmdBuffer));
-                VK_CALL(DestroyFence(fDevice, fence, nullptr));
-                SkDebugf("Fence failed to signal: %d\n", err);
-                SkFAIL("failing");
-            }
-            SkASSERT(!err);
+        if (!copy_testing_data(this, srcData, bufferAlloc, rowCopyBytes, rowCopyBytes, h)) {
+            GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
+            VK_CALL(DestroyImage(fDevice, image, nullptr));
+            GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
+            VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
+            return 0;
+        }
 
-            // Clean up transfer resources
+        const VkCommandBufferAllocateInfo cmdInfo = {
+            VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
+            NULL,                                             // pNext
+            fCmdPool,                                         // commandPool
+            VK_COMMAND_BUFFER_LEVEL_PRIMARY,                  // level
+            1                                                 // bufferCount
+        };
+
+        VkCommandBuffer cmdBuffer;
+        err = VK_CALL(AllocateCommandBuffers(fDevice, &cmdInfo, &cmdBuffer));
+        if (err) {
+            GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
+            VK_CALL(DestroyImage(fDevice, image, nullptr));
+            GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
+            VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
+            return 0;
+        }
+
+        VkCommandBufferBeginInfo cmdBufferBeginInfo;
+        memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
+        cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        cmdBufferBeginInfo.pNext = nullptr;
+        cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+        cmdBufferBeginInfo.pInheritanceInfo = nullptr;
+
+        err = VK_CALL(BeginCommandBuffer(cmdBuffer, &cmdBufferBeginInfo));
+        SkASSERT(!err);
+
+        // Set image layout and add barrier
+        VkImageMemoryBarrier barrier;
+        memset(&barrier, 0, sizeof(VkImageMemoryBarrier));
+        barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+        barrier.pNext = nullptr;
+        barrier.srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(initialLayout);
+        barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+        barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        barrier.image = image;
+        barrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0 , 1};
+
+        VK_CALL(CmdPipelineBarrier(cmdBuffer,
+                                   GrVkMemory::LayoutToPipelineStageFlags(initialLayout),
+                                   VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                   0,
+                                   0, nullptr,
+                                   0, nullptr,
+                                   1, &barrier));
+        initialLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+
+        // Submit copy command
+        VkBufferImageCopy region;
+        memset(&region, 0, sizeof(VkBufferImageCopy));
+        region.bufferOffset = 0;
+        region.bufferRowLength = w;
+        region.bufferImageHeight = h;
+        region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
+        region.imageOffset = { 0, 0, 0 };
+        region.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
+
+        VK_CALL(CmdCopyBufferToImage(cmdBuffer, buffer, image, initialLayout, 1, &region));
+
+        // End CommandBuffer
+        err = VK_CALL(EndCommandBuffer(cmdBuffer));
+        SkASSERT(!err);
+
+        // Create Fence for queue
+        VkFence fence;
+        VkFenceCreateInfo fenceInfo;
+        memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
+        fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+
+        err = VK_CALL(CreateFence(fDevice, &fenceInfo, nullptr, &fence));
+        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 = &cmdBuffer;
+        submitInfo.signalSemaphoreCount = 0;
+        submitInfo.pSignalSemaphores = nullptr;
+        err = VK_CALL(QueueSubmit(this->queue(), 1, &submitInfo, fence));
+        SkASSERT(!err);
+
+        err = VK_CALL(WaitForFences(fDevice, 1, &fence, true, UINT64_MAX));
+        if (VK_TIMEOUT == err) {
+            GrVkMemory::FreeImageMemory(this, linearTiling, alloc);
+            VK_CALL(DestroyImage(fDevice, image, nullptr));
             GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
             VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
             VK_CALL(FreeCommandBuffers(fDevice, fCmdPool, 1, &cmdBuffer));
             VK_CALL(DestroyFence(fDevice, fence, nullptr));
+            SkDebugf("Fence failed to signal: %d\n", err);
+            SkFAIL("failing");
         }
+        SkASSERT(!err);
+
+        // Clean up transfer resources
+        GrVkMemory::FreeBufferMemory(this, GrVkBuffer::kCopyRead_Type, bufferAlloc);
+        VK_CALL(DestroyBuffer(fDevice, buffer, nullptr));
+        VK_CALL(FreeCommandBuffers(fDevice, fCmdPool, 1, &cmdBuffer));
+        VK_CALL(DestroyFence(fDevice, fence, nullptr));
     }
 
     GrVkImageInfo* info = new GrVkImageInfo;