SkResourceCacheTest.cpp File Reference

#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkSize.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
#include "include/private/chromium/SkDiscardableMemory.h"
#include "src/core/SkBitmapCache.h"
#include "src/core/SkCachedData.h"
#include "src/core/SkMipmap.h"
#include "src/core/SkResourceCache.h"
#include "src/image/SkImage_Base.h"
#include "src/lazy/SkDiscardableMemoryPool.h"
#include "tests/Test.h"
#include <array>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <memory>

Go to the source code of this file.

Classes
struct	TestKey
struct	TestRec

Enumerations
enum	LockedState {   kUnlocked , kLocked , kUnlocked , kLocked ,   kNotLocked , kLocked , kUnlocked , kLocked }
enum	CachedState {   kNotInCache , kInCache , kNotInCache , kInCache ,   kNotInCache , kInCache , kNotInCache , kInCache }

Functions
static void	check_data (skiatest::Reporter *reporter, const SkCachedData *data, int refcnt, CachedState cacheState, LockedState lockedState)
static void	test_mipmapcache (skiatest::Reporter *reporter, SkResourceCache *cache)
static void	test_mipmap_notify (skiatest::Reporter *reporter, SkResourceCache *cache)
static SkDiscardableMemory *	pool_factory (size_t bytes)
static void	testBitmapCache_discarded_bitmap (skiatest::Reporter *reporter, SkResourceCache *cache, SkResourceCache::DiscardableFactory factory)
	DEF_TEST (BitmapCache_discarded_bitmap, reporter)
static void	test_discarded_image (skiatest::Reporter *reporter, const SkMatrix &transform, sk_sp< SkImage >(*buildImage)())
	DEF_TEST (BitmapCache_discarded_image, reporter)
static void	test_duplicate_add (SkResourceCache *cache, skiatest::Reporter *reporter, bool purgable)
	DEF_TEST (ResourceCache_purge, reporter)

Variables
static SkDiscardableMemoryPool *	gPool = nullptr
static int	gFactoryCalls = 0
static void *	gTestNamespace

Enumeration Type Documentation

CachedState

enum CachedState

Enumerator
kNotInCache
kInCache
kNotInCache
kInCache
kNotInCache
kInCache
kNotInCache
kInCache

Definition at line 44 of file SkResourceCacheTest.cpp.

                 {
    kNotInCache,
    kInCache,
};

LockedState

enum LockedState

Enumerator
kUnlocked
kLocked
kUnlocked
kLocked
kNotLocked
kLocked
kUnlocked
kLocked

Definition at line 39 of file SkResourceCacheTest.cpp.

                 {
    kNotLocked,
    kLocked,
};

Function Documentation

check_data()

static void check_data ( skiatest::Reporter *  reporter, const SkCachedData *  data, int  refcnt, CachedState  cacheState, LockedState  lockedState  )

static

Definition at line 49 of file SkResourceCacheTest.cpp.

                                                                                    {
    REPORTER_ASSERT(reporter, data->testing_only_getRefCnt() == refcnt);
    REPORTER_ASSERT(reporter, data->testing_only_isInCache() == (kInCache == cacheState));
    bool isLocked = (data->data() != nullptr);
    REPORTER_ASSERT(reporter, isLocked == (lockedState == kLocked));
}

DEF_TEST() [1/3]

DEF_TEST	(	BitmapCache_discarded_bitmap	,
		reporter
	)

Definition at line 142 of file SkResourceCacheTest.cpp.

                                                 {
    const size_t byteLimit = 100 * 1024;
    {
        SkResourceCache cache(byteLimit);
        testBitmapCache_discarded_bitmap(reporter, &cache, nullptr);
    }
    {
        sk_sp<SkDiscardableMemoryPool> pool(SkDiscardableMemoryPool::Make(byteLimit));
        gPool = pool.get();
        SkResourceCache::DiscardableFactory factory = pool_factory;
        SkResourceCache cache(factory);
        testBitmapCache_discarded_bitmap(reporter, &cache, factory);
    }
    REPORTER_ASSERT(reporter, gFactoryCalls > 0);
}

DEF_TEST() [2/3]

DEF_TEST	(	BitmapCache_discarded_image	,
		reporter
	)

Definition at line 190 of file SkResourceCacheTest.cpp.

                                                {
    // Cache entries associated with SkImages fall into two categories:
    //
    // 1) generated image bitmaps (managed by the image cacherator)
    // 2) scaled/resampled bitmaps (cached when HQ filters are used)
    //
    // To exercise the first cache type, we use generated/picture-backed SkImages.
    // To exercise the latter, we draw scaled bitmap images using HQ filters.
 
    const SkMatrix xforms[] = {
        SkMatrix::Scale(1, 1),
        SkMatrix::Scale(1.7f, 0.5f),
    };
 
    for (size_t i = 0; i < std::size(xforms); ++i) {
        test_discarded_image(reporter, xforms[i], []() {
            auto surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(10, 10)));
            surface->getCanvas()->clear(SK_ColorCYAN);
            return surface->makeImageSnapshot();
        });
 
        test_discarded_image(reporter, xforms[i], []() {
            SkPictureRecorder recorder;
            SkCanvas* canvas = recorder.beginRecording(10, 10);
            canvas->clear(SK_ColorCYAN);
            return SkImages::DeferredFromPicture(recorder.finishRecordingAsPicture(),
                                                 SkISize::Make(10, 10),
                                                 nullptr,
                                                 nullptr,
                                                 SkImages::BitDepth::kU8,
                                                 SkColorSpace::MakeSRGB());
        });
    }
}

DEF_TEST() [3/3]

DEF_TEST	(	ResourceCache_purge	,
		reporter
	)

Definition at line 297 of file SkResourceCacheTest.cpp.

                                        {
    for (bool purgable : { false, true }) {
        {
            SkResourceCache cache(1024 * 1024);
            test_duplicate_add(&cache, reporter, purgable);
        }
        {
            SkResourceCache cache(SkDiscardableMemory::Create);
            test_duplicate_add(&cache, reporter, purgable);
        }
    }
}

pool_factory()

static SkDiscardableMemory * pool_factory ( size_t  bytes )

static

Definition at line 130 of file SkResourceCacheTest.cpp.

                                                       {
    SkASSERT(gPool);
    gFactoryCalls++;
    return gPool->create(bytes);
}

test_discarded_image()

static void test_discarded_image ( skiatest::Reporter *  reporter, const SkMatrix &  transform, sk_sp< SkImage >(*)()  buildImage  )

static

Definition at line 158 of file SkResourceCacheTest.cpp.

                                                                 {
    auto surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(10, 10)));
    SkCanvas* canvas = surface->getCanvas();
 
    // SkBitmapCache is global, so other threads could be evicting our bitmaps.  Loop a few times
    // to mitigate this risk.
    const unsigned kRepeatCount = 42;
    for (unsigned i = 0; i < kRepeatCount; ++i) {
        SkAutoCanvasRestore acr(canvas, true);
 
        sk_sp<SkImage> image(buildImage());
 
        // draw the image (with a transform, to tickle different code paths) to ensure
        // any associated resources get cached
        canvas->concat(transform);
        // always use high quality to ensure caching when scaled
        canvas->drawImage(image, 0, 0, SkSamplingOptions({1.0f/3, 1.0f/3}));
 
        const auto desc = SkBitmapCacheDesc::Make(image.get());
 
        // delete the image
        image.reset(nullptr);
 
        // all resources should have been purged
        SkBitmap result;
        REPORTER_ASSERT(reporter, !SkBitmapCache::Find(desc, &result));
    }
}

test_duplicate_add()

static void test_duplicate_add ( SkResourceCache *  cache, skiatest::Reporter *  reporter, bool  purgable  )

static

Definition at line 259 of file SkResourceCacheTest.cpp.

                                              {
    int sharedID = 1;
    int data = 0;
 
    int flags0 = 0, flags1 = 0;
 
    auto rec0 = std::make_unique<TestRec>(sharedID, data, &flags0);
    auto rec1 = std::make_unique<TestRec>(sharedID, data, &flags1);
    SkASSERT(rec0->getKey() == rec1->getKey());
 
    TestRec* r0 = rec0.get();   // save the bare-pointer since we will release rec0
    r0->fCanBePurged = purgable;
 
    REPORTER_ASSERT(reporter, !(flags0 & TestRec::kDidInstall));
    REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall));
 
    cache->add(rec0.release(), nullptr);
    REPORTER_ASSERT(reporter, flags0 & TestRec::kDidInstall);
    REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall));
    flags0 = 0; // reset the flag
 
    cache->add(rec1.release(), nullptr);
    if (purgable) {
        // we purged rec0, and did install rec1
        REPORTER_ASSERT(reporter, !(flags0 & TestRec::kDidInstall));
        REPORTER_ASSERT(reporter, flags1 & TestRec::kDidInstall);
    } else {
        // we re-used rec0 and did not install rec1
        REPORTER_ASSERT(reporter, flags0 & TestRec::kDidInstall);
        REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall));
        r0->fCanBePurged = true;  // so we can cleanup the cache
    }
}

test_mipmap_notify()

static void test_mipmap_notify ( skiatest::Reporter *  reporter, SkResourceCache *  cache  )

static

Definition at line 96 of file SkResourceCacheTest.cpp.

                                                                                   {
    const int N = 3;
 
    SkBitmap src[N];
    sk_sp<SkImage> img[N];
    SkBitmapCacheDesc desc[N];
    for (int i = 0; i < N; ++i) {
        src[i].allocN32Pixels(5, 5);
        src[i].setImmutable();
        img[i] = src[i].asImage();
        SkMipmapCache::AddAndRef(as_IB(img[i].get()), cache)->unref();
        desc[i] = SkBitmapCacheDesc::Make(img[i].get());
    }
 
    for (int i = 0; i < N; ++i) {
        const SkMipmap* mipmap = SkMipmapCache::FindAndRef(desc[i], cache);
        // We're always using a local cache, so we know we won't be purged by other threads
        REPORTER_ASSERT(reporter, mipmap);
        SkSafeUnref(mipmap);
 
        img[i].reset(); // delete the image, which *should not* remove us from the cache
        mipmap = SkMipmapCache::FindAndRef(desc[i], cache);
        REPORTER_ASSERT(reporter, mipmap);
        SkSafeUnref(mipmap);
 
        src[i].reset(); // delete the underlying pixelref, which *should* remove us from the cache
        mipmap = SkMipmapCache::FindAndRef(desc[i], cache);
        REPORTER_ASSERT(reporter, !mipmap);
    }
}

test_mipmapcache()

static void test_mipmapcache ( skiatest::Reporter *  reporter, SkResourceCache *  cache  )

static

Definition at line 57 of file SkResourceCacheTest.cpp.

                                                                                 {
    cache->purgeAll();
 
    SkBitmap src;
    src.allocN32Pixels(5, 5);
    src.setImmutable();
    sk_sp<SkImage> img = src.asImage();
    const auto desc = SkBitmapCacheDesc::Make(img.get());
 
    const SkMipmap* mipmap = SkMipmapCache::FindAndRef(desc, cache);
    REPORTER_ASSERT(reporter, nullptr == mipmap);
 
    mipmap = SkMipmapCache::AddAndRef(as_IB(img.get()), cache);
    REPORTER_ASSERT(reporter, mipmap);
 
    {
        const SkMipmap* mm = SkMipmapCache::FindAndRef(desc, cache);
        REPORTER_ASSERT(reporter, mm);
        REPORTER_ASSERT(reporter, mm == mipmap);
        mm->unref();
    }
 
    check_data(reporter, mipmap, 2, kInCache, kLocked);
 
    mipmap->unref();
    // tricky, since technically after this I'm no longer an owner, but since the cache is
    // local, I know it won't get purged behind my back
    check_data(reporter, mipmap, 1, kInCache, kNotLocked);
 
    // find us again
    mipmap = SkMipmapCache::FindAndRef(desc, cache);
    check_data(reporter, mipmap, 2, kInCache, kLocked);
 
    cache->purgeAll();
    check_data(reporter, mipmap, 1, kNotInCache, kLocked);
 
    mipmap->unref();
}

testBitmapCache_discarded_bitmap()

static void testBitmapCache_discarded_bitmap ( skiatest::Reporter *  reporter, SkResourceCache *  cache, SkResourceCache::DiscardableFactory  factory  )

static

Definition at line 136 of file SkResourceCacheTest.cpp.

                                                                                        {
    test_mipmapcache(reporter, cache);
    test_mipmap_notify(reporter, cache);
}

Variable Documentation

gFactoryCalls

int gFactoryCalls = 0

static

Definition at line 128 of file SkResourceCacheTest.cpp.

gPool

SkDiscardableMemoryPool* gPool = nullptr

static

Definition at line 127 of file SkResourceCacheTest.cpp.

gTestNamespace

void* gTestNamespace

static

Definition at line 227 of file SkResourceCacheTest.cpp.