Don't allow uncacheable paths in tessellated path renderer

src/gpu/batches/GrTessellatingPathRenderer.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTessellatingPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 88 matching lines @@
 
 }  // namespace
 
 GrTessellatingPathRenderer::GrTessellatingPathRenderer() {
 }
 
 bool GrTessellatingPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // This path renderer can draw all fill styles, all stroke styles except hairlines, but does
     // not do antialiasing. It can do convex and concave paths, but we'll leave the convex ones to
     // simpler algorithms. Similary, we skip the non-hairlines that can be treated as hairline.
-    // An arbitrary path effect could produce a hairline result so we pass on those.
+    // An arbitrary path effect could produce a hairline result so we pass on those. We also skip
+    // volatile paths since they are not cacheable.
     return !IsStrokeHairlineOrEquivalent(*args.fStyle, *args.fViewMatrix, nullptr) &&
            !args.fStyle->strokeRec().isHairlineStyle() &&
-           !args.fStyle->hasNonDashPathEffect() && !args.fAntiAlias && !args.fPath->isConvex();
+           !args.fStyle->hasNonDashPathEffect() && !args.fAntiAlias && !args.fPath->isConvex() &&
+           !args.fPath->isVolatile();

[Stephen White, 2016/05/18 13:45:49]

Could you put this ahead of the other tests? (Various reasons...)

[bsalomon, 2016/05/18 13:53:43]

Because it is a fast check, right? I reordered them based on my guess of
relative costs in patchset 2.

 }
 
 class TessellatingPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     static GrDrawBatch* Create(const GrColor& color,
                                const SkPath& path,
                                const GrStyle& style,
                                const SkMatrix& viewMatrix,
@@ skipping 30 matching lines @@
         if (fStyle.applies()) {
             styleScale = GrStyle::MatrixToScaleFactor(fViewMatrix);
         }
 
         // construct a cache key from the path's genID and the view matrix
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
         GrUniqueKey key;
         int clipBoundsCnt =
             fPath.isInverseFillType() ? sizeof(fClipBounds) / sizeof(uint32_t) : 0;
         int styleDataCnt = GrStyle::KeySize(fStyle, GrStyle::Apply::kPathEffectAndStrokeRec);
-        if (styleDataCnt >= 0) {
-            GrUniqueKey::Builder builder(&key, kDomain, 2 + clipBoundsCnt + styleDataCnt);
-            builder[0] = fPath.getGenerationID();
-            builder[1] = fPath.getFillType();
-            // For inverse fills, the tessellation is dependent on clip bounds.
-            if (fPath.isInverseFillType()) {
-                memcpy(&builder[2], &fClipBounds, sizeof(fClipBounds));
-            }
-            if (styleDataCnt) {
-                GrStyle::WriteKey(&builder[2 + clipBoundsCnt], fStyle,
-                                  GrStyle::Apply::kPathEffectAndStrokeRec, styleScale);
-            }
-            builder.finish();
-            SkAutoTUnref<GrBuffer> cachedVertexBuffer(rp->findAndRefTByUniqueKey<GrBuffer>(key));
-            int actualCount;
-            if (cache_match(cachedVertexBuffer.get(), tol, &actualCount)) {
-                this->drawVertices(target, gp, cachedVertexBuffer.get(), 0, actualCount);
-                return;
-            }
+        // We should have excluded anything we wouldn't know how to cache.
+        SkASSERT(styleDataCnt >= 0);
+        GrUniqueKey::Builder builder(&key, kDomain, 2 + clipBoundsCnt + styleDataCnt);
+        builder[0] = fPath.getGenerationID();
+        builder[1] = fPath.getFillType();
+        // For inverse fills, the tessellation is dependent on clip bounds.
+        if (fPath.isInverseFillType()) {
+            memcpy(&builder[2], &fClipBounds, sizeof(fClipBounds));
+        }
+        if (styleDataCnt) {
+            GrStyle::WriteKey(&builder[2 + clipBoundsCnt], fStyle,
+                              GrStyle::Apply::kPathEffectAndStrokeRec, styleScale);
+        }
+        builder.finish();
+        SkAutoTUnref<GrBuffer> cachedVertexBuffer(rp->findAndRefTByUniqueKey<GrBuffer>(key));
+        int actualCount;
+        if (cache_match(cachedVertexBuffer.get(), tol, &actualCount)) {
+            this->drawVertices(target, gp, cachedVertexBuffer.get(), 0, actualCount);
+            return;
         }
 
         SkPath path;
         if (fStyle.applies()) {
             SkStrokeRec::InitStyle fill;
             SkAssertResult(fStyle.applyToPath(&path, &fill, fPath, styleScale));
             SkASSERT(SkStrokeRec::kFill_InitStyle == fill);
         } else {
             path = fPath;
         }
@@ skipping 126 matching lines @@
     }
     vmi.mapRect(&clipBounds);
     GrStyle style;
     do {
         GrTest::TestStyle(random, &style);
     } while (style.strokeRec().isHairlineStyle());
     return TessellatingPathBatch::Create(color, path, style, viewMatrix, clipBounds);
 }
 
 #endif