Update GrShape test to allow more flexible shape creation.

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 56 matching lines @@
             return false;
         }
     }
 #ifdef SK_BUILD_FOR_WIN
     free(const_cast<uint8_t*>(kZeros));
 #endif
     return true;
 }
 
 namespace {
+/**
+ * Geo is a factory for creating a GrShape from another representation. It also answers some
+ * questions about expected behavior for GrShape given the inputs.
+ */
+class Geo {
+public:
+    virtual ~Geo() {};
+    virtual GrShape makeShape(const SkPaint&) const = 0;
+    virtual SkPath path() const = 0;
+    // These functions allow tests to check for special cases where style gets
+    // applied by GrShape in its constructor (without calling GrShape::applyStyle).
+    // These unfortunately rely on knowing details of GrShape's implementation.
+    // These predicates are factored out here to avoid littering the rest of the
+    // test code with GrShape implementation details.
+    virtual bool fillChangesGeom() const { return false; }
+    virtual bool strokeIsConvertedToFill() const { return false; }
+    virtual bool strokeAndFillIsConvertedToFill(const SkPaint&) const { return false; }
+    // Is this something we expect GrShape to recognize as something simpler than a path.
+    virtual bool isNonPath(const SkPaint& paint) const { return true; }
+};
+
+class RectGeo : public Geo {
+public:
+    RectGeo(const SkRect& rect) : fRect(rect) {}
+
+    SkPath path() const override {
+        SkPath path;
+        path.addRect(fRect);
+        return path;
+    }
+
+    GrShape makeShape(const SkPaint& paint) const override {
+        return GrShape(fRect, paint);
+    }
+
+    bool strokeAndFillIsConvertedToFill(const SkPaint& paint) const override {
+        SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style);
+        // Converted to an outset rectangle.
+        return paint.getStrokeJoin() == SkPaint::kMiter_Join &&
+               paint.getStrokeMiter() >= SK_ScalarSqrt2;
+    }
+
+private:
+    SkRect fRect;
+};
+
+class RRectGeo : public Geo {
+public:
+    RRectGeo(const SkRRect& rrect) : fRRect(rrect) {}
+
+    GrShape makeShape(const SkPaint& paint) const override {
+        return GrShape(fRRect, paint);
+    }
+
+    SkPath path() const override {
+        SkPath path;
+        path.addRRect(fRRect);
+        return path;
+    }
+
+    bool strokeAndFillIsConvertedToFill(const SkPaint& paint) const override {
+        SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style);
+        if (fRRect.isRect()) {
+            return RectGeo(fRRect.rect()).strokeAndFillIsConvertedToFill(paint);
+        }
+        return false;
+    }
+
+private:
+    SkRRect fRRect;
+};
+
+class PathGeo : public Geo {
+public:
+    enum class Invert { kNo, kYes };
+
+    PathGeo(const SkPath& path, Invert invert) : fPath(path)  {
+        SkASSERT(!path.isInverseFillType());
+        if (Invert::kYes == invert) {
+            if (fPath.getFillType() == SkPath::kEvenOdd_FillType) {
+                fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
+            } else {
+                SkASSERT(fPath.getFillType() == SkPath::kWinding_FillType);
+                fPath.setFillType(SkPath::kInverseWinding_FillType);
+            }
+        }
+    }
+
+    GrShape makeShape(const SkPaint& paint) const override {
+        return GrShape(fPath, paint);
+    }
+
+    SkPath path() const override { return fPath; }
+
+    bool fillChangesGeom() const override {
+        // unclosed rects get closed. Lines get turned into empty geometry
+        return this->isUnclosedRect() || (fPath.isLine(nullptr) && !fPath.isInverseFillType());
+    }
+
+    bool strokeIsConvertedToFill() const override {
+        return this->isAxisAlignedLine();
+    }
+
+    bool strokeAndFillIsConvertedToFill(const SkPaint& paint) const override {
+        SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style);
+        if (this->isAxisAlignedLine()) {
+            // The fill is ignored (zero area) and the stroke is converted to a rrect.
+            return true;
+        }
+        SkRect rect;
+        unsigned start;
+        SkPath::Direction dir;
+        if (SkPathPriv::IsSimpleClosedRect(fPath, &rect, &dir, &start)) {
+            return RectGeo(rect).strokeAndFillIsConvertedToFill(paint);
+        }
+        return false;
+    }
+
+    bool isNonPath(const SkPaint& paint) const override {
+        return fPath.isLine(nullptr) || fPath.isEmpty();
+    }
+
+private:
+    bool isAxisAlignedLine() const {
+        SkPoint pts[2];
+        if (!fPath.isLine(pts)) {
+            return false;
+        }
+        return pts[0].fX == pts[1].fX || pts[0].fY == pts[1].fY;
+    }
+
+    bool isUnclosedRect() const {
+        bool closed;
+        return fPath.isRect(nullptr, &closed, nullptr) && !closed;
+    }
+
+    SkPath fPath;
+};
+
+class RRectPathGeo : public PathGeo {
+public:
+    enum class RRectForStroke { kNo, kYes };
+
+    RRectPathGeo(const SkPath& path, const SkRRect& equivalentRRect, RRectForStroke rrectForStroke,
+                 Invert invert)
+            : PathGeo(path, invert)
+            , fRRect(equivalentRRect)
+            , fRRectForStroke(rrectForStroke) {}
+
+    RRectPathGeo(const SkPath& path, const SkRect& equivalentRect, RRectForStroke rrectForStroke,
+                 Invert invert)
+            : RRectPathGeo(path, SkRRect::MakeRect(equivalentRect), rrectForStroke, invert) {}
+
+    bool isNonPath(const SkPaint& paint) const override {
+        if (SkPaint::kFill_Style == paint.getStyle() || RRectForStroke::kYes == fRRectForStroke) {
+            return true;
+        }
+        return false;
+    }
+
+    const SkRRect& rrect() const { return fRRect; }
+
+private:
+    SkRRect         fRRect;
+    RRectForStroke  fRRectForStroke;
+};
+
 class TestCase {
 public:
-    template <typename GEO>
-    TestCase(const GEO& geo, const SkPaint& paint, skiatest::Reporter* r,
-             SkScalar scale = SK_Scalar1) : fBase(geo, paint) {
+    TestCase(const Geo& geo, const SkPaint& paint, skiatest::Reporter* r,
+             SkScalar scale = SK_Scalar1) : fBase(geo.makeShape(paint)) {
         this->init(r, scale);
     }
 
+    template<typename... ShapeArgs>
+    TestCase(skiatest::Reporter* r, ShapeArgs... shapeArgs)
+            : fBase(shapeArgs...) {
+        this->init(r, SK_Scalar1);
+    }
+
     TestCase(const GrShape& shape, skiatest::Reporter* r, SkScalar scale = SK_Scalar1)
         : fBase(shape) {
         this->init(r, scale);
     }
 
     struct SelfExpectations {
         bool fPEHasEffect;
         bool fPEHasValidKey;
         bool fStrokeApplies;
     };
@@ skipping 331 matching lines @@
     static const SkScalar kIntervals[] = { 0.25, 3.f, 0.5, 2.f };
     static const SkScalar kPhase = 0.75;
     return SkDashPathEffect::Make(kIntervals, SK_ARRAY_COUNT(kIntervals), kPhase);
 }
 
 static sk_sp<SkPathEffect> make_null_dash() {
     static const SkScalar kNullIntervals[] = {0, 0, 0, 0, 0, 0};
     return SkDashPathEffect::Make(kNullIntervals, SK_ARRAY_COUNT(kNullIntervals), 0.f);
 }
 
-//////////////////////////////////////////////////////////////////////////////
-// These functions allow tests to check for special cases where style gets
-// applied by GrShape in its constructor (without calling GrShape::applyStyle).
-// These unfortunately rely on knowing details of GrShape's implementation.
-// These predicates are factored out here to avoid littering the rest of the
-// test code with GrShape implementation details.
-
-static bool path_is_axis_aligned_line(const SkPath& path) {
-    SkPoint pts[2];
-    if (!path.isLine(pts)) {
-        return false;
-    }
-    return pts[0].fX == pts[1].fX || pts[0].fY == pts[1].fY;
-}
-
-static bool path_is_unclosed_rect(const SkPath& path) {
-    bool closed;
-    return path.isRect(nullptr, &closed, nullptr) && !closed;
-}
-
-// Will a GrShape constructed from a geometry perform a geometric transformation if the style is
-// simple fill that would not otherwise be applied.
-template <typename GEO> static bool fill_changes_geom(const GEO& geo) { return false; }
-template <> bool fill_changes_geom<SkPath>(const SkPath& path) {
-    // unclosed rects get closed. Lines get turned into empty geometry
-    return path_is_unclosed_rect(path) || (path.isLine(nullptr) && !path.isInverseFillType());
-}
-
-// Will a GrShape constructed from the geometry with a stroke style (without path effect) perform a
-// geometric transformation that applies the the stroke immediately without storing a stroke style.
-template <typename GEO> static bool stroke_is_converted_to_fill(const GEO& geo) { return false; }
-template <> bool stroke_is_converted_to_fill(const SkPath& path) {
-    // converted to a rrect.
-    return path_is_axis_aligned_line(path);
-}
-
-// Will a GrShape constructed from the geometry with a stroke-and-fill style (without path effect)
-// perform a geometric transformation that applies the the stroke immediately without storing a
-// stroke-and-fill style.
-template <typename GEO> static bool stroke_and_fill_is_converted_to_fill(const GEO& geo, const SkPaint& paint);
-template <> bool stroke_and_fill_is_converted_to_fill(const SkRect& rect, const SkPaint& paint) {
-    SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style);
-    // Converted to an outset rectangle.
-    return paint.getStrokeJoin() == SkPaint::kMiter_Join &&
-           paint.getStrokeMiter() >= SK_ScalarSqrt2;
-}
-template <> bool stroke_and_fill_is_converted_to_fill(const SkPath& path, const SkPaint& paint) {
-    SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style);
-    if (path_is_axis_aligned_line(path)) {
-        // The fill is ignored (zero area) and the stroke is converted to a rrect.
-        return true;
-    }
-    SkRect rect;
-    unsigned start;
-    SkPath::Direction dir;
-    if (SkPathPriv::IsSimpleClosedRect(path, &rect, &dir, &start)) {
-        return stroke_and_fill_is_converted_to_fill<SkRect>(rect, paint);
-    }
-    return false;
-}
-template <> bool stroke_and_fill_is_converted_to_fill(const SkRRect& rr, const SkPaint& paint) {
-    SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style);
-    if (rr.isRect()) {
-        return stroke_and_fill_is_converted_to_fill<SkRect>(rr.rect(), paint);
-    }
-    return false;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-template<typename GEO>
-static void test_basic(skiatest::Reporter* reporter, const GEO& geo) {
+static void test_basic(skiatest::Reporter* reporter, const Geo& geo) {
     sk_sp<SkPathEffect> dashPE = make_dash();
 
     TestCase::SelfExpectations expectations;
     SkPaint fill;
 
     TestCase fillCase(geo, fill, reporter);
     expectations.fPEHasEffect = false;
     expectations.fPEHasValidKey = false;
     expectations.fStrokeApplies = false;
     fillCase.testExpectations(reporter, expectations);
     // Test that another GrShape instance built from the same primitive is the same.
     TestCase(geo, fill, reporter).compare(reporter, fillCase,
                                           TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint stroke2RoundBevel;
     stroke2RoundBevel.setStyle(SkPaint::kStroke_Style);
     stroke2RoundBevel.setStrokeCap(SkPaint::kRound_Cap);
     stroke2RoundBevel.setStrokeJoin(SkPaint::kBevel_Join);
     stroke2RoundBevel.setStrokeWidth(2.f);
     TestCase stroke2RoundBevelCase(geo, stroke2RoundBevel, reporter);
     expectations.fPEHasValidKey = true;
     expectations.fPEHasEffect = false;
-    expectations.fStrokeApplies = !stroke_is_converted_to_fill(geo);
+    expectations.fStrokeApplies = !geo.strokeIsConvertedToFill();
     stroke2RoundBevelCase.testExpectations(reporter, expectations);
     TestCase(geo, stroke2RoundBevel, reporter).compare(reporter, stroke2RoundBevelCase,
                                                        TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint stroke2RoundBevelDash = stroke2RoundBevel;
     stroke2RoundBevelDash.setPathEffect(make_dash());
     TestCase stroke2RoundBevelDashCase(geo, stroke2RoundBevelDash, reporter);
     expectations.fPEHasValidKey = true;
     expectations.fPEHasEffect = true;
     expectations.fStrokeApplies = true;
     stroke2RoundBevelDashCase.testExpectations(reporter, expectations);
     TestCase(geo, stroke2RoundBevelDash, reporter).compare(reporter, stroke2RoundBevelDashCase,
                                                            TestCase::kAllSame_ComparisonExpecation);
 
-    if (fill_changes_geom(geo) || stroke_is_converted_to_fill(geo)) {
+    if (geo.fillChangesGeom() || geo.strokeIsConvertedToFill()) {
         fillCase.compare(reporter, stroke2RoundBevelCase,
                          TestCase::kAllDifferent_ComparisonExpecation);
         fillCase.compare(reporter, stroke2RoundBevelDashCase,
                          TestCase::kAllDifferent_ComparisonExpecation);
     } else {
         fillCase.compare(reporter, stroke2RoundBevelCase,
                          TestCase::kSameUpToStroke_ComparisonExpecation);
         fillCase.compare(reporter, stroke2RoundBevelDashCase,
                          TestCase::kSameUpToPE_ComparisonExpecation);
     }
-    if (stroke_is_converted_to_fill(geo)) {
+    if (geo.strokeIsConvertedToFill()) {
         stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase,
                                       TestCase::kAllDifferent_ComparisonExpecation);
     } else {
         stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase,
                                       TestCase::kSameUpToPE_ComparisonExpecation);
     }
 
     // Stroke and fill cases
     SkPaint stroke2RoundBevelAndFill = stroke2RoundBevel;
     stroke2RoundBevelAndFill.setStyle(SkPaint::kStrokeAndFill_Style);
     TestCase stroke2RoundBevelAndFillCase(geo, stroke2RoundBevelAndFill, reporter);
     expectations.fPEHasValidKey = true;
     expectations.fPEHasEffect = false;
-    expectations.fStrokeApplies = !stroke_is_converted_to_fill(geo);
+    expectations.fStrokeApplies = !geo.strokeIsConvertedToFill();
     stroke2RoundBevelAndFillCase.testExpectations(reporter, expectations);
     TestCase(geo, stroke2RoundBevelAndFill, reporter).compare(reporter,
             stroke2RoundBevelAndFillCase, TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint stroke2RoundBevelAndFillDash = stroke2RoundBevelDash;
     stroke2RoundBevelAndFillDash.setStyle(SkPaint::kStrokeAndFill_Style);
     TestCase stroke2RoundBevelAndFillDashCase(geo, stroke2RoundBevelAndFillDash, reporter);
     expectations.fPEHasValidKey = true;
     expectations.fPEHasEffect = false;
-    expectations.fStrokeApplies = !stroke_is_converted_to_fill(geo);
+    expectations.fStrokeApplies = !geo.strokeIsConvertedToFill();
     stroke2RoundBevelAndFillDashCase.testExpectations(reporter, expectations);
     TestCase(geo, stroke2RoundBevelAndFillDash, reporter).compare(
         reporter, stroke2RoundBevelAndFillDashCase, TestCase::kAllSame_ComparisonExpecation);
     stroke2RoundBevelAndFillDashCase.compare(reporter, stroke2RoundBevelAndFillCase,
                                              TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint hairline;
     hairline.setStyle(SkPaint::kStroke_Style);
     hairline.setStrokeWidth(0.f);
     TestCase hairlineCase(geo, hairline, reporter);
     // Since hairline style doesn't change the SkPath data, it is keyed identically to fill (except
     // in the line and unclosed rect cases).
-    if (fill_changes_geom(geo)) {
+    if (geo.fillChangesGeom()) {
         hairlineCase.compare(reporter, fillCase, TestCase::kAllDifferent_ComparisonExpecation);
     } else {
         hairlineCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
     }
     REPORTER_ASSERT(reporter, hairlineCase.baseShape().style().isSimpleHairline());
     REPORTER_ASSERT(reporter, hairlineCase.appliedFullStyleShape().style().isSimpleHairline());
     REPORTER_ASSERT(reporter, hairlineCase.appliedPathEffectShape().style().isSimpleHairline());
 
 }
 
-template<typename GEO>
-static void test_scale(skiatest::Reporter* reporter, const GEO& geo) {
+static void test_scale(skiatest::Reporter* reporter, const Geo& geo) {
     sk_sp<SkPathEffect> dashPE = make_dash();
 
     static const SkScalar kS1 = 1.f;
     static const SkScalar kS2 = 2.f;
 
     SkPaint fill;
     TestCase fillCase1(geo, fill, reporter, kS1);
     TestCase fillCase2(geo, fill, reporter, kS2);
     // Scale doesn't affect fills.
     fillCase1.compare(reporter, fillCase2, TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint hairline;
     hairline.setStyle(SkPaint::kStroke_Style);
     hairline.setStrokeWidth(0.f);
     TestCase hairlineCase1(geo, hairline, reporter, kS1);
     TestCase hairlineCase2(geo, hairline, reporter, kS2);
     // Scale doesn't affect hairlines.
     hairlineCase1.compare(reporter, hairlineCase2, TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint stroke;
     stroke.setStyle(SkPaint::kStroke_Style);
     stroke.setStrokeWidth(2.f);
     TestCase strokeCase1(geo, stroke, reporter, kS1);
     TestCase strokeCase2(geo, stroke, reporter, kS2);
     // Scale affects the stroke
-    if (stroke_is_converted_to_fill(geo)) {
+    if (geo.strokeIsConvertedToFill()) {
         REPORTER_ASSERT(reporter, !strokeCase1.baseShape().style().applies());
         strokeCase1.compare(reporter, strokeCase2, TestCase::kAllSame_ComparisonExpecation);
     } else {
         strokeCase1.compare(reporter, strokeCase2, TestCase::kSameUpToStroke_ComparisonExpecation);
     }
 
     SkPaint strokeDash = stroke;
     strokeDash.setPathEffect(make_dash());
     TestCase strokeDashCase1(geo, strokeDash, reporter, kS1);
     TestCase strokeDashCase2(geo, strokeDash, reporter, kS2);
     // Scale affects the dash and the stroke.
     strokeDashCase1.compare(reporter, strokeDashCase2,
                             TestCase::kSameUpToPE_ComparisonExpecation);
 
     // Stroke and fill cases
     SkPaint strokeAndFill = stroke;
     strokeAndFill.setStyle(SkPaint::kStrokeAndFill_Style);
     TestCase strokeAndFillCase1(geo, strokeAndFill, reporter, kS1);
     TestCase strokeAndFillCase2(geo, strokeAndFill, reporter, kS2);
     SkPaint strokeAndFillDash = strokeDash;
     strokeAndFillDash.setStyle(SkPaint::kStrokeAndFill_Style);
     // Dash is ignored for stroke and fill
     TestCase strokeAndFillDashCase1(geo, strokeAndFillDash, reporter, kS1);
     TestCase strokeAndFillDashCase2(geo, strokeAndFillDash, reporter, kS2);
     // Scale affects the stroke, but check to make sure this didn't become a simpler shape (e.g.
     // stroke-and-filled rect can become a rect), in which case the scale shouldn't matter and the
     // geometries should agree.
-    if (stroke_and_fill_is_converted_to_fill(geo, strokeAndFillDash)) {
+    if (geo.strokeAndFillIsConvertedToFill(strokeAndFillDash)) {
         REPORTER_ASSERT(reporter, !strokeAndFillCase1.baseShape().style().applies());
         strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
                                    TestCase::kAllSame_ComparisonExpecation);
         strokeAndFillDashCase1.compare(reporter, strokeAndFillDashCase2,
                                        TestCase::kAllSame_ComparisonExpecation);
     } else {
         strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
                                    TestCase::kSameUpToStroke_ComparisonExpecation);
     }
     strokeAndFillDashCase1.compare(reporter, strokeAndFillCase1,
                                    TestCase::kAllSame_ComparisonExpecation);
     strokeAndFillDashCase2.compare(reporter, strokeAndFillCase2,
                                    TestCase::kAllSame_ComparisonExpecation);
 }
 
-template <typename GEO, typename T>
-static void test_stroke_param_impl(skiatest::Reporter* reporter, const GEO& geo,
+template <typename T>
+static void test_stroke_param_impl(skiatest::Reporter* reporter, const Geo& geo,
                                    std::function<void(SkPaint*, T)> setter, T a, T b,
                                    bool paramAffectsStroke,
                                    bool paramAffectsDashAndStroke) {
     // Set the stroke width so that we don't get hairline. However, call the setter afterward so
     // that it can override the stroke width.
     SkPaint strokeA;
     strokeA.setStyle(SkPaint::kStroke_Style);
     strokeA.setStrokeWidth(2.f);
     setter(&strokeA, a);
     SkPaint strokeB;
     strokeB.setStyle(SkPaint::kStroke_Style);
     strokeB.setStrokeWidth(2.f);
     setter(&strokeB, b);
 
     TestCase strokeACase(geo, strokeA, reporter);
     TestCase strokeBCase(geo, strokeB, reporter);
     if (paramAffectsStroke) {
         // If stroking is immediately incorporated into a geometric transformation then the base
         // shapes will differ.
-        if (stroke_is_converted_to_fill(geo)) {
+        if (geo.strokeIsConvertedToFill()) {
             strokeACase.compare(reporter, strokeBCase,
                                 TestCase::kAllDifferent_ComparisonExpecation);
         } else {
             strokeACase.compare(reporter, strokeBCase,
                                 TestCase::kSameUpToStroke_ComparisonExpecation);
         }
     } else {
         strokeACase.compare(reporter, strokeBCase, TestCase::kAllSame_ComparisonExpecation);
     }
 
     SkPaint strokeAndFillA = strokeA;
     SkPaint strokeAndFillB = strokeB;
     strokeAndFillA.setStyle(SkPaint::kStrokeAndFill_Style);
     strokeAndFillB.setStyle(SkPaint::kStrokeAndFill_Style);
     TestCase strokeAndFillACase(geo, strokeAndFillA, reporter);
     TestCase strokeAndFillBCase(geo, strokeAndFillB, reporter);
     if (paramAffectsStroke) {
         // If stroking is immediately incorporated into a geometric transformation then the base
         // shapes will differ.
-        if (stroke_and_fill_is_converted_to_fill(geo, strokeAndFillA) ||
-            stroke_and_fill_is_converted_to_fill(geo, strokeAndFillB)) {
+        if (geo.strokeAndFillIsConvertedToFill(strokeAndFillA) ||
+            geo.strokeAndFillIsConvertedToFill(strokeAndFillB)) {
             strokeAndFillACase.compare(reporter, strokeAndFillBCase,
                                        TestCase::kAllDifferent_ComparisonExpecation);
         } else {
             strokeAndFillACase.compare(reporter, strokeAndFillBCase,
                                        TestCase::kSameUpToStroke_ComparisonExpecation);
         }
     } else {
         strokeAndFillACase.compare(reporter, strokeAndFillBCase,
                                    TestCase::kAllSame_ComparisonExpecation);
     }
@@ skipping 13 matching lines @@
     dashB.setPathEffect(make_dash());
     TestCase dashACase(geo, dashA, reporter);
     TestCase dashBCase(geo, dashB, reporter);
     if (paramAffectsDashAndStroke) {
         dashACase.compare(reporter, dashBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
     } else {
         dashACase.compare(reporter, dashBCase, TestCase::kAllSame_ComparisonExpecation);
     }
 }
 
-template <typename GEO, typename T>
-static void test_stroke_param(skiatest::Reporter* reporter, const GEO& geo,
+template <typename T>
+static void test_stroke_param(skiatest::Reporter* reporter, const Geo& geo,
                               std::function<void(SkPaint*, T)> setter, T a, T b) {
     test_stroke_param_impl(reporter, geo, setter, a, b, true, true);
 };
 
-template <typename GEO>
-static void test_stroke_cap(skiatest::Reporter* reporter, const GEO& geo) {
-    GrShape shape(geo, GrStyle(SkStrokeRec::kHairline_InitStyle));
+static void test_stroke_cap(skiatest::Reporter* reporter, const Geo& geo) {
+    SkPaint hairline;
+    hairline.setStrokeWidth(0);
+    hairline.setStyle(SkPaint::kStroke_Style);
+    GrShape shape = geo.makeShape(hairline);
     // The cap should only affect shapes that may be open.
     bool affectsStroke = !shape.knownToBeClosed();
     // Dashing adds ends that need caps.
     bool affectsDashAndStroke = true;
-    test_stroke_param_impl<GEO, SkPaint::Cap>(
+    test_stroke_param_impl<SkPaint::Cap>(
         reporter,
         geo,
         [](SkPaint* p, SkPaint::Cap c) { p->setStrokeCap(c);},
         SkPaint::kButt_Cap, SkPaint::kRound_Cap,
         affectsStroke,
         affectsDashAndStroke);
 };
 
 static bool shape_known_not_to_have_joins(const GrShape& shape) {
     return shape.asLine(nullptr, nullptr) || shape.isEmpty();
 }
 
-template <typename GEO>
-static void test_stroke_join(skiatest::Reporter* reporter, const GEO& geo) {
-    GrShape shape(geo, GrStyle(SkStrokeRec::kHairline_InitStyle));
+static void test_stroke_join(skiatest::Reporter* reporter, const Geo& geo) {
+    SkPaint hairline;
+    hairline.setStrokeWidth(0);
+    hairline.setStyle(SkPaint::kStroke_Style);
+    GrShape shape = geo.makeShape(hairline);
     // GrShape recognizes certain types don't have joins and will prevent the join type from
     // affecting the style key.
     // Dashing doesn't add additional joins. However, GrShape currently loses track of this
     // after applying the dash.
     bool affectsStroke = !shape_known_not_to_have_joins(shape);
-    test_stroke_param_impl<GEO, SkPaint::Join>(
+    test_stroke_param_impl<SkPaint::Join>(
             reporter,
             geo,
             [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
             SkPaint::kRound_Join, SkPaint::kBevel_Join,
             affectsStroke, true);
 };
 
-template <typename GEO>
-static void test_miter_limit(skiatest::Reporter* reporter, const GEO& geo) {
+static void test_miter_limit(skiatest::Reporter* reporter, const Geo& geo) {
     auto setMiterJoinAndLimit = [](SkPaint* p, SkScalar miter) {
         p->setStrokeJoin(SkPaint::kMiter_Join);
         p->setStrokeMiter(miter);
     };
 
     auto setOtherJoinAndLimit = [](SkPaint* p, SkScalar miter) {
         p->setStrokeJoin(SkPaint::kRound_Join);
         p->setStrokeMiter(miter);
     };
 
-    GrShape shape(geo, GrStyle(SkStrokeRec::kHairline_InitStyle));
+    SkPaint hairline;
+    hairline.setStrokeWidth(0);
+    hairline.setStyle(SkPaint::kStroke_Style);
+    GrShape shape = geo.makeShape(hairline);
     bool mayHaveJoins = !shape_known_not_to_have_joins(shape);
 
     // The miter limit should affect stroked and dashed-stroked cases when the join type is
     // miter.
-    test_stroke_param_impl<GEO, SkScalar>(
+    test_stroke_param_impl<SkScalar>(
         reporter,
         geo,
         setMiterJoinAndLimit,
         0.5f, 0.75f,
         mayHaveJoins,
         true);
 
     // The miter limit should not affect stroked and dashed-stroked cases when the join type is
     // not miter.
-    test_stroke_param_impl<GEO, SkScalar>(
+    test_stroke_param_impl<SkScalar>(
         reporter,
         geo,
         setOtherJoinAndLimit,
         0.5f, 0.75f,
         false,
         false);
 }
 
-template<typename GEO>
-static void test_dash_fill(skiatest::Reporter* reporter, const GEO& geo) {
+static void test_dash_fill(skiatest::Reporter* reporter, const Geo& geo) {
     // A dash with no stroke should have no effect
     using DashFactoryFn = sk_sp<SkPathEffect>(*)();
     for (DashFactoryFn md : {&make_dash, &make_null_dash}) {
         SkPaint dashFill;
         dashFill.setPathEffect((*md)());
         TestCase dashFillCase(geo, dashFill, reporter);
 
         TestCase fillCase(geo, SkPaint(), reporter);
         dashFillCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
     }
 }
 
-template<typename GEO>
-void test_null_dash(skiatest::Reporter* reporter, const GEO& geo) {
+void test_null_dash(skiatest::Reporter* reporter, const Geo& geo) {
     SkPaint fill;
     SkPaint stroke;
     stroke.setStyle(SkPaint::kStroke_Style);
     stroke.setStrokeWidth(1.f);
     SkPaint dash;
     dash.setStyle(SkPaint::kStroke_Style);
     dash.setStrokeWidth(1.f);
     dash.setPathEffect(make_dash());
     SkPaint nullDash;
     nullDash.setStyle(SkPaint::kStroke_Style);
     nullDash.setStrokeWidth(1.f);
     nullDash.setPathEffect(make_null_dash());
 
     TestCase fillCase(geo, fill, reporter);
     TestCase strokeCase(geo, stroke, reporter);
     TestCase dashCase(geo, dash, reporter);
     TestCase nullDashCase(geo, nullDash, reporter);
 
     // We expect the null dash to be ignored so nullDashCase should match strokeCase, always.
     nullDashCase.compare(reporter, strokeCase, TestCase::kAllSame_ComparisonExpecation);
     // Check whether the fillCase or strokeCase/nullDashCase would undergo a geometric tranformation
     // on construction in order to determine how to compare the fill and stroke.
-    if (fill_changes_geom(geo) || stroke_is_converted_to_fill(geo)) {
+    if (geo.fillChangesGeom() || geo.strokeIsConvertedToFill()) {
         nullDashCase.compare(reporter, fillCase, TestCase::kAllDifferent_ComparisonExpecation);
     } else {
         nullDashCase.compare(reporter, fillCase, TestCase::kSameUpToStroke_ComparisonExpecation);
     }
     // In the null dash case we may immediately convert to a fill, but not for the normal dash case.
-    if (stroke_is_converted_to_fill(geo)) {
+    if (geo.strokeIsConvertedToFill()) {
         nullDashCase.compare(reporter, dashCase, TestCase::kAllDifferent_ComparisonExpecation);
     } else {
         nullDashCase.compare(reporter, dashCase, TestCase::kSameUpToPE_ComparisonExpecation);
     }
 }
 
-template <typename GEO>
-void test_path_effect_makes_rrect(skiatest::Reporter* reporter, const GEO& geo) {
+void test_path_effect_makes_rrect(skiatest::Reporter* reporter, const Geo& geo) {
     /**
      * This path effect takes any input path and turns it into a rrect. It passes through stroke
      * info.
      */
     class RRectPathEffect : SkPathEffect {
     public:
         static const SkRRect& RRect() {
             static const SkRRect kRRect = SkRRect::MakeRectXY(SkRect::MakeWH(12, 12), 3, 5);
             return kRRect;
         }
@@ skipping 22 matching lines @@
     TestCase geoPECase(geo, pe, reporter);
 
     SkPaint peStroke;
     peStroke.setPathEffect(RRectPathEffect::Make());
     peStroke.setStrokeWidth(2.f);
     peStroke.setStyle(SkPaint::kStroke_Style);
     TestCase geoPEStrokeCase(geo, peStroke, reporter);
 
     // Check whether constructing the filled case would cause the base shape to have a different
     // geometry (because of a geometric transformation upon initial GrShape construction).
-    if (fill_changes_geom(geo)) {
+    if (geo.fillChangesGeom()) {
         fillGeoCase.compare(reporter, geoPECase, TestCase::kAllDifferent_ComparisonExpecation);
         fillGeoCase.compare(reporter, geoPEStrokeCase,
                             TestCase::kAllDifferent_ComparisonExpecation);
     } else {
         fillGeoCase.compare(reporter, geoPECase, TestCase::kSameUpToPE_ComparisonExpecation);
         fillGeoCase.compare(reporter, geoPEStrokeCase, TestCase::kSameUpToPE_ComparisonExpecation);
     }
     geoPECase.compare(reporter, geoPEStrokeCase,
                       TestCase::kSameUpToStroke_ComparisonExpecation);
 
-    TestCase rrectFillCase(RRectPathEffect::RRect(), fill, reporter);
+    TestCase rrectFillCase(reporter, RRectPathEffect::RRect(), fill);
     SkPaint stroke = peStroke;
     stroke.setPathEffect(nullptr);
-    TestCase rrectStrokeCase(RRectPathEffect::RRect(), stroke, reporter);
+    TestCase rrectStrokeCase(reporter, RRectPathEffect::RRect(), stroke);
 
     SkRRect rrect;
     // Applying the path effect should make a SkRRect shape. There is no further stroking in the
     // geoPECase, so the full style should be the same as just the PE.
     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectShape().asRRect(&rrect, nullptr, nullptr,
                                                                          nullptr));
     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectKey() == rrectFillCase.baseKey());
 
     REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleShape().asRRect(&rrect, nullptr, nullptr,
                                                                         nullptr));
     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
     REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleKey() == rrectFillCase.baseKey());
 
     // In the PE+stroke case applying the full style should be the same as just stroking the rrect.
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectShape().asRRect(&rrect, nullptr,
                                                                                nullptr, nullptr));
     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == rrectFillCase.baseKey());
 
     REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedFullStyleShape().asRRect(&rrect, nullptr,
                                                                                nullptr, nullptr));
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() ==
                               rrectStrokeCase.appliedFullStyleKey());
 }
 
-template <typename GEO>
-void test_unknown_path_effect(skiatest::Reporter* reporter, const GEO& geo) {
+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);
@@ skipping 19 matching lines @@
     peStroke.setStrokeWidth(2.f);
     peStroke.setStyle(SkPaint::kStroke_Style);
     TestCase geoPEStrokeCase(geo, peStroke, reporter);
     TestCase::SelfExpectations expectations;
     expectations.fPEHasEffect = true;
     expectations.fPEHasValidKey = false;
     expectations.fStrokeApplies = true;
     geoPEStrokeCase.testExpectations(reporter, expectations);
 }
 
-template <typename GEO>
-void test_make_hairline_path_effect(skiatest::Reporter* reporter, const GEO& geo, bool isNonPath) {
+void test_make_hairline_path_effect(skiatest::Reporter* reporter, const Geo& geo) {
     /**
      * This path effect just changes the stroke rec to hairline.
      */
     class MakeHairlinePathEffect : SkPathEffect {
     public:
         bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec* strokeRec,
                         const SkRect* cullR) const override {
             *dst = src;
             strokeRec->setHairlineStyle();
             return true;
@@ skipping 11 matching lines @@
     SkPaint fill;
     SkPaint pe;
     pe.setPathEffect(MakeHairlinePathEffect::Make());
 
     TestCase peCase(geo, pe, reporter);
 
     SkPath a, b, c;
     peCase.baseShape().asPath(&a);
     peCase.appliedPathEffectShape().asPath(&b);
     peCase.appliedFullStyleShape().asPath(&c);
-    if (isNonPath) {
+    if (geo.isNonPath(pe)) {
         // 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());
 }
 
-/**
- * isNonPath indicates whether the initial shape made from the path is expected to be recognized
- * as a simpler shape type (e.g. rrect)
- */
-void test_volatile_path(skiatest::Reporter* reporter, const SkPath& path,
-                        bool isNonPath) {
-    SkPath vPath(path);
+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(vPath, dashAndStroke, reporter);
+    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 (isNonPath) {
+    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(path, dashAndStroke, reporter);
+        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()));
     }
 }
 
-template <typename GEO>
-void test_path_effect_makes_empty_shape(skiatest::Reporter* reporter, const GEO& geo) {
+void test_path_effect_makes_empty_shape(skiatest::Reporter* reporter, const Geo& geo) {
     /**
      * This path effect returns an empty path.
      */
     class EmptyPathEffect : SkPathEffect {
     public:
         bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*,
                         const SkRect* cullR) const override {
             dst->reset();
             return true;
         }
@@ skipping 27 matching lines @@
     peStroke.setStrokeWidth(2.f);
     peStroke.setStyle(SkPaint::kStroke_Style);
     TestCase geoPEStrokeCase(geo, peStroke, reporter);
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectThenStrokeKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectShape().isEmpty());
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleShape().isEmpty());
 }
 
-template <typename GEO>
-void test_path_effect_fails(skiatest::Reporter* reporter, const GEO& geo) {
+void test_path_effect_fails(skiatest::Reporter* reporter, const Geo& geo) {
     /**
      * This path effect always fails to apply.
      */
     class FailurePathEffect : SkPathEffect {
     public:
         bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*,
                         const SkRect* cullR) const override {
             return false;
         }
         void computeFastBounds(SkRect* dst, const SkRect& src) const override {
@@ skipping 44 matching lines @@
     REPORTER_ASSERT(reporter, paths_fill_same(a, b));
 
     strokeCase.appliedFullStyleShape().asPath(&a);
     peStrokeCase.appliedFullStyleShape().asPath(&b);
     REPORTER_ASSERT(reporter, paths_fill_same(a, b));
 }
 
 void test_empty_shape(skiatest::Reporter* reporter) {
     SkPath emptyPath;
     SkPaint fill;
-    TestCase fillEmptyCase(emptyPath, fill, reporter);
+    TestCase fillEmptyCase(reporter, emptyPath, fill);
     REPORTER_ASSERT(reporter, fillEmptyCase.baseShape().isEmpty());
     REPORTER_ASSERT(reporter, fillEmptyCase.appliedPathEffectShape().isEmpty());
     REPORTER_ASSERT(reporter, fillEmptyCase.appliedFullStyleShape().isEmpty());
 
     Key emptyKey(fillEmptyCase.baseKey());
     REPORTER_ASSERT(reporter, emptyKey.count());
     TestCase::SelfExpectations expectations;
     expectations.fStrokeApplies = false;
     expectations.fPEHasEffect = false;
     // This will test whether applying style preserves emptiness
     fillEmptyCase.testExpectations(reporter, expectations);
 
     // Stroking an empty path should have no effect
     SkPath emptyPath2;
     SkPaint stroke;
     stroke.setStrokeWidth(2.f);
     stroke.setStyle(SkPaint::kStroke_Style);
-    TestCase strokeEmptyCase(emptyPath2, stroke, reporter);
+    TestCase strokeEmptyCase(reporter, emptyPath2, stroke);
     strokeEmptyCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation);
 
     // Dashing and stroking an empty path should have no effect
     SkPath emptyPath3;
     SkPaint dashAndStroke;
     dashAndStroke.setPathEffect(make_dash());
     dashAndStroke.setStrokeWidth(2.f);
     dashAndStroke.setStyle(SkPaint::kStroke_Style);
-    TestCase dashAndStrokeEmptyCase(emptyPath3, dashAndStroke, reporter);
+    TestCase dashAndStrokeEmptyCase(reporter, emptyPath3, dashAndStroke);
     dashAndStrokeEmptyCase.compare(reporter, fillEmptyCase,
                                    TestCase::kAllSame_ComparisonExpecation);
 
     // A shape made from an empty rrect should behave the same as an empty path.
     SkRRect emptyRRect = SkRRect::MakeRect(SkRect::MakeEmpty());
     REPORTER_ASSERT(reporter, emptyRRect.getType() == SkRRect::kEmpty_Type);
-    TestCase dashAndStrokeEmptyRRectCase(emptyRRect, dashAndStroke, reporter);
+    TestCase dashAndStrokeEmptyRRectCase(reporter, emptyRRect, dashAndStroke);
     dashAndStrokeEmptyRRectCase.compare(reporter, fillEmptyCase,
                                         TestCase::kAllSame_ComparisonExpecation);
 
     // Same for a rect.
     SkRect emptyRect = SkRect::MakeEmpty();
-    TestCase dashAndStrokeEmptyRectCase(emptyRect, dashAndStroke, reporter);
+    TestCase dashAndStrokeEmptyRectCase(reporter, emptyRect, dashAndStroke);
     dashAndStrokeEmptyRectCase.compare(reporter, fillEmptyCase,
                                        TestCase::kAllSame_ComparisonExpecation);
 }
 
 // rect and oval types have rrect start indices that collapse to the same point. Here we select the
 // canonical point in these cases.
 unsigned canonicalize_rrect_start(int s, const SkRRect& rrect) {
     switch (rrect.getType()) {
         case SkRRect::kRect_Type:
             return (s + 1) & 0b110;
@@ skipping 271 matching lines @@
     SkPaint fill;
     SkPaint stroke;
     stroke.setStyle(SkPaint::kStroke_Style);
     stroke.setStrokeWidth(2.f);
     SkPaint hairline;
     hairline.setStyle(SkPaint::kStroke_Style);
     hairline.setStrokeWidth(0.f);
     SkPaint dash = stroke;
     dash.setPathEffect(make_dash());
 
-    TestCase fillAB(lineAB, fill, r);
-    TestCase fillEmpty(SkPath(), fill, r);
+    TestCase fillAB(r, lineAB, fill);
+    TestCase fillEmpty(r, SkPath(), fill);
     fillAB.compare(r, fillEmpty, TestCase::kAllSame_ComparisonExpecation);
     REPORTER_ASSERT(r, !fillAB.baseShape().asLine(nullptr, nullptr));
 
-    TestCase strokeAB(lineAB, stroke, r);
-    TestCase strokeBA(lineBA, stroke, r);
-    TestCase strokeAC(lineAC, stroke, r);
+    TestCase strokeAB(r, lineAB, stroke);
+    TestCase strokeBA(r, lineBA, stroke);
+    TestCase strokeAC(r, lineAC, stroke);
 
-    TestCase hairlineAB(lineAB, hairline, r);
-    TestCase hairlineBA(lineBA, hairline, r);
-    TestCase hairlineAC(lineAC, hairline, r);
+    TestCase hairlineAB(r, lineAB, hairline);
+    TestCase hairlineBA(r, lineBA, hairline);
+    TestCase hairlineAC(r, lineAC, hairline);
 
-    TestCase dashAB(lineAB, dash, r);
-    TestCase dashBA(lineBA, dash, r);
-    TestCase dashAC(lineAC, dash, r);
+    TestCase dashAB(r, lineAB, dash);
+    TestCase dashBA(r, lineBA, dash);
+    TestCase dashAC(r, lineAC, dash);
 
     strokeAB.compare(r, fillAB, TestCase::kAllDifferent_ComparisonExpecation);
 
     strokeAB.compare(r, strokeBA, TestCase::kAllSame_ComparisonExpecation);
     strokeAB.compare(r, strokeAC, TestCase::kAllDifferent_ComparisonExpecation);
 
     hairlineAB.compare(r, hairlineBA, TestCase::kAllSame_ComparisonExpecation);
     hairlineAB.compare(r, hairlineAC, TestCase::kAllDifferent_ComparisonExpecation);
 
     dashAB.compare(r, dashBA, TestCase::kAllDifferent_ComparisonExpecation);
@@ skipping 24 matching lines @@
     REPORTER_ASSERT(r, strokeAB.baseShape().asLine(pts, &inverted) && !inverted &&
                        pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]);
     REPORTER_ASSERT(r, hairlineAB.baseShape().asLine(pts, &inverted) && !inverted &&
                        pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]);
     REPORTER_ASSERT(r, dashAB.baseShape().asLine(pts, &inverted) && !inverted &&
                        pts[0] == kA && pts[1] == kB);
     REPORTER_ASSERT(r, dashBA.baseShape().asLine(pts, &inverted) && !inverted &&
                        pts[0] == kB && pts[1] == kA);
 
 
-    TestCase strokeInvAB(invLineAB, stroke, r);
-    TestCase hairlineInvAB(invLineAB, hairline, r);
-    TestCase dashInvAB(invLineAB, dash, r);
+    TestCase strokeInvAB(r, invLineAB, stroke);
+    TestCase hairlineInvAB(r, invLineAB, hairline);
+    TestCase dashInvAB(r, invLineAB, dash);
     strokeInvAB.compare(r, strokeAB, TestCase::kAllDifferent_ComparisonExpecation);
     hairlineInvAB.compare(r, hairlineAB, TestCase::kAllDifferent_ComparisonExpecation);
     // Dashing ignores inverse.
     dashInvAB.compare(r, dashAB, TestCase::kAllSame_ComparisonExpecation);
 
     REPORTER_ASSERT(r, strokeInvAB.baseShape().asLine(pts, &inverted) && inverted &&
                        pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]);
     REPORTER_ASSERT(r, hairlineInvAB.baseShape().asLine(pts, &inverted) && inverted &&
                        pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]);
     // Dashing ignores inverse.
@@ skipping 15 matching lines @@
     SkPaint roundCap = buttCap;
     roundCap.setStrokeCap(SkPaint::kRound_Cap);
 
     // vertical
     SkPath linePath;
     linePath.moveTo(4, 4);
     linePath.lineTo(4, 5);
 
     SkPaint fill;
 
-    TestCase(linePath, buttCap, r).compare(r, TestCase(SkRect::MakeLTRB(2, 4, 6, 5), fill, r),
+    TestCase(r, linePath, buttCap).compare(r, TestCase(r, SkRect::MakeLTRB(2, 4, 6, 5), fill),
                                            TestCase::kAllSame_ComparisonExpecation);
 
-    TestCase(linePath, squareCap, r).compare(r, TestCase(SkRect::MakeLTRB(2, 2, 6, 7), fill, r),
+    TestCase(r, linePath, squareCap).compare(r, TestCase(r, SkRect::MakeLTRB(2, 2, 6, 7), fill),
                                              TestCase::kAllSame_ComparisonExpecation);
 
-    TestCase(linePath, roundCap, r).compare(r,
-        TestCase(SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 6, 7), 2, 2), fill, r),
+    TestCase(r, linePath, roundCap).compare(r,
+        TestCase(r, SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 6, 7), 2, 2), fill),
         TestCase::kAllSame_ComparisonExpecation);
 
     // horizontal
     linePath.reset();
     linePath.moveTo(4, 4);
     linePath.lineTo(5, 4);
 
-    TestCase(linePath, buttCap, r).compare(r, TestCase(SkRect::MakeLTRB(4, 2, 5, 6), fill, r),
+    TestCase(r, linePath, buttCap).compare(r, TestCase(r, SkRect::MakeLTRB(4, 2, 5, 6), fill),
                                            TestCase::kAllSame_ComparisonExpecation);
-    TestCase(linePath, squareCap, r).compare(r, TestCase(SkRect::MakeLTRB(2, 2, 7, 6), fill, r),
+    TestCase(r, linePath, squareCap).compare(r, TestCase(r, SkRect::MakeLTRB(2, 2, 7, 6), fill),
                                              TestCase::kAllSame_ComparisonExpecation);
-    TestCase(linePath, roundCap, r).compare(r,
-         TestCase(SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 7, 6), 2, 2), fill, r),
+    TestCase(r, linePath, roundCap).compare(r,
+         TestCase(r, SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 7, 6), 2, 2), fill),
          TestCase::kAllSame_ComparisonExpecation);
 
     // point
     linePath.reset();
     linePath.moveTo(4, 4);
     linePath.lineTo(4, 4);
 
-    TestCase(linePath, buttCap, r).compare(r, TestCase(SkRect::MakeEmpty(), fill, r),
+    TestCase(r, linePath, buttCap).compare(r, TestCase(r, SkRect::MakeEmpty(), fill),
                                            TestCase::kAllSame_ComparisonExpecation);
-    TestCase(linePath, squareCap, r).compare(r, TestCase(SkRect::MakeLTRB(2, 2, 6, 6), fill, r),
+    TestCase(r, linePath, squareCap).compare(r, TestCase(r, SkRect::MakeLTRB(2, 2, 6, 6), fill),
                                              TestCase::kAllSame_ComparisonExpecation);
-    TestCase(linePath, roundCap, r).compare(r,
-        TestCase(SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 6, 6), 2, 2), fill, r),
+    TestCase(r, linePath, roundCap).compare(r,
+        TestCase(r, SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 6, 6), 2, 2), fill),
         TestCase::kAllSame_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)}) {
-        test_basic(reporter, r);
-        test_scale(reporter, r);
-        test_dash_fill(reporter, r);
-        test_null_dash(reporter, r);
-        // Test modifying various stroke params.
-        test_stroke_param<SkRect, SkScalar>(
-                reporter, r,
-                [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);},
-                SkIntToScalar(2), SkIntToScalar(4));
-        test_stroke_join(reporter, r);
-        test_stroke_cap(reporter, r);
-        test_miter_limit(reporter, r);
-        test_path_effect_makes_rrect(reporter, r);
-        test_unknown_path_effect(reporter, r);
-        test_path_effect_makes_empty_shape(reporter, r);
-        test_path_effect_fails(reporter, r);
-        test_make_hairline_path_effect(reporter, r, true);
-        GrShape shape(r);
-        REPORTER_ASSERT(reporter, !shape.asLine(nullptr, nullptr));
+        geos.emplace_back(new RectGeo(r));
+        SkPath rectPath;
+        rectPath.addRect(r);
+        geos.emplace_back(new RRectPathGeo(rectPath, r, RRectPathGeo::RRectForStroke::kYes,
+                                           PathGeo::Invert::kNo));
+        geos.emplace_back(new RRectPathGeo(rectPath, r, RRectPathGeo::RRectForStroke::kYes,
+                                           PathGeo::Invert::kYes));
+        rrectPathGeos.emplace_back(new RRectPathGeo(rectPath, r, RRectPathGeo::RRectForStroke::kYes,
+                                                    PathGeo::Invert::kNo));
     }
-
     for (auto rr : { SkRRect::MakeRect(SkRect::MakeWH(10, 10)),
                      SkRRect::MakeRectXY(SkRect::MakeWH(10, 10), 3, 4),
                      SkRRect::MakeOval(SkRect::MakeWH(20, 20))}) {
-        test_basic(reporter, rr);
+        geos.emplace_back(new RRectGeo(rr));
         test_rrect(reporter, rr);
-        test_scale(reporter, rr);
-        test_dash_fill(reporter, rr);
-        test_null_dash(reporter, rr);
-        // Test modifying various stroke params.
-        test_stroke_param<SkRRect, SkScalar>(
-                          reporter, rr,
-                          [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);},
-                          SkIntToScalar(2), SkIntToScalar(4));
-        test_stroke_join(reporter, rr);
-        test_stroke_cap(reporter, rr);
-        test_miter_limit(reporter, rr);
-        test_path_effect_makes_rrect(reporter, rr);
-        test_unknown_path_effect(reporter, rr);
-        test_path_effect_makes_empty_shape(reporter, rr);
-        test_path_effect_fails(reporter, rr);
-        test_make_hairline_path_effect(reporter, rr, true);
-        GrShape shape(rr);
-        REPORTER_ASSERT(reporter, !shape.asLine(nullptr, nullptr));
+        SkPath rectPath;
+        rectPath.addRRect(rr);
+        geos.emplace_back(new RRectPathGeo(rectPath, rr, RRectPathGeo::RRectForStroke::kYes,
+                                           PathGeo::Invert::kNo));
+        geos.emplace_back(new RRectPathGeo(rectPath, rr, RRectPathGeo::RRectForStroke::kYes,
+                                           PathGeo::Invert::kYes));
+        rrectPathGeos.emplace_back(new RRectPathGeo(rectPath, rr,
+                                                    RRectPathGeo::RRectForStroke::kYes,
+                                                    PathGeo::Invert::kNo));
     }
 
-    struct TestPath {
-        TestPath(const SkPath& path, bool isRRectFill, bool isRRectStroke, bool isLine,
-                 const SkRRect& rrect)
-            : fPath(path)
-            , fIsRRectForFill(isRRectFill)
-            , fIsRRectForStroke(isRRectStroke)
-            , fIsLine(isLine)
-            , fRRect(rrect) {}
-        SkPath  fPath;
-        bool    fIsRRectForFill;
-        bool    fIsRRectForStroke;
-        bool    fIsLine;
-        SkRRect fRRect;
-    };
-    SkTArray<TestPath> paths;
-
-    SkPath circlePath;
-    circlePath.addCircle(10, 10, 10);
-    paths.emplace_back(circlePath, true, true, false, SkRRect::MakeOval(SkRect::MakeWH(20,20)));
-
-    SkPath rectPath;
-    rectPath.addRect(SkRect::MakeWH(10, 10));
-    paths.emplace_back(rectPath, true, true, false, SkRRect::MakeRect(SkRect::MakeWH(10, 10)));
-
     SkPath openRectPath;
     openRectPath.moveTo(0, 0);
     openRectPath.lineTo(10, 0);
     openRectPath.lineTo(10, 10);
     openRectPath.lineTo(0, 10);
-    paths.emplace_back(openRectPath, true, false, false, SkRRect::MakeRect(SkRect::MakeWH(10, 10)));
+    geos.emplace_back(new RRectPathGeo(openRectPath, SkRect::MakeWH(10, 10),
+                                       RRectPathGeo::RRectForStroke::kNo, PathGeo::Invert::kNo));
+    geos.emplace_back(new RRectPathGeo(openRectPath, SkRect::MakeWH(10, 10),
+                                       RRectPathGeo::RRectForStroke::kNo, PathGeo::Invert::kYes));
+    rrectPathGeos.emplace_back(new RRectPathGeo(openRectPath, SkRect::MakeWH(10, 10),
+                                                RRectPathGeo::RRectForStroke::kNo,
+                                                PathGeo::Invert::kNo));
 
     SkPath quadPath;
     quadPath.quadTo(10, 10, 5, 8);
-    paths.emplace_back(quadPath, false, false, false, SkRRect());
+    geos.emplace_back(new PathGeo(quadPath, PathGeo::Invert::kNo));
+    geos.emplace_back(new PathGeo(quadPath, PathGeo::Invert::kYes));
 
     SkPath linePath;
     linePath.lineTo(10, 10);
-    paths.emplace_back(linePath, false, false, true, SkRRect());
+    geos.emplace_back(new PathGeo(linePath, PathGeo::Invert::kNo));
+    geos.emplace_back(new PathGeo(linePath, PathGeo::Invert::kYes));
 
     // Horizontal and vertical paths become rrects when stroked.
     SkPath vLinePath;
     vLinePath.lineTo(0, 10);
-    paths.emplace_back(vLinePath, false, false, true, SkRRect());
+    geos.emplace_back(new PathGeo(vLinePath, PathGeo::Invert::kNo));
+    geos.emplace_back(new PathGeo(vLinePath, PathGeo::Invert::kYes));
 
     SkPath hLinePath;
     hLinePath.lineTo(10, 0);
-    paths.emplace_back(hLinePath, false, false, true, SkRRect());
+    geos.emplace_back(new PathGeo(hLinePath, PathGeo::Invert::kNo));
+    geos.emplace_back(new PathGeo(hLinePath, PathGeo::Invert::kYes));
 
-    for (auto testPath : paths) {
-        for (bool inverseFill : {false, true}) {
-            if (inverseFill) {
-                if (testPath.fPath.getFillType() == SkPath::kEvenOdd_FillType) {
-                    testPath.fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
-                } else {
-                    SkASSERT(testPath.fPath.getFillType() == SkPath::kWinding_FillType);
-                    testPath.fPath.setFillType(SkPath::kInverseWinding_FillType);
-                }
-            }
-            const SkPath& path = testPath.fPath;
-            test_basic(reporter, path);
-            test_null_dash(reporter, path);
-            test_path_effect_makes_rrect(reporter, path);
-            test_scale(reporter, path);
-            // This test uses a stroking paint, hence use of fIsRRectForStroke
-            test_volatile_path(reporter, path, testPath.fIsRRectForStroke || testPath.fIsLine);
-            test_dash_fill(reporter, path);
-            // Test modifying various stroke params.
-            test_stroke_param<SkPath, SkScalar>(
-                reporter, path,
+    for (int i = 0; i < geos.count(); ++i) {
+        test_basic(reporter, *geos[i]);
+        test_scale(reporter, *geos[i]);
+        test_dash_fill(reporter, *geos[i]);
+        test_null_dash(reporter, *geos[i]);
+        // Test modifying various stroke params.
+        test_stroke_param<SkScalar>(
+                reporter, *geos[i],
                 [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);},
                 SkIntToScalar(2), SkIntToScalar(4));
-            test_stroke_join(reporter, path);
-            test_stroke_cap(reporter, path);
-            test_miter_limit(reporter, path);
-            test_unknown_path_effect(reporter, path);
-            test_path_effect_makes_empty_shape(reporter, path);
-            test_path_effect_fails(reporter, path);
-            test_make_hairline_path_effect(reporter, path, testPath.fIsRRectForStroke ||
-                                                           testPath.fIsLine);
-        }
+        test_stroke_join(reporter, *geos[i]);
+        test_stroke_cap(reporter, *geos[i]);
+        test_miter_limit(reporter, *geos[i]);
+        test_path_effect_makes_rrect(reporter, *geos[i]);
+        test_unknown_path_effect(reporter, *geos[i]);
+        test_path_effect_makes_empty_shape(reporter, *geos[i]);
+        test_path_effect_fails(reporter, *geos[i]);
+        test_make_hairline_path_effect(reporter, *geos[i]);
+        test_volatile_path(reporter, *geos[i]);
     }
 
-    for (auto testPath : paths) {
-        const SkPath& path = testPath.fPath;
-
+    for (int i = 0; i < rrectPathGeos.count(); ++i) {
+        const RRectPathGeo& rrgeo = *rrectPathGeos[i];
         SkPaint fillPaint;
-        TestCase fillPathCase(path, fillPaint, reporter);
+        TestCase fillPathCase(reporter, rrgeo.path(), fillPaint);
         SkRRect rrect;
-        REPORTER_ASSERT(reporter, testPath.fIsRRectForFill ==
+        REPORTER_ASSERT(reporter, rrgeo.isNonPath(fillPaint) ==
                                   fillPathCase.baseShape().asRRect(&rrect, nullptr, nullptr,
                                                                    nullptr));
-        if (testPath.fIsRRectForFill) {
-            TestCase fillPathCase2(testPath.fPath, fillPaint, reporter);
-            REPORTER_ASSERT(reporter, rrect == testPath.fRRect);
-            TestCase fillRRectCase(rrect, fillPaint, reporter);
+        if (rrgeo.isNonPath(fillPaint)) {
+            TestCase fillPathCase2(reporter, rrgeo.path(), fillPaint);
+            REPORTER_ASSERT(reporter, rrect == rrgeo.rrect());
+            TestCase fillRRectCase(reporter, rrect, fillPaint);
             fillPathCase2.compare(reporter, fillRRectCase,
                                   TestCase::kAllSame_ComparisonExpecation);
         }
         SkPaint strokePaint;
         strokePaint.setStrokeWidth(3.f);
         strokePaint.setStyle(SkPaint::kStroke_Style);
-        TestCase strokePathCase(path, strokePaint, reporter);
-        if (testPath.fIsRRectForStroke) {
+        TestCase strokePathCase(reporter, rrgeo.path(), strokePaint);
+        if (rrgeo.isNonPath(strokePaint)) {
             REPORTER_ASSERT(reporter, strokePathCase.baseShape().asRRect(&rrect, nullptr, nullptr,
                                                                          nullptr));
-        }
-
-        if (testPath.fIsRRectForStroke) {
-            REPORTER_ASSERT(reporter, rrect == testPath.fRRect);
-            TestCase strokeRRectCase(rrect, strokePaint, reporter);
+            REPORTER_ASSERT(reporter, rrect == rrgeo.rrect());
+            TestCase strokeRRectCase(reporter, rrect, strokePaint);
             strokePathCase.compare(reporter, strokeRRectCase,
                                    TestCase::kAllSame_ComparisonExpecation);
         }
     }
 
     // Test a volatile empty path.
-    test_volatile_path(reporter, SkPath(), true);
+    test_volatile_path(reporter, PathGeo(SkPath(), PathGeo::Invert::kNo));
 
     test_empty_shape(reporter);
 
     test_lines(reporter);
 
     test_stroked_lines(reporter);
 }
 
 #endif