One signature for creating unit tests that run on premade GrContexts

tests/ReadWriteAlphaTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 
 // This test is specific to the GPU backend.
@@ skipping 15 matching lines @@
             if (e != a) {
                 ERRORF(reporter,
                        "Failed alpha readback. Expected: 0x%02x, Got: 0x%02x at (%d,%d), %s",
                        e, a, x, y, extraMsg.c_str());
                 return;
             }
         }
     }
 }
 
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) {
     unsigned char alphaData[X_SIZE * Y_SIZE];
 
     bool match;
     static const size_t kRowBytes[] = {0, X_SIZE, X_SIZE + 1, 2 * X_SIZE - 1};
     for (int rt = 0; rt < 2; ++rt) {
         GrSurfaceDesc desc;
         // let Skia know we will be using this texture as a render target
         desc.fFlags     = rt ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;
         // it is a single channel texture
         desc.fConfig    = kAlpha_8_GrPixelConfig;
         desc.fWidth     = X_SIZE;
         desc.fHeight    = Y_SIZE;
 
         // We are initializing the texture with zeros here
         memset(alphaData, 0, X_SIZE * Y_SIZE);
         SkAutoTUnref<GrTexture> texture(
-            context->textureProvider()->createTexture(desc, SkBudgeted::kNo , alphaData, 0));
+            ctxInfo.fGrContext->textureProvider()->createTexture(desc, SkBudgeted::kNo , alphaData,
+                                                                 0));
         if (!texture) {
             if (!rt) {
                 ERRORF(reporter, "Could not create alpha texture.");
             }
             continue;
         }
 
         // create a distinctive texture
         for (int y = 0; y < Y_SIZE; ++y) {
             for (int x = 0; x < X_SIZE; ++x) {
@@ skipping 79 matching lines @@
             desc.fHeight    = Y_SIZE;
 
             uint32_t rgbaData[X_SIZE * Y_SIZE];
             // Make the alpha channel of the rgba texture come from alphaData.
             for (int y = 0; y < Y_SIZE; ++y) {
                 for (int x = 0; x < X_SIZE; ++x) {
                     rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]);
                 }
             }
             SkAutoTUnref<GrTexture> texture(
-                context->textureProvider()->createTexture(desc, SkBudgeted::kNo, rgbaData, 0));
+                ctxInfo.fGrContext->textureProvider()->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.");
                 }
                 continue;
             }
 
             for (auto rowBytes : kRowBytes) {
                 size_t nonZeroRowBytes = rowBytes ? rowBytes : X_SIZE;
@@ skipping 10 matching lines @@
                 SkString msg;
                 msg.printf("rt:%d, rb:%d", rt, SkToU32(rowBytes));
                 validate_alpha_data(reporter, X_SIZE, Y_SIZE, readback.get(), nonZeroRowBytes,
                                     alphaData, msg);
             }
         }
     }
 }
 
 #endif