diff options
-rw-r--r-- | bench/GrResourceCacheBench.cpp | 22 | ||||
-rw-r--r-- | gyp/gpu.gypi | 4 | ||||
-rw-r--r-- | include/gpu/GrContext.h | 6 | ||||
-rw-r--r-- | include/gpu/GrGpuResource.h | 8 | ||||
-rw-r--r-- | src/gpu/GrClipMaskManager.h | 2 | ||||
-rwxr-xr-x | src/gpu/GrContext.cpp | 32 | ||||
-rw-r--r-- | src/gpu/GrGpu.cpp | 4 | ||||
-rw-r--r-- | src/gpu/GrGpuResource.cpp | 28 | ||||
-rw-r--r-- | src/gpu/GrResourceCache.cpp (renamed from src/gpu/GrResourceCache2.cpp) | 48 | ||||
-rw-r--r-- | src/gpu/GrResourceCache.h (renamed from src/gpu/GrResourceCache2.h) | 20 | ||||
-rw-r--r-- | src/gpu/GrTest.cpp | 8 | ||||
-rw-r--r-- | tests/ResourceCacheTest.cpp | 384 |
12 files changed, 283 insertions, 283 deletions
diff --git a/bench/GrResourceCacheBench.cpp b/bench/GrResourceCacheBench.cpp index 7469217c3f..39007c30b2 100644 --- a/bench/GrResourceCacheBench.cpp +++ b/bench/GrResourceCacheBench.cpp @@ -13,7 +13,7 @@ #include "GrGpuResource.h" #include "GrContext.h" #include "GrGpu.h" -#include "GrResourceCache2.h" +#include "GrResourceCache.h" #include "SkCanvas.h" enum { @@ -69,17 +69,17 @@ protected: // Set the cache budget to be very large so no purging occurs. context->setResourceCacheLimits(CACHE_SIZE_COUNT, 1 << 30); - GrResourceCache2* cache2 = context->getResourceCache2(); + GrResourceCache* cache = context->getResourceCache(); // Make sure the cache is empty. - cache2->purgeAllUnlocked(); - SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes()); + cache->purgeAllUnlocked(); + SkASSERT(0 == cache->getResourceCount() && 0 == cache->getResourceBytes()); GrGpu* gpu = context->getGpu(); for (int i = 0; i < loops; ++i) { populate_cache(gpu, CACHE_SIZE_COUNT); - SkASSERT(CACHE_SIZE_COUNT == cache2->getResourceCount()); + SkASSERT(CACHE_SIZE_COUNT == cache->getResourceCount()); } } @@ -106,11 +106,11 @@ protected: // Set the cache budget to be very large so no purging occurs. fContext->setResourceCacheLimits(CACHE_SIZE_COUNT, 1 << 30); - GrResourceCache2* cache2 = fContext->getResourceCache2(); + GrResourceCache* cache = fContext->getResourceCache(); // Make sure the cache is empty. - cache2->purgeAllUnlocked(); - SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes()); + cache->purgeAllUnlocked(); + SkASSERT(0 == cache->getResourceCount() && 0 == cache->getResourceBytes()); GrGpu* gpu = fContext->getGpu(); @@ -121,13 +121,13 @@ protected: if (!fContext) { return; } - GrResourceCache2* cache2 = fContext->getResourceCache2(); - SkASSERT(CACHE_SIZE_COUNT == cache2->getResourceCount()); + GrResourceCache* cache = fContext->getResourceCache(); + SkASSERT(CACHE_SIZE_COUNT == cache->getResourceCount()); for (int i = 0; i < loops; ++i) { for (int k = 0; k < CACHE_SIZE_COUNT; ++k) { GrContentKey key; BenchResource::ComputeKey(k, &key); - SkAutoTUnref<GrGpuResource> resource(cache2->findAndRefContentResource(key)); + SkAutoTUnref<GrGpuResource> resource(cache->findAndRefContentResource(key)); SkASSERT(resource); } } diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi index 2036b89956..5cc743fcae 100644 --- a/gyp/gpu.gypi +++ b/gyp/gpu.gypi @@ -144,8 +144,8 @@ '<(skia_src_path)/gpu/GrRenderTarget.cpp', '<(skia_src_path)/gpu/GrReducedClip.cpp', '<(skia_src_path)/gpu/GrReducedClip.h', - '<(skia_src_path)/gpu/GrResourceCache2.cpp', - '<(skia_src_path)/gpu/GrResourceCache2.h', + '<(skia_src_path)/gpu/GrResourceCache.cpp', + '<(skia_src_path)/gpu/GrResourceCache.h', '<(skia_src_path)/gpu/GrStencil.cpp', '<(skia_src_path)/gpu/GrStencil.h', '<(skia_src_path)/gpu/GrStencilAndCoverPathRenderer.cpp', diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h index 4a9701f103..48510d6129 100644 --- a/include/gpu/GrContext.h +++ b/include/gpu/GrContext.h @@ -33,7 +33,7 @@ class GrPath; class GrPathRenderer; class GrPipelineBuilder; class GrResourceEntry; -class GrResourceCache2; +class GrResourceCache; class GrTestTarget; class GrTextContext; class GrTextureParams; @@ -755,7 +755,7 @@ public: GrDrawTarget* getTextTarget(); const GrIndexBuffer* getQuadIndexBuffer() const; GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; } - GrResourceCache2* getResourceCache2() { return fResourceCache2; } + GrResourceCache* getResourceCache() { return fResourceCache; } // Called by tests that draw directly to the context via GrDrawTarget void getTestTarget(GrTestTarget*); @@ -792,7 +792,7 @@ private: SkAutoTUnref<GrRenderTarget> fRenderTarget; const GrClipData* fClip; // TODO: make this ref counted - GrResourceCache2* fResourceCache2; + GrResourceCache* fResourceCache; GrFontCache* fFontCache; SkAutoTDelete<GrLayerCache> fLayerCache; diff --git a/include/gpu/GrGpuResource.h b/include/gpu/GrGpuResource.h index dcb4a47d2c..8e983d89c5 100644 --- a/include/gpu/GrGpuResource.h +++ b/include/gpu/GrGpuResource.h @@ -16,7 +16,7 @@ class GrContext; class GrGpu; -class GrResourceCache2; +class GrResourceCache; /** * Base class for GrGpuResource. Handles the various types of refs we need. Separated out as a base @@ -113,13 +113,13 @@ private: // This class is used to manage conversion of refs to pending reads/writes. friend class GrGpuResourceRef; - friend class GrResourceCache2; // to check IO ref counts. + friend class GrResourceCache; // to check IO ref counts. template <typename, GrIOType> friend class GrPendingIOResource; }; /** - * Base class for objects that can be kept in the GrResourceCache2. + * Base class for objects that can be kept in the GrResourceCache. */ class SK_API GrGpuResource : public GrIORef<GrGpuResource> { public: @@ -276,7 +276,7 @@ private: static uint32_t CreateUniqueID(); - // We're in an internal doubly linked list owned by GrResourceCache2 + // We're in an internal doubly linked list owned by GrResourceCache SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrGpuResource); diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipMaskManager.h index ed3d431268..bc164da36e 100644 --- a/src/gpu/GrClipMaskManager.h +++ b/src/gpu/GrClipMaskManager.h @@ -57,7 +57,7 @@ public: /** * Purge resources to free up memory. TODO: This class shouldn't hold any long lived refs - * which will allow ResourceCache2 to automatically purge anything this class has created. + * which will allow Resourcecache to automatically purge anything this class has created. */ void purgeResources(); diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index 7a910c5744..6c6ec50356 100755 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -23,7 +23,7 @@ #include "GrOvalRenderer.h" #include "GrPathRenderer.h" #include "GrPathUtils.h" -#include "GrResourceCache2.h" +#include "GrResourceCache.h" #include "GrSoftwarePathRenderer.h" #include "GrStencilAndCoverTextContext.h" #include "GrStrokeInfo.h" @@ -88,7 +88,7 @@ GrContext::GrContext(const Options& opts) : fOptions(opts) { fClip = NULL; fPathRendererChain = NULL; fSoftwarePathRenderer = NULL; - fResourceCache2 = NULL; + fResourceCache = NULL; fFontCache = NULL; fDrawBuffer = NULL; fDrawBufferVBAllocPool = NULL; @@ -111,8 +111,8 @@ bool GrContext::init(GrBackend backend, GrBackendContext backendContext) { } void GrContext::initCommon() { - fResourceCache2 = SkNEW(GrResourceCache2); - fResourceCache2->setOverBudgetCallback(OverBudgetCB, this); + fResourceCache = SkNEW(GrResourceCache); + fResourceCache->setOverBudgetCallback(OverBudgetCB, this); fFontCache = SkNEW_ARGS(GrFontCache, (fGpu)); @@ -137,7 +137,7 @@ GrContext::~GrContext() { (*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo); } - SkDELETE(fResourceCache2); + SkDELETE(fResourceCache); SkDELETE(fFontCache); SkDELETE(fDrawBuffer); SkDELETE(fDrawBufferVBAllocPool); @@ -154,7 +154,7 @@ GrContext::~GrContext() { void GrContext::abandonContext() { // abandon first to so destructors // don't try to free the resources in the API. - fResourceCache2->abandonAll(); + fResourceCache->abandonAll(); fGpu->contextAbandoned(); @@ -202,10 +202,10 @@ void GrContext::freeGpuResources() { void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const { if (resourceCount) { - *resourceCount = fResourceCache2->getBudgetedResourceCount(); + *resourceCount = fResourceCache->getBudgetedResourceCount(); } if (resourceBytes) { - *resourceBytes = fResourceCache2->getBudgetedResourceBytes(); + *resourceBytes = fResourceCache->getBudgetedResourceBytes(); } } @@ -299,13 +299,13 @@ GrTexture* GrContext::internalRefScratchTexture(const GrSurfaceDesc& inDesc, uin GrTexturePriv::ComputeScratchKey(*desc, &key); uint32_t scratchFlags = 0; if (kNoPendingIO_ScratchTextureFlag & flags) { - scratchFlags = GrResourceCache2::kRequireNoPendingIO_ScratchFlag; + scratchFlags = GrResourceCache::kRequireNoPendingIO_ScratchFlag; } else if (!(desc->fFlags & kRenderTarget_GrSurfaceFlag)) { // If it is not a render target then it will most likely be populated by // writePixels() which will trigger a flush if the texture has pending IO. - scratchFlags = GrResourceCache2::kPreferNoPendingIO_ScratchFlag; + scratchFlags = GrResourceCache::kPreferNoPendingIO_ScratchFlag; } - GrGpuResource* resource = fResourceCache2->findAndRefScratchResource(key, scratchFlags); + GrGpuResource* resource = fResourceCache->findAndRefScratchResource(key, scratchFlags); if (resource) { GrSurface* surface = static_cast<GrSurface*>(resource); GrRenderTarget* rt = surface->asRenderTarget(); @@ -1569,15 +1569,15 @@ const GrFragmentProcessor* GrContext::createUPMToPMEffect(GrTexture* texture, void GrContext::getResourceCacheLimits(int* maxTextures, size_t* maxTextureBytes) const { if (maxTextures) { - *maxTextures = fResourceCache2->getMaxResourceCount(); + *maxTextures = fResourceCache->getMaxResourceCount(); } if (maxTextureBytes) { - *maxTextureBytes = fResourceCache2->getMaxResourceBytes(); + *maxTextureBytes = fResourceCache->getMaxResourceBytes(); } } void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) { - fResourceCache2->setLimits(maxTextures, maxTextureBytes); + fResourceCache->setLimits(maxTextures, maxTextureBytes); } bool GrContext::addResourceToCache(const GrContentKey& key, GrGpuResource* resource) { @@ -1589,11 +1589,11 @@ bool GrContext::addResourceToCache(const GrContentKey& key, GrGpuResource* resou } bool GrContext::isResourceInCache(const GrContentKey& key) const { - return fResourceCache2->hasContentKey(key); + return fResourceCache->hasContentKey(key); } GrGpuResource* GrContext::findAndRefCachedResource(const GrContentKey& key) { - return fResourceCache2->findAndRefContentResource(key); + return fResourceCache->findAndRefContentResource(key); } ////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp index 67637e741a..d23d4524a9 100644 --- a/src/gpu/GrGpu.cpp +++ b/src/gpu/GrGpu.cpp @@ -13,7 +13,7 @@ #include "GrContext.h" #include "GrDrawTargetCaps.h" #include "GrIndexBuffer.h" -#include "GrResourceCache2.h" +#include "GrResourceCache.h" #include "GrStencilBuffer.h" #include "GrVertexBuffer.h" @@ -88,7 +88,7 @@ bool GrGpu::attachStencilBufferToRenderTarget(GrRenderTarget* rt, bool budgeted) GrScratchKey sbKey; GrStencilBuffer::ComputeKey(rt->width(), rt->height(), rt->numSamples(), &sbKey); SkAutoTUnref<GrStencilBuffer> sb(static_cast<GrStencilBuffer*>( - this->getContext()->getResourceCache2()->findAndRefScratchResource(sbKey))); + this->getContext()->getResourceCache()->findAndRefScratchResource(sbKey))); if (sb) { rt->setStencilBuffer(sb); bool attached = this->attachStencilBufferToRenderTarget(sb, rt); diff --git a/src/gpu/GrGpuResource.cpp b/src/gpu/GrGpuResource.cpp index 7fb5559362..7f65af25d4 100644 --- a/src/gpu/GrGpuResource.cpp +++ b/src/gpu/GrGpuResource.cpp @@ -7,14 +7,14 @@ */ #include "GrGpuResource.h" -#include "GrResourceCache2.h" +#include "GrResourceCache.h" #include "GrGpu.h" -static inline GrResourceCache2* get_resource_cache2(GrGpu* gpu) { +static inline GrResourceCache* get_resource_cache(GrGpu* gpu) { SkASSERT(gpu); SkASSERT(gpu->getContext()); - SkASSERT(gpu->getContext()->getResourceCache2()); - return gpu->getContext()->getResourceCache2(); + SkASSERT(gpu->getContext()->getResourceCache()); + return gpu->getContext()->getResourceCache(); } GrGpuResource::GrGpuResource(GrGpu* gpu, LifeCycle lifeCycle) @@ -25,7 +25,7 @@ GrGpuResource::GrGpuResource(GrGpu* gpu, LifeCycle lifeCycle) } void GrGpuResource::registerWithCache() { - get_resource_cache2(fGpu)->resourceAccess().insertResource(this); + get_resource_cache(fGpu)->resourceAccess().insertResource(this); } GrGpuResource::~GrGpuResource() { @@ -36,7 +36,7 @@ GrGpuResource::~GrGpuResource() { void GrGpuResource::release() { SkASSERT(fGpu); this->onRelease(); - get_resource_cache2(fGpu)->resourceAccess().removeResource(this); + get_resource_cache(fGpu)->resourceAccess().removeResource(this); fGpu = NULL; fGpuMemorySize = 0; } @@ -44,7 +44,7 @@ void GrGpuResource::release() { void GrGpuResource::abandon() { SkASSERT(fGpu); this->onAbandon(); - get_resource_cache2(fGpu)->resourceAccess().removeResource(this); + get_resource_cache(fGpu)->resourceAccess().removeResource(this); fGpu = NULL; fGpuMemorySize = 0; } @@ -79,12 +79,12 @@ void GrGpuResource::didChangeGpuMemorySize() const { size_t oldSize = fGpuMemorySize; SkASSERT(kInvalidGpuMemorySize != oldSize); fGpuMemorySize = kInvalidGpuMemorySize; - get_resource_cache2(fGpu)->resourceAccess().didChangeGpuMemorySize(this, oldSize); + get_resource_cache(fGpu)->resourceAccess().didChangeGpuMemorySize(this, oldSize); } void GrGpuResource::removeContentKey() { SkASSERT(fContentKey.isValid()); - get_resource_cache2(fGpu)->resourceAccess().willRemoveContentKey(this); + get_resource_cache(fGpu)->resourceAccess().willRemoveContentKey(this); fContentKey.reset(); } @@ -104,7 +104,7 @@ bool GrGpuResource::setContentKey(const GrContentKey& key) { fContentKey = key; - if (!get_resource_cache2(fGpu)->resourceAccess().didSetContentKey(this)) { + if (!get_resource_cache(fGpu)->resourceAccess().didSetContentKey(this)) { fContentKey.reset(); return false; } @@ -117,7 +117,7 @@ void GrGpuResource::notifyIsPurgeable() const { SkDELETE(this); } else { GrGpuResource* mutableThis = const_cast<GrGpuResource*>(this); - get_resource_cache2(fGpu)->resourceAccess().notifyPurgeable(mutableThis); + get_resource_cache(fGpu)->resourceAccess().notifyPurgeable(mutableThis); } } @@ -133,7 +133,7 @@ void GrGpuResource::setScratchKey(const GrScratchKey& scratchKey) { void GrGpuResource::removeScratchKey() { if (!this->wasDestroyed() && fScratchKey.isValid()) { - get_resource_cache2(fGpu)->resourceAccess().willRemoveScratchKey(this); + get_resource_cache(fGpu)->resourceAccess().willRemoveScratchKey(this); fScratchKey.reset(); } } @@ -141,14 +141,14 @@ void GrGpuResource::removeScratchKey() { void GrGpuResource::makeBudgeted() { if (GrGpuResource::kUncached_LifeCycle == fLifeCycle) { fLifeCycle = kCached_LifeCycle; - get_resource_cache2(fGpu)->resourceAccess().didChangeBudgetStatus(this); + get_resource_cache(fGpu)->resourceAccess().didChangeBudgetStatus(this); } } void GrGpuResource::makeUnbudgeted() { if (GrGpuResource::kCached_LifeCycle == fLifeCycle && !fContentKey.isValid()) { fLifeCycle = kUncached_LifeCycle; - get_resource_cache2(fGpu)->resourceAccess().didChangeBudgetStatus(this); + get_resource_cache(fGpu)->resourceAccess().didChangeBudgetStatus(this); } } diff --git a/src/gpu/GrResourceCache2.cpp b/src/gpu/GrResourceCache.cpp index c1656593b5..2b842a8f08 100644 --- a/src/gpu/GrResourceCache2.cpp +++ b/src/gpu/GrResourceCache.cpp @@ -7,7 +7,7 @@ */ -#include "GrResourceCache2.h" +#include "GrResourceCache.h" #include "GrGpuResource.h" #include "SkChecksum.h" @@ -45,12 +45,12 @@ uint32_t GrResourceKeyHash(const uint32_t* data, size_t size) { ////////////////////////////////////////////////////////////////////////////// -class GrResourceCache2::AutoValidate : ::SkNoncopyable { +class GrResourceCache::AutoValidate : ::SkNoncopyable { public: - AutoValidate(GrResourceCache2* cache) : fCache(cache) { cache->validate(); } + AutoValidate(GrResourceCache* cache) : fCache(cache) { cache->validate(); } ~AutoValidate() { fCache->validate(); } private: - GrResourceCache2* fCache; + GrResourceCache* fCache; }; ////////////////////////////////////////////////////////////////////////////// @@ -58,7 +58,7 @@ private: static const int kDefaultMaxCount = 2 * (1 << 10); static const size_t kDefaultMaxSize = 96 * (1 << 20); -GrResourceCache2::GrResourceCache2() +GrResourceCache::GrResourceCache() : fMaxCount(kDefaultMaxCount) , fMaxBytes(kDefaultMaxSize) #if GR_CACHE_STATS @@ -77,17 +77,17 @@ GrResourceCache2::GrResourceCache2() , fOverBudgetData(NULL) { } -GrResourceCache2::~GrResourceCache2() { +GrResourceCache::~GrResourceCache() { this->releaseAll(); } -void GrResourceCache2::setLimits(int count, size_t bytes) { +void GrResourceCache::setLimits(int count, size_t bytes) { fMaxCount = count; fMaxBytes = bytes; this->purgeAsNeeded(); } -void GrResourceCache2::insertResource(GrGpuResource* resource) { +void GrResourceCache::insertResource(GrGpuResource* resource) { SkASSERT(resource); SkASSERT(!resource->wasDestroyed()); SkASSERT(!this->isInCache(resource)); @@ -117,7 +117,7 @@ void GrResourceCache2::insertResource(GrGpuResource* resource) { this->purgeAsNeeded(); } -void GrResourceCache2::removeResource(GrGpuResource* resource) { +void GrResourceCache::removeResource(GrGpuResource* resource) { SkASSERT(this->isInCache(resource)); size_t size = resource->gpuMemorySize(); @@ -138,7 +138,7 @@ void GrResourceCache2::removeResource(GrGpuResource* resource) { this->validate(); } -void GrResourceCache2::abandonAll() { +void GrResourceCache::abandonAll() { AutoValidate av(this); SkASSERT(!fPurging); @@ -156,7 +156,7 @@ void GrResourceCache2::abandonAll() { SkASSERT(!fBudgetedBytes); } -void GrResourceCache2::releaseAll() { +void GrResourceCache::releaseAll() { AutoValidate av(this); SkASSERT(!fPurging); @@ -173,7 +173,7 @@ void GrResourceCache2::releaseAll() { SkASSERT(!fBudgetedBytes); } -class GrResourceCache2::AvailableForScratchUse { +class GrResourceCache::AvailableForScratchUse { public: AvailableForScratchUse(bool rejectPendingIO) : fRejectPendingIO(rejectPendingIO) { } @@ -188,7 +188,7 @@ private: bool fRejectPendingIO; }; -GrGpuResource* GrResourceCache2::findAndRefScratchResource(const GrScratchKey& scratchKey, +GrGpuResource* GrResourceCache::findAndRefScratchResource(const GrScratchKey& scratchKey, uint32_t flags) { SkASSERT(!fPurging); SkASSERT(scratchKey.isValid()); @@ -216,19 +216,19 @@ GrGpuResource* GrResourceCache2::findAndRefScratchResource(const GrScratchKey& s return resource; } -void GrResourceCache2::willRemoveScratchKey(const GrGpuResource* resource) { +void GrResourceCache::willRemoveScratchKey(const GrGpuResource* resource) { SkASSERT(resource->cacheAccess().getScratchKey().isValid()); fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource); } -void GrResourceCache2::willRemoveContentKey(const GrGpuResource* resource) { +void GrResourceCache::willRemoveContentKey(const GrGpuResource* resource) { // Someone has a ref to this resource in order to invalidate it. When the ref count reaches // zero we will get a notifyPurgable() and figure out what to do with it. SkASSERT(resource->getContentKey().isValid()); fContentHash.remove(resource->getContentKey()); } -bool GrResourceCache2::didSetContentKey(GrGpuResource* resource) { +bool GrResourceCache::didSetContentKey(GrGpuResource* resource) { SkASSERT(!fPurging); SkASSERT(resource); SkASSERT(this->isInCache(resource)); @@ -244,7 +244,7 @@ bool GrResourceCache2::didSetContentKey(GrGpuResource* resource) { return true; } -void GrResourceCache2::makeResourceMRU(GrGpuResource* resource) { +void GrResourceCache::makeResourceMRU(GrGpuResource* resource) { SkASSERT(!fPurging); SkASSERT(resource); SkASSERT(this->isInCache(resource)); @@ -252,7 +252,7 @@ void GrResourceCache2::makeResourceMRU(GrGpuResource* resource) { fResources.addToHead(resource); } -void GrResourceCache2::notifyPurgeable(GrGpuResource* resource) { +void GrResourceCache::notifyPurgeable(GrGpuResource* resource) { SkASSERT(resource); SkASSERT(this->isInCache(resource)); SkASSERT(resource->isPurgeable()); @@ -303,7 +303,7 @@ void GrResourceCache2::notifyPurgeable(GrGpuResource* resource) { this->validate(); } -void GrResourceCache2::didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) { +void GrResourceCache::didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) { // SkASSERT(!fPurging); GrPathRange increases size during flush. :( SkASSERT(resource); SkASSERT(this->isInCache(resource)); @@ -325,7 +325,7 @@ void GrResourceCache2::didChangeGpuMemorySize(const GrGpuResource* resource, siz this->validate(); } -void GrResourceCache2::didChangeBudgetStatus(GrGpuResource* resource) { +void GrResourceCache::didChangeBudgetStatus(GrGpuResource* resource) { SkASSERT(!fPurging); SkASSERT(resource); SkASSERT(this->isInCache(resource)); @@ -348,7 +348,7 @@ void GrResourceCache2::didChangeBudgetStatus(GrGpuResource* resource) { this->validate(); } -void GrResourceCache2::internalPurgeAsNeeded() { +void GrResourceCache::internalPurgeAsNeeded() { SkASSERT(!fPurging); SkASSERT(!fNewlyPurgeableResourceWhilePurging); SkASSERT(fBudgetedCount > fMaxCount || fBudgetedBytes > fMaxBytes); @@ -385,7 +385,7 @@ void GrResourceCache2::internalPurgeAsNeeded() { this->validate(); } -void GrResourceCache2::purgeAllUnlocked() { +void GrResourceCache::purgeAllUnlocked() { SkASSERT(!fPurging); SkASSERT(!fNewlyPurgeableResourceWhilePurging); @@ -413,7 +413,7 @@ void GrResourceCache2::purgeAllUnlocked() { this->validate(); } -void GrResourceCache2::processInvalidContentKeys( +void GrResourceCache::processInvalidContentKeys( const SkTArray<GrContentKeyInvalidatedMessage>& msgs) { for (int i = 0; i < msgs.count(); ++i) { GrGpuResource* resource = this->findAndRefContentResource(msgs[i].key()); @@ -425,7 +425,7 @@ void GrResourceCache2::processInvalidContentKeys( } #ifdef SK_DEBUG -void GrResourceCache2::validate() const { +void GrResourceCache::validate() const { // Reduce the frequency of validations for large resource counts. static SkRandom gRandom; int mask = (SkNextPow2(fCount + 1) >> 5) - 1; diff --git a/src/gpu/GrResourceCache2.h b/src/gpu/GrResourceCache.h index e844f11e6a..522641ba37 100644 --- a/src/gpu/GrResourceCache2.h +++ b/src/gpu/GrResourceCache.h @@ -6,8 +6,8 @@ * found in the LICENSE file. */ -#ifndef GrResourceCache2_DEFINED -#define GrResourceCache2_DEFINED +#ifndef GrResourceCache_DEFINED +#define GrResourceCache_DEFINED #include "GrGpuResource.h" #include "GrGpuResourceCacheAccess.h" @@ -36,10 +36,10 @@ class SkString; * If a resource has neither key type then it will be deleted as soon as the last reference to it * is dropped. If a key has both keys the content key takes precedence. */ -class GrResourceCache2 { +class GrResourceCache { public: - GrResourceCache2(); - ~GrResourceCache2(); + GrResourceCache(); + ~GrResourceCache(); /** Used to access functionality needed by GrGpuResource for lifetime management. */ class ResourceAccess; @@ -254,9 +254,9 @@ private: }; -class GrResourceCache2::ResourceAccess { +class GrResourceCache::ResourceAccess { private: - ResourceAccess(GrResourceCache2* cache) : fCache(cache) { } + ResourceAccess(GrResourceCache* cache) : fCache(cache) { } ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { } ResourceAccess& operator=(const ResourceAccess&); // unimpl @@ -315,13 +315,13 @@ private: const ResourceAccess* operator&() const; ResourceAccess* operator&(); - GrResourceCache2* fCache; + GrResourceCache* fCache; friend class GrGpuResource; // To access all the proxy inline methods. - friend class GrResourceCache2; // To create this type. + friend class GrResourceCache; // To create this type. }; -inline GrResourceCache2::ResourceAccess GrResourceCache2::resourceAccess() { +inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() { return ResourceAccess(this); } diff --git a/src/gpu/GrTest.cpp b/src/gpu/GrTest.cpp index 2f32eb5d4a..14259e6b38 100644 --- a/src/gpu/GrTest.cpp +++ b/src/gpu/GrTest.cpp @@ -9,7 +9,7 @@ #include "GrTest.h" #include "GrInOrderDrawBuffer.h" -#include "GrResourceCache2.h" +#include "GrResourceCache.h" #include "SkString.h" void GrTestTarget::init(GrContext* ctx, GrDrawTarget* target) { @@ -38,12 +38,12 @@ void GrContext::setMaxTextureSizeOverride(int maxTextureSizeOverride) { } void GrContext::purgeAllUnlockedResources() { - fResourceCache2->purgeAllUnlocked(); + fResourceCache->purgeAllUnlocked(); } void GrContext::dumpCacheStats(SkString* out) const { #if GR_CACHE_STATS - fResourceCache2->dumpStats(out); + fResourceCache->dumpStats(out); #endif } @@ -75,7 +75,7 @@ void GrGpu::Stats::dump(SkString* out) { #endif #if GR_CACHE_STATS -void GrResourceCache2::dumpStats(SkString* out) const { +void GrResourceCache::dumpStats(SkString* out) const { this->validate(); int locked = 0; diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp index 7a3355f162..856bd723a7 100644 --- a/tests/ResourceCacheTest.cpp +++ b/tests/ResourceCacheTest.cpp @@ -10,7 +10,7 @@ #include "GrContext.h" #include "GrContextFactory.h" #include "GrGpu.h" -#include "GrResourceCache2.h" +#include "GrResourceCache.h" #include "SkCanvas.h" #include "SkGr.h" #include "SkMessageBus.h" @@ -160,12 +160,12 @@ public: fContext.reset(GrContext::CreateMockContext()); SkASSERT(fContext); fContext->setResourceCacheLimits(maxCnt, maxBytes); - GrResourceCache2* cache2 = fContext->getResourceCache2(); - cache2->purgeAllUnlocked(); - SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes()); + GrResourceCache* cache = fContext->getResourceCache(); + cache->purgeAllUnlocked(); + SkASSERT(0 == cache->getResourceCount() && 0 == cache->getResourceBytes()); } - GrResourceCache2* cache() { return fContext->getResourceCache2(); } + GrResourceCache* cache() { return fContext->getResourceCache(); } GrContext* context() { return fContext; } @@ -176,7 +176,7 @@ private: static void test_no_key(skiatest::Reporter* reporter) { Mock mock(10, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); // Create a bunch of resources with no keys TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu())); @@ -189,37 +189,37 @@ static void test_no_key(skiatest::Reporter* reporter) { d->setSize(14); REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 4 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 4 == cache->getResourceCount()); REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() + c->gpuMemorySize() + - d->gpuMemorySize() == cache2->getResourceBytes()); + d->gpuMemorySize() == cache->getResourceBytes()); // Should be safe to purge without deleting the resources since we still have refs. - cache2->purgeAllUnlocked(); + cache->purgeAllUnlocked(); REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive()); // Since the resources have neither content nor scratch keys, delete immediately upon unref. a->unref(); REPORTER_ASSERT(reporter, 3 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 3 == cache->getResourceCount()); REPORTER_ASSERT(reporter, b->gpuMemorySize() + c->gpuMemorySize() + d->gpuMemorySize() == - cache2->getResourceBytes()); + cache->getResourceBytes()); c->unref(); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); REPORTER_ASSERT(reporter, b->gpuMemorySize() + d->gpuMemorySize() == - cache2->getResourceBytes()); + cache->getResourceBytes()); d->unref(); REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache2->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache->getResourceBytes()); b->unref(); REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes()); } // Each integer passed as a template param creates a new domain. @@ -232,7 +232,7 @@ template <int> static void make_content_key(GrContentKey* key, int data) { static void test_budgeting(skiatest::Reporter* reporter) { Mock mock(10, 300); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); GrContentKey contentKey; make_content_key<0>(&contentKey, 0); @@ -255,69 +255,69 @@ static void test_budgeting(skiatest::Reporter* reporter) { GrContentKey contentKey2; make_content_key<0>(&contentKey2, 1); REPORTER_ASSERT(reporter, !wrapped->cacheAccess().setContentKey(contentKey2)); - REPORTER_ASSERT(reporter, NULL == cache2->findAndRefContentResource(contentKey2)); + REPORTER_ASSERT(reporter, NULL == cache->findAndRefContentResource(contentKey2)); // Make sure sizes are as we expect - REPORTER_ASSERT(reporter, 4 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 4 == cache->getResourceCount()); REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() + wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() == - cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount()); + cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() == - cache2->getBudgetedResourceBytes()); + cache->getBudgetedResourceBytes()); // Our refs mean that the resources are non purgeable. - cache2->purgeAllUnlocked(); - REPORTER_ASSERT(reporter, 4 == cache2->getResourceCount()); + cache->purgeAllUnlocked(); + REPORTER_ASSERT(reporter, 4 == cache->getResourceCount()); REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() + wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() == - cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount()); + cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() == - cache2->getBudgetedResourceBytes()); + cache->getBudgetedResourceBytes()); // Unreffing the wrapped resource should free it right away. wrapped->unref(); - REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 3 == cache->getResourceCount()); REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() + - unbudgeted->gpuMemorySize() == cache2->getResourceBytes()); + unbudgeted->gpuMemorySize() == cache->getResourceBytes()); // Now try freeing the budgeted resources first wrapped = SkNEW_ARGS(TestResource, (context->getGpu(), GrGpuResource::kWrapped_LifeCycle)); scratch->setSize(12); content->unref(); - cache2->purgeAllUnlocked(); - REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount()); + cache->purgeAllUnlocked(); + REPORTER_ASSERT(reporter, 3 == cache->getResourceCount()); REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + wrapped->gpuMemorySize() + - unbudgeted->gpuMemorySize() == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, scratch->gpuMemorySize() == cache2->getBudgetedResourceBytes()); + unbudgeted->gpuMemorySize() == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, scratch->gpuMemorySize() == cache->getBudgetedResourceBytes()); scratch->unref(); - cache2->purgeAllUnlocked(); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + cache->purgeAllUnlocked(); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() + wrapped->gpuMemorySize() == - cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes()); + cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes()); wrapped->unref(); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes()); unbudgeted->unref(); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes()); } static void test_unbudgeted(skiatest::Reporter* reporter) { Mock mock(10, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); GrContentKey contentKey; make_content_key<0>(&contentKey, 0); @@ -331,58 +331,58 @@ static void test_unbudgeted(skiatest::Reporter* reporter) { scratch = TestResource::CreateScratch(context->getGpu(), TestResource::kB_SimulatedProperty); scratch->setSize(10); scratch->unref(); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 10 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 10 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 10 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 10 == cache->getBudgetedResourceBytes()); content = SkNEW_ARGS(TestResource, (context->getGpu())); content->setSize(11); REPORTER_ASSERT(reporter, content->cacheAccess().setContentKey(contentKey)); content->unref(); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes()); - size_t large = 2 * cache2->getResourceBytes(); + size_t large = 2 * cache->getResourceBytes(); unbudgeted = SkNEW_ARGS(TestResource, (context->getGpu(), large, GrGpuResource::kUncached_LifeCycle)); - REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 21 + large == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 3 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes()); unbudgeted->unref(); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes()); wrapped = SkNEW_ARGS(TestResource, (context->getGpu(), large, GrGpuResource::kWrapped_LifeCycle)); - REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 21 + large == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 3 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes()); wrapped->unref(); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes()); - - cache2->purgeAllUnlocked(); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes()); + + cache->purgeAllUnlocked(); + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes()); } static void test_unbudgeted_to_scratch(skiatest::Reporter* reporter) { Mock mock(10, 300); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); TestResource* resource = TestResource::CreateScratch(context->getGpu(), TestResource::kA_SimulatedProperty, false); @@ -395,19 +395,19 @@ static void test_unbudgeted_to_scratch(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, resource->cacheAccess().getScratchKey() == key); REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch()); REPORTER_ASSERT(reporter, !resource->cacheAccess().isBudgeted()); - REPORTER_ASSERT(reporter, NULL == cache2->findAndRefScratchResource(key)); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, size == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, NULL == cache->findAndRefScratchResource(key)); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, size == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes()); // Once it is unrefed, it should become available as scratch. resource->unref(); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, size == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, size == cache2->getBudgetedResourceBytes()); - resource = static_cast<TestResource*>(cache2->findAndRefScratchResource(key)); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, size == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, size == cache->getBudgetedResourceBytes()); + resource = static_cast<TestResource*>(cache->findAndRefScratchResource(key)); REPORTER_ASSERT(reporter, resource); REPORTER_ASSERT(reporter, resource->cacheAccess().getScratchKey() == key); REPORTER_ASSERT(reporter, resource->cacheAccess().isScratch()); @@ -420,20 +420,20 @@ static void test_unbudgeted_to_scratch(skiatest::Reporter* reporter) { } else { // After the second time around, try removing the scratch key resource->cacheAccess().removeScratchKey(); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, size == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, size == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, size == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, size == cache->getBudgetedResourceBytes()); REPORTER_ASSERT(reporter, !resource->cacheAccess().getScratchKey().isValid()); REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch()); REPORTER_ASSERT(reporter, resource->cacheAccess().isBudgeted()); // now when it is unrefed it should die since it has no key. resource->unref(); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes()); } } } @@ -441,7 +441,7 @@ static void test_unbudgeted_to_scratch(skiatest::Reporter* reporter) { static void test_duplicate_scratch_key(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); // Create two resources that have the same scratch key. TestResource* a = TestResource::CreateScratch(context->getGpu(), @@ -453,40 +453,40 @@ static void test_duplicate_scratch_key(skiatest::Reporter* reporter) { GrScratchKey scratchKey1; TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey1); // Check for negative case consistency. (leaks upon test failure.) - REPORTER_ASSERT(reporter, NULL == cache2->findAndRefScratchResource(scratchKey1)); + REPORTER_ASSERT(reporter, NULL == cache->findAndRefScratchResource(scratchKey1)); GrScratchKey scratchKey; TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey); - // Scratch resources are registered with GrResourceCache2 just by existing. There are 2. + // Scratch resources are registered with GrResourceCache just by existing. There are 2. REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));) - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() == - cache2->getResourceBytes()); + cache->getResourceBytes()); // Our refs mean that the resources are non purgeable. - cache2->purgeAllUnlocked(); + cache->purgeAllUnlocked(); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); // Unref but don't purge a->unref(); b->unref(); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));) + SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));) // Purge again. This time resources should be purgeable. - cache2->purgeAllUnlocked(); + cache->purgeAllUnlocked(); REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));) } static void test_remove_scratch_key(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); // Create two resources that have the same scratch key. TestResource* a = TestResource::CreateScratch(context->getGpu(), @@ -501,52 +501,52 @@ static void test_remove_scratch_key(skiatest::Reporter* reporter) { // Ensure that scratch key lookup is correct for negative case. TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey); // (following leaks upon test failure). - REPORTER_ASSERT(reporter, cache2->findAndRefScratchResource(scratchKey) == NULL); + REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey) == NULL); - // Scratch resources are registered with GrResourceCache2 just by existing. There are 2. + // Scratch resources are registered with GrResourceCache just by existing. There are 2. TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));) - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); // Find the first resource and remove its scratch key GrGpuResource* find; - find = cache2->findAndRefScratchResource(scratchKey); + find = cache->findAndRefScratchResource(scratchKey); find->cacheAccess().removeScratchKey(); // It's still alive, but not cached by scratch key anymore REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache2->countScratchEntriesForKey(scratchKey));) - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); // The cache should immediately delete it when it's unrefed since it isn't accessible. find->unref(); REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache2->countScratchEntriesForKey(scratchKey));) - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); // Repeat for the second resource. - find = cache2->findAndRefScratchResource(scratchKey); + find = cache->findAndRefScratchResource(scratchKey); find->cacheAccess().removeScratchKey(); REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); // Should be able to call this multiple times with no problem. find->cacheAccess().removeScratchKey(); REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); find->unref(); REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive()); - SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); } static void test_scratch_key_consistency(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); // Create two resources that have the same scratch key. TestResource* a = TestResource::CreateScratch(context->getGpu(), @@ -581,20 +581,20 @@ static void test_scratch_key_consistency(skiatest::Reporter* reporter) { // Ensure that scratch key lookup is correct for negative case. TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey); // (following leaks upon test failure). - REPORTER_ASSERT(reporter, cache2->findAndRefScratchResource(scratchKey) == NULL); + REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey) == NULL); // Find the first resource with a scratch key and a copy of a scratch key. TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey); - GrGpuResource* find = cache2->findAndRefScratchResource(scratchKey); + GrGpuResource* find = cache->findAndRefScratchResource(scratchKey); REPORTER_ASSERT(reporter, find != NULL); find->unref(); scratchKey2 = scratchKey; - find = cache2->findAndRefScratchResource(scratchKey2); + find = cache->findAndRefScratchResource(scratchKey2); REPORTER_ASSERT(reporter, find != NULL); REPORTER_ASSERT(reporter, find == a || find == b); - GrGpuResource* find2 = cache2->findAndRefScratchResource(scratchKey2); + GrGpuResource* find2 = cache->findAndRefScratchResource(scratchKey2); REPORTER_ASSERT(reporter, find2 != NULL); REPORTER_ASSERT(reporter, find2 == a || find2 == b); REPORTER_ASSERT(reporter, find2 != find); @@ -605,7 +605,7 @@ static void test_scratch_key_consistency(skiatest::Reporter* reporter) { static void test_duplicate_content_key(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); GrContentKey key; make_content_key<0>(&key, 0); @@ -621,38 +621,38 @@ static void test_duplicate_content_key(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, !b->cacheAccess().setContentKey(key)); // Still have two resources because b is still reffed. - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() == - cache2->getResourceBytes()); + cache->getResourceBytes()); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); b->unref(); // Now b should be gone. - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache2->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache->getResourceBytes()); REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); - cache2->purgeAllUnlocked(); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache2->getResourceBytes()); + cache->purgeAllUnlocked(); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache->getResourceBytes()); REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); // Drop the ref on a but it isn't immediately purged as it still has a valid scratch key. a->unref(); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache2->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache->getResourceBytes()); REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); - cache2->purgeAllUnlocked(); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes()); + cache->purgeAllUnlocked(); + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes()); REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive()); } static void test_purge_invalidated(skiatest::Reporter* reporter) { Mock mock(5, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); GrContentKey key1, key2, key3; make_content_key<0>(&key1, 1); @@ -671,9 +671,9 @@ static void test_purge_invalidated(skiatest::Reporter* reporter) { // hold b until *after* the message is sent. c->unref(); - REPORTER_ASSERT(reporter, cache2->hasContentKey(key1)); - REPORTER_ASSERT(reporter, cache2->hasContentKey(key2)); - REPORTER_ASSERT(reporter, cache2->hasContentKey(key3)); + REPORTER_ASSERT(reporter, cache->hasContentKey(key1)); + REPORTER_ASSERT(reporter, cache->hasContentKey(key2)); + REPORTER_ASSERT(reporter, cache->hasContentKey(key3)); REPORTER_ASSERT(reporter, 3 == TestResource::NumAlive()); typedef GrContentKeyInvalidatedMessage Msg; @@ -682,19 +682,19 @@ static void test_purge_invalidated(skiatest::Reporter* reporter) { // Invalidate two of the three, they should be purged and no longer accessible via their keys. Bus::Post(Msg(key1)); Bus::Post(Msg(key2)); - cache2->purgeAsNeeded(); + cache->purgeAsNeeded(); // a should be deleted now, but we still have a ref on b. - REPORTER_ASSERT(reporter, !cache2->hasContentKey(key1)); - REPORTER_ASSERT(reporter, !cache2->hasContentKey(key2)); + REPORTER_ASSERT(reporter, !cache->hasContentKey(key1)); + REPORTER_ASSERT(reporter, !cache->hasContentKey(key2)); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, cache2->hasContentKey(key3)); + REPORTER_ASSERT(reporter, cache->hasContentKey(key3)); // Invalidate the third. Bus::Post(Msg(key3)); - cache2->purgeAsNeeded(); + cache->purgeAsNeeded(); // we still have a ref on b, c should be recycled as scratch. REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, !cache2->hasContentKey(key3)); + REPORTER_ASSERT(reporter, !cache->hasContentKey(key3)); // make b purgeable. It should be immediately deleted since it has no key. b->unref(); @@ -703,16 +703,16 @@ static void test_purge_invalidated(skiatest::Reporter* reporter) { // Make sure we actually get to c via it's scratch key, before we say goodbye. GrScratchKey scratchKey; TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey); - GrGpuResource* scratch = cache2->findAndRefScratchResource(scratchKey); + GrGpuResource* scratch = cache->findAndRefScratchResource(scratchKey); REPORTER_ASSERT(reporter, scratch == c); SkSafeUnref(scratch); // Get rid of c. - cache2->purgeAllUnlocked(); - scratch = cache2->findAndRefScratchResource(scratchKey); + cache->purgeAllUnlocked(); + scratch = cache->findAndRefScratchResource(scratchKey); REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); - REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceCount()); + REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes()); REPORTER_ASSERT(reporter, !scratch); SkSafeUnref(scratch); } @@ -720,7 +720,7 @@ static void test_purge_invalidated(skiatest::Reporter* reporter) { static void test_cache_chained_purge(skiatest::Reporter* reporter) { Mock mock(3, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); GrContentKey key1, key2; make_content_key<0>(&key1, 1); @@ -743,14 +743,14 @@ static void test_cache_chained_purge(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - cache2->purgeAllUnlocked(); + cache->purgeAllUnlocked(); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); // Break the cycle a->setUnrefWhenDestroyed(NULL); REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); - cache2->purgeAllUnlocked(); + cache->purgeAllUnlocked(); REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive()); } @@ -763,7 +763,7 @@ static void test_resource_size_changed(skiatest::Reporter* reporter) { { Mock mock(3, 30000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu())); a->cacheAccess().setContentKey(key1); @@ -773,24 +773,24 @@ static void test_resource_size_changed(skiatest::Reporter* reporter) { b->cacheAccess().setContentKey(key2); b->unref(); - REPORTER_ASSERT(reporter, 200 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 200 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); { - SkAutoTUnref<TestResource> find2(static_cast<TestResource*>(cache2->findAndRefContentResource(key2))); + SkAutoTUnref<TestResource> find2(static_cast<TestResource*>(cache->findAndRefContentResource(key2))); find2->setSize(200); - SkAutoTUnref<TestResource> find1(static_cast<TestResource*>(cache2->findAndRefContentResource(key1))); + SkAutoTUnref<TestResource> find1(static_cast<TestResource*>(cache->findAndRefContentResource(key1))); find1->setSize(50); } - REPORTER_ASSERT(reporter, 250 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 250 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); } // Test increasing a resources size beyond the cache budget. { Mock mock(2, 300); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu())); a->setSize(100); @@ -802,17 +802,17 @@ static void test_resource_size_changed(skiatest::Reporter* reporter) { b->cacheAccess().setContentKey(key2); b->unref(); - REPORTER_ASSERT(reporter, 200 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 200 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 2 == cache->getResourceCount()); { - SkAutoTUnref<TestResource> find2(static_cast<TestResource*>(cache2->findAndRefContentResource(key2))); + SkAutoTUnref<TestResource> find2(static_cast<TestResource*>(cache->findAndRefContentResource(key2))); find2->setSize(201); } - REPORTER_ASSERT(reporter, !cache2->hasContentKey(key1)); + REPORTER_ASSERT(reporter, !cache->hasContentKey(key1)); - REPORTER_ASSERT(reporter, 201 == cache2->getResourceBytes()); - REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); + REPORTER_ASSERT(reporter, 201 == cache->getResourceBytes()); + REPORTER_ASSERT(reporter, 1 == cache->getResourceCount()); } } @@ -824,7 +824,7 @@ static void test_large_resource_count(skiatest::Reporter* reporter) { Mock mock(2 * kResourceCnt, 2 * kResourceCnt + 1000); GrContext* context = mock.context(); - GrResourceCache2* cache2 = mock.cache(); + GrResourceCache* cache = mock.cache(); for (int i = 0; i < kResourceCnt; ++i) { GrContentKey key1, key2; @@ -845,33 +845,33 @@ static void test_large_resource_count(skiatest::Reporter* reporter) { } REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2 * kResourceCnt); - REPORTER_ASSERT(reporter, cache2->getBudgetedResourceBytes() == 2 * kResourceCnt); - REPORTER_ASSERT(reporter, cache2->getBudgetedResourceCount() == 2 * kResourceCnt); - REPORTER_ASSERT(reporter, cache2->getResourceBytes() == 2 * kResourceCnt); - REPORTER_ASSERT(reporter, cache2->getResourceCount() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache->getBudgetedResourceBytes() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache->getBudgetedResourceCount() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache->getResourceBytes() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache->getResourceCount() == 2 * kResourceCnt); for (int i = 0; i < kResourceCnt; ++i) { GrContentKey key1, key2; make_content_key<1>(&key1, i); make_content_key<2>(&key2, i); - REPORTER_ASSERT(reporter, cache2->hasContentKey(key1)); - REPORTER_ASSERT(reporter, cache2->hasContentKey(key2)); + REPORTER_ASSERT(reporter, cache->hasContentKey(key1)); + REPORTER_ASSERT(reporter, cache->hasContentKey(key2)); } - cache2->purgeAllUnlocked(); + cache->purgeAllUnlocked(); REPORTER_ASSERT(reporter, TestResource::NumAlive() == 0); - REPORTER_ASSERT(reporter, cache2->getBudgetedResourceBytes() == 0); - REPORTER_ASSERT(reporter, cache2->getBudgetedResourceCount() == 0); - REPORTER_ASSERT(reporter, cache2->getResourceBytes() == 0); - REPORTER_ASSERT(reporter, cache2->getResourceCount() == 0); + REPORTER_ASSERT(reporter, cache->getBudgetedResourceBytes() == 0); + REPORTER_ASSERT(reporter, cache->getBudgetedResourceCount() == 0); + REPORTER_ASSERT(reporter, cache->getResourceBytes() == 0); + REPORTER_ASSERT(reporter, cache->getResourceCount() == 0); for (int i = 0; i < kResourceCnt; ++i) { GrContentKey key1, key2; make_content_key<1>(&key1, i); make_content_key<2>(&key2, i); - REPORTER_ASSERT(reporter, !cache2->hasContentKey(key1)); - REPORTER_ASSERT(reporter, !cache2->hasContentKey(key2)); + REPORTER_ASSERT(reporter, !cache->hasContentKey(key1)); + REPORTER_ASSERT(reporter, !cache->hasContentKey(key2)); } } |