Canonicalize path fill types for stroked 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 281 matching lines @@
     // Having a dash path effect can allow 'a' but not 'b' to turn a inverse fill type into a
     // non-inverse fill type  (or vice versa).
     bool ignoreInversenessDifference = false;
     if (pathA.isInverseFillType() != pathB.isInverseFillType()) {
         const GrShape* s1 = pathA.isInverseFillType() ? &a : &b;
         const GrShape* s2 = pathA.isInverseFillType() ? &b : &a;
         bool canDropInverse1 = s1->style().isDashed();
         bool canDropInverse2 = s2->style().isDashed();
         ignoreInversenessDifference = (canDropInverse1 != canDropInverse2);
     }
-
+    bool ignoreWindingVsEvenOdd = false;
+    if (SkPath::ConvertToNonInverseFillType(pathA.getFillType()) !=
+        SkPath::ConvertToNonInverseFillType(pathB.getFillType())) {
+        const SkStrokeRec::Style  strokeRecStyleA = a.style().strokeRec().getStyle();
+        const SkStrokeRec::Style  strokeRecStyleB = b.style().strokeRec().getStyle();

[robertphillips, 2016/06/23 18:47:54]

add a "static bool can_change(const GrStyle, const SkPath&)" ?

+        bool aCanChange = !a.style().hasNonDashPathEffect() &&
+                          (strokeRecStyleA == SkStrokeRec::kStroke_Style ||
+                           strokeRecStyleA == SkStrokeRec::kHairline_Style ||
+                           (a.style().isSimpleFill() && pathA.isConvex()));
+        bool bCanChange = !b.style().hasNonDashPathEffect() &&
+                          (strokeRecStyleB == SkStrokeRec::kStroke_Style ||
+                           strokeRecStyleB == SkStrokeRec::kHairline_Style ||
+                           (b.style().isSimpleFill() && pathB.isConvex()));
+        if (aCanChange != bCanChange) {
+            ignoreWindingVsEvenOdd = true;
+        }
+    }
     if (allowSameRRectButDiffStartAndDir) {
         REPORTER_ASSERT(r, rrectA == rrectB);
         REPORTER_ASSERT(r, paths_fill_same(pathA, pathB));
         REPORTER_ASSERT(r, ignoreInversenessDifference || invertedA == invertedB);
     } else {
         SkPath pA = pathA;
         SkPath pB = pathB;
         if (ignoreInversenessDifference) {
             pA.setFillType(SkPath::ConvertToNonInverseFillType(pathA.getFillType()));
             pB.setFillType(SkPath::ConvertToNonInverseFillType(pathB.getFillType()));
+        }
+        if (ignoreWindingVsEvenOdd) {
+            pA.setFillType(pA.isInverseFillType() ? SkPath::kInverseEvenOdd_FillType
+                                                  : SkPath::kEvenOdd_FillType);
+            pB.setFillType(pB.isInverseFillType() ? SkPath::kInverseEvenOdd_FillType
+                                                  : SkPath::kEvenOdd_FillType);
+        }
+        if (!ignoreInversenessDifference && !ignoreWindingVsEvenOdd) {
+            REPORTER_ASSERT(r, keyA == keyB);
+        } else {
             REPORTER_ASSERT(r, keyA != keyB);
-        } else {
-            REPORTER_ASSERT(r, keyA == keyB);
         }
         if (a.style().isSimpleFill() != b.style().isSimpleFill()) {
             // GrShape will close paths with simple fill style. Make the non-filled path closed
             // so that the comparision will succeed. Make sure both are closed before comparing.
             pA.close();
             pB.close();
         }
         REPORTER_ASSERT(r, pA == pB);
         REPORTER_ASSERT(r, aIsRRect == bIsRRect);
         if (aIsRRect) {
@@ skipping 509 matching lines @@
     peCase.appliedPathEffectShape().asPath(&b);
     peCase.appliedFullStyleShape().asPath(&c);
     if (isNonPath) {
         // RRect types can have a change in start index or direction after the PE is applied. This
         // is because once the PE is applied, GrShape may canonicalize the dir and index since it
         // is not germane to the styling any longer.
         // Instead we just check that the paths would fill the same both before and after styling.
         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());
     }
     REPORTER_ASSERT(reporter, peCase.appliedPathEffectShape().style().isSimpleHairline());
     REPORTER_ASSERT(reporter, peCase.appliedFullStyleShape().style().isSimpleHairline());
 }
 
 /**
@@ skipping 611 matching lines @@
         REPORTER_ASSERT(reporter, testPath.fIsLine == strokePathCase.baseShape().asLine(nullptr));
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif