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

src/core/SkDraw.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDraw.h"
 #include "SkBlitter.h"
 #include "SkCanvas.h"
@@ skipping 577 matching lines @@
                 // temporarily mark the paint as filling.
                 SkPaint newPaint(paint);
                 newPaint.setStyle(SkPaint::kFill_Style);
 
                 SkScalar width = newPaint.getStrokeWidth();
                 SkScalar radius = SkScalarHalf(width);
 
                 if (newPaint.getStrokeCap() == SkPaint::kRound_Cap) {
                     SkPath      path;
                     SkMatrix    preMatrix;
-
+                    
                     path.addCircle(0, 0, radius);
                     for (size_t i = 0; i < count; i++) {
                         preMatrix.setTranslate(pts[i].fX, pts[i].fY);
                         // pass true for the last point, since we can modify
                         // then path then
+                        path.setIsVolatile((count-1) == i);
                         if (fDevice) {
                             fDevice->drawPath(*this, path, newPaint, &preMatrix,
                                               (count-1) == i);
                         } else {
                             this->drawPath(path, newPaint, &preMatrix,
                                            (count-1) == i);
                         }
                     }
                 } else {
                     SkRect  r;
@@ skipping 98 matching lines @@
                     }
                 }
 #endif // DISABLE_DASHING_OPTIMIZATION
                 // couldn't take fast path so fall through!
             case SkCanvas::kPolygon_PointMode: {
                 count -= 1;
                 SkPath path;
                 SkPaint p(paint);
                 p.setStyle(SkPaint::kStroke_Style);
                 size_t inc = (SkCanvas::kLines_PointMode == mode) ? 2 : 1;
+                path.setIsVolatile(true);
                 for (size_t i = 0; i < count; i += inc) {
                     path.moveTo(pts[i]);
                     path.lineTo(pts[i+1]);
                     if (fDevice) {
                         fDevice->drawPath(*this, path, p, NULL, true);
                     } else {
                         this->drawPath(path, p, NULL, true);
                     }
                     path.rewind();
                 }
@@ skipping 272 matching lines @@
     // nothing to draw
     if (fRC->isEmpty()) {
         return;
     }
 
     SkPath*         pathPtr = (SkPath*)&origSrcPath;
     bool            doFill = true;
     SkPath          tmpPath;
     SkMatrix        tmpMatrix;
     const SkMatrix* matrix = fMatrix;
+    tmpPath.setIsVolatile(true);
 
     if (prePathMatrix) {
         if (origPaint.getPathEffect() || origPaint.getStyle() != SkPaint::kFill_Style ||
                 origPaint.getRasterizer()) {
             SkPath* result = pathPtr;
 
             if (!pathIsMutable) {
                 result = &tmpPath;
                 pathIsMutable = true;
             }
@@ skipping 931 matching lines @@
     SkScalar        xpos;
     SkMatrix        scaledMatrix;
     SkScalar        scale = iter.getPathScale();
 
     scaledMatrix.setScale(scale, scale);
 
     while (iter.next(&iterPath, &xpos)) {
         if (iterPath) {
             SkPath      tmp;
             SkMatrix    m(scaledMatrix);
-
+            
+            tmp.setIsVolatile(true);
             m.postTranslate(xpos + hOffset, 0);
             if (matrix) {
                 m.postConcat(*matrix);
             }
             morphpath(&tmp, *iterPath, meas, m);
             if (fDevice) {
                 fDevice->drawPath(*this, tmp, iter.getPaint(), NULL, true);
             } else {
                 this->drawPath(tmp, iter.getPaint(), NULL, true);
             }
@@ skipping 400 matching lines @@
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, mask->computeImageSize());
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         draw_into_mask(*mask, devPath, style);
     }
 
     return true;
 }