Rm readPixels from GrSurface & move read/writeSurfacePixels to GrContextPriv (take 3)

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 re-reland of: https://skia-review.googlesource.com/c/11200/ (Rm readPixels from GrSurface & move read/writeSurfacePixels to GrContextPriv)

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

16 files changed, 224 insertions, 163 deletions

diff --git a/tests/BlendTest.cpp b/tests/BlendTest.cpp
index 193c37dd4a..2d16fb2ff2 100644
--- a/tests/BlendTest.cpp
+++ b/tests/BlendTest.cpp
@@ -92,8 +92,7 @@ static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
     backingDesc.fOrigin = kDefault_GrSurfaceOrigin;
     backingDesc.fFlags = kRenderTarget_GrSurfaceFlag;
 
-    (*backingSurface)
-            .reset(context->resourceProvider()->createTexture(backingDesc, SkBudgeted::kNo));
+    *backingSurface = context->resourceProvider()->createTexture(backingDesc, SkBudgeted::kNo);
 
     GrBackendTextureDesc desc;
     desc.fConfig = config;
diff --git a/tests/FloatingPointTextureTest.cpp b/tests/FloatingPointTextureTest.cpp
index 4214e4eebf..5adc2e7892 100644
--- a/tests/FloatingPointTextureTest.cpp
+++ b/tests/FloatingPointTextureTest.cpp
@@ -17,6 +17,7 @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
+#include "GrContextPriv.h"
 #include "GrResourceProvider.h"
 #include "GrTexture.h"
 #include "SkHalf.h"
@@ -51,14 +52,18 @@ void runFPTest(skiatest::Reporter* reporter, GrContext* context,
         desc.fHeight = DEV_H;
         desc.fConfig = config;
         desc.fOrigin = 0 == origin ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
-        sk_sp<GrTexture> fpTexture(context->resourceProvider()->createTexture(
-            desc, SkBudgeted::kNo, controlPixelData.begin(), 0));
+        sk_sp<GrTextureProxy> fpProxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
+                                                                     desc, SkBudgeted::kNo,
+                                                                     controlPixelData.begin(), 0);
         // Floating point textures are NOT supported everywhere
-        if (nullptr == fpTexture) {
+        if (!fpProxy) {
             continue;
         }
-        REPORTER_ASSERT(reporter,
-                        fpTexture->readPixels(0, 0, DEV_W, DEV_H, desc.fConfig, readBuffer.begin(), 0));
+        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,
                         0 == memcmp(readBuffer.begin(), controlPixelData.begin(), readBuffer.bytes()));
     }
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 489aec1391..5400d92bc6 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -285,28 +285,30 @@ 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;
-    sk_sp<GrTexture> dummyTexture1(
-        context->resourceProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
+    proxies[0] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
+                                              dummyDesc, SkBudgeted::kNo, nullptr, 0);
     dummyDesc.fFlags = kNone_GrSurfaceFlags;
+    dummyDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
     dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
     dummyDesc.fWidth = 16;
     dummyDesc.fHeight = 22;
-    sk_sp<GrTexture> dummyTexture2(
-        context->resourceProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
+    proxies[1] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
+                                              dummyDesc, SkBudgeted::kNo, nullptr, 0);
 
-    if (!dummyTexture1 || ! dummyTexture2) {
+    if (!proxies[0] || !proxies[1]) {
         SkDebugf("Could not allocate dummy textures");
         return false;
     }
 
-    GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
-
     // dummy scissor state
     GrScissorState scissor;
 
@@ -326,7 +328,7 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
         std::unique_ptr<GrLegacyMeshDrawOp> op(GrRandomDrawOp(&random, context));
         SkASSERT(op);
 
-        GrProcessorTestData ptd(&random, context, renderTargetContext.get(), dummyTextures);
+        GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
         set_random_color_coverage_stages(&grPaint, &ptd, maxStages);
         set_random_xpf(&grPaint, &ptd);
         bool snapToCenters = set_random_state(&grPaint, &random);
@@ -360,7 +362,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(), dummyTextures);
+            GrProcessorTestData ptd(&random, context, renderTargetContext.get(), proxies);
             GrPaint grPaint;
             grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
 
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index d98d0d0428..97700b1a85 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -27,11 +27,10 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
     desc.fWidth = 256;
     desc.fHeight = 256;
     desc.fSampleCnt = 0;
-    GrSurface* texRT1 = context->resourceProvider()->createTexture(
-            desc, SkBudgeted::kNo, nullptr, 0);
+    sk_sp<GrSurface> texRT1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
 
-    REPORTER_ASSERT(reporter, texRT1 == texRT1->asRenderTarget());
-    REPORTER_ASSERT(reporter, texRT1 == texRT1->asTexture());
+    REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asRenderTarget());
+    REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asTexture());
     REPORTER_ASSERT(reporter, static_cast<GrSurface*>(texRT1->asRenderTarget()) ==
                     texRT1->asTexture());
     REPORTER_ASSERT(reporter, texRT1->asRenderTarget() ==
@@ -40,10 +39,10 @@ DEF_GPUTEST_FOR_NULLGL_CONTEXT(GrSurface, reporter, ctxInfo) {
                     static_cast<GrSurface*>(texRT1->asTexture()));
 
     desc.fFlags = kNone_GrSurfaceFlags;
-    GrSurface* tex1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, nullptr, 0);
+    sk_sp<GrTexture> tex1 = context->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
     REPORTER_ASSERT(reporter, nullptr == tex1->asRenderTarget());
-    REPORTER_ASSERT(reporter, tex1 == tex1->asTexture());
-    REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1) == tex1->asTexture());
+    REPORTER_ASSERT(reporter, tex1.get() == tex1->asTexture());
+    REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1.get()) == tex1->asTexture());
 
     GrBackendObject backendTex = context->getGpu()->createTestingOnlyBackendTexture(
         nullptr, 256, 256, kRGBA_8888_GrPixelConfig);
@@ -66,8 +65,6 @@ 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 fe67925fda..95ade044bd 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -181,18 +181,6 @@ 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();
 
@@ -208,10 +196,16 @@ static sk_sp<GrTextureProxy> create_proxy(GrResourceProvider* resourceProvider)
                                         srcBM.rowBytes());
 }
 
-
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
-    sk_sp<GrTexture> srcTexture(create_texture(ctxInfo.grContext()));
-    if (!srcTexture) {
+    GrContext* context = ctxInfo.grContext();
+
+    sk_sp<GrTextureProxy> srcProxy(create_proxy(context->resourceProvider()));
+    if (!srcProxy) {
+        return;
+    }
+
+    GrTexture* tex = srcProxy->instantiate(context->resourceProvider());
+    if (!tex) {
         return;
     }
 
@@ -222,8 +216,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ct
     backendDesc.fWidth = kFullSize;
     backendDesc.fHeight = kFullSize;
     backendDesc.fSampleCnt = 0;
-    backendDesc.fTextureHandle = srcTexture->getTextureHandle();
-    sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(ctxInfo.grContext(),
+    backendDesc.fTextureHandle = tex->getTextureHandle();
+    sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(context,
                                                      backendDesc,
                                                      kPremul_SkAlphaType));
     if (!srcImage) {
diff --git a/tests/ImageStorageTest.cpp b/tests/ImageStorageTest.cpp
index 59bb38b02a..f3e3482b07 100644
--- a/tests/ImageStorageTest.cpp
+++ b/tests/ImageStorageTest.cpp
@@ -20,9 +20,17 @@
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
     class TestFP : public GrFragmentProcessor {
     public:
-        static sk_sp<GrFragmentProcessor> Make(sk_sp<GrTexture> texture, GrSLMemoryModel mm,
+        static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
+                                               sk_sp<GrTextureProxy> proxy,
+                                               GrSLMemoryModel mm,
                                                GrSLRestrict restrict) {
-            return sk_sp<GrFragmentProcessor>(new TestFP(std::move(texture), mm, 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));
         }
 
         const char* name() const override { return "Image Load Test FP"; }
@@ -127,15 +135,17 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
                     continue;
                 }
                 desc.fConfig = test.fConfig;
-                sk_sp<GrTexture> imageStorageTexture(context->resourceProvider()->createTexture(
-                        desc, SkBudgeted::kYes, test.fData.get(), 0));
+                sk_sp<GrTextureProxy> imageStorageTexture =
+                    GrSurfaceProxy::MakeDeferred(context->resourceProvider(), 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(imageStorageTexture, mm, restrict));
+                paint.addColorFragmentProcessor(TestFP::Make(context->resourceProvider(),
+                                                             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 8ef57318ed..eacd0617a2 100644
--- a/tests/IntTextureTest.cpp
+++ b/tests/IntTextureTest.cpp
@@ -10,6 +10,7 @@
 #if SK_SUPPORT_GPU
 #include "GrClip.h"
 #include "GrContext.h"
+#include "GrContextPriv.h"
 #include "GrRenderTargetContext.h"
 #include "GrResourceProvider.h"
 #include "GrTexture.h"
@@ -64,7 +65,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
         levels[1].fPixels = testData.get();
         levels[1].fRowBytes = (kS / 2) * sizeof(int32_t);
 
-        sk_sp<GrTexture> temp(context->resourceProvider()->createMipMappedTexture(desc,
+        sk_sp<GrTextureProxy> temp(context->resourceProvider()->createMipMappedTexture(
+                                                                                  desc,
                                                                                   SkBudgeted::kYes,
                                                                                   levels, 2));
         REPORTER_ASSERT(reporter, !temp);
@@ -80,21 +82,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 = texture->readPixels(0, 0, kS, kS, kRGBA_8888_GrPixelConfig, readData.get());
+        bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
+                                                                0, 0, kS, kS,
+                                                                kRGBA_8888_GrPixelConfig,
+                                                                nullptr, readData.get());
         REPORTER_ASSERT(reporter, !success);
     }
     {
         std::unique_ptr<uint16_t[]> halfData(new uint16_t[4 * kS * kS]);
-        bool success = texture->readPixels(0, 0, kS, kS, kRGBA_half_GrPixelConfig, halfData.get());
+        bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
+                                                                0, 0, kS, kS,
+                                                                kRGBA_half_GrPixelConfig,
+                                                                nullptr, halfData.get());
         REPORTER_ASSERT(reporter, !success);
     }
     {
@@ -102,8 +104,10 @@ 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 = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig,
-                                           readData.get());
+        bool success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
+                                                                0, 0, kS, kS,
+                                                                kRGBA_8888_sint_GrPixelConfig,
+                                                                nullptr, readData.get());
         REPORTER_ASSERT(reporter, success);
         if (success) {
             check_pixels(reporter, kS, kS, testData.get(), readData.get(), "readPixels");
@@ -111,8 +115,12 @@ 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 = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig,
-                                           readData.get(), 0, GrContext::kUnpremul_PixelOpsFlag);
+        bool success = context->contextPriv().readSurfacePixels(
+                                                proxy.get(), nullptr,
+                                                0, 0, kS, kS,
+                                                kRGBA_8888_sint_GrPixelConfig,
+                                                nullptr, readData.get(), 0,
+                                                GrContextPriv::kUnpremul_PixelOpsFlag);
         REPORTER_ASSERT(reporter, !success);
     }
 
@@ -125,16 +133,11 @@ 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 = copySurface->readPixels(0, 0, kS, kS,
-                                               kRGBA_8888_sint_GrPixelConfig, readData.get());
+        bool success = context->contextPriv().readSurfacePixels(dstContext->asSurfaceProxy(),
+                                                                nullptr, 0, 0, kS, kS,
+                                                                kRGBA_8888_sint_GrPixelConfig,
+                                                                nullptr, readData.get());
         REPORTER_ASSERT(reporter, success);
         if (success) {
             check_pixels(reporter, kS, kS, testData.get(), readData.get(), "copyIntegerToInteger");
@@ -168,27 +171,39 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
 
     {
         // Can't write pixels from a non-int config.
-        bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_GrPixelConfig,
-                                            bottomRightQuarter, kRowBytes);
+        bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
+                                                                 0, 0, kS/2, kS/2,
+                                                                 kRGBA_8888_GrPixelConfig, nullptr,
+                                                                 bottomRightQuarter, kRowBytes);
         REPORTER_ASSERT(reporter, !success);
     }
     {
         // Can't use unpremul flag.
-        bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_sint_GrPixelConfig,
+        bool success = context->contextPriv().writeSurfacePixels(
+                                            proxy.get(), nullptr,
+                                            0, 0, kS/2, kS/2,
+                                            kRGBA_8888_sint_GrPixelConfig,
+                                            nullptr,
                                             bottomRightQuarter, kRowBytes,
-                                            GrContext::kUnpremul_PixelOpsFlag);
+                                            GrContextPriv::kUnpremul_PixelOpsFlag);
         REPORTER_ASSERT(reporter, !success);
     }
     {
-        bool success = texture->writePixels(0, 0, kS/2, kS/2, kRGBA_8888_sint_GrPixelConfig,
-                                            bottomRightQuarter, kRowBytes);
+        bool success = context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
+                                                                 0, 0, kS/2, kS/2,
+                                                                 kRGBA_8888_sint_GrPixelConfig,
+                                                                 nullptr,
+                                                                 bottomRightQuarter, kRowBytes);
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             return;
         }
 
         sk_bzero(readData.get(), sizeof(int32_t) * kS * kS);
-        success = texture->readPixels(0, 0, kS, kS, kRGBA_8888_sint_GrPixelConfig, readData.get());
+        success = context->contextPriv().readSurfacePixels(proxy.get(), nullptr,
+                                                           0, 0, kS, kS,
+                                                           kRGBA_8888_sint_GrPixelConfig,
+                                                           nullptr, readData.get(), 0);
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             return;
@@ -219,10 +234,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
         expectedData.get()[i] = ((0xFF * a) << 24) | ((0xFF * b) << 16) |
                                 ((0xFF * g) << 8) | (0xFF * r);
     }
-    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
+    context->contextPriv().writeSurfacePixels(proxy.get(), nullptr,
+                                              0, 0, kS, kS,
+                                              kRGBA_8888_sint_GrPixelConfig, nullptr,
+                                              testData.get(), 0);
 
     sk_sp<GrRenderTargetContext> rtContext = context->makeRenderTargetContext(
             SkBackingFit::kExact, kS, kS, kRGBA_8888_GrPixelConfig, nullptr);
@@ -238,7 +253,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
 
     for (auto filter : kNamedFilters) {
         sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(context->resourceProvider(),
-                                                                  intTextureProxy, nullptr,
+                                                                  proxy, nullptr,
                                                                   SkMatrix::I(),
                                                                   filter.fMode));
         REPORTER_ASSERT(reporter, fp);
diff --git a/tests/PackedConfigsTextureTest.cpp b/tests/PackedConfigsTextureTest.cpp
index 7a51651e7f..35d9dfc3c5 100644
--- a/tests/PackedConfigsTextureTest.cpp
+++ b/tests/PackedConfigsTextureTest.cpp
@@ -15,6 +15,7 @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
+#include "GrContextPriv.h"
 #include "GrResourceProvider.h"
 #include "GrTexture.h"
 
@@ -116,10 +117,13 @@ void runTest(skiatest::Reporter* reporter, GrContext* context,
         desc.fHeight = DEV_H;
         desc.fConfig = config;
         desc.fOrigin = 0 == origin ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
-        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);
+        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);
         if (kRGBA_4444_GrPixelConfig == config) {
             check_4444(reporter, controlPixelData, readBuffer);
         } else {
diff --git a/tests/ProcessorTest.cpp b/tests/ProcessorTest.cpp
index b8691f2689..3eb4e16f20 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,6 +298,8 @@ 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) {
@@ -306,8 +308,8 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
                     texel_color(random.nextULessThan(256), random.nextULessThan(256));
         }
     }
-    sk_sp<GrTexture> tex0(context->resourceProvider()->createTexture(
-            desc, SkBudgeted::kYes, rgbaData.get(), 256 * sizeof(GrColor)));
+    proxies[0] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), 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;
@@ -317,10 +319,9 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
             alphaData.get()[256 * y + x] = random.nextULessThan(256);
         }
     }
-    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);
+    proxies[1] = GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kYes,
+                                              alphaData.get(), 256);
+    GrProcessorTestData testData(&random, context, rtc.get(), proxies);
 
     // 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 648ae1d6c8..7657e28f5a 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.reset(provider->createTexture(desc, budgeted));
+                                    tex = 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.reset(provider->createTexture(desc, budgeted));
+                                    tex = 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.reset(provider->createTexture(desc, budgeted));
+                        tex = 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.reset(provider->createTexture(desc, budgeted));
+                        tex = provider->createTexture(desc, budgeted);
                     }
 
                     sk_sp<GrSurfaceProxy> sProxy(GrSurfaceProxy::MakeWrapped(tex));
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index 774f0af06a..c67e62b090 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -16,6 +16,7 @@
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
+#include "GrContextPriv.h"
 #include "GrResourceProvider.h"
 #include "SkGr.h"
 #endif
@@ -123,11 +124,16 @@ static void fill_src_canvas(SkCanvas* canvas) {
 }
 
 #if SK_SUPPORT_GPU
-static void fill_src_texture(GrTexture* texture) {
+static void fill_src_texture(GrContext* context, GrTextureProxy* proxy) {
     SkBitmap bmp = make_src_bitmap();
     bmp.lockPixels();
-    texture->writePixels(0, 0, DEV_W, DEV_H, kSkia8888_GrPixelConfig, bmp.getPixels(),
-                         bmp.rowBytes());
+
+    SkDEBUGCODE(bool result =) context->contextPriv().writeSurfacePixels(
+                                                            proxy, nullptr,
+                                                            0, 0, DEV_W, DEV_H,
+                                                            kSkia8888_GrPixelConfig, nullptr,
+                                                            bmp.getPixels(), bmp.rowBytes());
+    SkASSERT(result);
     bmp.unlockPixels();
 }
 #endif
@@ -436,8 +442,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Gpu, reporter, ctxInfo) {
 #endif
 
 #if SK_SUPPORT_GPU
-static void test_readpixels_texture(skiatest::Reporter* reporter, GrTexture* texture) {
-    fill_src_texture(texture);
+static void test_readpixels_texture(skiatest::Reporter* reporter,
+                                    GrContext* context, sk_sp<GrTextureProxy> proxy) {
+    fill_src_texture(context, proxy.get());
     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)) {
@@ -452,16 +459,18 @@ static void test_readpixels_texture(skiatest::Reporter* reporter, GrTexture* tex
                 // Try doing the read directly from a non-renderable texture
                 if (startsWithPixels) {
                     fill_dst_bmp_with_init_data(&bmp);
-                    GrPixelConfig dstConfig =
-                            SkImageInfo2GrPixelConfig(bmp.info(), *texture->getContext()->caps());
+                    GrPixelConfig dstConfig = SkImageInfo2GrPixelConfig(bmp.info(),
+                                                                        *context->caps());
                     uint32_t flags = 0;
                     if (gReadPixelsConfigs[c].fAlphaType == kUnpremul_SkAlphaType) {
-                        flags = GrContext::kUnpremul_PixelOpsFlag;
+                        flags = GrContextPriv::kUnpremul_PixelOpsFlag;
                     }
                     bmp.lockPixels();
-                    bool success = texture->readPixels(srcRect.fLeft, srcRect.fTop, bmp.width(),
-                                                       bmp.height(), dstConfig, bmp.getPixels(),
-                                                       bmp.rowBytes(), flags);
+                    bool success = context->contextPriv().readSurfacePixels(
+                                                       proxy.get(), nullptr,
+                                                       srcRect.fLeft, srcRect.fTop, bmp.width(),
+                                                       bmp.height(), dstConfig, nullptr,
+                                                       bmp.getPixels(), bmp.rowBytes(), flags);
                     bmp.unlockPixels();
                     check_read(reporter, bmp, srcRect.fLeft, srcRect.fTop,
                                success, true,
@@ -481,9 +490,10 @@ 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, texture.get());
+            sk_sp<GrTexture> texture =
+                    ctxInfo.grContext()->resourceProvider()->createTexture(desc, SkBudgeted::kNo);
+            test_readpixels_texture(reporter, ctxInfo.grContext(),
+                                    GrSurfaceProxy::MakeWrapped(std::move(texture)));
         }
     }
 }
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index ac34b9dc32..2a68191a2d 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -159,9 +159,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
                     rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]);
                 }
             }
-            sk_sp<GrTexture> texture(
-                context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, rgbaData, 0));
-            if (!texture) {
+            sk_sp<GrTextureProxy> proxy =
+                GrSurfaceProxy::MakeDeferred(context->resourceProvider(), desc, SkBudgeted::kNo,
+                                             rgbaData, 0);
+            if (!proxy) {
                 // 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.");
@@ -177,8 +178,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
                 memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE);
 
                 // read the texture back
-                bool result = texture->readPixels(0, 0, desc.fWidth, desc.fHeight,
-                                                  kAlpha_8_GrPixelConfig,
+                bool result = context->contextPriv().readSurfacePixels(
+                                                  proxy.get(), nullptr,
+                                                  0, 0, desc.fWidth, desc.fHeight,
+                                                  kAlpha_8_GrPixelConfig, nullptr,
                                                   readback.get(), rowBytes);
                 REPORTER_ASSERT_MESSAGE(reporter, result, "8888 readPixels failed");
 
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index a7a2b4540d..fcf3fe88f3 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.reset(resourceProvider->createTexture(smallMSAADesc, SkBudgeted::kNo));
+            smallMSAART1 = 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 sk_sp<GrTexture>(provider->createTexture(desc, SkBudgeted::kYes));
+    return provider->createTexture(desc, SkBudgeted::kYes);
 }
 
-static sk_sp<GrTexture> make_mipmap_texture(GrResourceProvider* provider,
-                                            GrSurfaceFlags flags,
-                                            int width, int height,
-                                            int sampleCnt) {
+static sk_sp<GrTextureProxy> make_mipmap_proxy(GrResourceProvider* provider,
+                                               GrSurfaceFlags flags,
+                                               int width, int height,
+                                               int sampleCnt) {
     SkBitmap bm;
 
     bm.allocN32Pixels(width, height, true);
@@ -1552,8 +1552,7 @@ static sk_sp<GrTexture> make_mipmap_texture(GrResourceProvider* provider,
     desc.fSampleCnt = sampleCnt;
     desc.fIsMipMapped = true;
 
-    return sk_sp<GrTexture>(provider->createMipMappedTexture(desc, SkBudgeted::kYes,
-                                                             texels.get(), mipLevelCount));
+    return provider->createMipMappedTexture(desc, SkBudgeted::kYes, texels.get(), mipLevelCount);
 }
 
 // Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,
@@ -1564,42 +1563,49 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) {
 
     static const int kSize = 64;
 
-    sk_sp<GrTexture> tex;
-
     // Normal versions
-    tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
-    size_t size = tex->gpuMemorySize();
-    REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
+    {
+        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
+        }
 
-    if (context->caps()->maxSampleCount() >= 4) {
-        tex = make_normal_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
+        tex = make_normal_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
         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
+        REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
     }
 
-    tex = make_normal_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
-    size = tex->gpuMemorySize();
-    REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
 
     // Mipmapped versions
-    tex = make_mipmap_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 0);
-    size = tex->gpuMemorySize();
-    REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
+    {
+        sk_sp<GrTextureProxy> proxy;
 
-    if (context->caps()->maxSampleCount() >= 4) {
-        tex = make_mipmap_texture(provider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 4);
-        size = tex->gpuMemorySize();
-        REPORTER_ASSERT(reporter, 
+        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,
                             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
-    }
+        }
 
-    tex = make_mipmap_texture(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
-    size = tex->gpuMemorySize();
-    REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
+        proxy = make_mipmap_proxy(provider, kNone_GrSurfaceFlags, kSize, kSize, 0);
+        size = proxy->gpuMemorySize();
+        REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
+    }
 }
 
 #endif
diff --git a/tests/SRGBReadWritePixelsTest.cpp b/tests/SRGBReadWritePixelsTest.cpp
index 9729774cd0..e3087e639e 100644
--- a/tests/SRGBReadWritePixelsTest.cpp
+++ b/tests/SRGBReadWritePixelsTest.cpp
@@ -169,6 +169,7 @@ 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 d0349614f1..aca7509748 100644
--- a/tests/TestUtils.cpp
+++ b/tests/TestUtils.cpp
@@ -80,6 +80,8 @@ 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));
 
@@ -106,6 +108,8 @@ 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 8b6a56bd9f..50fc84fda8 100644
--- a/tests/VkUploadPixelsTests.cpp
+++ b/tests/VkUploadPixelsTests.cpp
@@ -12,6 +12,7 @@
 #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"
@@ -82,51 +83,60 @@ void basic_texture_test(skiatest::Reporter* reporter, GrContext* context, GrPixe
     surfDesc.fHeight = kHeight;
     surfDesc.fConfig = config;
     surfDesc.fSampleCnt = 0;
-    GrTexture* tex0 = gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
+    sk_sp<GrTexture> tex0(gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0));
     if (tex0) {
         REPORTER_ASSERT(reporter, canCreate);
-        gpu->readPixels(tex0, 0, 0, kWidth, kHeight, config, dstBuffer, 0);
+        gpu->readPixels(tex0.get(), 0, 0, kWidth, kHeight, config, dstBuffer, 0);
         REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
                                                                          dstBuffer,
                                                                          config,
                                                                          kWidth,
                                                                          kHeight));
 
-        tex0->writePixels(2, 10, 10, 2, config, srcBuffer);
+        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);
+
         memset(dstBuffer, 0, kWidth*kHeight*sizeof(GrColor));
-        gpu->readPixels(tex0, 2, 10, 10, 2, config, dstBuffer, 0);
+        gpu->readPixels(tex0.get(), 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;
-    GrTexture* tex1 = gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0);
+    sk_sp<GrTexture> tex1(gpu->createTexture(surfDesc, SkBudgeted::kNo, srcBuffer, 0));
     if (tex1) {
         REPORTER_ASSERT(reporter, canCreate);
-        gpu->readPixels(tex1, 0, 0, kWidth, kHeight, config, dstBuffer, 0);
+        gpu->readPixels(tex1.get(), 0, 0, kWidth, kHeight, config, dstBuffer, 0);
         REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_color(srcBuffer,
                                                                          dstBuffer,
                                                                          config,
                                                                          kWidth,
                                                                          kHeight));
 
-        tex1->writePixels(5, 4, 4, 5, config, srcBuffer);
+        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);
+
         memset(dstBuffer, 0, kWidth*kHeight*sizeof(GrColor));
-        gpu->readPixels(tex1, 5, 4, 4, 5, config, dstBuffer, 0);
+        gpu->readPixels(tex1.get(), 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);
     }