Implement Vulkan GrBackendObject for textures.

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,
                                    const GrSurfaceDesc& desc,
                                    GrGpuResource::LifeCycle lifeCycle,
                                    const GrVkImage::Resource* imageResource,
                                    const GrVkImage::Resource* msaaResource,
                                    const GrVkImageView* colorAttachmentView,
@@ skipping 168 matching lines @@
     GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, desc, lifeCycle, 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,
-                                            const GrVkImage::Resource* imageResource) {
-    SkASSERT(imageResource);
+                                            const GrVkTextureInfo* info) {
+    // We can wrap a rendertarget without its allocation, as long as we don't take ownership
+    SkASSERT(info->fAlloc || kAdopted_LifeCycle != lifeCycle);

[bsalomon, 2016/03/17 17:19:03]

Seems ok to assert here but should the onWrap**() method in GrVkGpu gracefull
fail before this cons would be called? It is reachable from public facing
methods (SkImage factories). Might be good to have a unit test.

Also, should this be documented with GrVkTextureInfo? (that alloc may be null
iff the texture is wrapped with borrow semantics)

[jvanverth1, 2016/03/18 14:30:00]

Done.

 
-    // Note: we assume the caller will unref the imageResource
-    // Create() will increment the refCount, and we'll unref when we're done with it
-    return GrVkRenderTarget::Create(gpu, desc, lifeCycle, imageResource);
+    GrVkImage::Resource::Flags flags = (VK_IMAGE_TILING_LINEAR == info->fImageTiling) 
+                                     ? Resource::kLinearTiling_Flag : Resource::kNo_Flags;
+
+    const GrVkImage::Resource* imageResource = new GrVkImage::Resource(info->fImage,
+                                                                       info->fAlloc,
+                                                                       flags);
+    if (!imageResource) {
+        return nullptr;
+    }
+
+    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, desc, lifeCycle, imageResource);
+    // Create() will increment the refCount of the image resource if it succeeds
+    imageResource->unref(gpu);
+    return rt;
 }
 
 bool GrVkRenderTarget::completeStencilAttachment() {
     this->createFramebuffer(this->getVkGpu());
     return true;
 }
 
 void GrVkRenderTarget::createFramebuffer(GrVkGpu* gpu) {
     if (fFramebuffer) {
         fFramebuffer->unref(gpu);
@@ skipping 159 matching lines @@
 
     return nullptr;
 }
 
 
 GrVkGpu* GrVkRenderTarget::getVkGpu() const {
     SkASSERT(!this->wasDestroyed());
     return static_cast<GrVkGpu*>(this->getGpu());
 }