Update getBackendInfo calls on GrBackendTexture to support VkImageLayout better.

The big api level change here is that the getBackendInfo calls now return by value
instead of a pointer. These changes are being made in support of Vulkan so that
the client can update the VkImageLayout on the GrBackendTexture and have that
update get reflected in our internal tracking of the image. This is done by storing
a ref counted GrVkImageLayout object on the GrBackendTexture and the GrVkImage.

Bug: skia:
Change-Id: I8c6158fd3a66eb61fef97ebf09ea5364bca3f1ae
Reviewed-on: https://skia-review.googlesource.com/119101
Reviewed-by: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>

5 files changed, 187 insertions, 30 deletions

diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index b44f5b2bfa..d7f3861888 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -98,16 +98,20 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
         return;
     }
 
-    const GrGLTextureInfo* texInfo = backendTexture1.getGLTextureInfo();
+    GrGLTextureInfo texInfo;
+    if (!backendTexture1.getGLTextureInfo(&texInfo)) {
+        ERRORF(reporter, "Failed to get GrGLTextureInfo");
+        return;
+    }
 
-    if (GR_GL_TEXTURE_2D != texInfo->fTarget) {
+    if (GR_GL_TEXTURE_2D != texInfo.fTarget) {
         ERRORF(reporter, "Expected backend texture to be 2D");
         cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, &backendTexture1, image);
         return;
     }
 
     // Wrap the texture in an EGLImage
-    image = glCtx1->texture2DToEGLImage(texInfo->fID);
+    image = glCtx1->texture2DToEGLImage(texInfo.fID);
     if (GR_EGL_NO_IMAGE == image) {
         ERRORF(reporter, "Error creating EGL Image from texture");
         cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, &backendTexture1, image);
@@ -128,8 +132,8 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
         pixels.get()[i] = 0xDDAABBCC;
     }
     GR_GL_CALL(glCtx1->gl(), ActiveTexture(GR_GL_TEXTURE0));
-    GR_GL_CALL(glCtx1->gl(), BindTexture(texInfo->fTarget, texInfo->fID));
-    GR_GL_CALL(glCtx1->gl(), TexSubImage2D(texInfo->fTarget, 0, 0, 0, kSize, kSize,
+    GR_GL_CALL(glCtx1->gl(), BindTexture(texInfo.fTarget, texInfo.fID));
+    GR_GL_CALL(glCtx1->gl(), TexSubImage2D(texInfo.fTarget, 0, 0, 0, kSize, kSize,
                                            GR_GL_RGBA, GR_GL_UNSIGNED_BYTE, pixels.get()));
     GR_GL_CALL(glCtx1->gl(), Finish());
     // We've been making direct GL calls in GL context 1, let GrContext 1 know its internal
diff --git a/tests/GrMipMappedTest.cpp b/tests/GrMipMappedTest.cpp
index 4e8179950d..aaca9b4410 100644
--- a/tests/GrMipMappedTest.cpp
+++ b/tests/GrMipMappedTest.cpp
@@ -181,22 +181,34 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrBackendTextureImageMipMappedTest, reporter,
 
             GrBackendTexture genBackendTex = genTexture->getBackendTexture();
 
-            if (const GrGLTextureInfo* genTexInfo = genBackendTex.getGLTextureInfo()) {
-                const GrGLTextureInfo* origTexInfo = backendTex.getGLTextureInfo();
-                if (willUseMips && GrMipMapped::kNo == mipMapped) {
-                    // We did a copy so the texture IDs should be different
-                    REPORTER_ASSERT(reporter, origTexInfo->fID != genTexInfo->fID);
+            if (kOpenGL_GrBackend == genBackendTex.backend()) {
+                GrGLTextureInfo genTexInfo;
+                GrGLTextureInfo origTexInfo;
+                if (genBackendTex.getGLTextureInfo(&genTexInfo) &&
+                    backendTex.getGLTextureInfo(&origTexInfo)) {
+                    if (willUseMips && GrMipMapped::kNo == mipMapped) {
+                        // We did a copy so the texture IDs should be different
+                        REPORTER_ASSERT(reporter, origTexInfo.fID != genTexInfo.fID);
+                    } else {
+                        REPORTER_ASSERT(reporter, origTexInfo.fID == genTexInfo.fID);
+                    }
                 } else {
-                    REPORTER_ASSERT(reporter, origTexInfo->fID == genTexInfo->fID);
+                    ERRORF(reporter, "Failed to get GrGLTextureInfo");
                 }
 #ifdef SK_VULKAN
-            } else if (const GrVkImageInfo* genImageInfo = genBackendTex.getVkImageInfo()) {
-                const GrVkImageInfo* origImageInfo = backendTex.getVkImageInfo();
-                if (willUseMips && GrMipMapped::kNo == mipMapped) {
-                    // We did a copy so the texture IDs should be different
-                    REPORTER_ASSERT(reporter, origImageInfo->fImage != genImageInfo->fImage);
+            } else if (kVulkan_GrBackend == genBackendTex.backend()) {
+                GrVkImageInfo genImageInfo;
+                GrVkImageInfo origImageInfo;
+                if (genBackendTex.getVkImageInfo(&genImageInfo) &&
+                    backendTex.getVkImageInfo(&origImageInfo)) {
+                    if (willUseMips && GrMipMapped::kNo == mipMapped) {
+                        // We did a copy so the texture IDs should be different
+                        REPORTER_ASSERT(reporter, origImageInfo.fImage != genImageInfo.fImage);
+                    } else {
+                        REPORTER_ASSERT(reporter, origImageInfo.fImage == genImageInfo.fImage);
+                    }
                 } else {
-                    REPORTER_ASSERT(reporter, origImageInfo->fImage == genImageInfo->fImage);
+                    ERRORF(reporter, "Failed to get GrVkImageInfo");
                 }
 #endif
             } else {
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index fd9baecd4b..55730816bb 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -1065,7 +1065,12 @@ static uint32_t GetIdForBackendTexture(GrBackendTexture texture) {
         return 0;
     }
 
-    return texture.getGLTextureInfo()->fID;
+    GrGLTextureInfo info;
+    if (!texture.getGLTextureInfo(&info)) {
+        return 0;
+    }
+
+    return info.fID;
 }
 
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(makeBackendTexture, reporter, ctxInfo) {
diff --git a/tests/VkBackendSurfaceTest.cpp b/tests/VkBackendSurfaceTest.cpp
new file mode 100644
index 0000000000..298dc38b4e
--- /dev/null
+++ b/tests/VkBackendSurfaceTest.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// This is a GPU-backend specific test. It relies on static intializers to work
+
+#include "SkTypes.h"
+
+#if SK_SUPPORT_GPU && defined(SK_VULKAN)
+
+#include "GrTest.h"
+#include "Test.h"
+
+#include "GrBackendSurface.h"
+#include "GrContextPriv.h"
+#include "GrTextureProxy.h"
+#include "GrTexture.h"
+#include "SkImage.h"
+#include "SkImage_Base.h"
+#include "vk/GrVkGpu.h"
+#include "vk/GrVkImageLayout.h"
+#include "vk/GrVkTexture.h"
+#include "vk/GrVkTypes.h"
+
+DEF_GPUTEST_FOR_VULKAN_CONTEXT(VkImageLayoutTest, reporter, ctxInfo) {
+    GrContext* context = ctxInfo.grContext();
+    GrVkGpu* gpu = static_cast<GrVkGpu*>(context->contextPriv().getGpu());
+
+    GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(nullptr, 1, 1,
+                                                                       kRGBA_8888_GrPixelConfig,
+                                                                       false,
+                                                                       GrMipMapped::kNo);
+    REPORTER_ASSERT(reporter, backendTex.isValid());
+
+    GrVkImageInfo info;
+    REPORTER_ASSERT(reporter, backendTex.getVkImageInfo(&info));
+    VkImageLayout initLayout = info.fImageLayout;
+
+    // Verify that setting that layout via a copy of a backendTexture is reflected in all the
+    // backendTextures.
+    GrBackendTexture backendTexCopy = backendTex;
+    REPORTER_ASSERT(reporter, backendTexCopy.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
+
+    backendTexCopy.setVkImageLayout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+
+    REPORTER_ASSERT(reporter, backendTex.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == info.fImageLayout);
+
+    REPORTER_ASSERT(reporter, backendTexCopy.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == info.fImageLayout);
+
+    // Setting back the layout since we didn't actually change it
+    backendTex.setVkImageLayout(initLayout);
+
+    sk_sp<SkImage> wrappedImage = SkImage::MakeFromTexture(context, backendTex,
+                                                           kTopLeft_GrSurfaceOrigin,
+                                                           kRGBA_8888_SkColorType,
+                                                           kPremul_SkAlphaType, nullptr);
+    REPORTER_ASSERT(reporter, wrappedImage.get());
+
+    sk_sp<GrTextureProxy> texProxy = as_IB(wrappedImage)->asTextureProxyRef();
+    REPORTER_ASSERT(reporter, texProxy.get());
+    REPORTER_ASSERT(reporter, texProxy->priv().isInstantiated());
+    GrTexture* texture = texProxy->priv().peekTexture();
+    REPORTER_ASSERT(reporter, texture);
+
+    // Verify that modifying the layout via the GrVkTexture is reflected in the GrBackendTexture
+    GrVkTexture* vkTexture = static_cast<GrVkTexture*>(texture);
+    REPORTER_ASSERT(reporter, initLayout == vkTexture->currentLayout());
+    vkTexture->updateImageLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+
+    REPORTER_ASSERT(reporter, backendTex.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == info.fImageLayout);
+
+    GrBackendTexture backendTexImage = wrappedImage->getBackendTexture(false);
+    REPORTER_ASSERT(reporter, backendTexImage.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == info.fImageLayout);
+
+    // Verify that modifying the layout via the GrBackendTexutre is reflected in the GrVkTexture
+    backendTexImage.setVkImageLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+    REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == vkTexture->currentLayout());
+
+    // Verify that modifying the layout via the old textureHandle sitll works in is reflected in the
+    // GrVkTexture and GrBackendTexture.
+    GrVkImageInfo* backendInfo = (GrVkImageInfo*)wrappedImage->getTextureHandle(false);
+    REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == backendInfo->fImageLayout);
+
+    backendInfo->updateImageLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+    REPORTER_ASSERT(reporter,
+                    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == vkTexture->currentLayout());
+    REPORTER_ASSERT(reporter, backendTexImage.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == info.fImageLayout);
+
+    vkTexture->updateImageLayout(initLayout);
+
+    REPORTER_ASSERT(reporter, backendTex.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
+
+    REPORTER_ASSERT(reporter, backendTexCopy.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
+
+    REPORTER_ASSERT(reporter, backendTexImage.getVkImageInfo(&info));
+    REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
+
+    // Check that we can do things like assigning the backend texture to invalid one, assign an
+    // invalid one, assin a backend texture to inself etc. Success here is that we don't hit any of
+    // our ref counting asserts.
+    REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(backendTex, backendTexCopy));
+
+    GrBackendTexture invalidTexture;
+    REPORTER_ASSERT(reporter, !invalidTexture.isValid());
+    REPORTER_ASSERT(reporter, !GrBackendTexture::TestingOnly_Equals(invalidTexture, backendTexCopy));
+
+    backendTexCopy = invalidTexture;
+    REPORTER_ASSERT(reporter, !backendTexCopy.isValid());
+    REPORTER_ASSERT(reporter, !GrBackendTexture::TestingOnly_Equals(invalidTexture, backendTexCopy));
+
+    invalidTexture = backendTex;
+    REPORTER_ASSERT(reporter, invalidTexture.isValid());
+    REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(invalidTexture, backendTex));
+
+    invalidTexture = invalidTexture;
+    REPORTER_ASSERT(reporter, invalidTexture.isValid());
+    REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(invalidTexture, invalidTexture));
+
+    gpu->deleteTestingOnlyBackendTexture(backendTex);
+}
+
+#endif
diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp
index 367fdb5c53..cd0b72e0fe 100644
--- a/tests/VkWrapTests.cpp
+++ b/tests/VkWrapTests.cpp
@@ -36,14 +36,15 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
     GrBackendTexture origBackendTex = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH,
                                                                            kPixelConfig, false,
                                                                            GrMipMapped::kNo);
-    const GrVkImageInfo* imageInfo = origBackendTex.getVkImageInfo();
+    GrVkImageInfo imageInfo;
+    SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
 
     sk_sp<GrTexture> tex = gpu->wrapBackendTexture(origBackendTex, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
     // image is null
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         backendCopy.fImage = VK_NULL_HANDLE;
         GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
         tex = gpu->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership);
@@ -54,7 +55,7 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
 
     // alloc is null
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         backendCopy.fAlloc = GrVkAlloc();
         GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
         tex = gpu->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership);
@@ -65,7 +66,7 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
 
     // check adopt creation
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
         tex = gpu->wrapBackendTexture(backendTex, kAdopt_GrWrapOwnership);
 
@@ -79,16 +80,17 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) {
     GrBackendTexture origBackendTex = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH,
                                                                            kPixelConfig, true,
                                                                            GrMipMapped::kNo);
-    const GrVkImageInfo* imageInfo = origBackendTex.getVkImageInfo();
+    GrVkImageInfo imageInfo;
+    SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
 
-    GrBackendRenderTarget origBackendRT(kW, kH, 1, 0, *imageInfo);
+    GrBackendRenderTarget origBackendRT(kW, kH, 1, 0, imageInfo);
 
     sk_sp<GrRenderTarget> rt = gpu->wrapBackendRenderTarget(origBackendRT);
     REPORTER_ASSERT(reporter, rt);
 
     // image is null
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         backendCopy.fImage = VK_NULL_HANDLE;
         GrBackendRenderTarget backendRT(kW, kH, 1, 0, backendCopy);
         rt = gpu->wrapBackendRenderTarget(backendRT);
@@ -97,7 +99,7 @@ void wrap_rt_test(skiatest::Reporter* reporter, GrContext* context) {
 
     // alloc is null
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         backendCopy.fAlloc = GrVkAlloc();
         // can wrap null alloc
         GrBackendRenderTarget backendRT(kW, kH, 1, 0, backendCopy);
@@ -116,7 +118,8 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
     GrBackendTexture origBackendTex = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH,
                                                                            kPixelConfig, true,
                                                                            GrMipMapped::kNo);
-    const GrVkImageInfo* imageInfo = origBackendTex.getVkImageInfo();
+    GrVkImageInfo imageInfo;
+    SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
 
     sk_sp<GrTexture> tex =
             gpu->wrapRenderableBackendTexture(origBackendTex, 1, kBorrow_GrWrapOwnership);
@@ -124,7 +127,7 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
 
     // image is null
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         backendCopy.fImage = VK_NULL_HANDLE;
         GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
         tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kBorrow_GrWrapOwnership);
@@ -135,7 +138,7 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
 
     // alloc is null
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         backendCopy.fAlloc = GrVkAlloc();
         GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
         tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kBorrow_GrWrapOwnership);
@@ -146,7 +149,7 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
 
     // check adopt creation
     {
-        GrVkImageInfo backendCopy = *imageInfo;
+        GrVkImageInfo backendCopy = imageInfo;
         GrBackendTexture backendTex = GrBackendTexture(kW, kH, backendCopy);
         tex = gpu->wrapRenderableBackendTexture(backendTex, 1, kAdopt_GrWrapOwnership);
         REPORTER_ASSERT(reporter, tex);