One signature for creating unit tests that run on premade GrContexts

tests/ImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include <initializer_list>
 #include "DMGpuSupport.h"
 
 #include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDevice.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkImage_Base.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPixelSerializer.h"
 #include "SkRRect.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkUtils.h"
 #include "Test.h"
 
-using sk_gpu_test::GrContextFactory;
+using namespace sk_gpu_test;
 
 static void assert_equal(skiatest::Reporter* reporter, SkImage* a, const SkIRect* subsetA,
                          SkImage* b) {
     const int widthA = subsetA ? subsetA->width() : a->width();
     const int heightA = subsetA ? subsetA->height() : a->height();
 
     REPORTER_ASSERT(reporter, widthA == b->width());
     REPORTER_ASSERT(reporter, heightA == b->height());
 
     // see https://bug.skia.org/3965
@@ skipping 129 matching lines @@
     decoded = SkImage::MakeFromEncoded(origEncoded, &ir);
     REPORTER_ASSERT(reporter, decoded);
     assert_equal(reporter, image, &ir, decoded.get());
 }
 
 DEF_TEST(ImageEncode, reporter) {
     test_encode(reporter, create_image().get());
 }
 
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, context) {
-    test_encode(reporter, create_gpu_image(context).get());
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, ctxInfo) {
+    test_encode(reporter, create_gpu_image(ctxInfo.fGrContext).get());
 }
 #endif
 
 namespace {
 
 const char* kSerializedData = "serialized";
 
 class MockSerializer : public SkPixelSerializer {
 public:
     MockSerializer(SkData* (*func)()) : fFunc(func), fDidEncode(false) { }
@@ skipping 171 matching lines @@
 #include "SkBitmapCache.h"
 
 /*
  *  This tests the caching (and preemptive purge) of the raster equivalent of a gpu-image.
  *  We cache it for performance when drawing into a raster surface.
  *
  *  A cleaner test would know if each drawImage call triggered a read-back from the gpu,
  *  but we don't have that facility (at the moment) so we use a little internal knowledge
  *  of *how* the raster version is cached, and look for that.
  */
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_Gpu2Cpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_Gpu2Cpu, reporter, ctxInfo) {
     SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
-    sk_sp<SkImage> image(create_gpu_image(context));
+    sk_sp<SkImage> image(create_gpu_image(ctxInfo.fGrContext));
     const uint32_t uniqueID = image->uniqueID();
 
     auto surface(SkSurface::MakeRaster(info));
 
     // now we can test drawing a gpu-backed image into a cpu-backed surface
 
     {
         SkBitmap cachedBitmap;
         REPORTER_ASSERT(reporter, !SkBitmapCache::Find(uniqueID, &cachedBitmap));
     }
@@ skipping 12 matching lines @@
         }
     }
 
     image.reset(nullptr);
     {
         SkBitmap cachedBitmap;
         REPORTER_ASSERT(reporter, !SkBitmapCache::Find(uniqueID, &cachedBitmap));
     }
 }
 
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_newTextureImage, reporter, context, glContext) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_newTextureImage, reporter, contextInfo) {
+    GrContext* context = contextInfo.fGrContext;
+    sk_gpu_test::GLTestContext* glContext = contextInfo.fGLContext;
+
     GrContextFactory otherFactory;
-    GrContextFactory::ContextInfo otherContextInfo =
+    ContextInfo otherContextInfo =
         otherFactory.getContextInfo(GrContextFactory::kNativeGL_ContextType);
     glContext->makeCurrent();
 
     std::function<sk_sp<SkImage>()> imageFactories[] = {
         create_image,
         create_codec_image,
         create_data_image,
         // Create an image from a picture.
         create_picture_image,
         // Create a texture image.
@@ skipping 147 matching lines @@
     RasterDataHolder dataHolder;
     image = create_rasterproc_image(&dataHolder);
     test_read_pixels(reporter, image.get());
     image.reset();
     REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
 
     image = create_codec_image();
     test_read_pixels(reporter, image.get());
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageReadPixels_Gpu, reporter, context) {
-    test_read_pixels(reporter, create_gpu_image(context).get());
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageReadPixels_Gpu, reporter, ctxInfo) {
+    test_read_pixels(reporter, create_gpu_image(ctxInfo.fGrContext).get());
 }
 #endif
 
 static void check_legacy_bitmap(skiatest::Reporter* reporter, const SkImage* image,
                                 const SkBitmap& bitmap, SkImage::LegacyBitmapMode mode) {
     REPORTER_ASSERT(reporter, image->width() == bitmap.width());
     REPORTER_ASSERT(reporter, image->height() == bitmap.height());
     REPORTER_ASSERT(reporter, image->isOpaque() == bitmap.isOpaque());
 
     if (SkImage::kRO_LegacyBitmapMode == mode) {
@@ skipping 41 matching lines @@
         image = create_rasterproc_image(&dataHolder);
         test_legacy_bitmap(reporter, image.get(), mode);
         image.reset();
         REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
 
         image = create_codec_image();
         test_legacy_bitmap(reporter, image.get(), mode);
     }
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageLegacyBitmap_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageLegacyBitmap_Gpu, reporter, ctxInfo) {
     const SkImage::LegacyBitmapMode modes[] = {
         SkImage::kRO_LegacyBitmapMode,
         SkImage::kRW_LegacyBitmapMode,
     };
     for (auto& mode : modes) {
-        sk_sp<SkImage> image(create_gpu_image(context));
+        sk_sp<SkImage> image(create_gpu_image(ctxInfo.fGrContext));
         test_legacy_bitmap(reporter, image.get(), mode);
     }
 }
 #endif
 
 static void test_peek(skiatest::Reporter* reporter, SkImage* image, bool expectPeekSuccess) {
     SkPixmap pm;
     bool success = image->peekPixels(&pm);
     REPORTER_ASSERT(reporter, expectPeekSuccess == success);
     if (success) {
@@ skipping 17 matching lines @@
     RasterDataHolder dataHolder;
     image = create_rasterproc_image(&dataHolder);
     test_peek(reporter, image.get(), true);
     image.reset();
     REPORTER_ASSERT(reporter, 1 == dataHolder.fReleaseCount);
 
     image = create_codec_image();
     test_peek(reporter, image.get(), false);
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImagePeek_Gpu, reporter, context) {
-    sk_sp<SkImage> image(create_gpu_image(context));
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImagePeek_Gpu, reporter, ctxInfo) {
+    sk_sp<SkImage> image(create_gpu_image(ctxInfo.fGrContext));
     test_peek(reporter, image.get(), false);
 }
 #endif
 
 #if SK_SUPPORT_GPU
 struct TextureReleaseChecker {
     TextureReleaseChecker() : fReleaseCount(0) {}
     int fReleaseCount;
     static void Release(void* self) {
         static_cast<TextureReleaseChecker*>(self)->fReleaseCount++;
     }
 };
 static void check_image_color(skiatest::Reporter* reporter, SkImage* image, SkPMColor expected) {
     const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
     SkPMColor pixel;
     REPORTER_ASSERT(reporter, image->readPixels(info, &pixel, sizeof(pixel), 0, 0));
     REPORTER_ASSERT(reporter, pixel == expected);
 }
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_NewFromTexture, reporter, context) {
-    GrTextureProvider* provider = context->textureProvider();
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_NewFromTexture, reporter, ctxInfo) {
+    GrTextureProvider* provider = ctxInfo.fGrContext->textureProvider();
     const int w = 10;
     const int h = 10;
     SkPMColor storage[w * h];
     const SkPMColor expected0 = SkPreMultiplyColor(SK_ColorRED);
     sk_memset32(storage, expected0, w * h);
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;  // needs to be a rendertarget for readpixels();
     desc.fOrigin = kDefault_GrSurfaceOrigin;
     desc.fWidth = w;
     desc.fHeight = h;
     desc.fConfig = kSkia8888_GrPixelConfig;
     desc.fSampleCnt = 0;
     SkAutoTUnref<GrTexture> tex(provider->createTexture(desc, SkBudgeted::kNo, storage, w * 4));
     if (!tex) {
         REPORTER_ASSERT(reporter, false);
         return;
     }
 
     GrBackendTextureDesc backendDesc;
     backendDesc.fConfig = kSkia8888_GrPixelConfig;
     backendDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
     backendDesc.fWidth = w;
     backendDesc.fHeight = h;
     backendDesc.fSampleCnt = 0;
     backendDesc.fTextureHandle = tex->getTextureHandle();
     TextureReleaseChecker releaseChecker;
     sk_sp<SkImage> refImg(
-        SkImage::MakeFromTexture(context, backendDesc, kPremul_SkAlphaType,
+        SkImage::MakeFromTexture(ctxInfo.fGrContext, backendDesc, kPremul_SkAlphaType,
                                  TextureReleaseChecker::Release, &releaseChecker));
-    sk_sp<SkImage> cpyImg(SkImage::MakeFromTextureCopy(context, backendDesc, kPremul_SkAlphaType));
+    sk_sp<SkImage> cpyImg(SkImage::MakeFromTextureCopy(ctxInfo.fGrContext, backendDesc,
+                                                       kPremul_SkAlphaType));
 
     check_image_color(reporter, refImg.get(), expected0);
     check_image_color(reporter, cpyImg.get(), expected0);
 
     // Now lets jam new colors into our "external" texture, and see if the images notice
     const SkPMColor expected1 = SkPreMultiplyColor(SK_ColorBLUE);
     sk_memset32(storage, expected1, w * h);
     tex->writePixels(0, 0, w, h, kSkia8888_GrPixelConfig, storage, GrContext::kFlushWrites_PixelOp);
 
     // The cpy'd one should still see the old color
@@ skipping 42 matching lines @@
             uint32_t pixelB = *bpm.addr32(x, y);
             if (pixelA != pixelB) {
                 ERRORF(reporter, "Expected image pixels to be the same. At %d,%d 0x%08x != 0x%08x",
                        x, y, pixelA, pixelB);
                 return;
             }
         }
     }
 }
 
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(NewTextureFromPixmap, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(NewTextureFromPixmap, reporter, ctxInfo) {
     for (auto create : {&create_image,
                         &create_image_565,
                         &create_image_ct}) {
         sk_sp<SkImage> image((*create)());
         if (!image) {
             ERRORF(reporter, "Could not create image");
             return;
         }
 
         SkPixmap pixmap;
         if (!image->peekPixels(&pixmap)) {
             ERRORF(reporter, "peek failed");
         } else {
-            sk_sp<SkImage> texImage(SkImage::MakeTextureFromPixmap(context, pixmap,
+            sk_sp<SkImage> texImage(SkImage::MakeTextureFromPixmap(ctxInfo.fGrContext, pixmap,
                                                                    SkBudgeted::kNo));
             if (!texImage) {
                 ERRORF(reporter, "NewTextureFromPixmap failed.");
             } else {
                 check_images_same(reporter, image.get(), texImage.get());
             }
         }
     }
 }
 
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredTextureImage, reporter, context, glContext) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredTextureImage, reporter, ctxInfo) {
+    GrContext* context = ctxInfo.fGrContext;
+    sk_gpu_test::GLTestContext* glContext = ctxInfo.fGLContext;
     SkAutoTUnref<GrContextThreadSafeProxy> proxy(context->threadSafeProxy());
 
     GrContextFactory otherFactory;
-    GrContextFactory::ContextInfo otherContextInfo =
+    ContextInfo otherContextInfo =
         otherFactory.getContextInfo(GrContextFactory::kNativeGL_ContextType);
 
     glContext->makeCurrent();
     REPORTER_ASSERT(reporter, proxy);
     struct {
         std::function<sk_sp<SkImage> ()> fImageFactory;
         bool                       fExpectation;
     } testCases[] = {
         { create_image,          true },
         { create_codec_image,    true },
@@ skipping 47 matching lines @@
                         otherContextInfo.fGrContext, buffer, budgeted));
                     REPORTER_ASSERT(reporter, !newImage2);
                     glContext->makeCurrent();
                 }
             }
             sk_free(buffer);
         }
     }
 }
 #endif