1 /*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "include/core/SkBitmap.h"
9 #include "include/core/SkCanvas.h"
10 #include "include/core/SkColor.h"
11 #include "include/core/SkColorSpace.h"
12 #include "include/core/SkImage.h"
13 #include "include/core/SkMatrix.h"
14 #include "include/core/SkPictureRecorder.h"
15 #include "include/core/SkRefCnt.h"
16 #include "include/core/SkSamplingOptions.h"
17 #include "include/core/SkSize.h"
18 #include "include/core/SkSurface.h"
19 #include "include/core/SkTypes.h"
20 #include "include/private/chromium/SkDiscardableMemory.h"
21 #include "src/core/SkBitmapCache.h"
22 #include "src/core/SkCachedData.h"
23 #include "src/core/SkMipmap.h"
24 #include "src/core/SkResourceCache.h"
25 #include "src/image/SkImage_Base.h"
26 #include "src/lazy/SkDiscardableMemoryPool.h"
27 #include "tests/Test.h"
28
29 #include <array>
30 #include <cstddef>
31 #include <cstdint>
32 #include <initializer_list>
33 #include <memory>
34
35 ////////////////////////////////////////////////////////////////////////////////////////
36
37 enum LockedState {
38 kNotLocked,
39 kLocked,
40 };
41
42 enum CachedState {
43 kNotInCache,
44 kInCache,
45 };
46
check_data(skiatest::Reporter * reporter,const SkCachedData * data,int refcnt,CachedState cacheState,LockedState lockedState)47 static void check_data(skiatest::Reporter* reporter, const SkCachedData* data,
48 int refcnt, CachedState cacheState, LockedState lockedState) {
49 REPORTER_ASSERT(reporter, data->testing_only_getRefCnt() == refcnt);
50 REPORTER_ASSERT(reporter, data->testing_only_isInCache() == (kInCache == cacheState));
51 bool isLocked = (data->data() != nullptr);
52 REPORTER_ASSERT(reporter, isLocked == (lockedState == kLocked));
53 }
54
test_mipmapcache(skiatest::Reporter * reporter,SkResourceCache * cache)55 static void test_mipmapcache(skiatest::Reporter* reporter, SkResourceCache* cache) {
56 cache->purgeAll();
57
58 SkBitmap src;
59 src.allocN32Pixels(5, 5);
60 src.setImmutable();
61 sk_sp<SkImage> img = src.asImage();
62 const auto desc = SkBitmapCacheDesc::Make(img.get());
63
64 const SkMipmap* mipmap = SkMipmapCache::FindAndRef(desc, cache);
65 REPORTER_ASSERT(reporter, nullptr == mipmap);
66
67 mipmap = SkMipmapCache::AddAndRef(as_IB(img.get()), cache);
68 REPORTER_ASSERT(reporter, mipmap);
69
70 {
71 const SkMipmap* mm = SkMipmapCache::FindAndRef(desc, cache);
72 REPORTER_ASSERT(reporter, mm);
73 REPORTER_ASSERT(reporter, mm == mipmap);
74 mm->unref();
75 }
76
77 check_data(reporter, mipmap, 2, kInCache, kLocked);
78
79 mipmap->unref();
80 // tricky, since technically after this I'm no longer an owner, but since the cache is
81 // local, I know it won't get purged behind my back
82 check_data(reporter, mipmap, 1, kInCache, kNotLocked);
83
84 // find us again
85 mipmap = SkMipmapCache::FindAndRef(desc, cache);
86 check_data(reporter, mipmap, 2, kInCache, kLocked);
87
88 cache->purgeAll();
89 check_data(reporter, mipmap, 1, kNotInCache, kLocked);
90
91 mipmap->unref();
92 }
93
test_mipmap_notify(skiatest::Reporter * reporter,SkResourceCache * cache)94 static void test_mipmap_notify(skiatest::Reporter* reporter, SkResourceCache* cache) {
95 const int N = 3;
96
97 SkBitmap src[N];
98 sk_sp<SkImage> img[N];
99 SkBitmapCacheDesc desc[N];
100 for (int i = 0; i < N; ++i) {
101 src[i].allocN32Pixels(5, 5);
102 src[i].setImmutable();
103 img[i] = src[i].asImage();
104 SkMipmapCache::AddAndRef(as_IB(img[i].get()), cache)->unref();
105 desc[i] = SkBitmapCacheDesc::Make(img[i].get());
106 }
107
108 for (int i = 0; i < N; ++i) {
109 const SkMipmap* mipmap = SkMipmapCache::FindAndRef(desc[i], cache);
110 // We're always using a local cache, so we know we won't be purged by other threads
111 REPORTER_ASSERT(reporter, mipmap);
112 SkSafeUnref(mipmap);
113
114 img[i].reset(); // delete the image, which *should not* remove us from the cache
115 mipmap = SkMipmapCache::FindAndRef(desc[i], cache);
116 REPORTER_ASSERT(reporter, mipmap);
117 SkSafeUnref(mipmap);
118
119 src[i].reset(); // delete the underlying pixelref, which *should* remove us from the cache
120 mipmap = SkMipmapCache::FindAndRef(desc[i], cache);
121 REPORTER_ASSERT(reporter, !mipmap);
122 }
123 }
124
125 static SkDiscardableMemoryPool* gPool = nullptr;
126 static int gFactoryCalls = 0;
127
pool_factory(size_t bytes)128 static SkDiscardableMemory* pool_factory(size_t bytes) {
129 SkASSERT(gPool);
130 gFactoryCalls++;
131 return gPool->create(bytes);
132 }
133
testBitmapCache_discarded_bitmap(skiatest::Reporter * reporter,SkResourceCache * cache,SkResourceCache::DiscardableFactory factory)134 static void testBitmapCache_discarded_bitmap(skiatest::Reporter* reporter, SkResourceCache* cache,
135 SkResourceCache::DiscardableFactory factory) {
136 test_mipmapcache(reporter, cache);
137 test_mipmap_notify(reporter, cache);
138 }
139
DEF_TEST(BitmapCache_discarded_bitmap,reporter)140 DEF_TEST(BitmapCache_discarded_bitmap, reporter) {
141 const size_t byteLimit = 100 * 1024;
142 {
143 SkResourceCache cache(byteLimit);
144 testBitmapCache_discarded_bitmap(reporter, &cache, nullptr);
145 }
146 {
147 sk_sp<SkDiscardableMemoryPool> pool(SkDiscardableMemoryPool::Make(byteLimit));
148 gPool = pool.get();
149 SkResourceCache::DiscardableFactory factory = pool_factory;
150 SkResourceCache cache(factory);
151 testBitmapCache_discarded_bitmap(reporter, &cache, factory);
152 }
153 REPORTER_ASSERT(reporter, gFactoryCalls > 0);
154 }
155
test_discarded_image(skiatest::Reporter * reporter,const SkMatrix & transform,sk_sp<SkImage> (* buildImage)())156 static void test_discarded_image(skiatest::Reporter* reporter, const SkMatrix& transform,
157 sk_sp<SkImage> (*buildImage)()) {
158 auto surface(SkSurface::MakeRasterN32Premul(10, 10));
159 SkCanvas* canvas = surface->getCanvas();
160
161 // SkBitmapCache is global, so other threads could be evicting our bitmaps. Loop a few times
162 // to mitigate this risk.
163 const unsigned kRepeatCount = 42;
164 for (unsigned i = 0; i < kRepeatCount; ++i) {
165 SkAutoCanvasRestore acr(canvas, true);
166
167 sk_sp<SkImage> image(buildImage());
168
169 // draw the image (with a transform, to tickle different code paths) to ensure
170 // any associated resources get cached
171 canvas->concat(transform);
172 // always use high quality to ensure caching when scaled
173 canvas->drawImage(image, 0, 0, SkSamplingOptions({1.0f/3, 1.0f/3}));
174
175 const auto desc = SkBitmapCacheDesc::Make(image.get());
176
177 // delete the image
178 image.reset(nullptr);
179
180 // all resources should have been purged
181 SkBitmap result;
182 REPORTER_ASSERT(reporter, !SkBitmapCache::Find(desc, &result));
183 }
184 }
185
186
187 // Verify that associated bitmap cache entries are purged on SkImage destruction.
DEF_TEST(BitmapCache_discarded_image,reporter)188 DEF_TEST(BitmapCache_discarded_image, reporter) {
189 // Cache entries associated with SkImages fall into two categories:
190 //
191 // 1) generated image bitmaps (managed by the image cacherator)
192 // 2) scaled/resampled bitmaps (cached when HQ filters are used)
193 //
194 // To exercise the first cache type, we use generated/picture-backed SkImages.
195 // To exercise the latter, we draw scaled bitmap images using HQ filters.
196
197 const SkMatrix xforms[] = {
198 SkMatrix::Scale(1, 1),
199 SkMatrix::Scale(1.7f, 0.5f),
200 };
201
202 for (size_t i = 0; i < std::size(xforms); ++i) {
203 test_discarded_image(reporter, xforms[i], []() {
204 auto surface(SkSurface::MakeRasterN32Premul(10, 10));
205 surface->getCanvas()->clear(SK_ColorCYAN);
206 return surface->makeImageSnapshot();
207 });
208
209 test_discarded_image(reporter, xforms[i], []() {
210 SkPictureRecorder recorder;
211 SkCanvas* canvas = recorder.beginRecording(10, 10);
212 canvas->clear(SK_ColorCYAN);
213 return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
214 SkISize::Make(10, 10), nullptr, nullptr,
215 SkImage::BitDepth::kU8,
216 SkColorSpace::MakeSRGB());
217 });
218 }
219 }
220
221 ///////////////////////////////////////////////////////////////////////////////////////////////////
222
223 static void* gTestNamespace;
224
225 struct TestKey : SkResourceCache::Key {
226 int32_t fData;
227
TestKeyTestKey228 TestKey(int sharedID, int32_t data) : fData(data) {
229 this->init(&gTestNamespace, sharedID, sizeof(fData));
230 }
231 };
232
233 struct TestRec : SkResourceCache::Rec {
234 enum {
235 kDidInstall = 1 << 0,
236 };
237
238 TestKey fKey;
239 int* fFlags;
240 bool fCanBePurged;
241
TestRecTestRec242 TestRec(int sharedID, int32_t data, int* flagPtr) : fKey(sharedID, data), fFlags(flagPtr) {
243 fCanBePurged = false;
244 }
245
getKeyTestRec246 const Key& getKey() const override { return fKey; }
bytesUsedTestRec247 size_t bytesUsed() const override { return 1024; /* just need a value */ }
canBePurgedTestRec248 bool canBePurged() override { return fCanBePurged; }
postAddInstallTestRec249 void postAddInstall(void*) override {
250 *fFlags |= kDidInstall;
251 }
getCategoryTestRec252 const char* getCategory() const override { return "test-category"; }
253 };
254
test_duplicate_add(SkResourceCache * cache,skiatest::Reporter * reporter,bool purgable)255 static void test_duplicate_add(SkResourceCache* cache, skiatest::Reporter* reporter,
256 bool purgable) {
257 int sharedID = 1;
258 int data = 0;
259
260 int flags0 = 0, flags1 = 0;
261
262 auto rec0 = std::make_unique<TestRec>(sharedID, data, &flags0);
263 auto rec1 = std::make_unique<TestRec>(sharedID, data, &flags1);
264 SkASSERT(rec0->getKey() == rec1->getKey());
265
266 TestRec* r0 = rec0.get(); // save the bare-pointer since we will release rec0
267 r0->fCanBePurged = purgable;
268
269 REPORTER_ASSERT(reporter, !(flags0 & TestRec::kDidInstall));
270 REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall));
271
272 cache->add(rec0.release(), nullptr);
273 REPORTER_ASSERT(reporter, flags0 & TestRec::kDidInstall);
274 REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall));
275 flags0 = 0; // reset the flag
276
277 cache->add(rec1.release(), nullptr);
278 if (purgable) {
279 // we purged rec0, and did install rec1
280 REPORTER_ASSERT(reporter, !(flags0 & TestRec::kDidInstall));
281 REPORTER_ASSERT(reporter, flags1 & TestRec::kDidInstall);
282 } else {
283 // we re-used rec0 and did not install rec1
284 REPORTER_ASSERT(reporter, flags0 & TestRec::kDidInstall);
285 REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall));
286 r0->fCanBePurged = true; // so we can cleanup the cache
287 }
288 }
289
290 /*
291 * Test behavior when the same key is added more than once.
292 */
DEF_TEST(ResourceCache_purge,reporter)293 DEF_TEST(ResourceCache_purge, reporter) {
294 for (bool purgable : { false, true }) {
295 {
296 SkResourceCache cache(1024 * 1024);
297 test_duplicate_add(&cache, reporter, purgable);
298 }
299 {
300 SkResourceCache cache(SkDiscardableMemory::Create);
301 test_duplicate_add(&cache, reporter, purgable);
302 }
303 }
304 }
305