One signature for creating unit tests that run on premade GrContexts

tests/SurfaceTest.cpp

 /*
  * Copyright 2013 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 "SkCanvas.h"
 #include "SkData.h"
@@ skipping 56 matching lines @@
 }
 #endif
 
 DEF_TEST(SurfaceEmpty, reporter) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     REPORTER_ASSERT(reporter, nullptr == SkSurface::MakeRaster(info));
     REPORTER_ASSERT(reporter, nullptr == SkSurface::MakeRasterDirect(info, nullptr, 0));
 
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceEmpty_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceEmpty_Gpu, reporter, ctxInfo) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     REPORTER_ASSERT(reporter, nullptr ==
-                    SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr));
+                    SkSurface::MakeRenderTarget(ctxInfo.fGrContext, SkBudgeted::kNo, info, 0,
+                                                nullptr));
 }
 #endif
 
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWrappedTexture, reporter, context) {
-    GrGpu* gpu = context->getGpu();
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWrappedTexture, reporter, ctxInfo) {
+    GrGpu* gpu = ctxInfo.fGrContext->getGpu();
     if (!gpu) {
         return;
     }
 
     // Test the wrapped factory for SkSurface by creating a backend texture and then wrap it in
     // a SkSurface.
     static const int kW = 100;
     static const int kH = 100;
     static const uint32_t kOrigColor = 0xFFAABBCC;
     SkAutoTArray<uint32_t> pixels(kW * kH);
     sk_memset32(pixels.get(), kOrigColor, kW * kH);
     GrBackendObject texHandle = gpu->createTestingOnlyBackendTexture(pixels.get(), kW, kH,
                                                                      kRGBA_8888_GrPixelConfig);
 
     GrBackendTextureDesc wrappedDesc;
     wrappedDesc.fConfig = kRGBA_8888_GrPixelConfig;
     wrappedDesc.fWidth = kW;
     wrappedDesc.fHeight = kH;
     wrappedDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
     wrappedDesc.fSampleCnt = 0;
     wrappedDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
     wrappedDesc.fTextureHandle = texHandle;
 
-    auto surface(SkSurface::MakeFromBackendTexture(context, wrappedDesc, nullptr));
+    auto surface(SkSurface::MakeFromBackendTexture(ctxInfo.fGrContext, wrappedDesc, nullptr));
     REPORTER_ASSERT(reporter, surface);
     if (surface) {
         // Validate that we can draw to the canvas and that the original texture color is preserved
         // in pixels that aren't rendered to via the surface.
         SkPaint paint;
         static const SkColor kRectColor = ~kOrigColor | 0xFF000000;
         paint.setColor(kRectColor);
         surface->getCanvas()->drawRect(SkRect::MakeWH(SkIntToScalar(kW), SkIntToScalar(kH)/2),
                                        paint);
         SkImageInfo readInfo = SkImageInfo::MakeN32Premul(kW, kH);
@@ skipping 57 matching lines @@
     }
 }
 DEF_TEST(SurfaceCanvasPeek, reporter) {
     for (auto& surface_func : { &create_surface, &create_direct_surface }) {
         SkImageInfo requestInfo;
         auto surface(surface_func(kPremul_SkAlphaType, &requestInfo));
         test_canvas_peek(reporter, surface, requestInfo, true);
     }
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCanvasPeek_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCanvasPeek_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         SkImageInfo requestInfo;
-        auto surface(surface_func(context, kPremul_SkAlphaType, &requestInfo));
+        auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, &requestInfo));
         test_canvas_peek(reporter, surface, requestInfo, false);
     }
 }
 #endif
 
 // For compatibility with clients that still call accessBitmap(), we need to ensure that we bump
 // the bitmap's genID when we draw to it, else they won't know it has new values. When they are
 // exclusively using surface/image, and we can hide accessBitmap from device, we can remove this
 // test.
 void test_access_pixels(skiatest::Reporter* reporter, const sk_sp<SkSurface>& surface) {
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(0);
 
     SkBaseDevice* device = canvas->getDevice_just_for_deprecated_compatibility_testing();
     SkBitmap bm = device->accessBitmap(false);
     uint32_t genID0 = bm.getGenerationID();
     // Now we draw something, which needs to "dirty" the genID (sorta like copy-on-write)
     canvas->drawColor(SK_ColorBLUE);
     // Now check that we get a different genID
     uint32_t genID1 = bm.getGenerationID();
     REPORTER_ASSERT(reporter, genID0 != genID1);
 }
 DEF_TEST(SurfaceAccessPixels, reporter) {
     for (auto& surface_func : { &create_surface, &create_direct_surface }) {
         auto surface(surface_func(kPremul_SkAlphaType, nullptr));
         test_access_pixels(reporter, surface);
     }
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceAccessPixels_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceAccessPixels_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+        auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
         test_access_pixels(reporter, surface);
     }
 }
 #endif
 
 static void test_snapshot_alphatype(skiatest::Reporter* reporter, const sk_sp<SkSurface>& surface,
                                     bool expectOpaque) {
     REPORTER_ASSERT(reporter, surface);
     if (surface) {
         sk_sp<SkImage> image(surface->makeImageSnapshot());
         REPORTER_ASSERT(reporter, image);
         if (image) {
             REPORTER_ASSERT(reporter, image->isOpaque() == SkToBool(expectOpaque));
         }
     }
 }
 DEF_TEST(SurfaceSnapshotAlphaType, reporter) {
     for (auto& surface_func : { &create_surface, &create_direct_surface }) {
         for (auto& isOpaque : { true, false }) {
             SkAlphaType alphaType = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
             auto surface(surface_func(alphaType, nullptr));
             test_snapshot_alphatype(reporter, surface, isOpaque);
         }
     }
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceSnapshotAlphaType_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceSnapshotAlphaType_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& isOpaque : { true, false }) {
             SkAlphaType alphaType = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-            auto surface(surface_func(context, alphaType, nullptr));
+            auto surface(surface_func(ctxInfo.fGrContext, alphaType, nullptr));
             test_snapshot_alphatype(reporter, surface, isOpaque);
         }
     }
 }
 #endif
 
 static GrBackendObject get_surface_backend_texture_handle(
     SkSurface* s, SkSurface::BackendHandleAccess a) {
     return s->getTextureHandle(a);
 }
@@ skipping 27 matching lines @@
     for (auto& handle_access_func :
             { &get_surface_backend_texture_handle, &get_surface_backend_render_target_handle }) {
         for (auto& accessMode : accessModes) {
             auto surface(create_surface());
             test_backend_handle_access_copy_on_write(reporter, surface.get(), accessMode,
                                                      handle_access_func);
         }
     }
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendHandleAccessCopyOnWrite_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendHandleAccessCopyOnWrite_Gpu, reporter, ctxInfo) {
         const SkSurface::BackendHandleAccess accessModes[] = {
         SkSurface::kFlushRead_BackendHandleAccess,
         SkSurface::kFlushWrite_BackendHandleAccess,
         SkSurface::kDiscardWrite_BackendHandleAccess,
     };
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& handle_access_func :
                 { &get_surface_backend_texture_handle, &get_surface_backend_render_target_handle }) {
             for (auto& accessMode : accessModes) {
-                auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+                auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
                 test_backend_handle_access_copy_on_write(reporter, surface.get(), accessMode,
                                                          handle_access_func);
             }
         }
     }
 }
 #endif
 
 static bool same_image(SkImage* a, SkImage* b,
                        std::function<intptr_t(SkImage*)> getImageBackingStore) {
@@ skipping 67 matching lines @@
 
     auto surface(create_surface());
     test_unique_image_snap(reporter, surface.get(), false, getImageBackingStore,
                            getSufaceBackingStore);
     surface = create_direct_surface();
     test_unique_image_snap(reporter, surface.get(), true, getImageBackingStore,
                            getSufaceBackingStore);
 }
 
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(UniqueImageSnapshot_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(UniqueImageSnapshot_Gpu, reporter, ctxInfo) {
+    GrContext* context = ctxInfo.fGrContext;
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         auto surface(surface_func(context, kOpaque_SkAlphaType, nullptr));
 
         auto imageBackingStore = [reporter](SkImage* image) {
             GrTexture* texture = as_IB(image)->peekTexture();
             if (!texture) {
                 ERRORF(reporter, "Not texture backed.");
                 return static_cast<intptr_t>(0);
             }
             return static_cast<intptr_t>(texture->getUniqueID());
@@ skipping 81 matching lines @@
     REPORTER_ASSERT(reporter, image0->uniqueID() != image2->uniqueID());
 
     obj = func(surface, SkSurface::kDiscardWrite_BackendHandleAccess);
     REPORTER_ASSERT(reporter, obj != 0);
     sk_sp<SkImage> image3(surface->makeImageSnapshot());
     // expect a new(er) image, since we claimed we would write
     REPORTER_ASSERT(reporter, image0->uniqueID() != image3->uniqueID());
     REPORTER_ASSERT(reporter, image2->uniqueID() != image3->uniqueID());
 }
 // No CPU test.
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendHandleAccessIDs_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendHandleAccessIDs_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& test_func : { &test_backend_handle_unique_id, &test_backend_handle_gen_id }) {
             for (auto& handle_access_func :
                 { &get_surface_backend_texture_handle, &get_surface_backend_render_target_handle}) {
-                auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+                auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
                 test_func(reporter, surface.get(), handle_access_func);
             }
         }
     }
 }
 #endif
 
 // Verify that the right canvas commands trigger a copy on write.
 static void test_copy_on_write(skiatest::Reporter* reporter, SkSurface* surface) {
     SkCanvas* canvas = surface->getCanvas();
@@ skipping 66 matching lines @@
     EXPECT_COPY_ON_WRITE(drawText(testText.c_str(), testText.size(), 0, 1, testPaint))
     EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \
         testPaint))
     EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, nullptr, \
         testPaint))
 }
 DEF_TEST(SurfaceCopyOnWrite, reporter) {
     test_copy_on_write(reporter, create_surface().get());
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCopyOnWrite_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCopyOnWrite_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+        auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
         test_copy_on_write(reporter, surface.get());
     }
 }
 #endif
 
 static void test_writable_after_snapshot_release(skiatest::Reporter* reporter,
                                                  SkSurface* surface) {
     // This test succeeds by not triggering an assertion.
     // The test verifies that the surface remains writable (usable) after
     // acquiring and releasing a snapshot without triggering a copy on write.
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(1);
     surface->makeImageSnapshot();  // Create and destroy SkImage
     canvas->clear(2);  // Must not assert internally
 }
 DEF_TEST(SurfaceWriteableAfterSnapshotRelease, reporter) {
     test_writable_after_snapshot_release(reporter, create_surface().get());
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWriteableAfterSnapshotRelease_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWriteableAfterSnapshotRelease_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+        auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
         test_writable_after_snapshot_release(reporter, surface.get());
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
 static void test_crbug263329(skiatest::Reporter* reporter,
                              SkSurface* surface1,
                              SkSurface* surface2) {
     // This is a regression test for crbug.com/263329
@@ skipping 18 matching lines @@
     canvas2->clear(5);
     sk_sp<SkImage> image4(surface2->makeImageSnapshot());
     REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image3)->peekTexture());
     // The following assertion checks crbug.com/263329
     REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image2)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image1)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image3)->peekTexture() != as_IB(image2)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image3)->peekTexture() != as_IB(image1)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image2)->peekTexture() != as_IB(image1)->peekTexture());
 }
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCRBug263329_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCRBug263329_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        auto surface1(surface_func(context, kPremul_SkAlphaType, nullptr));
-        auto surface2(surface_func(context, kPremul_SkAlphaType, nullptr));
+        auto surface1(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
+        auto surface2(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
         test_crbug263329(reporter, surface1.get(), surface2.get());
     }
 }
 #endif
 
 DEF_TEST(SurfaceGetTexture, reporter) {
     auto surface(create_surface());
     sk_sp<SkImage> image(surface->makeImageSnapshot());
     REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == nullptr);
     surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
     REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == nullptr);
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacepeekTexture_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacepeekTexture_Gpu, reporter, ctxInfo) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+        auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
         sk_sp<SkImage> image(surface->makeImageSnapshot());
         GrTexture* texture = as_IB(image)->peekTexture();
         REPORTER_ASSERT(reporter, texture);
         REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
         surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
         REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == texture);
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
 #include "GrGpuResourcePriv.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Gpu.h"
 #include "SkSurface_Gpu.h"
 
 static SkBudgeted is_budgeted(const sk_sp<SkSurface>& surf) {
     SkSurface_Gpu* gsurf = (SkSurface_Gpu*)surf.get();
     return gsurf->getDevice()->accessRenderTarget()->resourcePriv().isBudgeted();
 }
 
 static SkBudgeted is_budgeted(SkImage* image) {
     return ((SkImage_Gpu*)image)->peekTexture()->resourcePriv().isBudgeted();
 }
 
 static SkBudgeted is_budgeted(const sk_sp<SkImage> image) {
     return is_budgeted(image.get());
 }
 
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, ctxInfo) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(8,8);
     for (auto sbudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
         for (auto ibudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
-            auto surface(SkSurface::MakeRenderTarget(context, sbudgeted, info));
+            auto surface(SkSurface::MakeRenderTarget(ctxInfo.fGrContext, sbudgeted, info));
             SkASSERT(surface);
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
 
             sk_sp<SkImage> image(surface->makeImageSnapshot(ibudgeted));
 
             // Initially the image shares a texture with the surface, and the surface decides
             // whether it is budgeted or not.
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(image));
 
@@ skipping 37 matching lines @@
 DEF_TEST(SurfaceNoCanvas, reporter) {
     SkSurface::ContentChangeMode modes[] =
             { SkSurface::kDiscard_ContentChangeMode, SkSurface::kRetain_ContentChangeMode};
     for (auto& test_func : { &test_no_canvas1, &test_no_canvas2 }) {
         for (auto& mode : modes) {
             test_func(reporter, create_surface().get(), mode);
         }
     }
 }
 #if SK_SUPPORT_GPU
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceNoCanvas_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceNoCanvas_Gpu, reporter, ctxInfo) {
     SkSurface::ContentChangeMode modes[] =
             { SkSurface::kDiscard_ContentChangeMode, SkSurface::kRetain_ContentChangeMode};
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& test_func : { &test_no_canvas1, &test_no_canvas2 }) {
             for (auto& mode : modes) {
-                auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+                auto surface(surface_func(ctxInfo.fGrContext, kPremul_SkAlphaType, nullptr));
                 test_func(reporter, surface.get(), mode);
             }
         }
     }
 }
 #endif
 
 static void check_rowbytes_remain_consistent(SkSurface* surface, skiatest::Reporter* reporter) {
     SkPixmap surfacePM;
     REPORTER_ASSERT(reporter, surface->peekPixels(&surfacePM));
@@ skipping 64 matching lines @@
                 }
                 ERRORF(reporter,
                        "%s but read 0x%08x (instead of 0x%08x) at %x,%d", msg.c_str(), pixel,
                        expectedValue, x, y);
                 return;
             }
         }
     }
 }
 
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, context) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, ctxInfo) {
+    GrContext* context = ctxInfo.fGrContext;
     std::function<GrSurface*(SkSurface*)> grSurfaceGetters[] = {
         [] (SkSurface* s){ return s->getCanvas()->internal_private_accessTopLayerRenderTarget(); },
         [] (SkSurface* s){
             SkBaseDevice* d =
                 s->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
             return d->accessRenderTarget(); },
         [] (SkSurface* s){ sk_sp<SkImage> i(s->makeImageSnapshot());
                            return as_IB(i)->peekTexture(); },
     };
     for (auto grSurfaceGetter : grSurfaceGetters) {
@@ skipping 17 matching lines @@
         desc.fHeight = kHeight;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fTextureHandle = textureObject;
 
         auto surface = SkSurface::MakeFromBackendTexture(context, desc, nullptr);
         test_surface_clear(reporter, surface, grSurfaceGetter, 0xABABABAB);
         context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
     }
 }
 #endif