Implement Vulkan GrBackendObject for textures.

src/gpu/vk/GrVkTexture.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 "GrVkTexture.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrVkUtil.h"
 
+#include "vk/GrVkTypes.h"
+
 #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
 
 // Because this class is virtually derived from GrSurface we must explicitly call its constructor.
 GrVkTexture::GrVkTexture(GrVkGpu* gpu,
                          const GrSurfaceDesc& desc,
                          GrGpuResource::LifeCycle lifeCycle,
                          const GrVkImage::Resource* imageResource,
                          const GrVkImageView* view)
     : GrSurface(gpu, lifeCycle, desc)
     , GrVkImage(imageResource)
@@ skipping 45 matching lines @@
     GrVkTexture* texture = Create(gpu, desc, lifeCycle, imageDesc.fFormat, imageResource);
     // Create() will increment the refCount of the image resource if it succeeds
     imageResource->unref(gpu);
 
     return texture;
 }
 
 GrVkTexture* GrVkTexture::CreateWrappedTexture(GrVkGpu* gpu, const GrSurfaceDesc& desc,
                                                GrGpuResource::LifeCycle lifeCycle,
                                                VkFormat format, 
-                                               const GrVkImage::Resource* imageResource) {
-    SkASSERT(imageResource);
+                                               const GrVkTextureInfo* info) {
+    // Wrapped textures require both image and allocation
+    SkASSERT(info->fImage && info->fAlloc);
 
-    // 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 Create(gpu, desc, lifeCycle, format, 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;
+    }
+
+    GrVkTexture* texture = Create(gpu, desc, lifeCycle, format, imageResource);
+    // Create() will increment the refCount of the image resource if it succeeds
+    imageResource->unref(gpu);
+
+    return texture;
 }
 
 GrVkTexture::~GrVkTexture() {
     // either release or abandon should have been called by the owner of this object.
     SkASSERT(!fTextureView);
 }
 
 void GrVkTexture::onRelease() {
     // we create this and don't hand it off, so we should always destroy it
     if (fTextureView) {
@@ skipping 23 matching lines @@
 GrBackendObject GrVkTexture::getTextureHandle() const {
     // Currently just passing back the pointer to the Resource as the handle
     return (GrBackendObject)&fResource;
 }
 
 GrVkGpu* GrVkTexture::getVkGpu() const {
     SkASSERT(!this->wasDestroyed());
     return static_cast<GrVkGpu*>(this->getGpu());
 }