Make GrShape compute keys for short paths from path data instead of using the gen id.

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 1060 matching lines @@
 
 void test_unknown_path_effect(skiatest::Reporter* reporter, const Geo& geo) {
     /**
      * This path effect just adds two lineTos to the input path.
      */
     class AddLineTosPathEffect : SkPathEffect {
     public:
         bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*,
                         const SkRect* cullR) const override {
             *dst = src;
-            dst->lineTo(0, 0);
-            dst->lineTo(10, 10);
+            // To avoid triggering data-based keying of paths with few verbs we add many segments.
+            for (int i = 0; i < 100; ++i) {
+                dst->lineTo(SkIntToScalar(i), SkIntToScalar(i));
+            }
             return true;
         }
         void computeFastBounds(SkRect* dst, const SkRect& src) const override {
             *dst = src;
             dst->growToInclude(0, 0);
-            dst->growToInclude(10, 10);
+            dst->growToInclude(100, 100);
         }
         static sk_sp<SkPathEffect> Make() { return sk_sp<SkPathEffect>(new AddLineTosPathEffect); }
         Factory getFactory() const override { return nullptr; }
         void toString(SkString*) const override {}
     private:
         AddLineTosPathEffect() {}
     };
 
      // This path effect should make the keys invalid when it is applied. We only produce a path
      // effect key for dash path effects. So the only way another arbitrary path effect can produce
@@ skipping 50 matching lines @@
         REPORTER_ASSERT(reporter, paths_fill_same(a, b));
         REPORTER_ASSERT(reporter, paths_fill_same(a, c));
     } else {
         // 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);
-        REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey().empty());
-        REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey().empty());
+        // 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.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.
-    if (geo.isNonPath(dashAndStroke)) {
+    // as a specialized geometry or it has a small verb count.
+    if (geo.isNonPath(dashAndStroke) || vPath.countVerbs() <= GrShape::kMaxKeyFromDataVerbCnt) {
         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 573 matching lines @@
 
     TestCase(r, linePath, buttCap).compare(r, TestCase(r, SkRect::MakeEmpty(), fill),
                                            TestCase::kAllSame_ComparisonExpecation);
     TestCase(r, linePath, squareCap).compare(r, TestCase(r, SkRect::MakeLTRB(2, 2, 6, 6), fill),
                                              TestCase::kAllSame_ComparisonExpecation);
     TestCase(r, linePath, roundCap).compare(r,
         TestCase(r, SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 6, 6), 2, 2), fill),
         TestCase::kAllSame_ComparisonExpecation);
 }
 
+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,
+                                 TestCase::ComparisonExpecation expectation) {
+        for (const SkPaint& paint : paints) {
+            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);
+                    }
+                }
+            }
+        }
+    };
+
+    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);
+
+    // 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);
+
+    // 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);
+
+    // 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);
+
+    // 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);
+}
+
 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)}) {
         geos.emplace_back(new RectGeo(r));
         SkPath rectPath;
@@ skipping 106 matching lines @@
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, PathGeo(SkPath(), PathGeo::Invert::kNo));
 
     test_empty_shape(reporter);
 
     test_lines(reporter);
 
     test_stroked_lines(reporter);
+
+    test_short_path_keys(reporter);
 }
 
 #endif