Set temporary paths volatile so we don't cache them.

src/gpu/GrAADistanceFieldPathRenderer.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 13 matching lines @@
 
 #define PLOT_WIDTH  256
 #define PLOT_HEIGHT 256
 
 #define NUM_PLOTS_X   (ATLAS_TEXTURE_WIDTH / PLOT_WIDTH)
 #define NUM_PLOTS_Y   (ATLAS_TEXTURE_HEIGHT / PLOT_HEIGHT)
 
 SK_CONF_DECLARE(bool, c_DumpPathCache, "gpu.dumpPathCache", false,
                 "Dump the contents of the path cache before every purge.");
 
+#ifdef DF_PATH_TRACKING
+static int g_NumCachedPaths = 0;
+static int g_NumFreedPaths = 0;
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 GrAADistanceFieldPathRenderer::~GrAADistanceFieldPathRenderer() {
     PathDataList::Iter iter;
     iter.init(fPathList, PathDataList::Iter::kHead_IterStart);
     PathData* pathData;
     while ((pathData = iter.get())) {
         iter.next();
         fPathList.remove(pathData);
         SkDELETE(pathData);
     }
     
     SkDELETE(fAtlas);
+
+#ifdef DF_PATH_TRACKING
+    SkDebugf("Num cached paths: %d\n", g_NumCachedPaths);
+    SkDebugf("Num freed paths: %d\n", g_NumFreedPaths);
+#endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrAADistanceFieldPathRenderer::canDrawPath(const SkPath& path,
                                                 const SkStrokeRec& stroke,
                                                 const GrDrawTarget* target,
                                                 bool antiAlias) const {
+    
     // TODO: Support inverse fill
     // TODO: Support strokes
     if (!target->caps()->shaderDerivativeSupport() || !antiAlias || path.isInverseFillType()
-        || SkStrokeRec::kFill_Style != stroke.getStyle()) {
+        || path.isVolatile() || SkStrokeRec::kFill_Style != stroke.getStyle()) {
         return false;
     }
 
     // currently don't support perspective or scaling more than 3x
     const GrDrawState& drawState = target->getDrawState();
     const SkMatrix& vm = drawState.getViewMatrix();
     if (vm.hasPerspective() || vm.getMaxScale() > 3.0f) {
         return false;
     }
     
@@ skipping 156 matching lines @@
     scaledBounds.offset(-SkIntToScalar(SK_DistanceFieldInset) - kAntiAliasPad + dx,
                         -SkIntToScalar(SK_DistanceFieldInset) - kAntiAliasPad + dy);
     pathData->fBounds = scaledBounds;
     // origin we render from is inset from distance field edge
     atlasLocation.fX += SK_DistanceFieldInset;
     atlasLocation.fY += SK_DistanceFieldInset;
     pathData->fAtlasLocation = atlasLocation;
     
     fPathCache.add(pathData);
     fPathList.addToTail(pathData);
-    
+#ifdef DF_PATH_TRACKING
+    ++g_NumCachedPaths;
+#endif
+
     return pathData;
 }
 
 bool GrAADistanceFieldPathRenderer::freeUnusedPlot() {
     // find an unused plot
     GrPlot* plot = fAtlas->getUnusedPlot();
     if (NULL == plot) {
         return false;
     }
     plot->resetRects();
 
     // remove any paths that use this plot
     PathDataList::Iter iter;
     iter.init(fPathList, PathDataList::Iter::kHead_IterStart);
     PathData* pathData;
     while ((pathData = iter.get())) {
         iter.next();
         if (plot == pathData->fPlot) {
             fPathCache.remove(pathData->fGenID);
             fPathList.remove(pathData);
             SkDELETE(pathData);
+#ifdef DF_PATH_TRACKING
+            --g_NumFreedPaths;
+#endif
         }
     }
         
     // tell the atlas to free the plot
     GrAtlas::RemovePlot(&fPlotUsage, plot);
     
     return true;
 }
 
 bool GrAADistanceFieldPathRenderer::internalDrawPath(const SkPath& path,
@@ skipping 67 matching lines @@
     
 
     vm.mapRect(&r);
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6, &r);
     target->resetVertexSource();
     target->resetIndexSource();
     
     return true;
 }