Expand GrStyle's interface.

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 14 matching lines @@
     key->reset(size);
     shape.writeUnstyledKey(key->begin());
     return true;
 }
 
 namespace {
 
 class TestCase {
 public:
     template <typename GEO>
-    TestCase(const GEO& geo, const SkPaint& paint) : fBase(geo, paint) {
-        this->init();
+    TestCase(const GEO& geo, const SkPaint& paint, skiatest::Reporter* r) : fBase(geo, paint) {
+        this->init(r);
     }
 
     struct SelfExpectations {
         bool fPEHasEffect;
         bool fPEHasValidKey;
         bool fStrokeApplies;
     };
 
     void testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const;
 
@@ skipping 10 matching lines @@
     const GrShape& appliedPathEffectShape() const { return fAppliedPE; }
     const GrShape& appliedFullStyleShape() const { return fAppliedFull; }
 
     // The returned array's count will be 0 if the key shape has no key.
     const Key& baseKey() const { return fBaseKey; }
     const Key& appliedPathEffectKey() const { return fAppliedPEKey; }
     const Key& appliedFullStyleKey() const { return fAppliedFullKey; }
     const Key& appliedPathEffectThenStrokeKey() const { return fAppliedPEThenStrokeKey; }
 
 private:
-    void init() {
-        fAppliedPE           = fBase.applyPathEffect();
-        fAppliedPEThenStroke = fAppliedPE.applyFullStyle();
-        fAppliedFull         = fBase.applyFullStyle();
+    void init(skiatest::Reporter* r) {
+        fAppliedPE           = fBase.applyStyle(GrStyle::Apply::kPathEffectOnly);
+        fAppliedPEThenStroke = fAppliedPE.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec);
+        fAppliedFull         = fBase.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec);
 
         make_key(&fBaseKey, fBase);
         make_key(&fAppliedPEKey, fAppliedPE);
         make_key(&fAppliedPEThenStrokeKey, fAppliedPEThenStroke);
         make_key(&fAppliedFullKey, fAppliedFull);
+
+        // Applying the path effect and then the stroke should always be the same as applying
+        // both in one go.
+        REPORTER_ASSERT(r, fAppliedPEThenStrokeKey == fAppliedFullKey);
+        SkPath a, b;
+        fAppliedPEThenStroke.asPath(&a);
+        fAppliedFull.asPath(&b);
+        REPORTER_ASSERT(r, a == b);
+
+        // Check that the same path is produced when style is applied by GrShape and GrStyle.
+        SkPath preStyle;
+        SkPath postPathEffect;
+        SkPath postAllStyle;
+
+        fBase.asPath(&preStyle);
+        SkStrokeRec postPathEffectStrokeRec(SkStrokeRec::kFill_InitStyle);
+        if (fBase.style().applyPathEffectToPath(&postPathEffect, &postPathEffectStrokeRec,
+                                                preStyle)) {
+            SkPath testPath;
+            fAppliedPE.asPath(&testPath);
+            REPORTER_ASSERT(r, testPath == postPathEffect);
+            REPORTER_ASSERT(r,
+                            postPathEffectStrokeRec.hasEqualEffect(fAppliedPE.style().strokeRec()));
+        }
+        SkStrokeRec::InitStyle fillOrHairline;
+        if (fBase.style().applyToPath(&postAllStyle, &fillOrHairline, preStyle)) {
+            SkPath testPath;
+            fAppliedFull.asPath(&testPath);
+            REPORTER_ASSERT(r, testPath == postAllStyle);
+            if (fillOrHairline == SkStrokeRec::kFill_InitStyle) {
+                REPORTER_ASSERT(r, fAppliedFull.style().isSimpleFill());
+            } else {
+                REPORTER_ASSERT(r, fAppliedFull.style().isSimpleHairline());
+            }
+        }
     }
 
     GrShape fBase;
     GrShape fAppliedPE;
     GrShape fAppliedPEThenStroke;
     GrShape fAppliedFull;
 
     Key fBaseKey;
     Key fAppliedPEKey;
     Key fAppliedPEThenStrokeKey;
     Key fAppliedFullKey;
 
 };
 
 void TestCase::testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const {
-    // Applying the path effect and then the stroke should always be the same as applying
-    // both in one go.
-    REPORTER_ASSERT(reporter, fAppliedPEThenStrokeKey == fAppliedFullKey);
-    SkPath a, b;
-    fAppliedPEThenStroke.asPath(&a);
-    fAppliedFull.asPath(&b);
-    REPORTER_ASSERT(reporter, a == b);
     // The base's key should always be valid (unless the path is volatile)
     REPORTER_ASSERT(reporter, fBaseKey.count());
     if (expectations.fPEHasEffect) {
         REPORTER_ASSERT(reporter, fBaseKey != fAppliedPEKey);
         REPORTER_ASSERT(reporter, expectations.fPEHasValidKey == SkToBool(fAppliedPEKey.count()));
         REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey);
         REPORTER_ASSERT(reporter, expectations.fPEHasValidKey == SkToBool(fAppliedFullKey.count()));
         if (expectations.fStrokeApplies && expectations.fPEHasValidKey) {
             REPORTER_ASSERT(reporter, fAppliedPEKey != fAppliedFullKey);
             REPORTER_ASSERT(reporter, SkToBool(fAppliedFullKey.count()));
         }
     } else {
         REPORTER_ASSERT(reporter, fBaseKey == fAppliedPEKey);
+        SkPath a, b;
         fBase.asPath(&a);
         fAppliedPE.asPath(&b);
         REPORTER_ASSERT(reporter, a == b);
         if (expectations.fStrokeApplies) {
             REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey);
         } else {
             REPORTER_ASSERT(reporter, fBaseKey == fAppliedFullKey);
         }
     }
 }
@@ skipping 55 matching lines @@
     return SkDashPathEffect::Make(kNullIntervals, SK_ARRAY_COUNT(kNullIntervals), 0.f);
 }
 
 template<typename 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);
+    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).compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
+    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);
+    TestCase stroke2RoundBevelCase(geo, stroke2RoundBevel, reporter);
     expectations.fPEHasValidKey = true;
     expectations.fPEHasEffect = false;
     expectations.fStrokeApplies = true;
     stroke2RoundBevelCase.testExpectations(reporter, expectations);
-    TestCase(geo, stroke2RoundBevel).compare(reporter, stroke2RoundBevelCase,
-                                             TestCase::kAllSame_ComparisonExpecation);
+    TestCase(geo, stroke2RoundBevel, reporter).compare(reporter, stroke2RoundBevelCase,
+                                                       TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint stroke2RoundBevelDash = stroke2RoundBevel;
     stroke2RoundBevelDash.setPathEffect(make_dash());
-    TestCase stroke2RoundBevelDashCase(geo, stroke2RoundBevelDash);
+    TestCase stroke2RoundBevelDashCase(geo, stroke2RoundBevelDash, reporter);
     expectations.fPEHasValidKey = true;
     expectations.fPEHasEffect = true;
     expectations.fStrokeApplies = true;
     stroke2RoundBevelDashCase.testExpectations(reporter, expectations);
-    TestCase(geo, stroke2RoundBevelDash).compare(reporter, stroke2RoundBevelDashCase,
-                                                 TestCase::kAllSame_ComparisonExpecation);
+    TestCase(geo, stroke2RoundBevelDash, reporter).compare(reporter, stroke2RoundBevelDashCase,
+                                                           TestCase::kAllSame_ComparisonExpecation);
 
     fillCase.compare(reporter, stroke2RoundBevelCase,
                      TestCase::kSameUpToStroke_ComparisonExpecation);
     fillCase.compare(reporter, stroke2RoundBevelDashCase,
                      TestCase::kSameUpToPE_ComparisonExpecation);
     stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase,
                                   TestCase::kSameUpToPE_ComparisonExpecation);
 
     SkPaint hairline;
     hairline.setStyle(SkPaint::kStroke_Style);
     hairline.setStrokeWidth(0.f);
-    TestCase hairlineCase(geo, hairline);
+    TestCase hairlineCase(geo, hairline, reporter);
     // Since hairline style doesn't change the SkPath data, it is keyed identically to fill.
     hairlineCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
 }
 
 template <typename GEO, typename T>
 static void test_stroke_param(skiatest::Reporter* reporter, const GEO& geo,
                               std::function<void(SkPaint*, T)> setter, T a, T b) {
     // Set the stroke width so that we don't get hairline. However, call the function second so that
     // it can override.
     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);
-    TestCase strokeBCase(geo, strokeB);
+    TestCase strokeACase(geo, strokeA, reporter);
+    TestCase strokeBCase(geo, strokeB, reporter);
     strokeACase.compare(reporter, strokeBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
 
     // Make sure stroking params don't affect fill style.
     SkPaint fillA = strokeA, fillB = strokeB;
     fillA.setStyle(SkPaint::kFill_Style);
     fillB.setStyle(SkPaint::kFill_Style);
-    TestCase fillACase(geo, fillA);
-    TestCase fillBCase(geo, fillB);
+    TestCase fillACase(geo, fillA, reporter);
+    TestCase fillBCase(geo, fillB, reporter);
     fillACase.compare(reporter, fillBCase, TestCase::kAllSame_ComparisonExpecation);
 
     // Make sure just applying the dash but not stroke gives the same key for both stroking
     // variations.
     SkPaint dashA = strokeA, dashB = strokeB;
     dashA.setPathEffect(make_dash());
     dashB.setPathEffect(make_dash());
-    TestCase dashACase(geo, dashA);
-    TestCase dashBCase(geo, dashB);
+    TestCase dashACase(geo, dashA, reporter);
+    TestCase dashBCase(geo, dashB, reporter);
     dashACase.compare(reporter, dashBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
 }
 
 template <typename GEO>
 static void test_miter_limit(skiatest::Reporter* reporter, const GEO& geo) {
     // Miter limit should only matter when stroking with miter joins. It shouldn't affect other
     // joins or fills.
     SkPaint miterA;
     miterA.setStyle(SkPaint::kStroke_Style);
     miterA.setStrokeWidth(2.f);
     miterA.setStrokeJoin(SkPaint::kMiter_Join);
     miterA.setStrokeMiter(0.5f);
     SkPaint miterB = miterA;
     miterA.setStrokeMiter(0.6f);
 
-    TestCase miterACase(geo, miterA);
-    TestCase miterBCase(geo, miterB);
+    TestCase miterACase(geo, miterA, reporter);
+    TestCase miterBCase(geo, miterB, reporter);
     miterACase.compare(reporter, miterBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
 
     SkPaint noMiterA = miterA, noMiterB = miterB;
     noMiterA.setStrokeJoin(SkPaint::kRound_Join);
     noMiterB.setStrokeJoin(SkPaint::kRound_Join);
-    TestCase noMiterACase(geo, noMiterA);
-    TestCase noMiterBCase(geo, noMiterB);
+    TestCase noMiterACase(geo, noMiterA, reporter);
+    TestCase noMiterBCase(geo, noMiterB, reporter);
     noMiterACase.compare(reporter, noMiterBCase, TestCase::kAllSame_ComparisonExpecation);
 
     SkPaint fillA = miterA, fillB = miterB;
     fillA.setStyle(SkPaint::kFill_Style);
     fillB.setStyle(SkPaint::kFill_Style);
-    TestCase fillACase(geo, fillA);
-    TestCase fillBCase(geo, fillB);
+    TestCase fillACase(geo, fillA, reporter);
+    TestCase fillBCase(geo, fillB, reporter);
     fillACase.compare(reporter, fillBCase, TestCase::kAllSame_ComparisonExpecation);
 }
 
 template<typename 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);
+        TestCase dashFillCase(geo, dashFill, reporter);
 
-        TestCase fillCase(geo, SkPaint());
+        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) {
     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);
-    TestCase strokeCase(geo, stroke);
-    TestCase dashCase(geo, dash);
-    TestCase nullDashCase(geo, nullDash);
+    TestCase fillCase(geo, fill, reporter);
+    TestCase strokeCase(geo, stroke, reporter);
+    TestCase dashCase(geo, dash, reporter);
+    TestCase nullDashCase(geo, nullDash, reporter);
 
     nullDashCase.compare(reporter, fillCase, TestCase::kSameUpToStroke_ComparisonExpecation);
     nullDashCase.compare(reporter, strokeCase, TestCase::kAllSame_ComparisonExpecation);
     nullDashCase.compare(reporter, dashCase, TestCase::kSameUpToPE_ComparisonExpecation);
 }
 
 template <typename 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
@@ skipping 16 matching lines @@
             *dst = RRect().getBounds();
         }
         static sk_sp<SkPathEffect> Make() { return sk_sp<SkPathEffect>(new RRectPathEffect); }
         Factory getFactory() const override { return nullptr; }
         void toString(SkString*) const override {}
     private:
         RRectPathEffect() {}
     };
 
     SkPaint fill;
-    TestCase fillGeoCase(geo, fill);
+    TestCase fillGeoCase(geo, fill, reporter);
 
     SkPaint pe;
     pe.setPathEffect(RRectPathEffect::Make());
-    TestCase geoPECase(geo, pe);
+    TestCase geoPECase(geo, pe, reporter);
 
     SkPaint peStroke;
     peStroke.setPathEffect(RRectPathEffect::Make());
     peStroke.setStrokeWidth(2.f);
     peStroke.setStyle(SkPaint::kStroke_Style);
-    TestCase geoPEStrokeCase(geo, peStroke);
+    TestCase geoPEStrokeCase(geo, peStroke, reporter);
 
     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);
+    TestCase rrectFillCase(RRectPathEffect::RRect(), fill, reporter);
     SkPaint stroke = peStroke;
     stroke.setPathEffect(nullptr);
-    TestCase rrectStrokeCase(RRectPathEffect::RRect(), stroke);
+    TestCase rrectStrokeCase(RRectPathEffect::RRect(), stroke, reporter);
 
     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));
     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectKey() == rrectFillCase.baseKey());
 
     REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleShape().asRRect(&rrect));
     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
@@ skipping 35 matching lines @@
         AddLineTosPathEffect() {}
     };
 
      // This path effect should make the keys invalid when it is applied. We only produce a pathe
      // effect key for dash path effects. So the only way another arbitrary path effect can produce
      // a styled result with a key is to produce a non-path shape that has a purely geometric key.
     SkPaint peStroke;
     peStroke.setPathEffect(AddLineTosPathEffect::Make());
     peStroke.setStrokeWidth(2.f);
     peStroke.setStyle(SkPaint::kStroke_Style);
-    TestCase geoPEStrokeCase(geo, peStroke);
+    TestCase geoPEStrokeCase(geo, peStroke, reporter);
     TestCase::SelfExpectations expectations;
     expectations.fPEHasEffect = true;
     expectations.fPEHasValidKey = false;
     expectations.fStrokeApplies = true;
     geoPEStrokeCase.testExpectations(reporter, expectations);
 }
 
 /**
  * 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);
     vPath.setIsVolatile(true);
 
     SkPaint dashAndStroke;
     dashAndStroke.setPathEffect(make_dash());
     dashAndStroke.setStrokeWidth(2.f);
     dashAndStroke.setStyle(SkPaint::kStroke_Style);
-    TestCase volatileCase(vPath, dashAndStroke);
+    TestCase volatileCase(vPath, dashAndStroke, reporter);
     // We expect a shape made from a volatile path to have a key iff the shape is recognized
     // as a specialized geometry.
     if (isNonPath) {
         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);
+        TestCase nonVolatileCase(path, dashAndStroke, reporter);
         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 19 matching lines @@
         EmptyPathEffect() {}
     };
 
     SkPath emptyPath;
     GrShape emptyShape(emptyPath);
     Key emptyKey;
     make_key(&emptyKey, emptyShape);
 
     SkPaint pe;
     pe.setPathEffect(EmptyPathEffect::Make());
-    TestCase geoCase(geo, pe);
+    TestCase geoCase(geo, pe, reporter);
     REPORTER_ASSERT(reporter, geoCase.appliedFullStyleKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoCase.appliedPathEffectKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoCase.appliedPathEffectThenStrokeKey() == emptyKey);
 
     SkPaint peStroke;
     peStroke.setPathEffect(EmptyPathEffect::Make());
     peStroke.setStrokeWidth(2.f);
     peStroke.setStyle(SkPaint::kStroke_Style);
-    TestCase geoPEStrokeCase(geo, peStroke);
+    TestCase geoPEStrokeCase(geo, peStroke, reporter);
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectThenStrokeKey() == emptyKey);
 }
 
 void test_empty_shape(skiatest::Reporter* reporter) {
     SkPath emptyPath;
     SkPaint fill;
-    TestCase fillEmptyCase(emptyPath, fill);
+    TestCase fillEmptyCase(emptyPath, fill, reporter);
 
     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);
+    TestCase strokeEmptyCase(emptyPath2, stroke, reporter);
     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);
+    TestCase dashAndStrokeEmptyCase(emptyPath3, dashAndStroke, reporter);
     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);
+    TestCase dashAndStrokeEmptyRRectCase(emptyRRect, dashAndStroke, reporter);
     dashAndStrokeEmptyRRectCase.compare(reporter, fillEmptyCase,
                                         TestCase::kAllSame_ComparisonExpecation);
 
     // Same for a rect.
     SkRect emptyRect = SkRect::MakeEmpty();
-    TestCase dashAndStrokeEmptyRectCase(emptyRect, dashAndStroke);
+    TestCase dashAndStrokeEmptyRectCase(emptyRect, dashAndStroke, reporter);
     dashAndStrokeEmptyRectCase.compare(reporter, fillEmptyCase,
                                        TestCase::kAllSame_ComparisonExpecation);
 }
 
 DEF_TEST(GrShape, reporter) {
     sk_sp<SkPathEffect> dashPE = make_dash();
 
     for (auto rr : { SkRRect::MakeRect(SkRect::MakeWH(10, 10)),
                      SkRRect::MakeRectXY(SkRect::MakeWH(10, 10), 3, 4)}) {
         test_basic(reporter, rr);
@@ skipping 74 matching lines @@
             SkPaint::kButt_Cap, SkPaint::kRound_Cap);
         test_stroke_param<SkPath, SkPaint::Join>(
             reporter, path,
             [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
             SkPaint::kMiter_Join, SkPaint::kRound_Join);
         test_miter_limit(reporter, path);
         test_unknown_path_effect(reporter, path);
         test_path_effect_makes_empty_shape(reporter, path);
 
         SkPaint fillPaint;
-        TestCase fillPathCase(path, fillPaint);
+        TestCase fillPathCase(path, fillPaint, reporter);
         SkRRect rrect;
         REPORTER_ASSERT(reporter, testPath.fIsRRectForFill ==
                                   fillPathCase.baseShape().asRRect(&rrect));
         if (testPath.fIsRRectForFill) {
             REPORTER_ASSERT(reporter, rrect == testPath.fRRect);
-            TestCase fillRRectCase(rrect, fillPaint);
+            TestCase fillRRectCase(rrect, fillPaint, reporter);
             fillPathCase.compare(reporter, fillRRectCase, TestCase::kAllSame_ComparisonExpecation);
         }
 
         SkPaint strokePaint;
         strokePaint.setStrokeWidth(3.f);
         strokePaint.setStyle(SkPaint::kStroke_Style);
-        TestCase strokePathCase(path, strokePaint);
+        TestCase strokePathCase(path, strokePaint, reporter);
         REPORTER_ASSERT(reporter, testPath.fIsRRectForStroke ==
                                   strokePathCase.baseShape().asRRect(&rrect));
         if (testPath.fIsRRectForStroke) {
             REPORTER_ASSERT(reporter, rrect == testPath.fRRect);
-            TestCase strokeRRectCase(rrect, strokePaint);
+            TestCase strokeRRectCase(rrect, strokePaint, reporter);
             strokePathCase.compare(reporter, strokeRRectCase,
                                  TestCase::kAllSame_ComparisonExpecation);
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif