Don't compute path keys for volatile paths in GrShape.

tests/GrShapeTest.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <initializer_list>
 #include <functional>
 #include "Test.h"
@@ skipping 1143 matching lines @@
         // The base shape cannot perform canonicalization on the path's fill type because of an
         // unknown path effect. However, after the path effect is applied the resulting hairline
         // shape will canonicalize the path fill type since hairlines (and stroking in general)
         // don't distinguish between even/odd and non-zero winding.
         a.setFillType(b.getFillType());
         REPORTER_ASSERT(reporter, a == b);
         REPORTER_ASSERT(reporter, a == c);
         // If the resulting path is small enough then it will have a key.
         REPORTER_ASSERT(reporter, paths_fill_same(a, b));
         REPORTER_ASSERT(reporter, paths_fill_same(a, c));
-        if (c.countVerbs() <= GrShape::kMaxKeyFromDataVerbCnt) {
-            REPORTER_ASSERT(reporter, !peCase.appliedPathEffectKey().empty());
-            REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey() ==
-                                      peCase.appliedFullStyleKey());
-        } else {
-            REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey().empty());
-            REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey().empty());
-        }
+        REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey().empty());
+        REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey().empty());
     }
     REPORTER_ASSERT(reporter, peCase.appliedPathEffectShape().style().isSimpleHairline());
     REPORTER_ASSERT(reporter, peCase.appliedFullStyleShape().style().isSimpleHairline());
 }
 
 void test_volatile_path(skiatest::Reporter* reporter, const Geo& geo) {
     SkPath vPath = geo.path();
     vPath.setIsVolatile(true);
 
     SkPaint dashAndStroke;
     dashAndStroke.setPathEffect(make_dash());
     dashAndStroke.setStrokeWidth(2.f);
     dashAndStroke.setStyle(SkPaint::kStroke_Style);
     TestCase volatileCase(reporter, vPath, dashAndStroke);
     // We expect a shape made from a volatile path to have a key iff the shape is recognized
-    // as a specialized geometry or it has a small verb count.
-    if (geo.isNonPath(dashAndStroke) || vPath.countVerbs() <= GrShape::kMaxKeyFromDataVerbCnt) {
+    // as a specialized geometry.
+    if (geo.isNonPath(dashAndStroke)) {
         REPORTER_ASSERT(reporter, SkToBool(volatileCase.baseKey().count()));
         // In this case all the keys should be identical to the non-volatile case.
         TestCase nonVolatileCase(reporter, geo.path(), dashAndStroke);
         volatileCase.compare(reporter, nonVolatileCase, TestCase::kAllSame_ComparisonExpecation);
     } else {
         // None of the keys should be valid.
         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.baseKey().count()));
         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedPathEffectKey().count()));
         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedFullStyleKey().count()));
         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedPathEffectThenStrokeKey().count()));
@@ skipping 582 matching lines @@
 
 static void test_short_path_keys(skiatest::Reporter* r) {
     SkPaint paints[4];
     paints[1].setStyle(SkPaint::kStroke_Style);
     paints[1].setStrokeWidth(5.f);
     paints[2].setStyle(SkPaint::kStroke_Style);
     paints[2].setStrokeWidth(0.f);
     paints[3].setStyle(SkPaint::kStrokeAndFill_Style);
     paints[3].setStrokeWidth(5.f);
 
-    auto compare = [r, &paints] (SkPath* pathA, SkPath* pathB,
+    auto compare = [r, &paints] (const SkPath& pathA, const SkPath& pathB,
                                  TestCase::ComparisonExpecation expectation) {
+        SkPath volatileA = pathA;
+        SkPath volatileB = pathB;
+        volatileA.setIsVolatile(true);
+        volatileB.setIsVolatile(true);
         for (const SkPaint& paint : paints) {
+            REPORTER_ASSERT(r, !GrShape(volatileA, paint).hasUnstyledKey());
+            REPORTER_ASSERT(r, !GrShape(volatileB, paint).hasUnstyledKey());
             for (PathGeo::Invert invert : {PathGeo::Invert::kNo, PathGeo::Invert::kYes}) {
-                for (bool aIsVolatile : {false, true}) {
-                    for (bool bIsVolatile : {false, true}) {
-                        pathA->setIsVolatile(aIsVolatile);
-                        pathB->setIsVolatile(bIsVolatile);
-                        TestCase caseA(PathGeo(*pathA, invert), paint, r);
-                        TestCase caseB(PathGeo(*pathB, invert), paint, r);
-                        caseA.compare(r, caseB, expectation);
-                    }
-                }
+                TestCase caseA(PathGeo(pathA, invert), paint, r);
+                TestCase caseB(PathGeo(pathB, invert), paint, r);
+                caseA.compare(r, caseB, expectation);
             }
         }
     };
 
     SkPath pathA;
     SkPath pathB;
 
     // Two identical paths
     pathA.lineTo(10.f, 10.f);
     pathA.conicTo(20.f, 20.f, 20.f, 30.f, 0.7f);
 
     pathB.lineTo(10.f, 10.f);
     pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.7f);
-    compare(&pathA, &pathB, TestCase::kAllSame_ComparisonExpecation);
+    compare(pathA, pathB, TestCase::kAllSame_ComparisonExpecation);
 
     // Give path b a different point
     pathB.reset();
     pathB.lineTo(10.f, 10.f);
     pathB.conicTo(21.f, 20.f, 20.f, 30.f, 0.7f);
-    compare(&pathA, &pathB, TestCase::kAllDifferent_ComparisonExpecation);
+    compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation);
 
     // Give path b a different conic weight
     pathB.reset();
     pathB.lineTo(10.f, 10.f);
     pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.6f);
-    compare(&pathA, &pathB, TestCase::kAllDifferent_ComparisonExpecation);
+    compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation);
 
     // Give path b an extra lineTo verb
     pathB.reset();
     pathB.lineTo(10.f, 10.f);
     pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.6f);
     pathB.lineTo(50.f, 50.f);
-    compare(&pathA, &pathB, TestCase::kAllDifferent_ComparisonExpecation);
+    compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation);
 
     // Give path b a close
     pathB.reset();
     pathB.lineTo(10.f, 10.f);
     pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.7f);
     pathB.close();
-    compare(&pathA, &pathB, TestCase::kAllDifferent_ComparisonExpecation);
+    compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation);
 }
 
 DEF_TEST(GrShape, reporter) {
     SkTArray<std::unique_ptr<Geo>> geos;
     SkTArray<std::unique_ptr<RRectPathGeo>> rrectPathGeos;
 
     for (auto r : { SkRect::MakeWH(10, 20),
                     SkRect::MakeWH(-10, -20),
                     SkRect::MakeWH(-10, 20),
                     SkRect::MakeWH(10, -20)}) {
@@ skipping 113 matching lines @@
     test_empty_shape(reporter);
 
     test_lines(reporter);
 
     test_stroked_lines(reporter);
 
     test_short_path_keys(reporter);
 }
 
 #endif