TestHelper Class Reference

Classes
struct	Stats

Public Types
typedef void(TestHelper::*	addAccessFP) (SkCanvas *, int wh, int id, bool failLookUp, bool failFillingIn)
typedef bool(TestHelper::*	checkFP) (SkCanvas *, int wh, int expectedHits, int expectedMisses, int expectedNumRefs, int expectedID)

Public Member Functions
	TestHelper (GrDirectContext *dContext, GrThreadSafeCache::IsNewerBetter isNewerBetter=default_is_newer_better)
	~TestHelper ()
Stats *	stats ()
int	numCacheEntries () const
GrDirectContext *	dContext ()
SkCanvas *	liveCanvas ()
SkCanvas *	ddlCanvas1 ()
sk_sp< GrDeferredDisplayList >	snap1 ()
SkCanvas *	ddlCanvas2 ()
sk_sp< GrDeferredDisplayList >	snap2 ()
GrThreadSafeCache *	threadSafeCache ()
const GrThreadSafeCache *	threadSafeCache () const
void	addViewAccess (SkCanvas *canvas, int wh, int id=kNoID, bool failLookup=false, bool failFillingIn=false)
bool	checkView (SkCanvas *canvas, int wh, int expectedHits, int expectedMisses, int expectedNumRefs, int expectedID)
void	addVertAccess (SkCanvas *canvas, int wh, int id, bool failLookup, bool failFillingIn, GrThreadSafeVertexTestOp **createdOp)
void	addVertAccess (SkCanvas *canvas, int wh, int id=kNoID, bool failLookup=false, bool failFillingIn=false)
bool	checkVert (SkCanvas *canvas, int wh, int expectedHits, int expectedMisses, int expectedNumRefs, int expectedID)
bool	checkImage (skiatest::Reporter *reporter, const sk_sp< SkSurface > &s)
bool	checkImage (skiatest::Reporter *reporter)
bool	checkImage (skiatest::Reporter *reporter, sk_sp< GrDeferredDisplayList > ddl)
size_t	gpuSize (int wh) const

Detailed Description

Definition at line 163 of file GrThreadSafeCacheTest.cpp.

Member Typedef Documentation

addAccessFP

typedef void(TestHelper::* TestHelper::addAccessFP) (SkCanvas *, int wh, int id, bool failLookUp, bool failFillingIn)

Definition at line 229 of file GrThreadSafeCacheTest.cpp.

checkFP

typedef bool(TestHelper::* TestHelper::checkFP) (SkCanvas *, int wh, int expectedHits, int expectedMisses, int expectedNumRefs, int expectedID)

Definition at line 231 of file GrThreadSafeCacheTest.cpp.

Constructor & Destructor Documentation

TestHelper()

TestHelper::TestHelper ( GrDirectContext *  dContext, GrThreadSafeCache::IsNewerBetter  isNewerBetter = default_is_newer_better  )

inline

Definition at line 174 of file GrThreadSafeCacheTest.cpp.

            : fDContext(dContext)
            , fIsNewerBetter(isNewerBetter) {
        fDst = SkSurfaces::RenderTarget(dContext, skgpu::Budgeted::kNo, default_ii(kImageWH));
        SkAssertResult(fDst);
 
        GrSurfaceCharacterization characterization;
        SkAssertResult(fDst->characterize(&characterization));
 
        fRecorder1 = std::make_unique<GrDeferredDisplayListRecorder>(characterization);
        this->ddlCanvas1()->clear(SkColors::kWhite);
 
        fRecorder2 = std::make_unique<GrDeferredDisplayListRecorder>(characterization);
        this->ddlCanvas2()->clear(SkColors::kWhite);
 
        fDst->getCanvas()->clear(SkColors::kWhite);
    }

~TestHelper()

TestHelper::~TestHelper ( )

inline

Definition at line 193 of file GrThreadSafeCacheTest.cpp.

                  {
        fDContext->flush();
        fDContext->submit(GrSyncCpu::kYes);
    }

Member Function Documentation

addVertAccess() [1/2]

void TestHelper::addVertAccess	(	SkCanvas *	canvas,
		int	wh,
		int	id,
		bool	failLookup,
		bool	failFillingIn,
		GrThreadSafeVertexTestOp **	createdOp
	)

Definition at line 669 of file GrThreadSafeCacheTest.cpp.

                                                                     {
    auto rContext = canvas->recordingContext();
    auto sdc = skgpu::ganesh::TopDeviceSurfaceDrawContext(canvas);
 
    GrOp::Owner op = GrThreadSafeVertexTestOp::Make(rContext, &fStats,
                                                    wh, id,
                                                    failLookup, failFillingIn,
                                                    fIsNewerBetter);
    if (createdOp) {
        *createdOp = (GrThreadSafeVertexTestOp*) op.get();
    }
 
    sdc->addDrawOp(std::move(op));
}

addVertAccess() [2/2]

void TestHelper::addVertAccess ( SkCanvas *  canvas, int  wh, int  id = kNoID, bool  failLookup = false, bool  failFillingIn = false  )

inline

Definition at line 344 of file GrThreadSafeCacheTest.cpp.

                                                   {
        this->addVertAccess(canvas, wh, id, failLookup, failFillingIn, nullptr);
    }

addViewAccess()

void TestHelper::addViewAccess ( SkCanvas *  canvas, int  wh, int  id = kNoID, bool  failLookup = false, bool  failFillingIn = false  )

inline

Definition at line 236 of file GrThreadSafeCacheTest.cpp.

                                                   {
        auto rContext = canvas->recordingContext();
 
        auto view = AccessCachedView(rContext, this->threadSafeCache(),
                                     wh, failLookup, failFillingIn, id, &fStats);
        SkASSERT(view);
 
        auto sdc = skgpu::ganesh::TopDeviceSurfaceDrawContext(canvas);
 
        sdc->drawTexture(nullptr,
                         view,
                         kPremul_SkAlphaType,
                         GrSamplerState::Filter::kNearest,
                         GrSamplerState::MipmapMode::kNone,
                         SkBlendMode::kSrcOver,
                         {1.0f, 1.0f, 1.0f, 1.0f},
                         SkRect::MakeWH(wh, wh),
                         SkRect::MakeWH(wh, wh),
                         GrQuadAAFlags::kNone,
                         SkCanvas::kFast_SrcRectConstraint,
                         SkMatrix::I(),
                         nullptr);
    }

checkImage() [1/3]

bool TestHelper::checkImage ( skiatest::Reporter *  reporter )

inline

Definition at line 426 of file GrThreadSafeCacheTest.cpp.

                                                {
        return this->checkImage(reporter, fDst);
    }

checkImage() [2/3]

bool TestHelper::checkImage ( skiatest::Reporter *  reporter, const sk_sp< SkSurface > &  s  )

inline

Definition at line 403 of file GrThreadSafeCacheTest.cpp.

                                                                           {
        SkBitmap actual;
 
        actual.allocPixels(default_ii(kImageWH));
 
        if (!s->readPixels(actual, 0, 0)) {
            return false;
        }
 
        SkBitmap expected = create_bitmap(kImageWH);
 
        const float tols[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
 
        auto error = std::function<ComparePixmapsErrorReporter>(
            [reporter](int x, int y, const float diffs[4]) {
                SkASSERT(x >= 0 && y >= 0);
                ERRORF(reporter, "mismatch at %d, %d (%f, %f, %f %f)",
                       x, y, diffs[0], diffs[1], diffs[2], diffs[3]);
            });
 
        return ComparePixels(expected.pixmap(), actual.pixmap(), tols, error);
    }

checkImage() [3/3]

bool TestHelper::checkImage ( skiatest::Reporter *  reporter, sk_sp< GrDeferredDisplayList >  ddl  )

inline

Definition at line 430 of file GrThreadSafeCacheTest.cpp.

                                                                                  {
        sk_sp<SkSurface> tmp =
                SkSurfaces::RenderTarget(fDContext, skgpu::Budgeted::kNo, default_ii(kImageWH));
        if (!tmp) {
            return false;
        }
 
        if (!skgpu::ganesh::DrawDDL(tmp, std::move(ddl))) {
            return false;
        }
 
        return this->checkImage(reporter, std::move(tmp));
    }

checkVert()

bool TestHelper::checkVert ( SkCanvas *  canvas, int  wh, int  expectedHits, int  expectedMisses, int  expectedNumRefs, int  expectedID  )

inline

Definition at line 352 of file GrThreadSafeCacheTest.cpp.

                                                                                              {
        if (fStats.fCacheHits != expectedHits || fStats.fCacheMisses != expectedMisses) {
            SkDebugf("Hits E: %d A: %d --- Misses E: %d A: %d\n",
                     expectedHits, fStats.fCacheHits, expectedMisses, fStats.fCacheMisses);
            return false;
        }
 
        skgpu::UniqueKey key;
        create_vert_key(&key, wh, kNoID);
 
        auto threadSafeCache = this->threadSafeCache();
 
        auto [vertData, xtraData] = threadSafeCache->findVertsWithData(key);
        if (!vertData) {
            return false;
        }
 
        if (expectedID < 0) {
            if (xtraData) {
                return false;
            }
        } else {
            if (!xtraData) {
                return false;
            }
 
            const int* cachedID = static_cast<const int*>(xtraData->data());
            if (*cachedID != expectedID) {
                return false;
            }
        }
 
        if (!vertData->refCntGreaterThan(expectedNumRefs+1) ||  // +1 for 'vertData's ref
            vertData->refCntGreaterThan(expectedNumRefs+2)) {
            return false;
        }
 
        {
            auto resourceProvider = fDContext->priv().resourceProvider();
            sk_sp<GrGpuBuffer> buffer = resourceProvider->findByUniqueKey<GrGpuBuffer>(key);
            if (buffer) {
                // the buffer holding the vertex data in this cache should never be discoverable
                // in the resource cache
                return false;
            }
        }
 
        return true;
    }

checkView()

bool TestHelper::checkView ( SkCanvas *  canvas, int  wh, int  expectedHits, int  expectedMisses, int  expectedNumRefs, int  expectedID  )

inline

Definition at line 266 of file GrThreadSafeCacheTest.cpp.

                                                                                              {
        if (fStats.fCacheHits != expectedHits || fStats.fCacheMisses != expectedMisses) {
            SkDebugf("Hits E: %d A: %d --- Misses E: %d A: %d\n",
                     expectedHits, fStats.fCacheHits, expectedMisses, fStats.fCacheMisses);
            return false;
        }
 
        skgpu::UniqueKey key;
        create_view_key(&key, wh, kNoID);
 
        auto threadSafeCache = this->threadSafeCache();
 
        auto [view, xtraData] = threadSafeCache->findWithData(key);
        if (!view.proxy()) {
            return false;
        }
 
        if (expectedID < 0) {
            if (xtraData) {
                return false;
            }
        } else {
            if (!xtraData) {
                return false;
            }
 
            const int* cachedID = static_cast<const int*>(xtraData->data());
            if (*cachedID != expectedID) {
                return false;
            }
        }
 
        if (!view.proxy()->refCntGreaterThan(expectedNumRefs+1) ||  // +1 for 'view's ref
            view.proxy()->refCntGreaterThan(expectedNumRefs+2)) {
            return false;
        }
 
        if (canvas) {
            GrRecordingContext* rContext = canvas->recordingContext();
            GrProxyProvider* recordingProxyProvider = rContext->priv().proxyProvider();
            sk_sp<GrTextureProxy> result = recordingProxyProvider->findProxyByUniqueKey(key);
            if (result) {
                // views in this cache should never appear in the recorder's cache
                return false;
            }
        }
 
        {
            GrProxyProvider* directProxyProvider = fDContext->priv().proxyProvider();
            sk_sp<GrTextureProxy> result = directProxyProvider->findProxyByUniqueKey(key);
            if (result) {
                // views in this cache should never appear in the main proxy cache
                return false;
            }
        }
 
        {
            auto resourceProvider = fDContext->priv().resourceProvider();
            sk_sp<GrSurface> surf = resourceProvider->findByUniqueKey<GrSurface>(key);
            if (surf) {
                // the textures backing the views in this cache should never be discoverable in the
                // resource cache
                return false;
            }
        }
 
        return true;
    }

dContext()

GrDirectContext * TestHelper::dContext ( )

inline

Definition at line 202 of file GrThreadSafeCacheTest.cpp.

{ return fDContext; }

ddlCanvas1()

SkCanvas * TestHelper::ddlCanvas1 ( )

inline

Definition at line 205 of file GrThreadSafeCacheTest.cpp.

{ return fRecorder1 ? fRecorder1->getCanvas() : nullptr; }

ddlCanvas2()

SkCanvas * TestHelper::ddlCanvas2 ( )

inline

Definition at line 215 of file GrThreadSafeCacheTest.cpp.

{ return fRecorder2 ? fRecorder2->getCanvas() : nullptr; }

gpuSize()

size_t TestHelper::gpuSize ( int  wh ) const

inline

Definition at line 444 of file GrThreadSafeCacheTest.cpp.

                                 {
        GrBackendFormat format = fDContext->defaultBackendFormat(kRGBA_8888_SkColorType,
                                                                 GrRenderable::kNo);
 
        return GrSurface::ComputeSize(format,
                                      {wh, wh},
                                      /*colorSamplesPerPixel=*/1,
                                      skgpu::Mipmapped::kNo,
                                      /*binSize=*/false);
    }

liveCanvas()

SkCanvas * TestHelper::liveCanvas ( )

inline

Definition at line 204 of file GrThreadSafeCacheTest.cpp.

{ return fDst ? fDst->getCanvas() : nullptr; }

numCacheEntries()

int TestHelper::numCacheEntries ( ) const

inline

Definition at line 200 of file GrThreadSafeCacheTest.cpp.

{ return this->threadSafeCache()->numEntries(); }

snap1()

sk_sp< GrDeferredDisplayList > TestHelper::snap1 ( )

inline

Definition at line 206 of file GrThreadSafeCacheTest.cpp.

                                         {
        if (fRecorder1) {
            sk_sp<GrDeferredDisplayList> tmp = fRecorder1->detach();
            fRecorder1 = nullptr;
            return tmp;
        }
 
        return nullptr;
    }

snap2()

sk_sp< GrDeferredDisplayList > TestHelper::snap2 ( )

inline

Definition at line 216 of file GrThreadSafeCacheTest.cpp.

                                         {
        if (fRecorder2) {
            sk_sp<GrDeferredDisplayList> tmp = fRecorder2->detach();
            fRecorder2 = nullptr;
            return tmp;
        }
 
        return nullptr;
    }

stats()

Stats * TestHelper::stats ( )

inline

Definition at line 198 of file GrThreadSafeCacheTest.cpp.

{ return &fStats; }

threadSafeCache() [1/2]

GrThreadSafeCache * TestHelper::threadSafeCache ( )

inline

Definition at line 226 of file GrThreadSafeCacheTest.cpp.

{ return fDContext->priv().threadSafeCache(); }

threadSafeCache() [2/2]

const GrThreadSafeCache * TestHelper::threadSafeCache ( ) const

inline

Definition at line 227 of file GrThreadSafeCacheTest.cpp.

{ return fDContext->priv().threadSafeCache(); }

---

The documentation for this class was generated from the following file:

• third_party/skia/tests/GrThreadSafeCacheTest.cpp