From f440cecbfdf1910104f36aedd0e963da2ae8b6a8 Mon Sep 17 00:00:00 2001 From: Robert Phillips Date: Fri, 19 Jan 2018 11:51:20 -0500 Subject: Move more internal methods from GrContext to GrContextPriv TBR=bsalomon@google.com Change-Id: Ia8cf0e0d30451c69bc7a08215aafa6abe6e0ddbe Reviewed-on: https://skia-review.googlesource.com/97080 Commit-Queue: Robert Phillips Reviewed-by: Greg Daniel --- tests/ResourceCacheTest.cpp | 122 +++++++++++++++++++++++++------------------- 1 file changed, 70 insertions(+), 52 deletions(-) (limited to 'tests/ResourceCacheTest.cpp') diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp index dd122a0dea..34ed4f7328 100644 --- a/tests/ResourceCacheTest.cpp +++ b/tests/ResourceCacheTest.cpp @@ -200,7 +200,7 @@ DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angl DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxInfo) { GrContext* context = ctxInfo.grContext(); GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider(); - GrGpu* gpu = context->getGpu(); + GrGpu* gpu = context->contextPriv().getGpu(); // this test is only valid for GL if (!gpu || !gpu->glContextForTesting()) { return; @@ -370,12 +370,13 @@ static void test_no_key(skiatest::Reporter* reporter) { Mock mock(10, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); // Create a bunch of resources with no keys - TestResource* a = new TestResource(context->getGpu()); - TestResource* b = new TestResource(context->getGpu()); - TestResource* c = new TestResource(context->getGpu()); - TestResource* d = new TestResource(context->getGpu()); + TestResource* a = new TestResource(gpu); + TestResource* b = new TestResource(gpu); + TestResource* c = new TestResource(gpu); + TestResource* d = new TestResource(gpu); a->setSize(11); b->setSize(12); c->setSize(13); @@ -427,21 +428,21 @@ static void test_budgeting(skiatest::Reporter* reporter) { Mock mock(10, 300); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); GrUniqueKey uniqueKey; make_unique_key<0>(&uniqueKey, 0); // Create a scratch, a unique, and a wrapped resource TestResource* scratch = - TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, TestResource::kB_SimulatedProperty); + TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); scratch->setSize(10); - TestResource* unique = new TestResource(context->getGpu()); + TestResource* unique = new TestResource(gpu); unique->setSize(11); unique->resourcePriv().setUniqueKey(uniqueKey); - TestResource* wrapped = TestResource::CreateWrapped(context->getGpu()); + TestResource* wrapped = TestResource::CreateWrapped(gpu); wrapped->setSize(12); - TestResource* unbudgeted = - new TestResource(context->getGpu(), SkBudgeted::kNo); + TestResource* unbudgeted = new TestResource(gpu, SkBudgeted::kNo); unbudgeted->setSize(13); // Make sure we can add a unique key to the wrapped resource @@ -483,7 +484,7 @@ static void test_budgeting(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes()); // Now try freeing the budgeted resources first - wrapped = TestResource::CreateWrapped(context->getGpu()); + wrapped = TestResource::CreateWrapped(gpu); scratch->setSize(12); unique->unref(); REPORTER_ASSERT(reporter, 11 == cache->getPurgeableBytes()); @@ -524,6 +525,7 @@ static void test_unbudgeted(skiatest::Reporter* reporter) { Mock mock(10, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); GrUniqueKey uniqueKey; make_unique_key<0>(&uniqueKey, 0); @@ -534,7 +536,7 @@ static void test_unbudgeted(skiatest::Reporter* reporter) { TestResource* unbudgeted; // A large uncached or wrapped resource shouldn't evict anything. - scratch = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + scratch = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); scratch->setSize(10); @@ -545,7 +547,7 @@ static void test_unbudgeted(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, 10 == cache->getBudgetedResourceBytes()); REPORTER_ASSERT(reporter, 10 == cache->getPurgeableBytes()); - unique = new TestResource(context->getGpu()); + unique = new TestResource(gpu); unique->setSize(11); unique->resourcePriv().setUniqueKey(uniqueKey); unique->unref(); @@ -556,7 +558,7 @@ static void test_unbudgeted(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes()); size_t large = 2 * cache->getResourceBytes(); - unbudgeted = new TestResource(context->getGpu(), SkBudgeted::kNo, large); + unbudgeted = new TestResource(gpu, SkBudgeted::kNo, large); REPORTER_ASSERT(reporter, 3 == cache->getResourceCount()); REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes()); REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); @@ -570,7 +572,7 @@ static void test_unbudgeted(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes()); REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes()); - wrapped = TestResource::CreateWrapped(context->getGpu(), large); + wrapped = TestResource::CreateWrapped(gpu, large); REPORTER_ASSERT(reporter, 3 == cache->getResourceCount()); REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes()); REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); @@ -598,10 +600,10 @@ void test_unbudgeted_to_scratch(skiatest::Reporter* reporter); Mock mock(10, 300); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); TestResource* resource = - TestResource::CreateScratch(context->getGpu(), SkBudgeted::kNo, - TestResource::kA_SimulatedProperty); + TestResource::CreateScratch(gpu, SkBudgeted::kNo, TestResource::kA_SimulatedProperty); GrScratchKey key; TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &key); @@ -662,12 +664,13 @@ static void test_duplicate_scratch_key(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); // Create two resources that have the same scratch key. - TestResource* a = TestResource::CreateScratch(context->getGpu(), + TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); - TestResource* b = TestResource::CreateScratch(context->getGpu(), + TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); a->setSize(11); @@ -709,11 +712,12 @@ static void test_remove_scratch_key(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); // Create two resources that have the same scratch key. - TestResource* a = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); - TestResource* b = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); a->unref(); b->unref(); @@ -768,11 +772,12 @@ static void test_scratch_key_consistency(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); // Create two resources that have the same scratch key. - TestResource* a = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); - TestResource* b = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); a->unref(); b->unref(); @@ -827,12 +832,13 @@ static void test_duplicate_unique_key(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); GrUniqueKey key; make_unique_key<0>(&key, 0); // Create two resources that we will attempt to register with the same unique key. - TestResource* a = new TestResource(context->getGpu()); + TestResource* a = new TestResource(gpu); a->setSize(11); // Set key on resource a. @@ -849,7 +855,7 @@ static void test_duplicate_unique_key(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); // Create resource b and set the same key. It should replace a's unique key cache entry. - TestResource* b = new TestResource(context->getGpu()); + TestResource* b = new TestResource(gpu); b->setSize(12); b->resourcePriv().setUniqueKey(key); REPORTER_ASSERT(reporter, b == cache->findAndRefUniqueResource(key)); @@ -869,7 +875,7 @@ static void test_duplicate_unique_key(skiatest::Reporter* reporter) { // Now replace b with c, but make sure c can start with one unique key and change it to b's key. // Also make b be unreffed when replacement occurs. b->unref(); - TestResource* c = new TestResource(context->getGpu()); + TestResource* c = new TestResource(gpu); GrUniqueKey differentKey; make_unique_key<0>(&differentKey, 1); c->setSize(13); @@ -906,7 +912,7 @@ static void test_duplicate_unique_key(skiatest::Reporter* reporter) { { GrUniqueKey key2; make_unique_key<0>(&key2, 0); - sk_sp d(new TestResource(context->getGpu())); + sk_sp d(new TestResource(gpu)); int foo = 4132; key2.setCustomData(SkData::MakeWithCopy(&foo, sizeof(foo))); d->resourcePriv().setUniqueKey(key2); @@ -922,6 +928,7 @@ static void test_purge_invalidated(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); GrUniqueKey key1, key2, key3; make_unique_key<0>(&key1, 1); @@ -929,9 +936,9 @@ static void test_purge_invalidated(skiatest::Reporter* reporter) { make_unique_key<0>(&key3, 3); // Add three resources to the cache. Only c is usable as scratch. - TestResource* a = new TestResource(context->getGpu()); - TestResource* b = new TestResource(context->getGpu()); - TestResource* c = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + TestResource* a = new TestResource(gpu); + TestResource* b = new TestResource(gpu); + TestResource* c = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kA_SimulatedProperty); a->resourcePriv().setUniqueKey(key1); b->resourcePriv().setUniqueKey(key2); @@ -990,13 +997,14 @@ static void test_cache_chained_purge(skiatest::Reporter* reporter) { Mock mock(3, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); GrUniqueKey key1, key2; make_unique_key<0>(&key1, 1); make_unique_key<0>(&key2, 2); - TestResource* a = new TestResource(context->getGpu()); - TestResource* b = new TestResource(context->getGpu()); + TestResource* a = new TestResource(gpu); + TestResource* b = new TestResource(gpu); a->resourcePriv().setUniqueKey(key1); b->resourcePriv().setUniqueKey(key2); @@ -1032,12 +1040,13 @@ static void test_resource_size_changed(skiatest::Reporter* reporter) { Mock mock(3, 30000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); - TestResource* a = new TestResource(context->getGpu()); + TestResource* a = new TestResource(gpu); a->resourcePriv().setUniqueKey(key1); a->unref(); - TestResource* b = new TestResource(context->getGpu()); + TestResource* b = new TestResource(gpu); b->resourcePriv().setUniqueKey(key2); b->unref(); @@ -1061,13 +1070,14 @@ static void test_resource_size_changed(skiatest::Reporter* reporter) { Mock mock(2, 300); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); - TestResource* a = new TestResource(context->getGpu()); + TestResource* a = new TestResource(gpu); a->setSize(100); a->resourcePriv().setUniqueKey(key1); a->unref(); - TestResource* b = new TestResource(context->getGpu()); + TestResource* b = new TestResource(gpu); b->setSize(100); b->resourcePriv().setUniqueKey(key2); b->unref(); @@ -1100,6 +1110,7 @@ static void test_timestamp_wrap(skiatest::Reporter* reporter) { Mock mock(kBudgetCnt, kBudgetSize); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); // Pick a random number of resources to add before the timestamp will wrap. cache->changeTimestamp(SK_MaxU32 - random.nextULessThan(kCount + 1)); @@ -1116,7 +1127,7 @@ static void test_timestamp_wrap(skiatest::Reporter* reporter) { GrUniqueKey key; make_unique_key<0>(&key, j); - TestResource* r = new TestResource(context->getGpu()); + TestResource* r = new TestResource(gpu); r->resourcePriv().setUniqueKey(key); if (random.nextU() % kLockedFreq) { // Make this is purgeable. @@ -1156,6 +1167,7 @@ static void test_flush(skiatest::Reporter* reporter) { Mock mock(1000000, 1000000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); // The current cache impl will round the max flush count to the next power of 2. So we choose a // power of two here to keep things simpler. @@ -1165,7 +1177,7 @@ static void test_flush(skiatest::Reporter* reporter) { { // Insert a resource and send a flush notification kFlushCount times. for (int i = 0; i < kFlushCount; ++i) { - TestResource* r = new TestResource(context->getGpu()); + TestResource* r = new TestResource(gpu); GrUniqueKey k; make_unique_key<1>(&k, i); r->resourcePriv().setUniqueKey(k); @@ -1195,7 +1207,7 @@ static void test_flush(skiatest::Reporter* reporter) { { GrGpuResource* refedResources[kFlushCount >> 1]; for (int i = 0; i < kFlushCount; ++i) { - TestResource* r = new TestResource(context->getGpu()); + TestResource* r = new TestResource(gpu); GrUniqueKey k; make_unique_key<1>(&k, i); r->resourcePriv().setUniqueKey(k); @@ -1236,7 +1248,7 @@ static void test_flush(skiatest::Reporter* reporter) { // eviction. context->flush(); for (int i = 0; i < 10; ++i) { - TestResource* r = new TestResource(context->getGpu()); + TestResource* r = new TestResource(gpu); GrUniqueKey k; make_unique_key<1>(&k, i); r->resourcePriv().setUniqueKey(k); @@ -1253,6 +1265,7 @@ static void test_time_purge(skiatest::Reporter* reporter) { Mock mock(1000000, 1000000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); static constexpr int kCnts[] = {1, 10, 1024}; auto nowish = []() { @@ -1271,7 +1284,7 @@ static void test_time_purge(skiatest::Reporter* reporter) { { // Insert resources and get time points between each addition. for (int i = 0; i < cnt; ++i) { - TestResource* r = new TestResource(context->getGpu()); + TestResource* r = new TestResource(gpu); GrUniqueKey k; make_unique_key<1>(&k, i); r->resourcePriv().setUniqueKey(k); @@ -1302,7 +1315,7 @@ static void test_time_purge(skiatest::Reporter* reporter) { { std::unique_ptr refedResources(new GrGpuResource*[cnt / 2]); for (int i = 0; i < cnt; ++i) { - TestResource* r = new TestResource(context->getGpu()); + TestResource* r = new TestResource(gpu); GrUniqueKey k; make_unique_key<1>(&k, i); r->resourcePriv().setUniqueKey(k); @@ -1337,7 +1350,7 @@ static void test_time_purge(skiatest::Reporter* reporter) { // eviction context->flush(); for (int i = 0; i < 10; ++i) { - TestResource* r = new TestResource(context->getGpu()); + TestResource* r = new TestResource(gpu); GrUniqueKey k; make_unique_key<1>(&k, i); r->resourcePriv().setUniqueKey(k); @@ -1355,6 +1368,7 @@ static void test_partial_purge(skiatest::Reporter* reporter) { Mock mock(6, 100); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); enum TestsCase { kOnlyScratch_TestCase = 0, @@ -1374,9 +1388,9 @@ static void test_partial_purge(skiatest::Reporter* reporter) { make_unique_key<0>(&key3, 3); // Add three unique resources to the cache. - TestResource *unique1 = new TestResource(context->getGpu()); - TestResource *unique2 = new TestResource(context->getGpu()); - TestResource *unique3 = new TestResource(context->getGpu()); + TestResource *unique1 = new TestResource(gpu); + TestResource *unique2 = new TestResource(gpu); + TestResource *unique3 = new TestResource(gpu); unique1->resourcePriv().setUniqueKey(key1); unique2->resourcePriv().setUniqueKey(key2); @@ -1387,9 +1401,9 @@ static void test_partial_purge(skiatest::Reporter* reporter) { unique3->setSize(12); // Add two scratch resources to the cache. - TestResource *scratch1 = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + TestResource *scratch1 = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kA_SimulatedProperty); - TestResource *scratch2 = TestResource::CreateScratch(context->getGpu(), SkBudgeted::kYes, + TestResource *scratch2 = TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty); scratch1->setSize(13); scratch2->setSize(14); @@ -1468,6 +1482,7 @@ static void test_large_resource_count(skiatest::Reporter* reporter) { Mock mock(2 * kResourceCnt, 2 * kResourceCnt + 1000); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); for (int i = 0; i < kResourceCnt; ++i) { GrUniqueKey key1, key2; @@ -1476,12 +1491,12 @@ static void test_large_resource_count(skiatest::Reporter* reporter) { TestResource* resource; - resource = new TestResource(context->getGpu()); + resource = new TestResource(gpu); resource->resourcePriv().setUniqueKey(key1); resource->setSize(1); resource->unref(); - resource = new TestResource(context->getGpu()); + resource = new TestResource(gpu); resource->resourcePriv().setUniqueKey(key2); resource->setSize(1); resource->unref(); @@ -1537,7 +1552,9 @@ static void test_custom_data(skiatest::Reporter* reporter) { static void test_abandoned(skiatest::Reporter* reporter) { Mock mock(10, 300); GrContext* context = mock.context(); - sk_sp resource(new TestResource(context->getGpu())); + GrGpu* gpu = context->contextPriv().getGpu(); + + sk_sp resource(new TestResource(gpu)); context->abandonContext(); REPORTER_ASSERT(reporter, resource->wasDestroyed()); @@ -1571,13 +1588,14 @@ static void test_tags(skiatest::Reporter* reporter) { Mock mock(kNumResources, kNumResources * TestResource::kDefaultSize); GrContext* context = mock.context(); GrResourceCache* cache = mock.cache(); + GrGpu* gpu = context->contextPriv().getGpu(); SkString tagStr; int tagIdx = 0; int currTagCnt = 0; for (int i = 0; i < kNumResources; ++i, ++currTagCnt) { - sk_sp resource(new TestResource(context->getGpu())); + sk_sp resource(new TestResource(gpu)); GrUniqueKey key; if (currTagCnt == tagIdx) { tagIdx += 1; -- cgit v1.2.3