cleanup GrContext resource cache api
R=robertphillips@google.com
Author: bsalomon@google.com
Review URL: https://codereview.chromium.org/275563005
git-svn-id: http://skia.googlecode.com/svn/trunk@14669 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/bench/benchmain.cpp b/bench/benchmain.cpp
index 3080a0f..e2cc9c1 100644
--- a/bench/benchmain.cpp
+++ b/bench/benchmain.cpp
@@ -433,14 +433,14 @@
size_t bytes;
int count;
- context->getTextureCacheLimits(&count, &bytes);
+ context->getResourceCacheLimits(&count, &bytes);
if (-1 != FLAGS_gpuCacheBytes) {
bytes = static_cast<size_t>(FLAGS_gpuCacheBytes);
}
if (-1 != FLAGS_gpuCacheCount) {
count = FLAGS_gpuCacheCount;
}
- context->setTextureCacheLimits(count, bytes);
+ context->setResourceCacheLimits(count, bytes);
#endif
}
diff --git a/gm/gmmain.cpp b/gm/gmmain.cpp
index abec105..a35317e 100644
--- a/gm/gmmain.cpp
+++ b/gm/gmmain.cpp
@@ -1774,14 +1774,14 @@
// Set the user specified cache limits if non-default.
size_t bytes;
int count;
- gr->getTextureCacheLimits(&count, &bytes);
+ gr->getResourceCacheLimits(&count, &bytes);
if (DEFAULT_CACHE_VALUE != gGpuCacheSizeBytes) {
bytes = static_cast<size_t>(gGpuCacheSizeBytes);
}
if (DEFAULT_CACHE_VALUE != gGpuCacheSizeCount) {
count = gGpuCacheSizeCount;
}
- gr->setTextureCacheLimits(count, bytes);
+ gr->setResourceCacheLimits(count, bytes);
}
}
if (!grSuccess) {
diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 195ab72..73a01b2 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -102,6 +102,62 @@
*/
void contextDestroyed();
+ ///////////////////////////////////////////////////////////////////////////
+ // Resource Cache
+
+ /**
+ * Return the current GPU resource cache limits.
+ *
+ * @param maxResources If non-null, returns maximum number of resources that
+ * can be held in the cache.
+ * @param maxResourceBytes If non-null, returns maximum number of bytes of
+ * video memory that can be held in the cache.
+ */
+ void getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const;
+ SK_ATTR_DEPRECATED("This function has been renamed to getResourceCacheLimits().")
+ void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const {
+ this->getResourceCacheLimits(maxTextures, maxTextureBytes);
+ }
+
+ /**
+ * Gets the current GPU resource cache usage.
+ *
+ * @param resourceCount If non-null, returns the number of resources that are held in the
+ * cache.
+ * @param maxResourceBytes If non-null, returns the total number of bytes of video memory held
+ * in the cache.
+ */
+ void getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const;
+
+ SK_ATTR_DEPRECATED("Use getResourceCacheUsage().")
+ size_t getGpuTextureCacheBytes() const {
+ size_t bytes;
+ this->getResourceCacheUsage(NULL, &bytes);
+ return bytes;
+ }
+
+ SK_ATTR_DEPRECATED("Use getResourceCacheUsage().")
+ int getGpuTextureCacheResourceCount() const {
+ int count;
+ this->getResourceCacheUsage(&count, NULL);
+ return count;
+ }
+
+ /**
+ * Specify the GPU resource cache limits. If the current cache exceeds either
+ * of these, it will be purged (LRU) to keep the cache within these limits.
+ *
+ * @param maxResources The maximum number of resources that can be held in
+ * the cache.
+ * @param maxResourceBytes The maximum number of bytes of video memory
+ * that can be held in the cache.
+ */
+ void setResourceCacheLimits(int maxResources, size_t maxResourceBytes);
+ SK_ATTR_DEPRECATED("This function has been renamed to setResourceCacheLimits().")
+ void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes) {
+ this->setResourceCacheLimits(maxTextures, maxTextureBytes);
+ }
+
/**
* Frees GPU created by the context. Can be called to reduce GPU memory
* pressure.
@@ -109,14 +165,32 @@
void freeGpuResources();
/**
- * Returns the number of bytes of GPU memory hosted by the texture cache.
+ * This method should be called whenever a GrResource is unreffed or
+ * switched from exclusive to non-exclusive. This
+ * gives the resource cache a chance to discard unneeded resources.
+ * Note: this entry point will be removed once totally ref-driven
+ * cache maintenance is implemented.
*/
- size_t getGpuTextureCacheBytes() const;
+ void purgeCache();
/**
- * Returns the number of resources hosted by the texture cache.
+ * Purge all the unlocked resources from the cache.
+ * This entry point is mainly meant for timing texture uploads
+ * and is not defined in normal builds of Skia.
*/
- int getGpuTextureCacheResourceCount() const;
+ void purgeAllUnlockedResources();
+
+ /**
+ * Stores a custom resource in the cache, based on the specified key.
+ */
+ void addResourceToCache(const GrResourceKey&, GrCacheable*);
+
+ /**
+ * Finds a resource in the cache, based on the specified key. This is intended for use in
+ * conjunction with addResourceToCache(). The return value will be NULL if not found. The
+ * caller must balance with a call to unref().
+ */
+ GrCacheable* findAndRefCachedResource(const GrResourceKey&);
///////////////////////////////////////////////////////////////////////////
// Textures
@@ -208,22 +282,6 @@
void unlockScratchTexture(GrTexture* texture);
/**
- * This method should be called whenever a GrTexture is unreffed or
- * switched from exclusive to non-exclusive. This
- * gives the resource cache a chance to discard unneeded textures.
- * Note: this entry point will be removed once totally ref-driven
- * cache maintenance is implemented
- */
- void purgeCache();
-
- /**
- * Purge all the unlocked resources from the cache.
- * This entry point is mainly meant for timing texture uploads
- * and is not defined in normal builds of Skia.
- */
- void purgeAllUnlockedResources();
-
- /**
* Creates a texture that is outside the cache. Does not count against
* cache's budget.
*/
@@ -242,27 +300,6 @@
int height) const;
/**
- * Return the current texture cache limits.
- *
- * @param maxTextures If non-null, returns maximum number of textures that
- * can be held in the cache.
- * @param maxTextureBytes If non-null, returns maximum number of bytes of
- * texture memory that can be held in the cache.
- */
- void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const;
-
- /**
- * Specify the texture cache limits. If the current cache exceeds either
- * of these, it will be purged (LRU) to keep the cache within these limits.
- *
- * @param maxTextures The maximum number of textures that can be held in
- * the cache.
- * @param maxTextureBytes The maximum number of bytes of texture memory
- * that can be held in the cache.
- */
- void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes);
-
- /**
* Return the max width or height of a texture supported by the current GPU.
*/
int getMaxTextureSize() const;
@@ -294,8 +331,6 @@
const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); }
- GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
-
/**
* Can the provided configuration act as a color render target?
*/
@@ -642,7 +677,6 @@
size_t rowBytes,
uint32_t pixelOpsFlags = 0);
-
/**
* Copies a rectangle of texels from src to dst. The size of dst is the size of the rectangle
* copied and topLeft is the position of the rect in src. The rectangle is clipped to src's
@@ -875,6 +909,7 @@
GrLayerCache* getLayerCache() { return fLayerCache.get(); }
GrDrawTarget* getTextTarget();
const GrIndexBuffer* getQuadIndexBuffer() const;
+ GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; }
// Called by tests that draw directly to the context via GrDrawTarget
void getTestTarget(GrTestTarget*);
@@ -899,18 +934,6 @@
GrPathRendererChain::DrawType drawType = GrPathRendererChain::kColor_DrawType,
GrPathRendererChain::StencilSupport* stencilSupport = NULL);
- /**
- * Stores a custom resource in the cache, based on the specified key.
- */
- void addResourceToCache(const GrResourceKey&, GrCacheable*);
-
- /**
- * Finds a resource in the cache, based on the specified key. This is intended for use in
- * conjunction with addResourceToCache(). The return value will be NULL if not found. The
- * caller must balance with a call to unref().
- */
- GrCacheable* findAndRefCachedResource(const GrResourceKey&);
-
#if GR_CACHE_STATS
void printCacheStats() const;
#endif
@@ -929,7 +952,7 @@
const GrClipData* fClip; // TODO: make this ref counted
GrDrawState* fDrawState;
- GrResourceCache* fTextureCache;
+ GrResourceCache* fResourceCache;
GrFontCache* fFontCache;
SkAutoTDelete<GrLayerCache> fLayerCache;
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index 71fb8d3..8003a06 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -1863,10 +1863,10 @@
{
GrContext* grContext = this->getGrContext();
if (grContext) {
- size_t cacheBytes = grContext->getGpuTextureCacheBytes();
+ size_t cacheBytes;
+ grContext->getResourceCacheUsage(NULL, &cacheBytes);
grContext->freeGpuResources();
- SkDebugf("Purged %d bytes from the GPU resource cache.\n",
- cacheBytes);
+ SkDebugf("Purged %d bytes from the GPU resource cache.\n", cacheBytes);
}
}
return true;
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index d2664c3..cd96def 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -94,7 +94,7 @@
fClip = NULL;
fPathRendererChain = NULL;
fSoftwarePathRenderer = NULL;
- fTextureCache = NULL;
+ fResourceCache = NULL;
fFontCache = NULL;
fDrawBuffer = NULL;
fDrawBufferVBAllocPool = NULL;
@@ -118,10 +118,9 @@
fDrawState = SkNEW(GrDrawState);
fGpu->setDrawState(fDrawState);
- fTextureCache = SkNEW_ARGS(GrResourceCache,
- (MAX_RESOURCE_CACHE_COUNT,
- MAX_RESOURCE_CACHE_BYTES));
- fTextureCache->setOverbudgetCallback(OverbudgetCB, this);
+ fResourceCache = SkNEW_ARGS(GrResourceCache, (MAX_RESOURCE_CACHE_COUNT,
+ MAX_RESOURCE_CACHE_BYTES));
+ fResourceCache->setOverbudgetCallback(OverbudgetCB, this);
fFontCache = SkNEW_ARGS(GrFontCache, (fGpu));
@@ -154,8 +153,8 @@
// of them before freeing the texture cache
fGpu->purgeResources();
- delete fTextureCache;
- fTextureCache = NULL;
+ delete fResourceCache;
+ fResourceCache = NULL;
delete fFontCache;
delete fDrawBuffer;
delete fDrawBufferVBAllocPool;
@@ -197,7 +196,7 @@
fAARectRenderer->reset();
fOvalRenderer->reset();
- fTextureCache->purgeAllUnlocked();
+ fResourceCache->purgeAllUnlocked();
fFontCache->freeAll();
fLayerCache->freeAll();
@@ -216,7 +215,7 @@
fAARectRenderer->reset();
fOvalRenderer->reset();
- fTextureCache->purgeAllUnlocked();
+ fResourceCache->purgeAllUnlocked();
fFontCache->freeAll();
fLayerCache->freeAll();
// a path renderer may be holding onto resources
@@ -224,12 +223,13 @@
SkSafeSetNull(fSoftwarePathRenderer);
}
-size_t GrContext::getGpuTextureCacheBytes() const {
- return fTextureCache->getCachedResourceBytes();
-}
-
-int GrContext::getGpuTextureCacheResourceCount() const {
- return fTextureCache->getCachedResourceCount();
+void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
+ if (NULL != resourceCount) {
+ *resourceCount = fResourceCache->getCachedResourceCount();
+ }
+ if (NULL != resourceBytes) {
+ *resourceBytes = fResourceCache->getCachedResourceBytes();
+ }
}
////////////////////////////////////////////////////////////////////////////////
@@ -238,7 +238,7 @@
const GrCacheID& cacheID,
const GrTextureParams* params) {
GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, params, desc, cacheID);
- GrCacheable* resource = fTextureCache->find(resourceKey);
+ GrCacheable* resource = fResourceCache->find(resourceKey);
SkSafeRef(resource);
return static_cast<GrTexture*>(resource);
}
@@ -247,7 +247,7 @@
const GrCacheID& cacheID,
const GrTextureParams* params) const {
GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, params, desc, cacheID);
- return fTextureCache->hasKey(resourceKey);
+ return fResourceCache->hasKey(resourceKey);
}
void GrContext::addStencilBuffer(GrStencilBuffer* sb) {
@@ -256,7 +256,7 @@
GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(sb->width(),
sb->height(),
sb->numSamples());
- fTextureCache->addResource(resourceKey, sb);
+ fResourceCache->addResource(resourceKey, sb);
}
GrStencilBuffer* GrContext::findStencilBuffer(int width, int height,
@@ -264,7 +264,7 @@
GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(width,
height,
sampleCnt);
- GrCacheable* resource = fTextureCache->find(resourceKey);
+ GrCacheable* resource = fResourceCache->find(resourceKey);
return static_cast<GrStencilBuffer*>(resource);
}
@@ -397,8 +397,8 @@
if (NULL != texture) {
// Adding a resource could put us overbudget. Try to free up the
// necessary space before adding it.
- fTextureCache->purgeAsNeeded(1, texture->gpuMemorySize());
- fTextureCache->addResource(resourceKey, texture);
+ fResourceCache->purgeAsNeeded(1, texture->gpuMemorySize());
+ fResourceCache->addResource(resourceKey, texture);
if (NULL != cacheKey) {
*cacheKey = resourceKey;
@@ -409,16 +409,16 @@
}
static GrTexture* create_scratch_texture(GrGpu* gpu,
- GrResourceCache* textureCache,
+ GrResourceCache* resourceCache,
const GrTextureDesc& desc) {
GrTexture* texture = gpu->createTexture(desc, NULL, 0);
if (NULL != texture) {
GrResourceKey key = GrTexture::ComputeScratchKey(texture->desc());
// Adding a resource could put us overbudget. Try to free up the
// necessary space before adding it.
- textureCache->purgeAsNeeded(1, texture->gpuMemorySize());
+ resourceCache->purgeAsNeeded(1, texture->gpuMemorySize());
// Make the resource exclusive so future 'find' calls don't return it
- textureCache->addResource(key, texture, GrResourceCache::kHide_OwnershipFlag);
+ resourceCache->addResource(key, texture, GrResourceCache::kHide_OwnershipFlag);
}
return texture;
}
@@ -436,7 +436,7 @@
if (!fGpu->caps()->reuseScratchTextures() &&
!(inDesc.fFlags & kRenderTarget_GrTextureFlagBit)) {
// If we're never recycling this texture we can always make it the right size
- return create_scratch_texture(fGpu, fTextureCache, inDesc);
+ return create_scratch_texture(fGpu, fResourceCache, inDesc);
}
GrTextureDesc desc = inDesc;
@@ -455,7 +455,7 @@
do {
GrResourceKey key = GrTexture::ComputeScratchKey(desc);
// Ensure we have exclusive access to the texture so future 'find' calls don't return it
- resource = fTextureCache->find(key, GrResourceCache::kHide_OwnershipFlag);
+ resource = fResourceCache->find(key, GrResourceCache::kHide_OwnershipFlag);
if (NULL != resource) {
resource->ref();
break;
@@ -480,7 +480,7 @@
desc.fFlags = inDesc.fFlags;
desc.fWidth = origWidth;
desc.fHeight = origHeight;
- resource = create_scratch_texture(fGpu, fTextureCache, desc);
+ resource = create_scratch_texture(fGpu, fResourceCache, desc);
}
return static_cast<GrTexture*>(resource);
@@ -503,13 +503,13 @@
if (fGpu->caps()->reuseScratchTextures() || NULL != texture->asRenderTarget()) {
// Since this texture came from an AutoScratchTexture it should
// still be in the exclusive pile. Recycle it.
- fTextureCache->makeNonExclusive(texture->getCacheEntry());
+ fResourceCache->makeNonExclusive(texture->getCacheEntry());
this->purgeCache();
} else if (texture->getDeferredRefCount() <= 0) {
// When we aren't reusing textures we know this scratch texture
// will never be reused and would be just wasting time in the cache
- fTextureCache->makeNonExclusive(texture->getCacheEntry());
- fTextureCache->deleteResource(texture->getCacheEntry());
+ fResourceCache->makeNonExclusive(texture->getCacheEntry());
+ fResourceCache->deleteResource(texture->getCacheEntry());
} else {
// In this case (fDeferredRefCount > 0) but the cache is the only
// one holding a real ref. Mark the object so when the deferred
@@ -529,14 +529,14 @@
// the same texture).
if (texture->getCacheEntry()->key().isScratch()) {
if (fGpu->caps()->reuseScratchTextures() || NULL != texture->asRenderTarget()) {
- fTextureCache->makeNonExclusive(texture->getCacheEntry());
+ fResourceCache->makeNonExclusive(texture->getCacheEntry());
this->purgeCache();
} else if (texture->unique() && texture->getDeferredRefCount() <= 0) {
// Only the cache now knows about this texture. Since we're never
// reusing scratch textures (in this code path) it would just be
// wasting time sitting in the cache.
- fTextureCache->makeNonExclusive(texture->getCacheEntry());
- fTextureCache->deleteResource(texture->getCacheEntry());
+ fResourceCache->makeNonExclusive(texture->getCacheEntry());
+ fResourceCache->deleteResource(texture->getCacheEntry());
} else {
// In this case (fRefCnt > 1 || defRefCnt > 0) but we don't really
// want to readd it to the cache (since it will never be reused).
@@ -551,8 +551,8 @@
}
void GrContext::purgeCache() {
- if (NULL != fTextureCache) {
- fTextureCache->purgeAsNeeded();
+ if (NULL != fResourceCache) {
+ fResourceCache->purgeAsNeeded();
}
}
@@ -575,13 +575,12 @@
return fGpu->createTexture(descCopy, srcData, rowBytes);
}
-void GrContext::getTextureCacheLimits(int* maxTextures,
- size_t* maxTextureBytes) const {
- fTextureCache->getLimits(maxTextures, maxTextureBytes);
+void GrContext::getResourceCacheLimits(int* maxTextures, size_t* maxTextureBytes) const {
+ fResourceCache->getLimits(maxTextures, maxTextureBytes);
}
-void GrContext::setTextureCacheLimits(int maxTextures, size_t maxTextureBytes) {
- fTextureCache->setLimits(maxTextures, maxTextureBytes);
+void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
+ fResourceCache->setLimits(maxTextures, maxTextureBytes);
}
int GrContext::getMaxTextureSize() const {
@@ -1812,26 +1811,26 @@
GrPath* GrContext::createPath(const SkPath& inPath, const SkStrokeRec& stroke) {
SkASSERT(fGpu->caps()->pathRenderingSupport());
- // TODO: now we add to fTextureCache. This should change to fResourceCache.
+ // TODO: now we add to fResourceCache. This should change to fResourceCache.
GrResourceKey resourceKey = GrPath::ComputeKey(inPath, stroke);
- GrPath* path = static_cast<GrPath*>(fTextureCache->find(resourceKey));
+ GrPath* path = static_cast<GrPath*>(fResourceCache->find(resourceKey));
if (NULL != path && path->isEqualTo(inPath, stroke)) {
path->ref();
} else {
path = fGpu->createPath(inPath, stroke);
- fTextureCache->purgeAsNeeded(1, path->gpuMemorySize());
- fTextureCache->addResource(resourceKey, path);
+ fResourceCache->purgeAsNeeded(1, path->gpuMemorySize());
+ fResourceCache->addResource(resourceKey, path);
}
return path;
}
void GrContext::addResourceToCache(const GrResourceKey& resourceKey, GrCacheable* resource) {
- fTextureCache->purgeAsNeeded(1, resource->gpuMemorySize());
- fTextureCache->addResource(resourceKey, resource);
+ fResourceCache->purgeAsNeeded(1, resource->gpuMemorySize());
+ fResourceCache->addResource(resourceKey, resource);
}
GrCacheable* GrContext::findAndRefCachedResource(const GrResourceKey& resourceKey) {
- GrCacheable* resource = fTextureCache->find(resourceKey);
+ GrCacheable* resource = fResourceCache->find(resourceKey);
SkSafeRef(resource);
return resource;
}
@@ -1839,6 +1838,6 @@
///////////////////////////////////////////////////////////////////////////////
#if GR_CACHE_STATS
void GrContext::printCacheStats() const {
- fTextureCache->printStats();
+ fResourceCache->printStats();
}
#endif
diff --git a/src/gpu/GrTest.cpp b/src/gpu/GrTest.cpp
index c434322..10dc034 100644
--- a/src/gpu/GrTest.cpp
+++ b/src/gpu/GrTest.cpp
@@ -38,5 +38,5 @@
}
void GrContext::purgeAllUnlockedResources() {
- fTextureCache->purgeAllUnlocked();
+ fResourceCache->purgeAllUnlocked();
}
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index d43552e..f90b906 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1080,7 +1080,7 @@
// a texture
size_t bmpSize = bitmap.getSize();
size_t cacheSize;
- fContext->getTextureCacheLimits(NULL, &cacheSize);
+ fContext->getResourceCacheLimits(NULL, &cacheSize);
if (bmpSize < cacheSize / 2) {
return false;
}
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index f6c8b1d..78c1124 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -26,16 +26,17 @@
src.eraseColor(SK_ColorBLACK);
size_t srcSize = src.getSize();
- size_t initialCacheSize = context->getGpuTextureCacheBytes();
+ size_t initialCacheSize;
+ context->getResourceCacheUsage(NULL, &initialCacheSize);
int oldMaxNum;
size_t oldMaxBytes;
- context->getTextureCacheLimits(&oldMaxNum, &oldMaxBytes);
+ context->getResourceCacheLimits(&oldMaxNum, &oldMaxBytes);
// Set the cache limits so we can fit 10 "src" images and the
// max number of textures doesn't matter
size_t maxCacheSize = initialCacheSize + 10*srcSize;
- context->setTextureCacheLimits(1000, maxCacheSize);
+ context->setResourceCacheLimits(1000, maxCacheSize);
SkBitmap readback;
readback.allocN32Pixels(size.width(), size.height());
@@ -47,13 +48,14 @@
// "modify" the src texture
src.notifyPixelsChanged();
- size_t curCacheSize = context->getGpuTextureCacheBytes();
+ size_t curCacheSize;
+ context->getResourceCacheUsage(NULL, &curCacheSize);
// we should never go over the size limit
REPORTER_ASSERT(reporter, curCacheSize <= maxCacheSize);
}
- context->setTextureCacheLimits(oldMaxNum, oldMaxBytes);
+ context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
}
class TestResource : public GrCacheable {
diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp
index fd4980e..7d5607c 100644
--- a/tests/SurfaceTest.cpp
+++ b/tests/SurfaceTest.cpp
@@ -304,21 +304,27 @@
SurfaceType surfaceType,
GrContext* context) {
context->freeGpuResources();
- REPORTER_ASSERT(reporter, 0 == context->getGpuTextureCacheResourceCount());
+ int resourceCount;
+
+ context->getResourceCacheUsage(&resourceCount, NULL);
+ REPORTER_ASSERT(reporter, 0 == resourceCount);
SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context));
// Note: the stencil buffer is always cached, so kGpu_SurfaceType uses
// one cached resource, and kGpuScratch_SurfaceType uses two.
int expectedCachedResources = surfaceType == kGpuScratch_SurfaceType ? 2 : 1;
- REPORTER_ASSERT(reporter, expectedCachedResources == context->getGpuTextureCacheResourceCount());
+ context->getResourceCacheUsage(&resourceCount, NULL);
+ REPORTER_ASSERT(reporter, expectedCachedResources == resourceCount);
// Verify that all the cached resources are locked in cache.
context->freeGpuResources();
- REPORTER_ASSERT(reporter, expectedCachedResources == context->getGpuTextureCacheResourceCount());
+ context->getResourceCacheUsage(&resourceCount, NULL);
+ REPORTER_ASSERT(reporter, expectedCachedResources == resourceCount);
// Verify that all the cached resources are unlocked upon surface release
surface.reset(0);
context->freeGpuResources();
- REPORTER_ASSERT(reporter, 0 == context->getGpuTextureCacheResourceCount());
+ context->getResourceCacheUsage(&resourceCount, NULL);
+ REPORTER_ASSERT(reporter, 0 == resourceCount);
}
static void Test_crbug263329(skiatest::Reporter* reporter,