Add a GPU paths to resource cache of the context

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrContext.h"
@@ skipping 38 matching lines @@
 
 #ifdef SK_DEBUG
     // change this to a 1 to see notifications when partial coverage fails
     #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
 #else
     #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
 #endif
 
 static const size_t MAX_TEXTURE_CACHE_COUNT = 2048;
 static const size_t MAX_TEXTURE_CACHE_BYTES = GR_DEFAULT_TEXTURE_CACHE_MB_LIMIT * 1024 * 1024;
+static const size_t MAX_PATH_CACHE_COUNT = 2048;
+static const size_t MAX_PATH_CACHE_BYTES = 1 * 1024 * 1024;
 
 static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 15;
 static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
 
 static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 1 << 11;
 static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 4;
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 
 // Glorified typedef to avoid including GrDrawState.h in GrContext.h
@@ skipping 35 matching lines @@
 }
 
 GrContext::GrContext() {
     ++THREAD_INSTANCE_COUNT;
     fDrawState = NULL;
     fGpu = NULL;
     fClip = NULL;
     fPathRendererChain = NULL;
     fSoftwarePathRenderer = NULL;
     fTextureCache = NULL;
+    fPathCache = NULL;
     fFontCache = NULL;
     fDrawBuffer = NULL;
     fDrawBufferVBAllocPool = NULL;
     fDrawBufferIBAllocPool = NULL;
     fFlushToReduceCacheSize = false;
     fAARectRenderer = NULL;
     fOvalRenderer = NULL;
     fViewMatrix.reset();
     fMaxTextureSizeOverride = 1 << 20;
 }
@@ skipping 42 matching lines @@
     }
 
     this->flush();
 
     // Since the gpu can hold scratch textures, give it a chance to let go
     // of them before freeing the texture cache
     fGpu->purgeResources();
 
     delete fTextureCache;
     fTextureCache = NULL;
+    delete fPathCache;
+    fPathCache = NULL;
     delete fFontCache;
     delete fDrawBuffer;
     delete fDrawBufferVBAllocPool;
     delete fDrawBufferIBAllocPool;
 
     fAARectRenderer->unref();
     fOvalRenderer->unref();
 
     fGpu->unref();
     SkSafeUnref(fPathRendererChain);
@@ skipping 24 matching lines @@
     delete fDrawBufferVBAllocPool;
     fDrawBufferVBAllocPool = NULL;
 
     delete fDrawBufferIBAllocPool;
     fDrawBufferIBAllocPool = NULL;
 
     fAARectRenderer->reset();
     fOvalRenderer->reset();
 
     fTextureCache->purgeAllUnlocked();
+    if (fPathCache) {
+        fPathCache->purgeAllUnlocked();
+    }
+
     fFontCache->freeAll();
     fGpu->markContextDirty();
 }
 
 void GrContext::resetContext(uint32_t state) {
     fGpu->markContextDirty(state);
 }
 
 void GrContext::freeGpuResources() {
     this->flush();
 
     fGpu->purgeResources();
 
     fAARectRenderer->reset();
     fOvalRenderer->reset();
 
     fTextureCache->purgeAllUnlocked();
+    if (fPathCache) {
+        fPathCache->purgeAllUnlocked();
+    }
     fFontCache->freeAll();
     // a path renderer may be holding onto resources
     SkSafeSetNull(fPathRendererChain);
     SkSafeSetNull(fSoftwarePathRenderer);
 }
 
 size_t GrContext::getGpuTextureCacheBytes() const {
   return fTextureCache->getCachedResourceBytes();
 }
 
@@ skipping 328 matching lines @@
 }
 
 int GrContext::getMaxRenderTargetSize() const {
     return fGpu->caps()->maxRenderTargetSize();
 }
 
 int GrContext::getMaxSampleCount() const {
     return fGpu->caps()->maxSampleCount();
 }
 
+GrPath* GrContext::createPath(const SkPath& inPath, const SkStrokeRec& stroke) {
+    if (!fGpu->caps()->pathRenderingSupport()) {
+        return NULL;
+    }
+
+    if (!fPathCache) {
+        fPathCache = SkNEW_ARGS(GrResourceCache,
+                               (MAX_PATH_CACHE_COUNT,
+                                MAX_PATH_CACHE_BYTES));
+        fPathCache->setOverbudgetCallback(OverbudgetCB, this);
+    }
+
+    GrResourceKey resourceKey = GrPath::ComputeKey(inPath, stroke);
+    GrPath* path = static_cast<GrPath*>(fPathCache->find(resourceKey));
+    if (NULL != path && path->isEqualTo(inPath, stroke)) {
+        path->ref();
+    } else {
+        path = fGpu->createPath(inPath, stroke);
+        fPathCache->purgeAsNeeded(1, path->sizeInBytes());
+        fPathCache->addResource(resourceKey, path);
+    }
+    return path;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrContext::wrapBackendTexture(const GrBackendTextureDesc& desc) {
     return fGpu->wrapBackendTexture(desc);
 }
 
 GrRenderTarget* GrContext::wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc) {
     return fGpu->wrapBackendRenderTarget(desc);
 }
 
@@ skipping 1174 matching lines @@
         return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM, matrix);
     } else {
         return NULL;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
     fTextureCache->printStats();
+    if (fPathCache) {
+        fPathCache->printStats();
+    }
 }
 #endif