GraphitePromiseImageTest.cpp File Reference

#include "include/gpu/graphite/BackendTexture.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkSurface.h"
#include "include/gpu/graphite/Context.h"
#include "include/gpu/graphite/Image.h"
#include "include/gpu/graphite/Recording.h"
#include "include/gpu/graphite/Surface.h"
#include "src/gpu/graphite/Caps.h"
#include "src/gpu/graphite/ContextPriv.h"
#include "src/gpu/graphite/RecordingPriv.h"
#include "tests/Test.h"
#include "tools/graphite/GraphiteTestContext.h"

Go to the source code of this file.

Functions
	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (NonVolatileGraphitePromiseImageTest, reporter, context, testGpuContext, true, CtsEnforcement::kNextRelease)
	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (NonVolatileGraphitePromiseImageFulfillFailureTest, reporter, context, testGpuContext, true, CtsEnforcement::kNextRelease)
	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (NonVolatileGraphitePromiseImageCreationFailureTest, reporter, context, testGpuContext, true, CtsEnforcement::kNextRelease)
	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (VolatileGraphitePromiseImageTest, reporter, context, testGpuContext, true, CtsEnforcement::kNextRelease)
	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (VolatileGraphitePromiseImageFulfillFailureTest, reporter, context, testGpuContext, true, CtsEnforcement::kNextRelease)
	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (GraphitePromiseImageRecorderLoss, reporter, context, testGpuContext, true, CtsEnforcement::kNextRelease)
	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (GraphitePromiseImageMultipleImgUses, reporter, context, testGpuContext, true, CtsEnforcement::kNextRelease)

Function Documentation

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [1/7]

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	GraphitePromiseImageMultipleImgUses	,
		reporter	,
		context	,
		testGpuContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 631 of file GraphitePromiseImageTest.cpp.

                                                                                 {
    constexpr SkISize kDimensions{ 16, 16 };
 
    static constexpr int kNumRecordings = 3;
 
    for (Volatile isVolatile : { Volatile::kNo, Volatile::kYes }) {
        int expectedVolatile = (isVolatile == Volatile::kYes) ? 1 : 0;
        int expectedNonVolatile = 1 - expectedVolatile;
 
        TestCtx testContext;
        setup_test_context(context, reporter, &testContext,
                           kDimensions, isVolatile, /* invalidBackendTex= */ false);
 
        std::unique_ptr<Recording> recordings[kNumRecordings];
 
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        for (int i = 0; i < kNumRecordings; ++i) {
            canvas->drawImage(testContext.fImg, 0, 0);
 
            recordings[i] = testContext.fRecorder->snap();
 
            if (isVolatile == Volatile::kYes) {
                check_fulfills_only(reporter, testContext.fPromiseChecker,
                                    /* expectedFulfillCnt= */ i);
            } else {
                check_fulfills_only(reporter, testContext.fPromiseChecker,
                                    /* expectedFulfillCnt= */ i > 0 ? 1 : 0);
            }
 
            REPORTER_ASSERT(reporter,
                            recordings[i]->priv().numVolatilePromiseImages() == expectedVolatile);
            REPORTER_ASSERT(reporter,
                            recordings[i]->priv().numNonVolatilePromiseImages() ==
                            expectedNonVolatile);
 
            REPORTER_ASSERT(reporter, context->insertRecording({ recordings[i].get() }));
 
            if (isVolatile == Volatile::kYes) {
                check_fulfills_only(reporter, testContext.fPromiseChecker,
                                    /* expectedFulfillCnt= */ i+1);
            } else {
                check_fulfills_only(reporter, testContext.fPromiseChecker,
                                    /* expectedFulfillCnt= */ 1);
            }
 
            // Non-volatiles are cleared out after a successful insertion
            REPORTER_ASSERT(reporter, recordings[i]->priv().numNonVolatilePromiseImages() == 0);
        }
 
        testGpuContext->syncedSubmit(context);
 
        testContext.fSurface.reset();
        testContext.fImg.reset();
        for (int i = 0; i < kNumRecordings; ++i) {
            recordings[i].reset();
        }
 
        if (isVolatile == Volatile::kYes) {
            check_all_done(reporter, testContext.fPromiseChecker,
                           /* expectedFulfillCnt= */ kNumRecordings);
        } else {
            check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 1);
        }
    }
}

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [2/7]

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	GraphitePromiseImageRecorderLoss	,
		reporter	,
		context	,
		testGpuContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 593 of file GraphitePromiseImageTest.cpp.

                                                                                 {
    constexpr SkISize kDimensions{ 16, 16 };
 
    for (Volatile isVolatile : { Volatile::kNo, Volatile::kYes }) {
        TestCtx testContext;
        setup_test_context(context, reporter, &testContext,
                           kDimensions, isVolatile, /* invalidBackendTex= */ false);
 
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        testContext.fRecorder.reset();  // Recorder drop
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 1);
 
        testGpuContext->syncedSubmit(context);
 
        testContext.fSurface.reset();
        testContext.fImg.reset();
        recording.reset();
 
        check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 1);
    }
}

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [3/7]

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	NonVolatileGraphitePromiseImageCreationFailureTest	,
		reporter	,
		context	,
		testGpuContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 402 of file GraphitePromiseImageTest.cpp.

                                    {
    // Note: these dimensions are invalid and will cause MakeGraphitePromiseTexture to fail
    constexpr SkISize kDimensions { 0, 0 };
 
    TestCtx testContext;
    setup_test_context(context, reporter, &testContext,
                       kDimensions, Volatile::kNo, /* invalidBackendTex= */ true);
 
    SkASSERT(!testContext.fImg);
 
    // Despite MakeGraphitePromiseTexture failing, ImageRelease is called
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fFulfillCount == 0);
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fImageReleaseCount == 1);
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.totalReleaseCount() == 0);
}

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [4/7]

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	NonVolatileGraphitePromiseImageFulfillFailureTest	,
		reporter	,
		context	,
		testGpuContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 328 of file GraphitePromiseImageTest.cpp.

                                    {
    constexpr SkISize kDimensions { 16, 16 };
 
    TestCtx testContext;
    setup_test_context(context, reporter, &testContext,
                       kDimensions, Volatile::kNo, /* invalidBackendTex= */ true);
 
    // Draw the image a few different ways.
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 1);
 
        // Test that reinserting gives uninstantiated PromiseImages a second chance
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 2);
    }
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        SkPaint paint;
        paint.setColorFilter(SkColorFilters::LinearToSRGBGamma());
        canvas->drawImage(testContext.fImg, 0, 0, SkSamplingOptions(), &paint);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 2);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 3);
    }
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        sk_sp<SkShader> shader = testContext.fImg->makeShader(SkSamplingOptions());
        REPORTER_ASSERT(reporter, shader);
 
        SkPaint paint;
        paint.setShader(std::move(shader));
        canvas->drawRect(SkRect::MakeWH(1, 1), paint);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 3);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 4);
    }
 
    testContext.fSurface.reset();
    testContext.fImg.reset();
 
    // Despite fulfill failing 4x, the imageRelease callback still fires
    testContext.fPromiseChecker.checkImageReleased(reporter, /* expectedReleaseCnt= */ 1);
 
    testGpuContext->syncedSubmit(context);
    // fulfill should've been called 4x while release should never have been called
    check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 4);
}

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [5/7]

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	NonVolatileGraphitePromiseImageTest	,
		reporter	,
		context	,
		testGpuContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 242 of file GraphitePromiseImageTest.cpp.

                                                                                 {
    constexpr SkISize kDimensions { 16, 16 };
 
    TestCtx testContext;
    setup_test_context(context, reporter, &testContext,
                       kDimensions, Volatile::kNo, /* invalidBackendTex= */ false);
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_unfulfilled(testContext.fPromiseChecker, reporter); // NVPIs not fulfilled at snap
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 1); // NVPIs fulfilled at insert
    }
 
    context->submit(SyncToCpu::kNo);
    // testContext.fImg still has a ref so we should not have called TextureRelease.
    check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                 /* expectedFulfillCnt= */ 1);
 
    testGpuContext->syncedSubmit(context);
    check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                 /* expectedFulfillCnt= */ 1);
 
    // Test that more draws and insertions don't refulfill the NVPI
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        canvas->drawImage(testContext.fImg, 0, 0);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 1); // No new fulfill
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        // testContext.fImg should still be fulfilled from the first time we inserted a Recording.
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 1);
    }
 
    testGpuContext->syncedSubmit(context);
    check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                 /* expectedFulfillCnt= */ 1);
 
    // Test that dropping the SkImage's ref doesn't change anything
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        testContext.fImg.reset();
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 1);
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 1);
    }
 
    // fImg's proxy is reffed by the recording so, despite fImg being reset earlier,
    // the imageRelease callback doesn't occur until the recording is deleted.
    testContext.fPromiseChecker.checkImageReleased(reporter, /* expectedReleaseCnt= */ 1);
 
    // testContext.fImg no longer holds a ref but the last recording is still not submitted.
    check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                 /* expectedFulfillCnt= */ 1);
 
    testGpuContext->syncedSubmit(context);
 
    // Now TextureRelease should definitely have been called.
    check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 1);
}

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [6/7]

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	VolatileGraphitePromiseImageFulfillFailureTest	,
		reporter	,
		context	,
		testGpuContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 519 of file GraphitePromiseImageTest.cpp.

                                                                                 {
    constexpr SkISize kDimensions { 16, 16 };
 
    TestCtx testContext;
    setup_test_context(context, reporter, &testContext,
                       kDimensions, Volatile::kYes, /* invalidBackendTex= */ true);
 
    // Draw the image a few different ways.
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 1);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 2);
    }
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        SkPaint paint;
        paint.setColorFilter(SkColorFilters::LinearToSRGBGamma());
        canvas->drawImage(testContext.fImg, 0, 0, SkSamplingOptions(), &paint);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 2);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 3);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 4);
    }
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        sk_sp<SkShader> shader = testContext.fImg->makeShader(SkSamplingOptions());
        REPORTER_ASSERT(reporter, shader);
 
        SkPaint paint;
        paint.setShader(std::move(shader));
        canvas->drawRect(SkRect::MakeWH(1, 1), paint);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 4);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 5);
 
        REPORTER_ASSERT(reporter, !context->insertRecording({ recording.get() }));
        check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 6);
    }
 
    testContext.fSurface.reset();
    testContext.fImg.reset();
 
    testGpuContext->syncedSubmit(context);
    check_fulfills_only(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 6);
}

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [7/7]

DEF_CONDITIONAL_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	VolatileGraphitePromiseImageTest	,
		reporter	,
		context	,
		testGpuContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 424 of file GraphitePromiseImageTest.cpp.

                                                                                 {
    constexpr SkISize kDimensions { 16, 16 };
 
    TestCtx testContext;
    setup_test_context(context, reporter, &testContext,
                       kDimensions, Volatile::kYes, /* invalidBackendTex= */ false);
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        // Nothing happens at snap time for VPIs
        check_unfulfilled(testContext.fPromiseChecker, reporter);
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 1);  // VPIs fulfilled on insert
 
        // Test that multiple insertions will clobber prior fulfills
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_two(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 2);
    }
 
    testGpuContext->syncedSubmit(context);
    check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 2);
 
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fTextureReleaseCounts[0] == 1);
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fTextureReleaseCounts[1] == 1);
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        canvas->drawImage(testContext.fImg, 0, 0);
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        // Nothing happens at snap time for volatile images
        check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 2);
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 3);
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_two(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 4);
    }
 
    testGpuContext->syncedSubmit(context);
    check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 4);
 
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fTextureReleaseCounts[0] == 2);
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fTextureReleaseCounts[1] == 2);
 
    {
        SkCanvas* canvas = testContext.fSurface->getCanvas();
 
        canvas->drawImage(testContext.fImg, 0, 0);
        testContext.fImg.reset();
 
        std::unique_ptr<Recording> recording = testContext.fRecorder->snap();
        // Nothing happens at snap time for volatile images
        check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 4);
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_one(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 5);
 
        REPORTER_ASSERT(reporter, context->insertRecording({ recording.get() }));
        check_fulfilled_ahead_by_two(reporter, testContext.fPromiseChecker,
                                     /* expectedFulfillCnt= */ 6);
    }
 
    // testContext.fImg no longer holds a ref but the last recordings are still not submitted.
    check_fulfilled_ahead_by_two(reporter, testContext.fPromiseChecker,
                                 /* expectedFulfillCnt= */ 6);
 
    testGpuContext->syncedSubmit(context);
 
    // Now all Releases should definitely have been called.
    check_all_done(reporter, testContext.fPromiseChecker, /* expectedFulfillCnt= */ 6);
 
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fTextureReleaseCounts[0] == 3);
    REPORTER_ASSERT(reporter, testContext.fPromiseChecker.fTextureReleaseCounts[1] == 3);
}