Add GrRenderTargetContext::resourceProvider & GrResourceProvider::caps

and retract GrSurfaceContextPriv a bit

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

14 files changed, 48 insertions, 63 deletions

diff --git a/tests/CopySurfaceTest.cpp b/tests/CopySurfaceTest.cpp
index 828eff073e..6acb23967b 100644
--- a/tests/CopySurfaceTest.cpp
+++ b/tests/CopySurfaceTest.cpp
@@ -74,14 +74,12 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CopySurface, reporter, ctxInfo) {
                             dstDesc.fFlags = dFlags;
 
                             sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(
-                                                                    *context->caps(),
                                                                     context->resourceProvider(),
                                                                     srcDesc, SkBudgeted::kNo,
                                                                     srcPixels.get(),
                                                                     kRowBytes));
 
                             sk_sp<GrTextureProxy> dst(GrSurfaceProxy::MakeDeferred(
-                                                                    *context->caps(),
                                                                     context->resourceProvider(),
                                                                     dstDesc, SkBudgeted::kNo,
                                                                     dstPixels.get(),
diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index 5ea5b3d22d..998e339abe 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -167,12 +167,10 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
         externalDesc.fSampleCnt = 0;
     }
 
-    test_read_pixels(reporter, context0, surfaceContext.get(), pixels.get(),
-                     "EGLImageTest-read");
+    test_read_pixels(reporter, surfaceContext.get(), pixels.get(), "EGLImageTest-read");
 
     // We should not be able to write to a EXTERNAL texture
-    test_write_pixels(reporter, context0, surfaceContext.get(), false,
-                      "EGLImageTest-write");
+    test_write_pixels(reporter, surfaceContext.get(), false, "EGLImageTest-write");
 
     // Only test RT-config
     // TODO: why do we always need to draw to copy from an external texture?
diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index 3979581266..fe67925fda 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -193,7 +193,7 @@ static GrTexture* create_texture(GrContext* context) {
     return context->resourceProvider()->createTexture(desc, SkBudgeted::kNo, srcBM.getPixels(), 0);
 }
 
-static sk_sp<GrTextureProxy> create_proxy(GrContext* context) {
+static sk_sp<GrTextureProxy> create_proxy(GrResourceProvider* resourceProvider) {
     SkBitmap srcBM = create_bm();
 
     GrSurfaceDesc desc;
@@ -202,8 +202,7 @@ static sk_sp<GrTextureProxy> create_proxy(GrContext* context) {
     desc.fWidth  = kFullSize;
     desc.fHeight = kFullSize;
 
-    return GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                        context->resourceProvider(),
+    return GrSurfaceProxy::MakeDeferred(resourceProvider,
                                         desc, SkBudgeted::kYes,
                                         srcBM.getPixels(),
                                         srcBM.rowBytes());
@@ -254,7 +253,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ct
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_GPUBacked, reporter, ctxInfo) {
     GrContext* context = ctxInfo.grContext();
 
-    sk_sp<GrTextureProxy> srcProxy(create_proxy(context));
+    sk_sp<GrTextureProxy> srcProxy(create_proxy(context->resourceProvider()));
     if (!srcProxy) {
         return;
     }
diff --git a/tests/IntTextureTest.cpp b/tests/IntTextureTest.cpp
index 93a9ced577..346f56bc68 100644
--- a/tests/IntTextureTest.cpp
+++ b/tests/IntTextureTest.cpp
@@ -71,8 +71,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(IntTexture, reporter, ctxInfo) {
     }
 
     // Test that we can create an integer texture.
-    sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                                               context->resourceProvider(),
+    sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
                                                                desc, SkBudgeted::kYes,
                                                                testData.get(),
                                                                kRowBytes);
diff --git a/tests/ProcessorTest.cpp b/tests/ProcessorTest.cpp
index 7d9349ba6d..a99e5324ec 100644
--- a/tests/ProcessorTest.cpp
+++ b/tests/ProcessorTest.cpp
@@ -142,7 +142,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
             bool texelBufferSupport = context->caps()->shaderCaps()->texelBufferSupport();
             bool imageLoadStoreSupport = context->caps()->shaderCaps()->imageLoadStoreSupport();
             sk_sp<GrTextureProxy> proxy1(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
-                                                                      *context->caps(), desc,
+                                                                      desc,
                                                                       SkBackingFit::kExact,
                                                                       SkBudgeted::kYes));
             sk_sp<GrTexture> texture2(
@@ -315,8 +315,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, repor
     }
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
-    sk_sp<GrTextureProxy> dataProxy = GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                                                   context->resourceProvider(),
+    sk_sp<GrTextureProxy> dataProxy = GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
                                                                    desc, SkBudgeted::kYes,
                                                                    rgbaData.get(),
                                                                    256 * sizeof(GrColor));
diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp
index 9514a52c06..a041d68c2b 100644
--- a/tests/ProxyConversionTest.cpp
+++ b/tests/ProxyConversionTest.cpp
@@ -118,7 +118,6 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo
 // Test converting between RenderTargetProxies and TextureProxies for deferred
 // Proxies
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxInfo) {
-    const GrCaps& caps = *ctxInfo.grContext()->caps();
     GrResourceProvider* resourceProvider = ctxInfo.grContext()->resourceProvider();
 
     GrSurfaceDesc desc;
@@ -128,7 +127,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
     {
-        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(resourceProvider, caps, desc,
+        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(resourceProvider, desc,
                                                                  SkBackingFit::kApprox,
                                                                  SkBudgeted::kYes));
 
@@ -140,9 +139,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
         REPORTER_ASSERT(reporter, tProxy->asRenderTargetProxy() == rtProxy);
         REPORTER_ASSERT(reporter, rtProxy->asRenderTargetProxy() == rtProxy);
     }
-    
+
     {
-        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(resourceProvider, caps, desc,
+        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(resourceProvider, desc,
                                                                  SkBackingFit::kApprox,
                                                                  SkBudgeted::kYes));
 
@@ -158,7 +157,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxIn
     {
         desc.fFlags = kNone_GrSurfaceFlags; // force no-RT
 
-        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(resourceProvider, caps, desc,
+        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(resourceProvider, desc,
                                                                  SkBackingFit::kApprox,
                                                                  SkBudgeted::kYes));
 
diff --git a/tests/ProxyRefTest.cpp b/tests/ProxyRefTest.cpp
index 612633c58c..ec47597b97 100644
--- a/tests/ProxyRefTest.cpp
+++ b/tests/ProxyRefTest.cpp
@@ -65,18 +65,18 @@ static void check_refs(skiatest::Reporter* reporter,
     SkASSERT(proxy->getPendingWriteCnt_TestOnly() == expectedNumWrites);
 }
 
-static sk_sp<GrSurfaceProxy> make_deferred(const GrCaps& caps, GrResourceProvider* provider) {
+static sk_sp<GrSurfaceProxy> make_deferred(GrResourceProvider* provider) {
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = kWidthHeight;
     desc.fHeight = kWidthHeight;
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
-    return GrSurfaceProxy::MakeDeferred(provider, caps, desc,
+    return GrSurfaceProxy::MakeDeferred(provider, desc,
                                         SkBackingFit::kApprox, SkBudgeted::kYes);
 }
 
-static sk_sp<GrSurfaceProxy> make_wrapped(const GrCaps& caps, GrResourceProvider* provider) {
+static sk_sp<GrSurfaceProxy> make_wrapped(GrResourceProvider* provider) {
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = kWidthHeight;
@@ -100,7 +100,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
     for (auto make : { make_deferred, make_wrapped }) {
         // A single write
         {
-            sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider));
+            sk_sp<GrSurfaceProxy> sProxy((*make)(provider));
 
             GrPendingIOResource<GrSurfaceProxy, kWrite_GrIOType> fWrite(sProxy.get());
 
@@ -120,7 +120,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
 
         // A single read
         {
-            sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider));
+            sk_sp<GrSurfaceProxy> sProxy((*make)(provider));
 
             GrPendingIOResource<GrSurfaceProxy, kRead_GrIOType> fRead(sProxy.get());
 
@@ -140,7 +140,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
 
         // A single read/write pair
         {
-            sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider));
+            sk_sp<GrSurfaceProxy> sProxy((*make)(provider));
 
             GrPendingIOResource<GrSurfaceProxy, kRW_GrIOType> fRW(sProxy.get());
 
@@ -160,7 +160,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
 
         // Multiple normal refs
         {
-            sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider));
+            sk_sp<GrSurfaceProxy> sProxy((*make)(provider));
             sProxy->ref();
             sProxy->ref();
 
@@ -181,7 +181,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
 
         // Continue using (reffing) proxy after instantiation
         {
-            sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider));
+            sk_sp<GrSurfaceProxy> sProxy((*make)(provider));
             sProxy->ref();
 
             GrPendingIOResource<GrSurfaceProxy, kWrite_GrIOType> fWrite(sProxy.get());
diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp
index 50af7f70ec..648ae1d6c8 100644
--- a/tests/ProxyTest.cpp
+++ b/tests/ProxyTest.cpp
@@ -141,8 +141,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
                                 }
 
                                 sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(
-                                                                                provider,
-                                                                                caps, desc,
+                                                                                provider, desc,
                                                                                 fit, budgeted));
                                 REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
                                 if (proxy) {
@@ -175,10 +174,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
                                 }
 
                                 sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(provider,
-                                                                                          caps,
-                                                                                          desc,
-                                                                                          fit,
-                                                                                          budgeted));
+                                                                                         desc,
+                                                                                         fit,
+                                                                                         budgeted));
                                 REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
                                 if (proxy) {
                                     // This forces the proxy to compute and cache its pre-instantiation
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index 4fff156b98..ac34b9dc32 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -56,8 +56,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
         // We are initializing the texture with zeros here
         memset(alphaData, 0, X_SIZE * Y_SIZE);
 
-        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                                                 context->resourceProvider(),
+        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
                                                                  desc,
                                                                  SkBudgeted::kNo,
                                                                  alphaData, 0));
diff --git a/tests/RectangleTextureTest.cpp b/tests/RectangleTextureTest.cpp
index 0f164ebc79..efc11bab26 100644
--- a/tests/RectangleTextureTest.cpp
+++ b/tests/RectangleTextureTest.cpp
@@ -37,13 +37,12 @@ static void test_basic_draw_as_src(skiatest::Reporter* reporter, GrContext* cont
         paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
         paint.addColorFragmentProcessor(std::move(fp));
         rtContext->drawPaint(GrNoClip(), std::move(paint), SkMatrix::I());
-        test_read_pixels(reporter, context, rtContext.get(), expectedPixelValues,
+        test_read_pixels(reporter, rtContext.get(), expectedPixelValues,
                          "RectangleTexture-basic-draw");
     }
 }
 
-static void test_clear(skiatest::Reporter* reporter, GrContext* context,
-                       GrSurfaceContext* rectContext) {
+static void test_clear(skiatest::Reporter* reporter, GrSurfaceContext* rectContext) {
     if (GrRenderTargetContext* rtc = rectContext->asRenderTargetContext()) {
         // Clear the whole thing.
         GrColor color0 = GrColorPackRGBA(0xA, 0xB, 0xC, 0xD);
@@ -83,7 +82,7 @@ static void test_clear(skiatest::Reporter* reporter, GrContext* context,
             }
         }
 
-        test_read_pixels(reporter, context, rtc, expectedPixels.get(), "RectangleTexture-clear");
+        test_read_pixels(reporter, rtc, expectedPixels.get(), "RectangleTexture-clear");
     }
 }
 
@@ -152,13 +151,14 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(RectangleTexture, reporter, ctxInfo) {
                                                                     std::move(rectProxy), nullptr);
         SkASSERT(rectContext);
 
-        test_read_pixels(reporter, context, rectContext.get(), refPixels, "RectangleTexture-read");
+        test_read_pixels(reporter, rectContext.get(), refPixels, "RectangleTexture-read");
 
-        test_copy_to_surface(reporter, context, rectContext.get(), "RectangleTexture-copy-to");
+        test_copy_to_surface(reporter, context->resourceProvider(),
+                              rectContext.get(), "RectangleTexture-copy-to");
 
-        test_write_pixels(reporter, context, rectContext.get(), true, "RectangleTexture-write");
+        test_write_pixels(reporter, rectContext.get(), true, "RectangleTexture-write");
 
-        test_clear(reporter, context, rectContext.get());
+        test_clear(reporter, rectContext.get());
 
         GR_GL_CALL(glContext->gl(), DeleteTextures(1, &rectTexID));
     }
diff --git a/tests/SRGBMipMapTest.cpp b/tests/SRGBMipMapTest.cpp
index bf983eef1b..124327a70e 100644
--- a/tests/SRGBMipMapTest.cpp
+++ b/tests/SRGBMipMapTest.cpp
@@ -120,7 +120,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SRGBMipMaps, reporter, ctxInfo) {
     desc.fHeight = texS;
 
     GrResourceProvider* resourceProvider = context->resourceProvider();
-    sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(*context->caps(), resourceProvider,
+    sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeDeferred(resourceProvider,
                                                                desc, SkBudgeted::kNo,
                                                                texData, 0);
 
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index d6922c394c..6c1f1bc04a 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -234,8 +234,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo)
         // gpu
         const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
 
-        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                                                 context->resourceProvider(),
+        sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
                                                                  desc, SkBudgeted::kNo,
                                                                  bm.getPixels(), bm.rowBytes()));
         if (!proxy) {
@@ -268,8 +267,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, ctxInfo) {
 
     const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
 
-    sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                                             context->resourceProvider(),
+    sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
                                                              desc, SkBudgeted::kNo,
                                                              bm.getPixels(), bm.rowBytes()));
     if (!proxy) {
@@ -308,8 +306,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_DeferredGpu, reporter, ctxInfo)
     desc.fWidth  = kFullSize;
     desc.fHeight = kFullSize;
 
-    sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                                             context->resourceProvider(),
+    sk_sp<GrTextureProxy> proxy(GrSurfaceProxy::MakeDeferred(context->resourceProvider(),
                                                              desc, SkBudgeted::kNo,
                                                              bm.getPixels(), 0));
     if (!proxy) {
diff --git a/tests/TestUtils.cpp b/tests/TestUtils.cpp
index 63a8d94871..d0349614f1 100644
--- a/tests/TestUtils.cpp
+++ b/tests/TestUtils.cpp
@@ -13,7 +13,7 @@
 #include "GrSurfaceProxy.h"
 #include "GrTextureProxy.h"
 
-void test_read_pixels(skiatest::Reporter* reporter, GrContext* context,
+void test_read_pixels(skiatest::Reporter* reporter,
                       GrSurfaceContext* srcContext, uint32_t expectedPixelValues[],
                       const char* testName) {
     int pixelCnt = srcContext->width() * srcContext->height();
@@ -36,7 +36,7 @@ void test_read_pixels(skiatest::Reporter* reporter, GrContext* context,
     }
 }
 
-void test_write_pixels(skiatest::Reporter* reporter, GrContext* context,
+void test_write_pixels(skiatest::Reporter* reporter,
                        GrSurfaceContext* dstContext, bool expectedToWork,
                        const char* testName) {
     int pixelCnt = dstContext->width() * dstContext->height();
@@ -63,7 +63,7 @@ void test_write_pixels(skiatest::Reporter* reporter, GrContext* context,
         return;
     }
 
-    test_read_pixels(reporter, context, dstContext, pixels.get(), testName);
+    test_read_pixels(reporter, dstContext, pixels.get(), testName);
 }
 
 void test_copy_from_surface(skiatest::Reporter* reporter, GrContext* context,
@@ -83,11 +83,11 @@ void test_copy_from_surface(skiatest::Reporter* reporter, GrContext* context,
 
         sk_sp<GrSurfaceContext> dstContext(GrSurfaceProxy::TestCopy(context, copyDstDesc, proxy));
 
-        test_read_pixels(reporter, context, dstContext.get(), expectedPixelValues, testName);
+        test_read_pixels(reporter, dstContext.get(), expectedPixelValues, testName);
     }
 }
 
-void test_copy_to_surface(skiatest::Reporter* reporter, GrContext* context,
+void test_copy_to_surface(skiatest::Reporter* reporter, GrResourceProvider* resourceProvider,
                           GrSurfaceContext* dstContext, const char* testName) {
 
     int pixelCnt = dstContext->width() * dstContext->height();
@@ -107,13 +107,12 @@ void test_copy_to_surface(skiatest::Reporter* reporter, GrContext* context,
     for (auto flags : { kNone_GrSurfaceFlags, kRenderTarget_GrSurfaceFlag }) {
         copySrcDesc.fFlags = flags;
 
-        sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(*context->caps(),
-                                                               context->resourceProvider(),
+        sk_sp<GrTextureProxy> src(GrSurfaceProxy::MakeDeferred(resourceProvider,
                                                                copySrcDesc,
                                                                SkBudgeted::kYes, pixels.get(), 0));
         dstContext->copy(src.get());
 
-        test_read_pixels(reporter, context, dstContext, pixels.get(), testName);
+        test_read_pixels(reporter, dstContext, pixels.get(), testName);
     }
 }
 
diff --git a/tests/TestUtils.h b/tests/TestUtils.h
index 7c3370ed7e..6f878bfa29 100644
--- a/tests/TestUtils.h
+++ b/tests/TestUtils.h
@@ -13,22 +13,22 @@ class GrSurfaceContext;
 class GrSurfaceProxy;
 
 // Ensure that reading back from 'srcContext' as RGBA 8888 matches 'expectedPixelValues
-void test_read_pixels(skiatest::Reporter* reporter, GrContext* context,
+void test_read_pixels(skiatest::Reporter*,
                       GrSurfaceContext* srcContext, uint32_t expectedPixelValues[],
                       const char* testName);
 
 // See if trying to write RGBA 8888 pixels to 'dstContext' matches matches the
 // expectation ('expectedToWork')
-void test_write_pixels(skiatest::Reporter* reporter, GrContext* context,
+void test_write_pixels(skiatest::Reporter*,
                        GrSurfaceContext* srcContext, bool expectedToWork, const char* testName);
 
 // Ensure that the pixels can be copied from 'proxy' to an RGBA 8888 destination (both
 // texture-backed and rendertarget-backed).
-void test_copy_from_surface(skiatest::Reporter* reporter, GrContext* context,
+void test_copy_from_surface(skiatest::Reporter*, GrContext*,
                             GrSurfaceProxy* proxy, uint32_t expectedPixelValues[],
                             bool onlyTestRTConfig, const char* testName);
 
 // Ensure that RGBA 8888 pixels can be copied into 'dstContext'
-void test_copy_to_surface(skiatest::Reporter* reporter, GrContext* context,
+void test_copy_to_surface(skiatest::Reporter*, GrResourceProvider*,
                           GrSurfaceContext* dstContext, const char* testName);
 #endif