Add some more testing around hairline GrShapes

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 239 matching lines @@
                      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, reporter);
     // Since hairline style doesn't change the SkPath data, it is keyed identically to fill.
     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, 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);
@@ skipping 187 matching lines @@
             dst->growToInclude(0, 0);
             dst->growToInclude(10, 10);
         }
         static sk_sp<SkPathEffect> Make() { return sk_sp<SkPathEffect>(new AddLineTosPathEffect); }
         Factory getFactory() const override { return nullptr; }
         void toString(SkString*) const override {}
     private:
         AddLineTosPathEffect() {}
     };
 
-     // This path effect should make the keys invalid when it is applied. We only produce a pathe
+     // This path effect should make the keys invalid when it is applied. We only produce a path
      // effect key for dash path effects. So the only way another arbitrary path effect can produce
      // 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, 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) {
+    /**
+     * 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;
+        }
+        void computeFastBounds(SkRect* dst, const SkRect& src) const override {  *dst = src; }
+        static sk_sp<SkPathEffect> Make() {
+            return sk_sp<SkPathEffect>(new MakeHairlinePathEffect);
+        }
+        Factory getFactory() const override { return nullptr; }
+        void toString(SkString*) const override {}
+    private:
+        MakeHairlinePathEffect() {}
+    };
+
+    SkPaint fill;
+    SkPaint pe;
+    pe.setPathEffect(MakeHairlinePathEffect::Make());
+
+    TestCase peCase(geo, pe, reporter);
+
+    SkPath a, b;
+    peCase.baseShape().asPath(&a);
+    peCase.appliedPathEffectShape().asPath(&b);
+    REPORTER_ASSERT(reporter, a == b);
+    peCase.appliedFullStyleShape().asPath(&b);
+    REPORTER_ASSERT(reporter, a == b);
+    REPORTER_ASSERT(reporter, peCase.appliedPathEffectShape().style().isSimpleHairline());
+    REPORTER_ASSERT(reporter, peCase.appliedFullStyleShape().style().isSimpleHairline());
+    if (isNonPath) {
+        REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey() == peCase.baseKey());
+        REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey() == peCase.baseKey());
+    } else {
+        REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey().empty());
+        REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey().empty());
+    }
+}
+
 /**
  * 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;
@@ skipping 124 matching lines @@
                           [](SkPaint* p, SkPaint::Cap c) { p->setStrokeCap(c);},
                           SkPaint::kButt_Cap, SkPaint::kRound_Cap);
         test_stroke_param<SkRRect, SkPaint::Join>(
                           reporter, rr,
                           [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
                           SkPaint::kMiter_Join, SkPaint::kRound_Join);
         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_make_hairline_path_effect(reporter, rr, true);
     }
 
     struct TestPath {
         TestPath(const SkPath& path, bool isRRectFill, bool isRRectStroke ,const SkRRect& rrect)
             : fPath(path)
             , fIsRRectForFill(isRRectFill)
             , fIsRRectForStroke(isRRectStroke)
             , fRRect(rrect) {}
         SkPath  fPath;
         bool    fIsRRectForFill;
@@ skipping 43 matching lines @@
             reporter, path,
             [](SkPaint* p, SkPaint::Cap c) { p->setStrokeCap(c);},
             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);
+        test_make_hairline_path_effect(reporter, path, testPath.fIsRRectForStroke);
 
         SkPaint 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, reporter);
             fillPathCase.compare(reporter, fillRRectCase, TestCase::kAllSame_ComparisonExpecation);
@@ skipping 13 matching lines @@
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif