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 "SkCachedData.h"
9 #include "SkDiscardableMemoryPool.h"
10 #include "Test.h"
11
12 enum LockedState {
13 kUnlocked,
14 kLocked,
15 };
16
17 enum CachedState {
18 kNotInCache,
19 kInCache,
20 };
21
check_data(skiatest::Reporter * reporter,SkCachedData * data,int refcnt,CachedState cacheState,LockedState lockedState)22 static void check_data(skiatest::Reporter* reporter, SkCachedData* data,
23 int refcnt, CachedState cacheState, LockedState lockedState) {
24 REPORTER_ASSERT(reporter, data->testing_only_getRefCnt() == refcnt);
25 REPORTER_ASSERT(reporter, data->testing_only_isInCache() == (kInCache == cacheState));
26 REPORTER_ASSERT(reporter, data->testing_only_isLocked() == (lockedState == kLocked));
27 }
28
make_data(size_t size,SkDiscardableMemoryPool * pool)29 static SkCachedData* make_data(size_t size, SkDiscardableMemoryPool* pool) {
30 if (pool) {
31 SkDiscardableMemory* dm = pool->create(size);
32 // the pool "can" return null, but it shouldn't in these controlled conditions
33 SkASSERT_RELEASE(dm);
34 return new SkCachedData(size, dm);
35 } else {
36 return new SkCachedData(sk_malloc_throw(size), size);
37 }
38 }
39
40 // returns with the data locked by client and cache
test_locking(skiatest::Reporter * reporter,size_t size,SkDiscardableMemoryPool * pool)41 static SkCachedData* test_locking(skiatest::Reporter* reporter,
42 size_t size, SkDiscardableMemoryPool* pool) {
43 SkCachedData* data = make_data(size, pool);
44
45 memset(data->writable_data(), 0x80, size); // just to use writable_data()
46
47 check_data(reporter, data, 1, kNotInCache, kLocked);
48
49 data->ref();
50 check_data(reporter, data, 2, kNotInCache, kLocked);
51 data->unref();
52 check_data(reporter, data, 1, kNotInCache, kLocked);
53
54 data->attachToCacheAndRef();
55 check_data(reporter, data, 2, kInCache, kLocked);
56
57 data->unref();
58 check_data(reporter, data, 1, kInCache, kUnlocked);
59
60 data->ref();
61 check_data(reporter, data, 2, kInCache, kLocked);
62
63 return data;
64 }
65
66 /*
67 * SkCachedData behaves differently (regarding its locked/unlocked state) depending on
68 * when it is in the cache or not. Being in the cache is signaled by calling attachToCacheAndRef()
69 * instead of ref(). (and balanced by detachFromCacheAndUnref).
70 *
71 * Thus, among other things, we test the end-of-life behavior when the client is the last owner
72 * and when the cache is.
73 */
DEF_TEST(CachedData,reporter)74 DEF_TEST(CachedData, reporter) {
75 SkAutoTUnref<SkDiscardableMemoryPool> pool(SkDiscardableMemoryPool::Create(1000));
76
77 for (int useDiscardable = 0; useDiscardable <= 1; ++useDiscardable) {
78 const size_t size = 100;
79
80 // test with client as last owner
81 SkCachedData* data = test_locking(reporter, size, useDiscardable ? pool.get() : nullptr);
82 check_data(reporter, data, 2, kInCache, kLocked);
83 data->detachFromCacheAndUnref();
84 check_data(reporter, data, 1, kNotInCache, kLocked);
85 data->unref();
86
87 // test with cache as last owner
88 data = test_locking(reporter, size, useDiscardable ? pool.get() : nullptr);
89 check_data(reporter, data, 2, kInCache, kLocked);
90 data->unref();
91 check_data(reporter, data, 1, kInCache, kUnlocked);
92 data->detachFromCacheAndUnref();
93 }
94 }
95
96