Refactor to separate backend object lifecycle and GpuResource budget decision

src/gpu/vk/GrVkRenderTarget.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 "GrVkRenderTarget.h"
 
 #include "GrRenderTargetPriv.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkFramebuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrVkResourceProvider.h"
 #include "GrVkUtil.h"
 
 #include "vk/GrVkTypes.h"
 
 #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
+                                   SkBudgeted budgeted,
                                    const GrSurfaceDesc& desc,
-                                   GrGpuResource::LifeCycle lifeCycle,
                                    const GrVkImage::Resource* imageResource,
                                    const GrVkImage::Resource* msaaResource,
                                    const GrVkImageView* colorAttachmentView,
                                    const GrVkImageView* resolveAttachmentView)
-    : GrSurface(gpu, lifeCycle, desc)
+    : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
     // for the moment we only support 1:1 color to stencil
-    , GrRenderTarget(gpu, lifeCycle, desc, kUnified_SampleConfig)
+    , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
     , fMSAAImageResource(msaaResource)
     , fResolveAttachmentView(resolveAttachmentView)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(desc.fSampleCnt);
     // The plus 1 is to account for the resolve texture.
     fColorValuesPerPixel = desc.fSampleCnt + 1; // TODO: this still correct?
     this->createFramebuffer(gpu);
-    this->registerWithCache();
+    this->registerWithCache(budgeted);
     msaaResource->ref();
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
                                    const GrSurfaceDesc& desc,
-                                   GrGpuResource::LifeCycle lifeCycle,
                                    const GrVkImage::Resource* imageResource,
                                    const GrVkImage::Resource* msaaResource,
                                    const GrVkImageView* colorAttachmentView,
-                                   const GrVkImageView* resolveAttachmentView,
-                                   Derived)
-    : GrSurface(gpu, lifeCycle, desc)
+                                   const GrVkImageView* resolveAttachmentView)
+    : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
     // for the moment we only support 1:1 color to stencil
-    , GrRenderTarget(gpu, lifeCycle, desc, kUnified_SampleConfig)
+    , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
     , fMSAAImageResource(msaaResource)
     , fResolveAttachmentView(resolveAttachmentView)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(desc.fSampleCnt);
     // The plus 1 is to account for the resolve texture.
     fColorValuesPerPixel = desc.fSampleCnt + 1; // TODO: this still correct?
     this->createFramebuffer(gpu);
     msaaResource->ref();
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
+                                   SkBudgeted budgeted,
                                    const GrSurfaceDesc& desc,
-                                   GrGpuResource::LifeCycle lifeCycle,
                                    const GrVkImage::Resource* imageResource,
                                    const GrVkImageView* colorAttachmentView)
-    : GrSurface(gpu, lifeCycle, desc)
+    : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
-    , GrRenderTarget(gpu, lifeCycle, desc, kUnified_SampleConfig)
+    , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
     , fMSAAImageResource(nullptr)
     , fResolveAttachmentView(nullptr)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(!desc.fSampleCnt);
     fColorValuesPerPixel = 1;
     this->createFramebuffer(gpu);
-    this->registerWithCache();
+    this->registerWithCache(budgeted);
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
                                    const GrSurfaceDesc& desc,
-                                   GrGpuResource::LifeCycle lifeCycle,
                                    const GrVkImage::Resource* imageResource,
-                                   const GrVkImageView* colorAttachmentView,
-                                   Derived)
-    : GrSurface(gpu, lifeCycle, desc)
+                                   const GrVkImageView* colorAttachmentView)
+    : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
-    , GrRenderTarget(gpu, lifeCycle, desc, kUnified_SampleConfig)
+    , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
     , fMSAAImageResource(nullptr)
     , fResolveAttachmentView(nullptr)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(!desc.fSampleCnt);
     fColorValuesPerPixel = 1;
     this->createFramebuffer(gpu);
 }
 
 GrVkRenderTarget*
 GrVkRenderTarget::Create(GrVkGpu* gpu,
+                         SkBudgeted budgeted,
                          const GrSurfaceDesc& desc,
-                         GrGpuResource::LifeCycle lifeCycle,
                          const GrVkImage::Resource* imageResource) {
     VkFormat pixelFormat;
     GrPixelConfigToVkFormat(desc.fConfig, &pixelFormat);
 
     VkImage colorImage;
 
     // create msaa surface if necessary
     const GrVkImage::Resource* msaaResource = nullptr;
     const GrVkImageView* resolveAttachmentView = nullptr;
     if (desc.fSampleCnt) {
@@ skipping 35 matching lines @@
     if (!colorAttachmentView) {
         if (msaaResource) {
             resolveAttachmentView->unref(gpu);
             msaaResource->unref(gpu);
         }
         return NULL;
     }
 
     GrVkRenderTarget* texRT;
     if (msaaResource) {
-        texRT = new GrVkRenderTarget(gpu, desc, lifeCycle, imageResource, msaaResource,
+        texRT = new GrVkRenderTarget(gpu, budgeted, desc, imageResource, msaaResource,
                                      colorAttachmentView, resolveAttachmentView);
         msaaResource->unref(gpu);
     } else {
-        texRT = new GrVkRenderTarget(gpu, desc, lifeCycle, imageResource,
+        texRT = new GrVkRenderTarget(gpu, budgeted, desc, imageResource,
                                      colorAttachmentView);
     }
 
     return texRT;
 }
 
 GrVkRenderTarget*
 GrVkRenderTarget::CreateNewRenderTarget(GrVkGpu* gpu,
+                                        SkBudgeted budgeted,
                                         const GrSurfaceDesc& desc,
-                                        GrGpuResource::LifeCycle lifeCycle,
                                         const GrVkImage::ImageDesc& imageDesc) {
     SkASSERT(imageDesc.fUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
 
     const GrVkImage::Resource* imageResource = GrVkImage::CreateResource(gpu, imageDesc);
     if (!imageResource) {
         return nullptr;
     }
 
-    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, desc, lifeCycle, imageResource);
+    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, budgeted, desc, imageResource);
     // Create() will increment the refCount of the image resource if it succeeds
     imageResource->unref(gpu);
     return rt;
 }
 
 GrVkRenderTarget*
 GrVkRenderTarget::CreateWrappedRenderTarget(GrVkGpu* gpu,
                                             const GrSurfaceDesc& desc,
-                                            GrGpuResource::LifeCycle lifeCycle,
+                                            GrWrapOwnership ownership,
                                             const GrVkTextureInfo* info) {
     SkASSERT(info);
     // We can wrap a rendertarget without its allocation, as long as we don't take ownership
     SkASSERT(VK_NULL_HANDLE != info->fImage);
-    SkASSERT(VK_NULL_HANDLE != info->fAlloc || kAdopted_LifeCycle != lifeCycle);
+    SkASSERT(VK_NULL_HANDLE != info->fAlloc || kAdopt_GrWrapOwnership != ownership);
 
     GrVkImage::Resource::Flags flags = (VK_IMAGE_TILING_LINEAR == info->fImageTiling)
                                      ? Resource::kLinearTiling_Flag : Resource::kNo_Flags;
 
     const GrVkImage::Resource* imageResource;
-    if (kBorrowed_LifeCycle == lifeCycle) {
+    if (kBorrow_GrWrapOwnership == ownership) {
         imageResource = new GrVkImage::BorrowedResource(info->fImage,
                                                         info->fAlloc,
                                                         flags,
                                                         info->fFormat);
     } else {
         imageResource = new GrVkImage::Resource(info->fImage, info->fAlloc, flags, info->fFormat);
     }
     if (!imageResource) {
         return nullptr;
     }
 
-    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, desc, lifeCycle, imageResource);
+    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, SkBudgeted::kNo, desc, imageResource);
     if (rt) {
         rt->fCurrentLayout = info->fImageLayout;
     }
     // Create() will increment the refCount of the image resource if it succeeds
     imageResource->unref(gpu);
 
     return rt;
 }
 
 bool GrVkRenderTarget::completeStencilAttachment() {
@@ skipping 119 matching lines @@
         fFramebuffer = nullptr;
     }
     if (fCachedSimpleRenderPass) {
         fCachedSimpleRenderPass->unrefAndAbandon();
         fCachedSimpleRenderPass = nullptr;
     }
 }
 
 void GrVkRenderTarget::onRelease() {
     this->releaseInternalObjects();
-    if (this->shouldFreeResources()) {
-        this->releaseImage(this->getVkGpu());
-    } else {
-        this->abandonImage();
-    }
-
+    this->releaseImage(this->getVkGpu());
     GrRenderTarget::onRelease();
 }
 
 void GrVkRenderTarget::onAbandon() {
     this->abandonInternalObjects();
     this->abandonImage();
     GrRenderTarget::onAbandon();
 }
 
 
@@ skipping 20 matching lines @@
     }
 
     return nullptr;
 }
 
 
 GrVkGpu* GrVkRenderTarget::getVkGpu() const {
     SkASSERT(!this->wasDestroyed());
     return static_cast<GrVkGpu*>(this->getGpu());
 }