Revert "Rm readPixels from GrSurface & move read/writeSurfacePixels to GrContextPriv (take 2)"

This reverts commit aaee31f18c0845417103d84285e365575def3c40.

Reason for revert: possible valgrind leak

Original change's description:
> Rm readPixels from GrSurface & move read/writeSurfacePixels to GrContextPriv (take 2)
> 
> This is in service of: https://skia-review.googlesource.com/c/11125/ (Add parallel proxyID to StencilOps & RenderTargetOpList) where I want a better choke point for texture creation to improve discard handling.
> 
> This is a reland of: https://skia-review.googlesource.com/c/11200/ (Rm readPixels from GrSurface & move read/writeSurfacePixels to GrContextPriv)
> 
> Change-Id: Icd0a90d2beb483dc24ed87c3bace9c817019e148
> Reviewed-on: https://skia-review.googlesource.com/11326
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Robert Phillips <robertphillips@google.com>
> 

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

Change-Id: Ia0b92bf6402cb5f9607310d356f43bff2e3e75eb
Reviewed-on: https://skia-review.googlesource.com/11361
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

16 files changed, 163 insertions, 224 deletions

diff --git a/tests/BlendTest.cpp b/tests/BlendTest.cpp
index 2d16fb2ff2..193c37dd4a 100644
--- a/tests/BlendTest.cpp
+++ b/tests/BlendTest.cpp
@@ -92,7 +92,8 @@ static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
     backingDesc.fOrigin = kDefault_GrSurfaceOrigin;
     backingDesc.fFlags = kRenderTarget_GrSurfaceFlag;
 
-    *backingSurface = context->resourceProvider()->createTexture(backingDesc, SkBudgeted::kNo);
+    (*backingSurface)
+            .reset(context->resourceProvider()->createTexture(backingDesc, SkBudgeted::kNo));
 
     GrBackendTextureDesc desc;
     desc.fConfig = config;
diff --git a/tests/FloatingPointTextureTest.cpp b/tests/FloatingPointTextureTest.cpp
index 5adc2e7892..4214e4eebf 100644
--- a/tests/FloatingPointTextureTest.cpp
+++ b/tests/FloatingPointTextureTest.cpp
@@ -17,7 +17,6 @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrResourceProvider.h"
 #include "GrTexture.h"
 #include "SkHalf.h"
@@ -52,18 +51,14 @@ void runFPTest(skiatest::Reporter* reporter, GrContext* context,
         desc.fHeight = DEV_H;
         desc.fConfig = config;
         desc.fOrigin = 0 == origin ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
-        sk_sp<GrTextureProxy> fpProxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
-                                                                     desc, SkBudgeted::kNo,
-                                                                     controlPixelData.begin(), 0);
+        sk_sp<GrTexture> fpTexture(context->resourceProvider()->createTexture(
+            desc, SkBudgeted::kNo, controlPixelData.begin(), 0));
         // Floating point textures are NOT supported everywhere
-        if (!fpProxy) {
+        if (nullptr == fpTexture) {
             continue;
         }
-        bool result = context->contextPriv().readSurfacePixels(fpProxy.get(), nullptr,
-                                                               0, 0, DEV_W, DEV_H,
-                                                               desc.fConfig, nullptr,
-                                                               readBuffer.begin(), 0);
-        REPORTER_ASSERT(reporter, result);
+        REPORTER_ASSERT(reporter,
+                        fpTexture->readPixels(0, 0, DEV_W, DEV_H, desc.fConfig, readBuffer.begin(), 0));
         REPORTER_ASSERT(reporter,
                         0 == memcmp(readBuffer.begin(), controlPixelData.begin(), readBuffer.bytes()));
     }
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 5400d92bc6..489aec1391 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -285,30 +285,28 @@ bool GrDrawingManager::ProgramUnitTest(GrContext*, int) { return true; }
 bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
     GrDrawingManager* drawingManager = context->contextPriv().drawingManager();
 
-    sk_sp<GrTextureProxy> proxies[2];
-
     // setup dummy textures
     GrSurfaceDesc dummyDesc;
     dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
-    dummyDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
     dummyDesc.fConfig = kRGBA_8888_GrPixelConfig;
     dummyDesc.fWidth = 34;
     dummyDesc.fHeight = 18;
-    proxies[0] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
-                                              dummyDesc, SkBudgeted::kNo, nullptr, 0);
+    sk_sp<GrTexture> dummyTexture1(
+        context->resourceProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
     dummyDesc.fFlags = kNone_GrSurfaceFlags;
-    dummyDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
     dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
     dummyDesc.fWidth = 16;
     dummyDesc.fHeight = 22;
-    proxies[1] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
-                                              dummyDesc, SkBudgeted::kNo, nullptr, 0);
+    sk_sp<GrTexture> dummyTexture2(
+        context->resourceProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
 
-    if (!proxies[0] || !proxies[1]) {
+    if (!dummyTexture1 || ! dummyTexture2) {
         SkDebugf("Could not allocate dummy textures");
         return false;
     }
 
+    GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
+
     // dummy scissor state
     GrScissorState scissor;
 
@@ -328,7 +326,7 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
         std::unique_ptr<GrLegacyMeshDrawOp> op(GrRandomDrawOp(&random, context));
         SkASSERT(op);
 
-        GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
+        GrProcessorTestData ptd(&random, context, renderTargetContext.get(), dummyTextures);
         set_random_color_coverage_stages(&grPaint, &ptd, maxStages);
         set_random_xpf(&grPaint, &ptd);
         bool snapToCenters = set_random_state(&grPaint, &random);
@@ -362,7 +360,7 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
         for (int j = 0; j < 10; ++j) {
             std::unique_ptr<GrLegacyMeshDrawOp> op(GrRandomDrawOp(&random, context));
             SkASSERT(op);
-            GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
+            GrProcessorTestData ptd(&random, context, renderTargetContext.get(), dummyTextures);
             GrPaint grPaint;
             grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
 
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 97700b1a85..d98d0d0428 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -27,10 +27,11 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
     desc.fWidth = 256;
     desc.fHeight = 256;
     desc.fSampleCnt = 0;
-    sk_sp<GrSurface> texRT1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
+    GrSurface* texRT1 = context->resourceProvider()->createTexture(
+            desc, SkBudgeted::kNo, nullptr, 0);
 
-    REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asRenderTarget());
-    REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asTexture());
+    REPORTER_ASSERT(reporter, texRT1 == texRT1->asRenderTarget());
+    REPORTER_ASSERT(reporter, texRT1 == texRT1->asTexture());
     REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT1->asRenderTarget()) ==
                     texRT1->asTexture());
     REPORTER_ASSERT(reporter, texRT1->asRenderTarget() ==
@@ -39,10 +40,10 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
                     static_cast<GrSurface*>(texRT1->asTexture()));
 
     desc.fFlags = kNone_GrSurfaceFlags;
-    sk_sp<GrTexture> tex1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
+    GrSurface* tex1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, nullptr, 0);
     REPORTER_ASSERT(reporter, nullptr == tex1->asRenderTarget());
-    REPORTER_ASSERT(reporter, tex1.get() == tex1->asTexture());
-    REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1.get()) == tex1->asTexture());
+    REPORTER_ASSERT(reporter, tex1 == tex1->asTexture());
+    REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1) == tex1->asTexture());
 
     GrBackendObject backendTex = context->getGpu()->createTestingOnlyBackendTexture(
         nullptr, 256, 256, kRGBA_8888_GrPixelConfig);
@@ -65,6 +66,8 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
     REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT2->asRenderTarget()) ==
                     static_cast<GrSurface*>(texRT2->asTexture()));
 
+    texRT1->unref();
+    tex1->unref();
     context->getGpu()->deleteTestingOnlyBackendTexture(backendTex);
 }
 
diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index 95ade044bd..fe67925fda 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -181,6 +181,18 @@ DEF_TEST(ImageFilterCache_ImageBackedRaster, reporter) {
 #include "GrContext.h"
 #include "GrResourceProvider.h"
 
+static GrTexture* create_texture(GrContext* context) {
+    SkBitmap srcBM = create_bm();
+
+    GrSurfaceDesc desc;
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+    desc.fFlags  = kNone_GrSurfaceFlags;
+    desc.fWidth  = kFullSize;
+    desc.fHeight = kFullSize;
+
+    return context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, srcBM.getPixels(), 0);
+}
+
 static sk_sp<GrTextureProxy> create_proxy(GrResourceProvider* resourceProvider) {
     SkBitmap srcBM = create_bm();
 
@@ -196,16 +208,10 @@ static sk_sp<GrTextureProxy> create_proxy(GrResourceProvider* resourceProvider)
                                         srcBM.rowBytes());
 }
 
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
-    GrContext* context = ctxInfo.grContext();
 
-    sk_sp<GrTextureProxy> srcProxy(create_proxy(context->resourceProvider()));
-    if (!srcProxy) {
-        return;
-    }
-
-    GrTexture* tex = srcProxy->instantiate(context->resourceProvider());
-    if (!tex) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
+    sk_sp<GrTexture> srcTexture(create_texture(ctxInfo.grContext()));
+    if (!srcTexture) {
         return;
     }
 
@@ -216,8 +222,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ct
     backendDesc.fWidth = kFullSize;
     backendDesc.fHeight = kFullSize;
     backendDesc.fSampleCnt = 0;
-    backendDesc.fTextureHandle = tex->getTextureHandle();
-    sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(context,
+    backendDesc.fTextureHandle = srcTexture->getTextureHandle();
+    sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(ctxInfo.grContext(),
                                                      backendDesc,
                                                      kPremul_SkAlphaType));
     if (!srcImage) {
diff --git a/tests/ImageStorageTest.cpp b/tests/ImageStorageTest.cpp
index f3e3482b07..59bb38b02a 100644
--- a/tests/ImageStorageTest.cpp
+++ b/tests/ImageStorageTest.cpp
@@ -20,17 +20,9 @@
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
     class TestFP : public GrFragmentProcessor {
     public:
-        static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
-                                               sk_sp<GrTextureProxy> proxy,
-                                               GrSLMemoryModel mm,
+        static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTexture> texture, GrSLMemoryModel mm,
                                                GrSLRestrict restrict) {
-            // MDB TODO: remove this once ImageStorageAccess is converted to GrTextureProxy
-            sk_sp<GrTexture> tex(sk_ref_sp(proxy->instantiate(resourceProvider)));
-            if (!tex) {
-                return nullptr;
-            }
-
-            return sk_sp<GrFragmentProcessor>(new TestFP(std::move(tex), mm, restrict));
+            return sk_sp<GrFragmentProcessor>(new TestFP(std::move(texture), mm, restrict));
         }
 
         const char* name() const override { return "Image Load Test FP"; }
@@ -135,17 +127,15 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
                     continue;
                 }
                 desc.fConfig = test.fConfig;
-                sk_sp<GrTextureProxy> imageStorageTexture =
-                    GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc,
-                                                 SkBudgeted::kYes, test.fData.get(), 0);
+                sk_sp<GrTexture> imageStorageTexture(context->resourceProvider()->createTexture(
+                        desc, SkBudgeted::kYes, test.fData.get(), 0));
 
                 sk_sp<GrRenderTargetContext> rtContext =
                     context->makeRenderTargetContext(SkBackingFit::kExact, kS, kS,
                                                      kRGBA_8888_GrPixelConfig, nullptr);
                 GrPaint paint;
                 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
-                paint.addColorFragmentProcessor(TestFP::Make(context->resourceProvider(),
-                                                             imageStorageTexture, mm, restrict));
+                paint.addColorFragmentProcessor(TestFP::Make(imageStorageTexture, mm, restrict));
                 rtContext->drawPaint(GrNoClip(), std::move(paint), SkMatrix::I());
                 std::unique_ptr<uint32_t[]> readData(new uint32_t[kS * kS]);
                 SkImageInfo info = SkImageInfo::Make(kS, kS, kRGBA_8888_SkColorType,
diff --git a/tests/IntTextureTest.cpp b/tests/IntTextureTest.cpp
index eacd0617a2..8ef57318ed 100644
--- a/tests/IntTextureTest.cpp
+++ b/tests/IntTextureTest.cpp
@@ -10,7 +10,6 @@
 #if SK_SUPPORT_GPU
 #include "GrClip.h"
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrRenderTargetContext.h"
 #include "GrResourceProvider.h"
 #include "GrTexture.h"
@@ -65,8 +64,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
         levels[1].fPixels = testData.get();
         levels[1].fRowBytes = (kS / 2) * sizeof(int32_t);
 
-        sk_sp<GrTextureProxy> temp(context->resourceProvider()->createMipMappedTexture(
-                                                                                  desc,
+        sk_sp<GrTexture> temp(context->resourceProvider()->createMipMappedTexture(desc,
                                                                                   SkBudgeted::kYes,
                                                                                   levels, 2));
         REPORTER_ASSERT(reporter, !temp);
@@ -82,21 +80,21 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
         return;
     }
 
+    GrTexture* texture = proxy->instantiate(context->resourceProvider());
+    REPORTER_ASSERT(reporter, texture);
+    if (!texture) {
+        return;
+    }
+
     std::unique_ptr<int32_t[]> readData(new int32_t[kS * kS]);
     // Test that reading to a non-integer config fails.
     {
-        bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
-                                                                0, 0, kS, kS,
-                                                                kRGBA_8888_GrPixelConfig,
-                                                                nullptr, readData.get());
+        bool success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_GrPixelConfig, readData.get());
         REPORTER_ASSERT(reporter, !success);
     }
     {
         std::unique_ptr<uint16_t[]> halfData(new uint16_t[4 * kS * kS]);
-        bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
-                                                                0, 0, kS, kS,
-                                                                kRGBA_half_GrPixelConfig,
-                                                                nullptr, halfData.get());
+        bool success = texture->readPixels(0, 0, kS, kS, kRGBA_half_GrPixelConfig, halfData.get());
         REPORTER_ASSERT(reporter, !success);
     }
     {
@@ -104,10 +102,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
         // we don't support. Right now this test is counting on GR_RGBA_INTEGER/GL_BYTE being the
         // implementation-dependent second format).
         sk_bzero(readData.get(), sizeof(int32_t) * kS * kS);
-        bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
-                                                                0, 0, kS, kS,
-                                                                kRGBA_8888_sint_GrPixelConfig,
-                                                                nullptr, readData.get());
+        bool success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig,
+                                           readData.get());
         REPORTER_ASSERT(reporter, success);
         if (success) {
             check_pixels(reporter, kS, kS, testData.get(), readData.get(), "readPixels");
@@ -115,12 +111,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
     }
     {
         // readPixels should fail if we attempt to use the unpremul flag with an integer texture.
-        bool success = context->contextPriv().readSurfacePixels(
-                                                proxy.get(), nullptr,
-                                                0, 0, kS, kS,
-                                                kRGBA_8888_sint_GrPixelConfig,
-                                                nullptr, readData.get(), 0,
-                                                GrContextPriv::kUnpremul_PixelOpsFlag);
+        bool success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig,
+                                           readData.get(), 0, GrContext::kUnpremul_PixelOpsFlag);
         REPORTER_ASSERT(reporter, !success);
     }
 
@@ -133,11 +125,16 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
             return;
         }
 
+        GrSurface* copySurface = dstContext->asTextureProxy()->instantiate(
+                                                                    context->resourceProvider());
+        REPORTER_ASSERT(reporter, copySurface);
+        if (!copySurface) {
+            return;
+        }
+
         sk_bzero(readData.get(), sizeof(int32_t) * kS * kS);
-        bool success = context->contextPriv().readSurfacePixels(dstContext->asSurfaceProxy(),
-                                                                nullptr, 0, 0, kS, kS,
-                                                                kRGBA_8888_sint_GrPixelConfig,
-                                                                nullptr, readData.get());
+        bool success = copySurface->readPixels(0, 0, kS, kS,
+                                               kRGBA_8888_sint_GrPixelConfig, readData.get());
         REPORTER_ASSERT(reporter, success);
         if (success) {
             check_pixels(reporter, kS, kS, testData.get(), readData.get(), "copyIntegerToInteger");
@@ -171,39 +168,27 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
 
     {
         // Can't write pixels from a non-int config.
-        bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
-                                                                 0, 0, kS/2, kS/2,
-                                                                 kRGBA_8888_GrPixelConfig, nullptr,
-                                                                 bottomRightQuarter, kRowBytes);
+        bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_GrPixelConfig,
+                                            bottomRightQuarter, kRowBytes);
         REPORTER_ASSERT(reporter, !success);
     }
     {
         // Can't use unpremul flag.
-        bool success = context->contextPriv().writeSurfacePixels(
-                                            proxy.get(), nullptr,
-                                            0, 0, kS/2, kS/2,
-                                            kRGBA_8888_sint_GrPixelConfig,
-                                            nullptr,
+        bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_sint_GrPixelConfig,
                                             bottomRightQuarter, kRowBytes,
-                                            GrContextPriv::kUnpremul_PixelOpsFlag);
+                                            GrContext::kUnpremul_PixelOpsFlag);
         REPORTER_ASSERT(reporter, !success);
     }
     {
-        bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
-                                                                 0, 0, kS/2, kS/2,
-                                                                 kRGBA_8888_sint_GrPixelConfig,
-                                                                 nullptr,
-                                                                 bottomRightQuarter, kRowBytes);
+        bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_sint_GrPixelConfig,
+                                            bottomRightQuarter, kRowBytes);
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             return;
         }
 
         sk_bzero(readData.get(), sizeof(int32_t) * kS * kS);
-        success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
-                                                           0, 0, kS, kS,
-                                                           kRGBA_8888_sint_GrPixelConfig,
-                                                           nullptr, readData.get(), 0);
+        success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig, readData.get());
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             return;
@@ -234,10 +219,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
         expectedData.get()[i] = ((0xFF * a) << 24) | ((0xFF * b) << 16) |
                                 ((0xFF * g) << 8) | (0xFF * r);
     }
-    context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
-                                              0, 0, kS, kS,
-                                              kRGBA_8888_sint_GrPixelConfig, nullptr,
-                                              testData.get(), 0);
+    texture->writePixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig, testData.get());
+
+    sk_sp<GrTextureProxy> intTextureProxy = GrSurfaceProxy::MakeWrapped(sk_ref_sp(texture));
+    texture = nullptr; // unused from here on out
 
     sk_sp<GrRenderTargetContext> rtContext = context->makeRenderTargetContext(
             SkBackingFit::kExact, kS, kS, kRGBA_8888_GrPixelConfig, nullptr);
@@ -253,7 +238,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
 
     for (auto filter : kNamedFilters) {
         sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(context->resourceProvider(),
-                                                                  proxy, nullptr,
+                                                                  intTextureProxy, nullptr,
                                                                   SkMatrix::I(),
                                                                   filter.fMode));
         REPORTER_ASSERT(reporter, fp);
diff --git a/tests/PackedConfigsTextureTest.cpp b/tests/PackedConfigsTextureTest.cpp
index 35d9dfc3c5..7a51651e7f 100644
--- a/tests/PackedConfigsTextureTest.cpp
+++ b/tests/PackedConfigsTextureTest.cpp
@@ -15,7 +15,6 @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrResourceProvider.h"
 #include "GrTexture.h"
 
@@ -117,13 +116,10 @@ void runTest(skiatest::Reporter* reporter, GrContext* context,
         desc.fHeight = DEV_H;
         desc.fConfig = config;
         desc.fOrigin = 0 == origin ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
-        sk_sp<GrTextureProxy> fpProxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
-                                                                     desc, SkBudgeted::kNo,
-                                                                     controlPixelData.begin(), 0);
-        SkASSERT(fpProxy);
-        context->contextPriv().readSurfacePixels(fpProxy.get(), nullptr, 0, 0, DEV_W, DEV_H,
-                                                 kRGBA_8888_GrPixelConfig, nullptr,
-                                                 readBuffer.begin(), 0);
+        sk_sp<GrTexture> fpTexture(context->resourceProvider()->createTexture(
+            desc, SkBudgeted::kNo, controlPixelData.begin(), 0));
+        SkASSERT(fpTexture);
+        fpTexture->readPixels(0, 0, DEV_W, DEV_H, kRGBA_8888_GrPixelConfig, readBuffer.begin(), 0);
         if (kRGBA_4444_GrPixelConfig == config) {
             check_4444(reporter, controlPixelData, readBuffer);
         } else {
diff --git a/tests/ProcessorTest.cpp b/tests/ProcessorTest.cpp
index 3eb4e16f20..b8691f2689 100644
--- a/tests/ProcessorTest.cpp
+++ b/tests/ProcessorTest.cpp
@@ -146,12 +146,12 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
                                                                       desc,
                                                                       SkBackingFit::kExact,
                                                                       SkBudgeted::kYes));
-            sk_sp<GrTexture> texture2 =
-                    context->resourceProvider()->createTexture(desc, SkBudgeted::kYes);
-            sk_sp<GrTexture> texture3 =
-                    context->resourceProvider()->createTexture(desc, SkBudgeted::kYes);
-            sk_sp<GrTexture> texture4 =
-                    context->resourceProvider()->createTexture(desc, SkBudgeted::kYes);
+            sk_sp<GrTexture> texture2(
+                    context->resourceProvider()->createTexture(desc, SkBudgeted::kYes));
+            sk_sp<GrTexture> texture3(
+                    context->resourceProvider()->createTexture(desc, SkBudgeted::kYes));
+            sk_sp<GrTexture> texture4(
+                    context->resourceProvider()->createTexture(desc, SkBudgeted::kYes));
             sk_sp<GrBuffer> buffer(texelBufferSupport
                                            ? context->resourceProvider()->createBuffer(
                                                      1024, GrBufferType::kTexel_GrBufferType,
@@ -298,8 +298,6 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
-    sk_sp<GrTextureProxy> proxies[2];
-
     // Put premul data into the RGBA texture that the test FPs can optionally use.
     std::unique_ptr<GrColor[]> rgbaData(new GrColor[256 * 256]);
     for (int y = 0; y < 256; ++y) {
@@ -308,8 +306,8 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
                     texel_color(random.nextULessThan(256), random.nextULessThan(256));
         }
     }
-    proxies[0] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kYes,
-                                              rgbaData.get(), 256 * sizeof(GrColor));
+    sk_sp<GrTexture> tex0(context->resourceProvider()->createTexture(
+            desc, SkBudgeted::kYes, rgbaData.get(), 256 * sizeof(GrColor)));
 
     // Put random values into the alpha texture that the test FPs can optionally use.
     desc.fConfig = kAlpha_8_GrPixelConfig;
@@ -319,9 +317,10 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
             alphaData.get()[256 * y + x] = random.nextULessThan(256);
         }
     }
-    proxies[1] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kYes,
-                                              alphaData.get(), 256);
-    GrProcessorTestData testData(&random, context, rtc.get(), proxies);
+    sk_sp<GrTexture> tex1(context->resourceProvider()->createTexture(desc, SkBudgeted::kYes,
+                                                                     alphaData.get(), 256));
+    GrTexture* textures[] = {tex0.get(), tex1.get()};
+    GrProcessorTestData testData(&random, context, rtc.get(), textures);
 
     // Use a different array of premul colors for the output of the fragment processor that preceeds
     // the fragment processor under test.
diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp
index 7657e28f5a..648ae1d6c8 100644
--- a/tests/ProxyTest.cpp
+++ b/tests/ProxyTest.cpp
@@ -137,7 +137,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
                                 if (SkBackingFit::kApprox == fit) {
                                     tex.reset(provider->createApproxTexture(desc, 0));
                                 } else {
-                                    tex = provider->createTexture(desc, budgeted);
+                                    tex.reset(provider->createTexture(desc, budgeted));
                                 }
 
                                 sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
@@ -170,7 +170,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
                                 if (SkBackingFit::kApprox == fit) {
                                     tex.reset(provider->createApproxTexture(desc, 0));
                                 } else {
-                                    tex = provider->createTexture(desc, budgeted);
+                                    tex.reset(provider->createTexture(desc, budgeted));
                                 }
 
                                 sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(provider,
@@ -249,7 +249,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
                     // Internal offscreen render target.
                     if (renderable) {
                         desc.fFlags = kRenderTarget_GrSurfaceFlag;
-                        tex = provider->createTexture(desc, budgeted);
+                        tex.reset(provider->createTexture(desc, budgeted));
                         sk_sp<GrRenderTarget> rt(sk_ref_sp(tex->asRenderTarget()));
 
                         sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(rt));
@@ -264,7 +264,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
                     if (!tex) {
                         SkASSERT(kNone_GrSurfaceFlags == desc.fFlags );
                         desc.fSampleCnt = 0;
-                        tex = provider->createTexture(desc, budgeted);
+                        tex.reset(provider->createTexture(desc, budgeted));
                     }
 
                     sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(tex));
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index c67e62b090..774f0af06a 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -16,7 +16,6 @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "GrContextPriv.h"
 #include "GrResourceProvider.h"
 #include "SkGr.h"
 #endif
@@ -124,16 +123,11 @@ static void fill_src_canvas(SkCanvas* canvas) {
 }
 
 #if SK_SUPPORT_GPU
-static void fill_src_texture(GrContext* context, GrTextureProxy* proxy) {
+static void fill_src_texture(GrTexture* texture) {
     SkBitmap bmp = make_src_bitmap();
     bmp.lockPixels();
-
-    SkDEBUGCODE(bool result =) context->contextPriv().writeSurfacePixels(
-                                                            proxy, nullptr,
-                                                            0, 0, DEV_W, DEV_H,
-                                                            kSkia8888_GrPixelConfig, nullptr,
-                                                            bmp.getPixels(), bmp.rowBytes());
-    SkASSERT(result);
+    texture->writePixels(0, 0, DEV_W, DEV_H, kSkia8888_GrPixelConfig, bmp.getPixels(),
+                         bmp.rowBytes());
     bmp.unlockPixels();
 }
 #endif
@@ -442,9 +436,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Gpu, reporter, ctxInfo) {
 #endif
 
 #if SK_SUPPORT_GPU
-static void test_readpixels_texture(skiatest::Reporter* reporter,
-                                    GrContext* context, sk_sp<GrTextureProxy> proxy) {
-    fill_src_texture(context, proxy.get());
+static void test_readpixels_texture(skiatest::Reporter* reporter, GrTexture* texture) {
+    fill_src_texture(texture);
     for (size_t rect = 0; rect < SK_ARRAY_COUNT(gReadPixelsTestRects); ++rect) {
         const SkIRect& srcRect = gReadPixelsTestRects[rect];
         for (BitmapInit bmi = kFirstBitmapInit; bmi <= kLast_BitmapInit; bmi = nextBMI(bmi)) {
@@ -459,18 +452,16 @@ static void test_readpixels_texture(skiatest::Reporter* reporter,
                 // Try doing the read directly from a non-renderable texture
                 if (startsWithPixels) {
                     fill_dst_bmp_with_init_data(&bmp);
-                    GrPixelConfig dstConfig = SkImageInfo2GrPixelConfig(bmp.info(),
-                                                                        *context->caps());
+                    GrPixelConfig dstConfig =
+                            SkImageInfo2GrPixelConfig(bmp.info(), *texture->getContext()->caps());
                     uint32_t flags = 0;
                     if (gReadPixelsConfigs[c].fAlphaType == kUnpremul_SkAlphaType) {
-                        flags = GrContextPriv::kUnpremul_PixelOpsFlag;
+                        flags = GrContext::kUnpremul_PixelOpsFlag;
                     }
                     bmp.lockPixels();
-                    bool success = context->contextPriv().readSurfacePixels(
-                                                       proxy.get(), nullptr,
-                                                       srcRect.fLeft, srcRect.fTop, bmp.width(),
-                                                       bmp.height(), dstConfig, nullptr,
-                                                       bmp.getPixels(), bmp.rowBytes(), flags);
+                    bool success = texture->readPixels(srcRect.fLeft, srcRect.fTop, bmp.width(),
+                                                       bmp.height(), dstConfig, bmp.getPixels(),
+                                                       bmp.rowBytes(), flags);
                     bmp.unlockPixels();
                     check_read(reporter, bmp, srcRect.fLeft, srcRect.fTop,
                                success, true,
@@ -490,10 +481,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Texture, reporter, ctxInfo) {
             desc.fHeight = DEV_H;
             desc.fConfig = kSkia8888_GrPixelConfig;
             desc.fOrigin = origin;
-            sk_sp<GrTexture> texture =
-                    ctxInfo.grContext()->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
-            test_readpixels_texture(reporter, ctxInfo.grContext(),
-                                    GrSurfaceProxy::MakeWrapped(std::move(texture)));
+            sk_sp<GrTexture> texture(ctxInfo.grContext()->resourceProvider()->createTexture(desc,
+                SkBudgeted::kNo));
+            test_readpixels_texture(reporter, texture.get());
         }
     }
 }
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index 2a68191a2d..ac34b9dc32 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -159,10 +159,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
                     rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]);
                 }
             }
-            sk_sp<GrTextureProxy> proxy =
-                GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kNo,
-                                             rgbaData, 0);
-            if (!proxy) {
+            sk_sp<GrTexture> texture(
+                context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, rgbaData, 0));
+            if (!texture) {
                 // We always expect to be able to create a RGBA texture
                 if (!rt  && kRGBA_8888_GrPixelConfig == desc.fConfig) {
                     ERRORF(reporter, "Failed to create RGBA texture.");
@@ -178,10 +177,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
                 memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE);
 
                 // read the texture back
-                bool result = context->contextPriv().readSurfacePixels(
-                                                  proxy.get(), nullptr,
-                                                  0, 0, desc.fWidth, desc.fHeight,
-                                                  kAlpha_8_GrPixelConfig, nullptr,
+                bool result = texture->readPixels(0, 0, desc.fWidth, desc.fHeight,
+                                                  kAlpha_8_GrPixelConfig,
                                                   readback.get(), rowBytes);
                 REPORTER_ASSERT_MESSAGE(reporter, result, "8888 readPixels failed");
 
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index fcf3fe88f3..a7a2b4540d 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -184,7 +184,7 @@ DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angl
             smallMSAART0 && smallMSAART0->asRenderTarget() &&
             smallMSAART0->asRenderTarget()->numColorSamples() < 8) {
             smallMSAADesc.fSampleCnt = 8;
-            smallMSAART1 = resourceProvider->createTexture(smallMSAADesc, SkBudgeted::kNo);
+            smallMSAART1.reset(resourceProvider->createTexture(smallMSAADesc, SkBudgeted::kNo));
             sk_sp<GrTexture> smallMSAART1(
                 resourceProvider->createTexture(smallMSAADesc, SkBudgeted::kNo));
             if (smallMSAART1 && smallMSAART1->asRenderTarget()) {
@@ -1514,13 +1514,13 @@ static sk_sp<GrTexture> make_normal_texture(GrResourceProvider* provider,
     desc.fConfig = kRGBA_8888_GrPixelConfig;
     desc.fSampleCnt = sampleCnt;
 
-    return provider->createTexture(desc, SkBudgeted::kYes);
+    return sk_sp<GrTexture>(provider->createTexture(desc, SkBudgeted::kYes));
 }
 
-static sk_sp<GrTextureProxy> make_mipmap_proxy(GrResourceProvider* provider,
-                                               GrSurfaceFlags flags,
-                                               int width, int height,
-                                               int sampleCnt) {
+static sk_sp<GrTexture> make_mipmap_texture(GrResourceProvider* provider,
+                                            GrSurfaceFlags flags,
+                                            int width, int height,
+                                            int sampleCnt) {
     SkBitmap bm;
 
     bm.allocN32Pixels(width, height, true);
@@ -1552,7 +1552,8 @@ static sk_sp<GrTextureProxy> make_mipmap_proxy(GrResourceProvider* provider,
     desc.fSampleCnt = sampleCnt;
     desc.fIsMipMapped = true;
 
-    return provider->createMipMappedTexture(desc, SkBudgeted::kYes, texels.get(), mipLevelCount);
+    return sk_sp<GrTexture>(provider->createMipMappedTexture(desc, SkBudgeted::kYes,
+                                                             texels.get(), mipLevelCount));
 }
 
 // Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,
@@ -1563,49 +1564,42 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) {
 
     static const int kSize = 64;
 
+    sk_sp<GrTexture> tex;
+
     // Normal versions
-    {
-        sk_sp<GrTexture> tex;
-
-        tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
-        size_t size = tex->gpuMemorySize();
-        REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
-
-        if (context->caps()->maxSampleCount() >= 4) {
-            tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
-            size = tex->gpuMemorySize();
-            REPORTER_ASSERT(reporter, kSize*kSize*4 == size ||    // msaa4 failed
-                                      kSize*kSize*4*4 == size ||  // auto-resolving
-                                      kSize*kSize*4*5 == size);   // explicit resolve buffer
-        }
+    tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
+    size_t size = tex->gpuMemorySize();
+    REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
 
-        tex = make_normal_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
+    if (context->caps()->maxSampleCount() >= 4) {
+        tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
         size = tex->gpuMemorySize();
-        REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
+        REPORTER_ASSERT(reporter, kSize*kSize*4 == size ||    // msaa4 failed
+                                  kSize*kSize*4*4 == size ||  // auto-resolving
+                                  kSize*kSize*4*5 == size);   // explicit resolve buffer
     }
 
+    tex = make_normal_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
+    size = tex->gpuMemorySize();
+    REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
 
     // Mipmapped versions
-    {
-        sk_sp<GrTextureProxy> proxy;
+    tex = make_mipmap_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
+    size = tex->gpuMemorySize();
+    REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
 
-        proxy = make_mipmap_proxy(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
-        size_t size = proxy->gpuMemorySize();
-        REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
-
-        if (context->caps()->maxSampleCount() >= 4) {
-            proxy = make_mipmap_proxy(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
-            size = proxy->gpuMemorySize();
-            REPORTER_ASSERT(reporter,
+    if (context->caps()->maxSampleCount() >= 4) {
+        tex = make_mipmap_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
+        size = tex->gpuMemorySize();
+        REPORTER_ASSERT(reporter, 
                             kSize*kSize*4+(kSize*kSize*4)/3 == size ||   // msaa4 failed
                             kSize*kSize*4*4+(kSize*kSize*4)/3 == size || // auto-resolving
                             kSize*kSize*4*5+(kSize*kSize*4)/3 == size);  // explicit resolve buffer
-        }
-
-        proxy = make_mipmap_proxy(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
-        size = proxy->gpuMemorySize();
-        REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
     }
+
+    tex = make_mipmap_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
+    size = tex->gpuMemorySize();
+    REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
 }
 
 #endif
diff --git a/tests/SRGBReadWritePixelsTest.cpp b/tests/SRGBReadWritePixelsTest.cpp
index e3087e639e..9729774cd0 100644
--- a/tests/SRGBReadWritePixelsTest.cpp
+++ b/tests/SRGBReadWritePixelsTest.cpp
@@ -169,7 +169,6 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SRGBReadWritePixels, reporter, ctxInfo) {
                                                  kPremul_SkAlphaType);
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
     desc.fWidth = kW;
     desc.fHeight = kH;
     desc.fConfig = kSRGBA_8888_GrPixelConfig;
diff --git a/tests/TestUtils.cpp b/tests/TestUtils.cpp
index aca7509748..d0349614f1 100644
--- a/tests/TestUtils.cpp
+++ b/tests/TestUtils.cpp
@@ -80,8 +80,6 @@ void test_copy_from_surface(skiatest::Reporter* reporter, GrContext* context,
         }
 
         copyDstDesc.fFlags = flags;
-        copyDstDesc.fOrigin = (kNone_GrSurfaceFlags == flags) ? kTopLeft_GrSurfaceOrigin
-                                                              : kBottomLeft_GrSurfaceOrigin;
 
         sk_sp<GrSurfaceContext> dstContext(GrSurfaceProxy::TestCopy(context, copyDstDesc, proxy));
 
@@ -108,8 +106,6 @@ void test_copy_to_surface(skiatest::Reporter* reporter, GrResourceProvider* reso
 
     for (auto flags : { kNone_GrSurfaceFlags, kRenderTarget_GrSurfaceFlag }) {
         copySrcDesc.fFlags = flags;
-        copySrcDesc.fOrigin = (kNone_GrSurfaceFlags == flags) ? kTopLeft_GrSurfaceOrigin
-                                                              : kBottomLeft_GrSurfaceOrigin;
 
         sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(resourceProvider,
                                                                copySrcDesc,
diff --git a/tests/VkUploadPixelsTests.cpp b/tests/VkUploadPixelsTests.cpp
index 50fc84fda8..8b6a56bd9f 100644
--- a/tests/VkUploadPixelsTests.cpp
+++ b/tests/VkUploadPixelsTests.cpp
@@ -12,7 +12,6 @@
 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS && defined(SK_VULKAN)
 
 #include "GrContextFactory.h"
-#include "GrContextPriv.h"
 #include "GrTest.h"
 #include "Test.h"
 #include "vk/GrVkGpu.h"
@@ -83,60 +82,51 @@ void basic_texture_test(skiatest::Reporter* reporter, GrContext* context, GrPixe
     surfDesc.fHeight = kHeight;
     surfDesc.fConfig = config;
     surfDesc.fSampleCnt = 0;
-    sk_sp<GrTexture> tex0(gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0));
+    GrTexture* tex0 = gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
     if (tex0) {
         REPORTER_ASSERT(reporter, canCreate);
-        gpu->readPixels(tex0.get(), 0, 0, kWidth, kHeight, config, dstBuffer, 0);
+        gpu->readPixels(tex0, 0, 0, kWidth, kHeight, config, dstBuffer, 0);
         REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
                                                                          dstBuffer,
                                                                          config,
                                                                          kWidth,
                                                                          kHeight));
 
-        sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(tex0);
-
-        bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
-                                                                 2, 10, 10, 2,
-                                                                 config, nullptr, srcBuffer, 0);
-        REPORTER_ASSERT(reporter, success);
-
+        tex0->writePixels(2, 10, 10, 2, config, srcBuffer);
         memset(dstBuffer, 0, kWidth*kHeight*sizeof(GrColor));
-        gpu->readPixels(tex0.get(), 2, 10, 10, 2, config, dstBuffer, 0);
+        gpu->readPixels(tex0, 2, 10, 10, 2, config, dstBuffer, 0);
         REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
                                                                          dstBuffer,
                                                                          config,
                                                                          10,
                                                                          2));
+
+        tex0->unref();
     } else {
         REPORTER_ASSERT(reporter, !canCreate);
     }
 
     surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
-    sk_sp<GrTexture> tex1(gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0));
+    GrTexture* tex1 = gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
     if (tex1) {
         REPORTER_ASSERT(reporter, canCreate);
-        gpu->readPixels(tex1.get(), 0, 0, kWidth, kHeight, config, dstBuffer, 0);
+        gpu->readPixels(tex1, 0, 0, kWidth, kHeight, config, dstBuffer, 0);
         REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
                                                                          dstBuffer,
                                                                          config,
                                                                          kWidth,
                                                                          kHeight));
 
-        sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrapped(tex1);
-
-        bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
-                                                                 5, 4, 4, 5, config, nullptr,
-                                                                 srcBuffer, 0);
-        REPORTER_ASSERT(reporter, success);
-
+        tex1->writePixels(5, 4, 4, 5, config, srcBuffer);
         memset(dstBuffer, 0, kWidth*kHeight*sizeof(GrColor));
-        gpu->readPixels(tex1.get(), 5, 4, 4, 5, config, dstBuffer, 0);
+        gpu->readPixels(tex1, 5, 4, 4, 5, config, dstBuffer, 0);
         REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
                                                                          dstBuffer,
                                                                          config,
                                                                          4,
                                                                          5));
 
+        tex1->unref();
     } else {
         REPORTER_ASSERT(reporter, !canCreate);
     }