Remove GrBackendTextureDesc

Change-Id: I2b123d1782400e97ab2ce2f11e3e3d325a13e6c8
Reviewed-on: https://skia-review.googlesource.com/24748
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

5 files changed, 47 insertions, 79 deletions

diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index 5ddccdf47a..84a6bfdb7f 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -9,14 +9,15 @@
 #include "TestUtils.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrContextFactory.h"
+#include "GrContextPriv.h"
+#include "GrRenderTargetContext.h"
 #include "GrShaderCaps.h"
-#include "GrSurfaceContext.h"
 #include "GrTest.h"
+#include "GrTextureContext.h"
+#include "gl/GLTestContext.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLUtil.h"
-#include "gl/GLTestContext.h"
 
 using sk_gpu_test::GLTestContext;
 
@@ -139,8 +140,8 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
 
     // TODO: If I make this TopLeft origin to match resolve_origin calls for kDefault, this test
     // fails on the Nexus5. Why?
-    sk_sp<GrSurfaceContext> surfaceContext = context0->contextPriv().makeBackendSurfaceContext(
-            backendTex, kBottomLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 0, nullptr);
+    sk_sp<GrTextureContext> surfaceContext = context0->contextPriv().makeBackendTextureContext(
+            backendTex, kBottomLeft_GrSurfaceOrigin, nullptr);
 
     if (!surfaceContext) {
         ERRORF(reporter, "Error wrapping external texture in GrSurfaceContext.");
@@ -150,23 +151,14 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
 
     // Should not be able to wrap as a RT
     {
-        sk_sp<GrSurfaceContext> temp = context0->contextPriv().makeBackendSurfaceContext(
-            backendTex, kBottomLeft_GrSurfaceOrigin, kRenderTarget_GrBackendTextureFlag, 0,
-            nullptr);
+        sk_sp<GrRenderTargetContext> temp =
+                context0->contextPriv().makeBackendTextureRenderTargetContext(
+                        backendTex, kBottomLeft_GrSurfaceOrigin, 0, nullptr);
         if (temp) {
             ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture as a RT.");
         }
     }
 
-    // Should not be able to wrap with a sample count
-    {
-        sk_sp<GrSurfaceContext> temp = context0->contextPriv().makeBackendSurfaceContext(
-            backendTex, kBottomLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 4, nullptr);
-        if (temp) {
-            ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture with MSAA.");
-        }
-    }
-
     test_read_pixels(reporter, surfaceContext.get(), pixels.get(), "EGLImageTest-read");
 
     // We should not be able to write to a EXTERNAL texture
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 0b0089381a..d67f1038fc 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -54,9 +54,8 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
                                                                kRGBA_8888_GrPixelConfig,
                                                                backendTexHandle);
 
-    sk_sp<GrSurface> texRT2 = context->resourceProvider()->wrapBackendTexture(
-        backendTex, kTopLeft_GrSurfaceOrigin, kRenderTarget_GrBackendTextureFlag, 0,
-        kBorrow_GrWrapOwnership);
+    sk_sp<GrSurface> texRT2 = context->resourceProvider()->wrapRenderableBackendTexture(
+            backendTex, kTopLeft_GrSurfaceOrigin, 0, kBorrow_GrWrapOwnership);
 
     REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asRenderTarget());
     REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asTexture());
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 50ddd00e8a..3cfa157924 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -228,8 +228,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxI
                                                                 kRGBA_8888_GrPixelConfig,
                                                                 texHandles[0]);
     sk_sp<GrTexture> borrowed(context->resourceProvider()->wrapBackendTexture(
-                              backendTex1, kTopLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 0,
-                              kBorrow_GrWrapOwnership));
+            backendTex1, kTopLeft_GrSurfaceOrigin, kBorrow_GrWrapOwnership));
 
     GrBackendTexture backendTex2 = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
                                                                 kW,
@@ -237,8 +236,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxI
                                                                 kRGBA_8888_GrPixelConfig,
                                                                 texHandles[1]);
     sk_sp<GrTexture> adopted(context->resourceProvider()->wrapBackendTexture(
-                             backendTex2, kTopLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 0,
-                             kAdopt_GrWrapOwnership));
+            backendTex2, kTopLeft_GrSurfaceOrigin, kAdopt_GrWrapOwnership));
 
     REPORTER_ASSERT(reporter, borrowed != nullptr && adopted != nullptr);
     if (!borrowed || !adopted) {
diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp
index ca0feb5f14..4e363153f0 100644
--- a/tests/VkWrapTests.cpp
+++ b/tests/VkWrapTests.cpp
@@ -38,8 +38,6 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
     GrBackendTexture backendTex = GrBackendTexture(kW, kH, *imageInfo);
     sk_sp<GrTexture> tex = gpu->wrapBackendTexture(backendTex,
                                                    kTopLeft_GrSurfaceOrigin,
-                                                   kNone_GrBackendTextureFlag,
-                                                   0,
                                                    kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
@@ -49,14 +47,10 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
     backendTex = GrBackendTexture(kW, kH, backendCopy);
     tex = gpu->wrapBackendTexture(backendTex,
                                   kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
                                   kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
     tex = gpu->wrapBackendTexture(backendTex,
                                   kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
                                   kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
 
@@ -66,14 +60,10 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
     backendTex = GrBackendTexture(kW, kH, backendCopy);
     tex = gpu->wrapBackendTexture(backendTex,
                                   kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
                                   kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
     tex = gpu->wrapBackendTexture(backendTex,
                                   kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
                                   kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
     // check adopt creation
@@ -81,8 +71,6 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
     backendTex = GrBackendTexture(kW, kH, backendCopy);
     tex = gpu->wrapBackendTexture(backendTex,
                                   kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
                                   kAdopt_GrWrapOwnership);
 
     REPORTER_ASSERT(reporter, tex);
@@ -130,55 +118,49 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
     const GrVkImageInfo* imageInfo = reinterpret_cast<const GrVkImageInfo*>(backendObj);
 
     GrBackendTexture backendTex = GrBackendTexture(kW, kH, *imageInfo);
-    sk_sp<GrTexture> tex = gpu->wrapBackendTexture(backendTex,
-                                                   kTopLeft_GrSurfaceOrigin,
-                                                   kRenderTarget_GrBackendTextureFlag,
-                                                   0,
-                                                   kBorrow_GrWrapOwnership);
+    sk_sp<GrTexture> tex = gpu->wrapRenderableBackendTexture(backendTex,
+                                                             kTopLeft_GrSurfaceOrigin,
+                                                             0,
+                                                             kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
     // image is null
     GrVkImageInfo backendCopy = *imageInfo;
     backendCopy.fImage = VK_NULL_HANDLE;
     backendTex = GrBackendTexture(kW, kH, backendCopy);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kBorrow_GrWrapOwnership);
+    tex = gpu->wrapRenderableBackendTexture(backendTex,
+                                            kTopLeft_GrSurfaceOrigin,
+                                            0,
+                                            kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    tex = gpu->wrapRenderableBackendTexture(backendTex,
+                                            kTopLeft_GrSurfaceOrigin,
+                                            0,
+                                            kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
 
     // alloc is null
     backendCopy.fImage = imageInfo->fImage;
     backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
     backendTex = GrBackendTexture(kW, kH, backendCopy);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kBorrow_GrWrapOwnership);
+    tex = gpu->wrapRenderableBackendTexture(backendTex,
+                                            kTopLeft_GrSurfaceOrigin,
+                                            0,
+                                            kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    tex = gpu->wrapRenderableBackendTexture(backendTex,
+                                            kTopLeft_GrSurfaceOrigin,
+                                            0,
+                                            kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
 
     // check adopt creation
     backendCopy.fAlloc = imageInfo->fAlloc;
     backendTex = GrBackendTexture(kW, kH, backendCopy);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    tex = gpu->wrapRenderableBackendTexture(backendTex,
+                                            kTopLeft_GrSurfaceOrigin,
+                                            0,
+                                            kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
     gpu->deleteTestingOnlyBackendTexture(backendObj, true);
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index 3aec3e68da..e876c8ff05 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -13,8 +13,10 @@
 #include "sk_tool_utils.h"
 
 #if SK_SUPPORT_GPU
+#include "GrBackendSurface.h"
 #include "GrContext.h"
 #include "GrGpu.h"
+#include "GrTest.h"
 #endif
 
 #include <initializer_list>
@@ -429,26 +431,21 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixelsNonTexture_Gpu, reporter, ctxInfo)
 
     for (auto& origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) {
         for (int sampleCnt : {0, 4}) {
-            GrBackendTextureDesc desc;
-            desc.fConfig = kSkia8888_GrPixelConfig;
-            desc.fWidth = DEV_W;
-            desc.fHeight = DEV_H;
-            desc.fFlags = kRenderTarget_GrBackendTextureFlag;
-            desc.fSampleCnt = sampleCnt;
-            desc.fOrigin = origin;
-            desc.fTextureHandle = context->getGpu()->createTestingOnlyBackendTexture(
-                nullptr, DEV_W, DEV_H, kSkia8888_GrPixelConfig, true);
-            sk_sp<SkSurface> surface(SkSurface::MakeFromBackendTextureAsRenderTarget(context, desc,
-                                                                                     nullptr));
+            auto handle = context->getGpu()->createTestingOnlyBackendTexture(
+                    nullptr, DEV_W, DEV_H, kSkia8888_GrPixelConfig, true);
+            GrBackendTexture backendTexture = GrTest::CreateBackendTexture(
+                    ctxInfo.backend(), DEV_W, DEV_H, kSkia8888_GrPixelConfig, handle);
+            sk_sp<SkSurface> surface(SkSurface::MakeFromBackendTextureAsRenderTarget(
+                    context, backendTexture, origin, sampleCnt, nullptr, nullptr));
             if (!surface) {
-                context->getGpu()->deleteTestingOnlyBackendTexture(desc.fTextureHandle);
+                context->getGpu()->deleteTestingOnlyBackendTexture(handle);
                 continue;
             }
 
             test_write_pixels(reporter, surface.get());
 
             surface.reset();
-            context->getGpu()->deleteTestingOnlyBackendTexture(desc.fTextureHandle);
+            context->getGpu()->deleteTestingOnlyBackendTexture(handle);
         }
     }
 }