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

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 688 matching lines @@
     // its parameter type is const).
     SkPath* pathPtr = const_cast<SkPath*>(&origSrcPath);
     SkTLazy<SkPath> tmpPath;
     SkTLazy<SkPath> effectPath;
 
     if (prePathMatrix) {
         SkPath* result = pathPtr;
 
         if (!pathIsMutable) {
             result = tmpPath.init();
+            result->setIsVolatile(true);
             pathIsMutable = true;
         }
         // should I push prePathMatrix on our MV stack temporarily, instead
         // of applying it here? See SkDraw.cpp

[bsalomon, 2014/10/23 17:54:09]

Seems like we should do this instead of making a new path here now that we get a
win from seeing the original path's gen ID.

[jvanverth1, 2014/10/23 20:06:18]

Filed as Issue 3055.

         pathPtr->transform(*prePathMatrix, result);
         pathPtr = result;
     }
     // at this point we're done with prePathMatrix
     SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
 
     GrStrokeInfo strokeInfo(paint);
     SkPathEffect* pathEffect = paint.getPathEffect();
     const SkRect* cullRect = NULL;  // TODO: what is our bounds?
     SkStrokeRec* strokePtr = strokeInfo.getStrokeRecPtr();
@@ skipping 10 matching lines @@
             SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
             if (stroke.applyToPath(strokedPath, *pathPtr)) {
                 pathPtr = strokedPath;
                 pathIsMutable = true;
                 strokeInfo.setFillStyle();
             }
         }
 
         // avoid possibly allocating a new path in transform if we can
         SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
+        if (pathIsMutable) {

[bsalomon, 2014/10/23 17:54:09]

Maybe we should avoid this early transformation to device space since we lose
the original path's gen ID.

[jvanverth1, 2014/10/23 20:06:18]

Filed as Issue 3056

+            devPathPtr->setIsVolatile(true);
+        }
 
         // transform the path into device space
         pathPtr->transform(fContext->getMatrix(), devPathPtr);
 
         SkRect maskRect;
         if (paint.getMaskFilter()->canFilterMaskGPU(devPathPtr->getBounds(),
                                                     draw.fClip->getBounds(),
                                                     fContext->getMatrix(),
                                                     &maskRect)) {
             // The context's matrix may change while creating the mask, so save the CTM here to
@@ skipping 1071 matching lines @@
     GrLayerHoister::UnlockLayers(fContext, atlased, nonAtlased, recycled);
 
     return true;
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }