Add some more getters to 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 278 matching lines @@
     SkRRect rrectA = SkRRect::MakeEmpty(), rrectB = SkRRect::MakeEmpty();
     SkPath::Direction dirA = SkPath::kCW_Direction, dirB = SkPath::kCW_Direction;
     unsigned startA = ~0U, startB = ~0U;
     bool invertedA = true, invertedB = true;
 
     bool aIsRRect = a.asRRect(&rrectA, &dirA, &startA, &invertedA);
     bool bIsRRect = b.asRRect(&rrectB, &dirB, &startB, &invertedB);
     bool aHasPE = a.style().hasPathEffect();
     bool bHasPE = b.style().hasPathEffect();
     bool allowSameRRectButDiffStartAndDir = (aIsRRect && bIsRRect) && (aHasPE != bHasPE);
-
+    // GrShape will close paths with simple fill style.
+    bool allowedClosednessDiff = (a.style().isSimpleFill() != b.style().isSimpleFill());
     SkPath pathA, pathB;
     a.asPath(&pathA);
     b.asPath(&pathB);
 
     // 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;
@@ skipping 10 matching lines @@
             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;
+        REPORTER_ASSERT(r, a.inverseFilled() == pA.isInverseFillType());
+        REPORTER_ASSERT(r, b.inverseFilled() == pB.isInverseFillType());
         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);
         }
-        if (a.style().isSimpleFill() != b.style().isSimpleFill()) {
+        if (allowedClosednessDiff) {
             // 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) {
             REPORTER_ASSERT(r, rrectA == rrectB);
             REPORTER_ASSERT(r, dirA == dirB);
             REPORTER_ASSERT(r, startA == startB);
             REPORTER_ASSERT(r, ignoreInversenessDifference || invertedA == invertedB);
         }
     }
     REPORTER_ASSERT(r, a.isEmpty() == b.isEmpty());
-    REPORTER_ASSERT(r, a.knownToBeClosed() == b.knownToBeClosed());
+    REPORTER_ASSERT(r, allowedClosednessDiff || a.knownToBeClosed() == b.knownToBeClosed());
+    // closedness can affect convexity.
+    REPORTER_ASSERT(r, allowedClosednessDiff || a.knownToBeConvex() == b.knownToBeConvex());
+    if (a.knownToBeConvex()) {
+        REPORTER_ASSERT(r, pathA.isConvex());
+    }
+    if (b.knownToBeConvex()) {
+        REPORTER_ASSERT(r, pathB.isConvex());
+    }
     REPORTER_ASSERT(r, a.bounds() == b.bounds());
     REPORTER_ASSERT(r, a.segmentMask() == b.segmentMask());
     SkPoint pts[4];
     REPORTER_ASSERT(r, a.asLine(pts) == b.asLine(pts + 2));
+    // mayBeInverseFilledAfterStyling() is allowed to differ if one has a arbitrary PE and the other
+    // doesn't (since the PE can set any fill type on its output path).
+    // Moreover, dash style explicitly ignores inverseness. So if one is dashed but not the other
+    // then they may disagree about inverseness.
+    if (a.style().hasNonDashPathEffect() == b.style().hasNonDashPathEffect() &&
+        a.style().isDashed() == b.style().isDashed()) {
+        REPORTER_ASSERT(r, a.mayBeInverseFilledAfterStyling() ==
+                           b.mayBeInverseFilledAfterStyling());
+    }
     if (a.asLine(pts)) {
         REPORTER_ASSERT(r, pts[2] == pts[0] && pts[3] == pts[1]);
     }
+    REPORTER_ASSERT(r, ignoreInversenessDifference || a.inverseFilled() == b.inverseFilled());
 }
 
 void TestCase::compare(skiatest::Reporter* r, const TestCase& that,
                        ComparisonExpecation expectation) const {
     SkPath a, b;
     switch (expectation) {
         case kAllDifferent_ComparisonExpecation:
             REPORTER_ASSERT(r, fBaseKey != that.fBaseKey);
             REPORTER_ASSERT(r, fAppliedPEKey != that.fAppliedPEKey);
             REPORTER_ASSERT(r, fAppliedFullKey != that.fAppliedFullKey);
@@ skipping 1120 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