Refactor Vulkan image, texture, RTs so that create and getter handles match.

src/gpu/vk/GrVkImage.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 "GrVkImage.h"
 #include "GrVkMemory.h"
@@ skipping 13 matching lines @@
             return VK_IMAGE_ASPECT_COLOR_BIT;
     }
 }
 
 void GrVkImage::setImageLayout(const GrVkGpu* gpu, VkImageLayout newLayout,
                                VkAccessFlags dstAccessMask,
                                VkPipelineStageFlags dstStageMask,
                                bool byRegion) {
     SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED != newLayout &&
              VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout);
+    VkImageLayout currentLayout = this->currentLayout();
     // Is this reasonable? Could someone want to keep the same layout but use the masks to force
     // a barrier on certain things?
-    if (newLayout == fCurrentLayout) {
+    if (newLayout == currentLayout) {
         return;
     }
 
-    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(fCurrentLayout);
-    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(fCurrentLayout);
+    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(currentLayout);
+    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(currentLayout);
 
-    VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fResource->fFormat);
+    VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fInfo.fFormat);
     VkImageMemoryBarrier imageMemoryBarrier = {
         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,          // sType
         NULL,                                            // pNext
         srcAccessMask,                                   // outputMask
         dstAccessMask,                                   // inputMask
-        fCurrentLayout,                                  // oldLayout
+        currentLayout,                                   // oldLayout
         newLayout,                                       // newLayout
         VK_QUEUE_FAMILY_IGNORED,                         // srcQueueFamilyIndex
         VK_QUEUE_FAMILY_IGNORED,                         // dstQueueFamilyIndex
-        fResource->fImage,                               // image
-        { aspectFlags, 0, fResource->fLevelCount, 0, 1 } // subresourceRange
+        fInfo.fImage,                                    // image
+        { aspectFlags, 0, fInfo.fLevelCount, 0, 1 }      // subresourceRange
     };
 
     gpu->addImageMemoryBarrier(srcStageMask, dstStageMask, byRegion, &imageMemoryBarrier);
 
-    fCurrentLayout = newLayout;
+    fInfo.fImageLayout = newLayout;
 }
 
-const GrVkImage::Resource* GrVkImage::CreateResource(const GrVkGpu* gpu,
-                                                     const ImageDesc& imageDesc) {
+bool GrVkImage::InitImageInfo(const GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImageInfo* info) {
     VkImage image = 0;
     VkDeviceMemory alloc;
 
     VkImageLayout initialLayout = (VK_IMAGE_TILING_LINEAR == imageDesc.fImageTiling)
         ? VK_IMAGE_LAYOUT_PREINITIALIZED
         : VK_IMAGE_LAYOUT_UNDEFINED;
 
     // Create Image
     VkSampleCountFlagBits vkSamples;
     if (!GrSampleCountToVkSampleCount(imageDesc.fSamples, &vkSamples)) {
-        return nullptr;
+        return false;
     }
 
     SkASSERT(VK_IMAGE_TILING_OPTIMAL == imageDesc.fImageTiling ||
              VK_SAMPLE_COUNT_1_BIT == vkSamples);
 
     const VkImageCreateInfo imageCreateInfo = {
         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,         // sType
         NULL,                                        // pNext
         0,                                           // VkImageCreateFlags
         imageDesc.fImageType,                        // VkImageType
         imageDesc.fFormat,                           // VkFormat
         { imageDesc.fWidth, imageDesc.fHeight, 1 },  // VkExtent3D
         imageDesc.fLevels,                           // mipLevels
         1,                                           // arrayLayers
         vkSamples,                                   // samples
         imageDesc.fImageTiling,                      // VkImageTiling
         imageDesc.fUsageFlags,                       // VkImageUsageFlags
         VK_SHARING_MODE_EXCLUSIVE,                   // VkSharingMode
         0,                                           // queueFamilyCount
         0,                                           // pQueueFamilyIndices
         initialLayout                                // initialLayout
     };
 
-    GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateImage(gpu->device(), &imageCreateInfo, nullptr, &image));
+    GR_VK_CALL_ERRCHECK(gpu->vkInterface(), CreateImage(gpu->device(), &imageCreateInfo, nullptr,
+                                                        &image));
 
     if (!GrVkMemory::AllocAndBindImageMemory(gpu, image, imageDesc.fMemProps, &alloc)) {
         VK_CALL(gpu, DestroyImage(gpu->device(), image, nullptr));
-        return nullptr;
+        return false;
     }
 
-    GrVkImage::Resource::Flags flags =
-        (VK_IMAGE_TILING_LINEAR == imageDesc.fImageTiling) ? Resource::kLinearTiling_Flag
-                                                           : Resource::kNo_Flags;
+    info->fImage = image;
+    info->fAlloc = alloc;
+    info->fImageTiling = imageDesc.fImageTiling;
+    info->fImageLayout = initialLayout;
+    info->fFormat = imageDesc.fFormat;
+    info->fLevelCount = imageDesc.fLevels;
+    return true;
+}
 
-    return (new GrVkImage::Resource(image, alloc, imageDesc.fFormat, imageDesc.fLevels, flags));
+void GrVkImage::DestroyImageInfo(const GrVkGpu* gpu, GrVkImageInfo* info) {
+    VK_CALL(gpu, DestroyImage(gpu->device(), info->fImage, nullptr));
+    VK_CALL(gpu, FreeMemory(gpu->device(), info->fAlloc, nullptr));
+}
+
+void GrVkImage::setNewResource(VkImage image, VkDeviceMemory alloc) {
+    fResource = new Resource(image, alloc);
 }
 
 GrVkImage::~GrVkImage() {
     // should have been released or abandoned first
     SkASSERT(!fResource);
 }
 
 void GrVkImage::releaseImage(const GrVkGpu* gpu) {
     if (fResource) {
         fResource->unref(gpu);
         fResource = nullptr;
     }
 }
 
 void GrVkImage::abandonImage() {
     if (fResource) {
         fResource->unrefAndAbandon();
         fResource = nullptr;
     }
 }
 
 void GrVkImage::Resource::freeGPUData(const GrVkGpu* gpu) const {
     VK_CALL(gpu, DestroyImage(gpu->device(), fImage, nullptr));
     VK_CALL(gpu, FreeMemory(gpu->device(), fAlloc, nullptr));
 }
 
 void GrVkImage::BorrowedResource::freeGPUData(const GrVkGpu* gpu) const {
 }