Revert "Plumb GrBackendTexture throughout skia."

This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.

Reason for revert: fix android roll

Original change's description:
> Plumb GrBackendTexture throughout skia.
> 
> Bug: skia:
> Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> Reviewed-on: https://skia-review.googlesource.com/13645
> Commit-Queue: Greg Daniel <egdaniel@google.com>
> Reviewed-by: Robert Phillips <robertphillips@google.com>
> 

TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
Reviewed-on: https://skia-review.googlesource.com/13773
Reviewed-by: Stan Iliev <stani@google.com>
Commit-Queue: Stan Iliev <stani@google.com>

10 files changed, 170 insertions, 238 deletions

diff --git a/tests/BlendTest.cpp b/tests/BlendTest.cpp
index 20ea6e0f00..0acbd07957 100644
--- a/tests/BlendTest.cpp
+++ b/tests/BlendTest.cpp
@@ -21,7 +21,6 @@
 #include "GrResourceProvider.h"
 #include "GrSurfaceContext.h"
 #include "GrSurfaceProxy.h"
-#include "GrTest.h"
 #include "GrTexture.h"
 #endif
 
@@ -100,16 +99,16 @@ static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
         return nullptr;
     }
 
-    GrBackendTexture backendTex =
-            GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                         width,
-                                         height,
-                                         config,
-                                         (*backingSurface)->getTextureHandle());
+    GrBackendTextureDesc desc;
+    desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+    desc.fOrigin = origin;
+    desc.fWidth = width;
+    desc.fHeight = height;
+    desc.fConfig = config;
+    desc.fSampleCnt = sampleCnt;
+    desc.fTextureHandle = (*backingSurface)->getTextureHandle();
     sk_sp<SkSurface> surface =
-            SkSurface::MakeFromBackendTextureAsRenderTarget(context, backendTex, origin,
-                                                            sampleCnt, nullptr, nullptr);
-
+            SkSurface::MakeFromBackendTextureAsRenderTarget(context, desc, nullptr);
     return surface;
 }
 }
diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index 1b94a6e602..998e339abe 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -13,7 +13,6 @@
 #include "GrContextFactory.h"
 #include "GrShaderCaps.h"
 #include "GrSurfaceContext.h"
-#include "GrTest.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLUtil.h"
 #include "gl/GLTestContext.h"
@@ -130,12 +129,14 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
     externalTexture.fID = glCtx0->eglImageToExternalTexture(image);
 
     // Wrap this texture ID in a GrTexture
-    GrBackendTexture backendTex(kSize, kSize, kRGBA_8888_GrPixelConfig, &externalTexture);
+    GrBackendTextureDesc externalDesc;
+    externalDesc.fConfig = kRGBA_8888_GrPixelConfig;
+    externalDesc.fWidth = kSize;
+    externalDesc.fHeight = kSize;
+    externalDesc.fTextureHandle = reinterpret_cast<GrBackendObject>(&externalTexture);
 
-    // 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);
+                                                                           externalDesc, nullptr);
 
     if (!surfaceContext) {
         ERRORF(reporter, "Error wrapping external texture in GrSurfaceContext.");
@@ -145,21 +146,25 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
 
     // Should not be able to wrap as a RT
     {
+        externalDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
+
         sk_sp<GrSurfaceContext> temp = context0->contextPriv().makeBackendSurfaceContext(
-            backendTex, kBottomLeft_GrSurfaceOrigin, kRenderTarget_GrBackendTextureFlag, 0,
-            nullptr);
+                                                                           externalDesc, nullptr);
         if (temp) {
             ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture as a RT.");
         }
+        externalDesc.fFlags = kNone_GrBackendTextureFlag;
     }
 
     // Should not be able to wrap with a sample count
     {
+        externalDesc.fSampleCnt = 4;
         sk_sp<GrSurfaceContext> temp = context0->contextPriv().makeBackendSurfaceContext(
-            backendTex, kBottomLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 4, nullptr);
+                                                                           externalDesc, nullptr);
         if (temp) {
             ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture with MSAA.");
         }
+        externalDesc.fSampleCnt = 0;
     }
 
     test_read_pixels(reporter, surfaceContext.get(), pixels.get(), "EGLImageTest-read");
diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp
index 780573d34f..f4b74c7cda 100644
--- a/tests/GrPorterDuffTest.cpp
+++ b/tests/GrPorterDuffTest.cpp
@@ -11,10 +11,8 @@
 
 #include "GrContextFactory.h"
 #include "GrContextOptions.h"
-#include "GrContextPriv.h"
 #include "GrGpu.h"
 #include "GrResourceProvider.h"
-#include "GrTest.h"
 #include "GrXferProcessor.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "gl/GrGLCaps.h"
@@ -1036,19 +1034,15 @@ DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, /*factory*/) {
         return;
     }
 
-    GrBackendObject backendTexHandle =
+    GrBackendObject backendTex =
         ctx->getGpu()->createTestingOnlyBackendTexture(nullptr, 100, 100, kRGBA_8888_GrPixelConfig);
-    GrBackendTexture backendTex = GrTest::CreateBackendTexture(ctx->contextPriv().getBackend(),
-                                                               100,
-                                                               100,
-                                                               kRGBA_8888_GrPixelConfig,
-                                                               backendTexHandle);
-
+    GrBackendTextureDesc fakeDesc;
+    fakeDesc.fConfig = kRGBA_8888_GrPixelConfig;
+    fakeDesc.fWidth = fakeDesc.fHeight = 100;
+    fakeDesc.fTextureHandle = backendTex;
     GrXferProcessor::DstTexture fakeDstTexture;
     fakeDstTexture.setTexture(
-        ctx->resourceProvider()->wrapBackendTexture(backendTex, kTopLeft_GrSurfaceOrigin,
-                                                    kNone_GrBackendTextureFlag, 0,
-                                                    kBorrow_GrWrapOwnership));
+        ctx->resourceProvider()->wrapBackendTexture(fakeDesc, kBorrow_GrWrapOwnership));
 
     static const GrProcessorAnalysisColor colorInputs[] = {
             GrProcessorAnalysisColor::Opaque::kNo, GrProcessorAnalysisColor::Opaque::kYes,
@@ -1071,7 +1065,7 @@ DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, /*factory*/) {
             }
         }
     }
-    ctx->getGpu()->deleteTestingOnlyBackendTexture(backendTexHandle);
+    ctx->getGpu()->deleteTestingOnlyBackendTexture(backendTex);
 }
 
 #endif
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 99c0becbef..97700b1a85 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -10,11 +10,9 @@
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrGpu.h"
 #include "GrRenderTarget.h"
 #include "GrResourceProvider.h"
-#include "GrTest.h"
 #include "GrTexture.h"
 #include "GrSurfacePriv.h"
 #include "Test.h"
@@ -46,18 +44,18 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
     REPORTER_ASSERT(reporter, tex1.get() == tex1->asTexture());
     REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1.get()) == tex1->asTexture());
 
-    GrBackendObject backendTexHandle = context->getGpu()->createTestingOnlyBackendTexture(
+    GrBackendObject backendTex = context->getGpu()->createTestingOnlyBackendTexture(
         nullptr, 256, 256, kRGBA_8888_GrPixelConfig);
-    GrBackendTexture backendTex = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                               256,
-                                                               256,
-                                                               kRGBA_8888_GrPixelConfig,
-                                                               backendTexHandle);
 
+    GrBackendTextureDesc backendDesc;
+    backendDesc.fConfig = kRGBA_8888_GrPixelConfig;
+    backendDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
+    backendDesc.fWidth = 256;
+    backendDesc.fHeight = 256;
+    backendDesc.fSampleCnt = 0;
+    backendDesc.fTextureHandle = backendTex;
     sk_sp<GrSurface> texRT2 = context->resourceProvider()->wrapBackendTexture(
-        backendTex, kTopLeft_GrSurfaceOrigin, kRenderTarget_GrBackendTextureFlag, 0,
-        kBorrow_GrWrapOwnership);
-
+        backendDesc, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asRenderTarget());
     REPORTER_ASSERT(reporter, texRT2.get() == texRT2->asTexture());
     REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT2->asRenderTarget()) ==
@@ -67,7 +65,7 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
     REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT2->asRenderTarget()) ==
                     static_cast<GrSurface*>(texRT2->asTexture()));
 
-    context->getGpu()->deleteTestingOnlyBackendTexture(backendTexHandle);
+    context->getGpu()->deleteTestingOnlyBackendTexture(backendTex);
 }
 
 #endif
diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index 0dda42e3a8..95ade044bd 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -179,9 +179,7 @@ DEF_TEST(ImageFilterCache_ImageBackedRaster, reporter) {
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrResourceProvider.h"
-#include "GrTest.h"
 
 static sk_sp<GrTextureProxy> create_proxy(GrResourceProvider* resourceProvider) {
     SkBitmap srcBM = create_bm();
@@ -211,16 +209,17 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ct
         return;
     }
 
-    GrBackendTexture backendTex = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                               kFullSize,
-                                                               kFullSize,
-                                                               kRGBA_8888_GrPixelConfig,
-                                                               tex->getTextureHandle());
-    GrSurfaceOrigin texOrigin = kTopLeft_GrSurfaceOrigin;
+    GrBackendTextureDesc backendDesc;
+    backendDesc.fFlags = kNone_GrBackendTextureFlag;
+    backendDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
+    backendDesc.fConfig = kRGBA_8888_GrPixelConfig;
+    backendDesc.fWidth = kFullSize;
+    backendDesc.fHeight = kFullSize;
+    backendDesc.fSampleCnt = 0;
+    backendDesc.fTextureHandle = tex->getTextureHandle();
     sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(context,
-                                                     backendTex,
-                                                     texOrigin,
-                                                     kPremul_SkAlphaType, nullptr));
+                                                     backendDesc,
+                                                     kPremul_SkAlphaType));
     if (!srcImage) {
         return;
     }
@@ -229,18 +228,18 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ct
     GrBackendObject readBackHandle = srcImage->getTextureHandle(false, &readBackOrigin);
     // TODO: Make it so we can check this (see skbug.com/5019)
 #if 0
-    if (readBackHandle != tex->getTextureHandle()) {
+    if (readBackHandle != backendDesc.fTextureHandle) {
         ERRORF(reporter, "backend mismatch %d %d\n",
-                       (int)readBackHandle, (int)tex->getTextureHandle());
+                       (int)readBackHandle, (int)backendDesc.fTextureHandle);
     }
-    REPORTER_ASSERT(reporter, readBackHandle == tex->getTextureHandle());
+    REPORTER_ASSERT(reporter, readBackHandle == backendDesc.fTextureHandle);
 #else
     REPORTER_ASSERT(reporter, SkToBool(readBackHandle));
 #endif
-    if (readBackOrigin != texOrigin) {
-        ERRORF(reporter, "origin mismatch %d %d\n", readBackOrigin, texOrigin);
+    if (readBackOrigin != backendDesc.fOrigin) {
+        ERRORF(reporter, "origin mismatch %d %d\n", readBackOrigin, backendDesc.fOrigin);
     }
-    REPORTER_ASSERT(reporter, readBackOrigin == texOrigin);
+    REPORTER_ASSERT(reporter, readBackOrigin == backendDesc.fOrigin);
 
     test_image_backed(reporter, srcImage);
 }
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 382a624253..77017f3885 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -32,9 +32,7 @@
 #include "sk_tool_utils.h"
 
 #if SK_SUPPORT_GPU
-#include "GrContextPriv.h"
 #include "GrGpu.h"
-#include "GrTest.h"
 #endif
 
 using namespace sk_gpu_test;
@@ -810,48 +808,44 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkImage_NewFromTextureRelease, reporter, c
     const int kWidth = 10;
     const int kHeight = 10;
     std::unique_ptr<uint32_t[]> pixels(new uint32_t[kWidth * kHeight]);
-
-    GrContext* ctx = ctxInfo.grContext();
-
-    GrBackendObject backendTexHandle =
-            ctxInfo.grContext()->getGpu()->createTestingOnlyBackendTexture(
-                    pixels.get(), kWidth, kHeight, kRGBA_8888_GrPixelConfig, true);
-
-    GrBackendTexture backendTex = GrTest::CreateBackendTexture(ctx->contextPriv().getBackend(),
-                                                               kWidth,
-                                                               kHeight,
-                                                               kRGBA_8888_GrPixelConfig,
-                                                               backendTexHandle);
+    GrBackendTextureDesc backendDesc;
+    backendDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
+    backendDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
+    backendDesc.fConfig = kRGBA_8888_GrPixelConfig;
+    backendDesc.fWidth = kWidth;
+    backendDesc.fHeight = kHeight;
+    backendDesc.fSampleCnt = 0;
+    backendDesc.fTextureHandle = ctxInfo.grContext()->getGpu()->createTestingOnlyBackendTexture(
+        pixels.get(), kWidth, kHeight, kRGBA_8888_GrPixelConfig, true);
 
     TextureReleaseChecker releaseChecker;
-    GrSurfaceOrigin texOrigin = kBottomLeft_GrSurfaceOrigin;
     sk_sp<SkImage> refImg(
-        SkImage::MakeFromTexture(ctx, backendTex, texOrigin, kPremul_SkAlphaType, nullptr,
+        SkImage::MakeFromTexture(ctxInfo.grContext(), backendDesc, kPremul_SkAlphaType,
                                  TextureReleaseChecker::Release, &releaseChecker));
 
     GrSurfaceOrigin readBackOrigin;
     GrBackendObject readBackHandle = refImg->getTextureHandle(false, &readBackOrigin);
     // TODO: Make it so we can check this (see skbug.com/5019)
 #if 0
-    if (*readBackHandle != *(backendTexHandle)) {
+    if (*readBackHandle != *(backendDesc.fTextureHandle)) {
         ERRORF(reporter, "backend mismatch %d %d\n",
-                       (int)readBackHandle, (int)backendTexHandle);
+                       (int)readBackHandle, (int)backendDesc.fTextureHandle);
     }
-    REPORTER_ASSERT(reporter, readBackHandle == backendTexHandle);
+    REPORTER_ASSERT(reporter, readBackHandle == backendDesc.fTextureHandle);
 #else
     REPORTER_ASSERT(reporter, SkToBool(readBackHandle));
 #endif
-    if (readBackOrigin != texOrigin) {
-        ERRORF(reporter, "origin mismatch %d %d\n", readBackOrigin, texOrigin);
+    if (readBackOrigin != backendDesc.fOrigin) {
+        ERRORF(reporter, "origin mismatch %d %d\n", readBackOrigin, backendDesc.fOrigin);
     }
-    REPORTER_ASSERT(reporter, readBackOrigin == texOrigin);
+    REPORTER_ASSERT(reporter, readBackOrigin == backendDesc.fOrigin);
 
     // Now exercise the release proc
     REPORTER_ASSERT(reporter, 0 == releaseChecker.fReleaseCount);
     refImg.reset(nullptr); // force a release of the image
     REPORTER_ASSERT(reporter, 1 == releaseChecker.fReleaseCount);
 
-    ctxInfo.grContext()->getGpu()->deleteTestingOnlyBackendTexture(backendTexHandle);
+    ctxInfo.grContext()->getGpu()->deleteTestingOnlyBackendTexture(backendDesc.fTextureHandle);
 }
 
 static void check_images_same(skiatest::Reporter* reporter, const SkImage* a, const SkImage* b) {
diff --git a/tests/RectangleTextureTest.cpp b/tests/RectangleTextureTest.cpp
index 967d86c9c4..41ee7b3c1c 100644
--- a/tests/RectangleTextureTest.cpp
+++ b/tests/RectangleTextureTest.cpp
@@ -13,14 +13,13 @@
 #include "GrContext.h"
 #include "GrContextPriv.h"
 #include "GrRenderTargetContext.h"
-#include "GrTest.h"
 #include "gl/GLTestContext.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLUtil.h"
 
 // skbug.com/5932
 static void test_basic_draw_as_src(skiatest::Reporter* reporter, GrContext* context,
-                                   sk_sp<GrTextureProxy> rectProxy, uint32_t expectedPixelValues[]) {
+                                   sk_sp<GrSurfaceProxy> rectProxy, uint32_t expectedPixelValues[]) {
     sk_sp<GrRenderTargetContext> rtContext(
             context->makeRenderTargetContext(SkBackingFit::kExact, rectProxy->width(),
                                              rectProxy->height(), rectProxy->config(),
@@ -31,7 +30,7 @@ static void test_basic_draw_as_src(skiatest::Reporter* reporter, GrContext* cont
         rtContext->clear(nullptr, 0xDDCCBBAA, true);
         sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(
                                                         context->resourceProvider(),
-                                                        rectProxy,
+                                                        sk_ref_sp(rectProxy->asTextureProxy()),
                                                         nullptr,
                                                         SkMatrix::I(), filter));
         GrPaint paint;
@@ -100,9 +99,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
         }
     }
 
-    for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
-        bool useBLOrigin = kBottomLeft_GrSurfaceOrigin == origin;
-
+    for (int origin = 0; origin < 2; ++origin) {
         GrGLuint rectTexID = glContext->createTextureRectangle(kWidth, kHeight, GR_GL_RGBA,
                                                                GR_GL_RGBA, GR_GL_UNSIGNED_BYTE,
                                                                pixels);
@@ -119,19 +116,25 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
         rectangleInfo.fID = rectTexID;
         rectangleInfo.fTarget = GR_GL_TEXTURE_RECTANGLE;
 
-        GrBackendTexture rectangleTex(kWidth, kHeight, kRGBA_8888_GrPixelConfig, &rectangleInfo);
+        GrBackendTextureDesc rectangleDesc;
+        rectangleDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
+        rectangleDesc.fConfig = kRGBA_8888_GrPixelConfig;
+        rectangleDesc.fWidth = kWidth;
+        rectangleDesc.fHeight = kHeight;
+        rectangleDesc.fOrigin = origin ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
+        rectangleDesc.fTextureHandle = reinterpret_cast<GrBackendObject>(&rectangleInfo);
 
         GrColor refPixels[kWidth * kHeight];
+        bool flipRef = rectangleDesc.fOrigin == kBottomLeft_GrSurfaceOrigin;
         for (int y = 0; y < kHeight; ++y) {
             for (int x = 0; x < kWidth; ++x) {
-                int y0 = useBLOrigin ? kHeight - y - 1 : y;
+                int y0 = flipRef ? kHeight - y - 1 : y;
                 refPixels[y * kWidth + x] = pixels[y0 * kWidth + x];
             }
         }
 
-        sk_sp<GrTextureProxy> rectProxy = GrSurfaceProxy::MakeWrappedBackend(context,
-                                                                             rectangleTex,
-                                                                             origin);
+        sk_sp<GrSurfaceProxy> rectProxy = GrSurfaceProxy::MakeWrappedBackend(context,
+                                                                             rectangleDesc);
         if (!rectProxy) {
             ERRORF(reporter, "Error creating proxy for rectangle texture.");
             GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 17e02ba193..07369380af 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -11,7 +11,6 @@
 #if SK_SUPPORT_GPU
 #include <thread>
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrContextFactory.h"
 #include "GrGpu.h"
 #include "GrGpuResourceCacheAccess.h"
@@ -219,32 +218,22 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxI
 
     context->resetContext();
 
-    GrBackendTexture backendTex1 = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                                kW,
-                                                                kH,
-                                                                kRGBA_8888_GrPixelConfig,
-                                                                texHandles[0]);
+    GrBackendTextureDesc desc;
+    desc.fConfig = kBGRA_8888_GrPixelConfig;
+    desc.fWidth = kW;
+    desc.fHeight = kH;
+
+    desc.fTextureHandle = texHandles[0];
     sk_sp<GrTexture> borrowed(context->resourceProvider()->wrapBackendTexture(
-                              backendTex1, kTopLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 0,
-                              kBorrow_GrWrapOwnership));
-
-    GrBackendTexture backendTex2 = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                                kW,
-                                                                kH,
-                                                                kRGBA_8888_GrPixelConfig,
-                                                                texHandles[1]);
+                              desc, kBorrow_GrWrapOwnership));
+
+    desc.fTextureHandle = texHandles[1];
     sk_sp<GrTexture> adopted(context->resourceProvider()->wrapBackendTexture(
-                             backendTex2, kTopLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 0,
-                             kAdopt_GrWrapOwnership));
-
-    GrBackendTexture backendTex3 = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                                kW,
-                                                                kH,
-                                                                kRGBA_8888_GrPixelConfig,
-                                                                texHandles[2]);
+                             desc, kAdopt_GrWrapOwnership));
+
+    desc.fTextureHandle = texHandles[2];
     sk_sp<GrTexture> adoptedAndCached(context->resourceProvider()->wrapBackendTexture(
-                             backendTex3, kTopLeft_GrSurfaceOrigin, kNone_GrBackendTextureFlag, 0,
-                             kAdoptAndCache_GrWrapOwnership));
+                                      desc, kAdoptAndCache_GrWrapOwnership));
 
     REPORTER_ASSERT(reporter, borrowed != nullptr && adopted != nullptr &&
                               adoptedAndCached != nullptr);
diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp
index 58ced7ebc0..e236928da7 100644
--- a/tests/SurfaceTest.cpp
+++ b/tests/SurfaceTest.cpp
@@ -25,7 +25,6 @@
 #include "GrRenderTargetContext.h"
 #include "GrGpu.h"
 #include "GrResourceProvider.h"
-#include "GrTest.h"
 #include <vector>
 #endif
 
@@ -588,24 +587,20 @@ static sk_sp<SkSurface> create_gpu_surface_backend_texture(
     const int kHeight = 10;
     std::unique_ptr<uint32_t[]> pixels(new uint32_t[kWidth * kHeight]);
     sk_memset32(pixels.get(), color, kWidth * kHeight);
-
-    GrBackendObject backendHandle = context->getGpu()->createTestingOnlyBackendTexture(
+    GrBackendTextureDesc desc;
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+    desc.fWidth = kWidth;
+    desc.fHeight = kHeight;
+    desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+    desc.fTextureHandle = context->getGpu()->createTestingOnlyBackendTexture(
         pixels.get(), kWidth, kHeight, kRGBA_8888_GrPixelConfig, true);
-
-    GrBackendTexture backendTex = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                               kWidth,
-                                                               kHeight,
-                                                               kRGBA_8888_GrPixelConfig,
-                                                               backendHandle);
-
-    sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(context, backendTex,
-                                                                 kDefault_GrSurfaceOrigin, sampleCnt,
-                                                                 nullptr, nullptr);
+    desc.fSampleCnt = sampleCnt;
+    sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(context, desc, nullptr);
     if (!surface) {
-        context->getGpu()->deleteTestingOnlyBackendTexture(backendHandle);
+        context->getGpu()->deleteTestingOnlyBackendTexture(desc.fTextureHandle);
         return nullptr;
     }
-    *outTexture = backendHandle;
+    *outTexture = desc.fTextureHandle;
     return surface;
 }
 
@@ -615,23 +610,21 @@ static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
     const int kHeight = 10;
     std::unique_ptr<uint32_t[]> pixels(new uint32_t[kWidth * kHeight]);
     sk_memset32(pixels.get(), color, kWidth * kHeight);
-
-    GrBackendObject backendHandle = context->getGpu()->createTestingOnlyBackendTexture(
+    GrBackendTextureDesc desc;
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+    desc.fWidth = kWidth;
+    desc.fHeight = kHeight;
+    desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+    desc.fTextureHandle = context->getGpu()->createTestingOnlyBackendTexture(
         pixels.get(), kWidth, kHeight, kRGBA_8888_GrPixelConfig, true);
-
-    GrBackendTexture backendTex = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                               kWidth,
-                                                               kHeight,
-                                                               kRGBA_8888_GrPixelConfig,
-                                                               backendHandle);
-    sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTextureAsRenderTarget(
-            context, backendTex, kDefault_GrSurfaceOrigin, sampleCnt, nullptr, nullptr);
-
+    desc.fSampleCnt = sampleCnt;
+    sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTextureAsRenderTarget(context, desc,
+                                                                               nullptr);
     if (!surface) {
-        context->getGpu()->deleteTestingOnlyBackendTexture(backendHandle);
+        context->getGpu()->deleteTestingOnlyBackendTexture(desc.fTextureHandle);
         return nullptr;
     }
-    *outTexture = backendHandle;
+    *outTexture = desc.fTextureHandle;
     return surface;
 }
 
@@ -886,26 +879,21 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCreationWithColorSpace_Gpu, reporter,
 
     std::vector<GrBackendObject> textureHandles;
     auto wrappedSurfaceMaker = [context,&textureHandles](const SkImageInfo& info) {
-        static const int kSize = 10;
-        GrPixelConfig config = SkImageInfo2GrPixelConfig(info, *context->caps());
-
-        GrBackendObject backendHandle = context->getGpu()->createTestingOnlyBackendTexture(
-                nullptr, kSize, kSize, config, true);
-
-        if (!backendHandle) {
+        GrBackendTextureDesc desc;
+        desc.fConfig = SkImageInfo2GrPixelConfig(info, *context->caps());
+        desc.fWidth = 10;
+        desc.fHeight = 10;
+        desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+        desc.fTextureHandle = context->getGpu()->createTestingOnlyBackendTexture(
+            nullptr, desc.fWidth, desc.fHeight, desc.fConfig, true);
+
+        if (!desc.fTextureHandle) {
             return sk_sp<SkSurface>(nullptr);
         }
-        textureHandles.push_back(backendHandle);
-
-        GrBackendTexture backendTex = GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
-                                                                   kSize,
-                                                                   kSize,
-                                                                   config,
-                                                                   backendHandle);
+        textureHandles.push_back(desc.fTextureHandle);
 
-        return SkSurface::MakeFromBackendTexture(context, backendTex,
-                                                 kDefault_GrSurfaceOrigin, 0,
-                                                 sk_ref_sp(info.colorSpace()), nullptr);
+        return SkSurface::MakeFromBackendTexture(context, desc, sk_ref_sp(info.colorSpace()),
+                                                 nullptr);
     };
 
     test_surface_creation_and_snapshot_with_color_space(reporter, "wrapped", f16Support,
diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp
index 44b5e72bc9..9279ef6895 100644
--- a/tests/VkWrapTests.cpp
+++ b/tests/VkWrapTests.cpp
@@ -31,56 +31,37 @@ void wrap_tex_test(skiatest::Reporter* reporter, GrContext* context) {
 
     GrBackendObject backendObj = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH, kPixelConfig,
                                                                       false);
-    const GrVkImageInfo* imageInfo = reinterpret_cast<const GrVkImageInfo*>(backendObj);
-
-    GrBackendTexture backendTex = GrBackendTexture(kW, kH, imageInfo);
-    sk_sp<GrTexture> tex = gpu->wrapBackendTexture(backendTex,
-                                                   kTopLeft_GrSurfaceOrigin,
-                                                   kNone_GrBackendTextureFlag,
-                                                   0,
-                                                   kBorrow_GrWrapOwnership);
+    const GrVkImageInfo* backendTex = reinterpret_cast<const GrVkImageInfo*>(backendObj);
+
+    // check basic borrowed creation
+    GrBackendTextureDesc desc;
+    desc.fConfig = kPixelConfig;
+    desc.fWidth = kW;
+    desc.fHeight = kH;
+    desc.fTextureHandle = backendObj;
+    sk_sp<GrTexture> tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
     // image is null
-    GrVkImageInfo backendCopy = *imageInfo;
+    GrVkImageInfo backendCopy = *backendTex;
     backendCopy.fImage = VK_NULL_HANDLE;
-    backendTex = GrBackendTexture(kW, kH, &backendCopy);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
-                                  kBorrow_GrWrapOwnership);
+    desc.fTextureHandle = (GrBackendObject) &backendCopy;
+    tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    tex = gpu->wrapBackendTexture(desc, kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
 
     // alloc is null
-    backendCopy.fImage = imageInfo->fImage;
+    backendCopy.fImage = backendTex->fImage;
     backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
-                                  kBorrow_GrWrapOwnership);
+    tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    tex = gpu->wrapBackendTexture(desc, kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
-    // check adopt creation
-    backendCopy.fAlloc = imageInfo->fAlloc;
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kNone_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
 
+    // check adopt creation
+    backendCopy.fAlloc = backendTex->fAlloc;
+    tex = gpu->wrapBackendTexture(desc, kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
     gpu->deleteTestingOnlyBackendTexture(backendObj, true);
@@ -129,56 +110,38 @@ void wrap_trt_test(skiatest::Reporter* reporter, GrContext* context) {
 
     GrBackendObject backendObj = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH, kPixelConfig,
                                                                       true);
-    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);
+    const GrVkImageInfo* backendTex = reinterpret_cast<const GrVkImageInfo*>(backendObj);
+
+    // check basic borrowed creation
+    GrBackendTextureDesc desc;
+    desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+    desc.fConfig = kPixelConfig;
+    desc.fWidth = kW;
+    desc.fHeight = kH;
+    desc.fTextureHandle = backendObj;
+    sk_sp<GrTexture> tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
     // image is null
-    GrVkImageInfo backendCopy = *imageInfo;
+    GrVkImageInfo backendCopy = *backendTex;
     backendCopy.fImage = VK_NULL_HANDLE;
-    backendTex = GrBackendTexture(kW, kH, &backendCopy);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kBorrow_GrWrapOwnership);
+    desc.fTextureHandle = (GrBackendObject)&backendCopy;
+    tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    tex = gpu->wrapBackendTexture(desc, kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
 
     // alloc is null
-    backendCopy.fImage = imageInfo->fImage;
+    backendCopy.fImage = backendTex->fImage;
     backendCopy.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kBorrow_GrWrapOwnership);
+    tex = gpu->wrapBackendTexture(desc, kBorrow_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    tex = gpu->wrapBackendTexture(desc, kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, !tex);
 
     // check adopt creation
-    backendCopy.fAlloc = imageInfo->fAlloc;
-    tex = gpu->wrapBackendTexture(backendTex,
-                                  kTopLeft_GrSurfaceOrigin,
-                                  kRenderTarget_GrBackendTextureFlag,
-                                  0,
-                                  kAdopt_GrWrapOwnership);
+    backendCopy.fAlloc = backendTex->fAlloc;
+    tex = gpu->wrapBackendTexture(desc, kAdopt_GrWrapOwnership);
     REPORTER_ASSERT(reporter, tex);
 
     gpu->deleteTestingOnlyBackendTexture(backendObj, true);