Incorporate scale into GrStyle and GrShape

tests/GrShapeTest.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <initializer_list>
 #include <functional>
 #include "Test.h"
@@ skipping 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, skiatest::Reporter* r) : fBase(geo, paint) {
-        this->init(r);
+    TestCase(const GEO& geo, const SkPaint& paint, skiatest::Reporter* r,
+             SkScalar scale = SK_Scalar1) : fBase(geo, paint) {
+        this->init(r, scale);
     }
 
     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(skiatest::Reporter* r) {
-        fAppliedPE           = fBase.applyStyle(GrStyle::Apply::kPathEffectOnly);
-        fAppliedPEThenStroke = fAppliedPE.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec);
-        fAppliedFull         = fBase.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec);
+    void init(skiatest::Reporter* r, SkScalar scale) {
+        fAppliedPE           = fBase.applyStyle(GrStyle::Apply::kPathEffectOnly, scale);
+        fAppliedPEThenStroke = fAppliedPE.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec,
+                                                     scale);
+        fAppliedFull         = fBase.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, scale);
 
         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 postPEStrokeRec(SkStrokeRec::kFill_InitStyle);
-        if (fBase.style().applyPathEffectToPath(&postPathEffect, &postPEStrokeRec, preStyle)) {
+        if (fBase.style().applyPathEffectToPath(&postPathEffect, &postPEStrokeRec, preStyle,
+                                                scale)) {
             // run postPathEffect through GrShape to get any geometry reductions that would have
             // occurred to fAppliedPE.
             GrShape(postPathEffect, GrStyle(postPEStrokeRec, nullptr)).asPath(&postPathEffect);
 
             SkPath testPath;
             fAppliedPE.asPath(&testPath);
             REPORTER_ASSERT(r, testPath == postPathEffect);
             REPORTER_ASSERT(r, postPEStrokeRec.hasEqualEffect(fAppliedPE.style().strokeRec()));
         }
         SkStrokeRec::InitStyle fillOrHairline;
-        if (fBase.style().applyToPath(&postAllStyle, &fillOrHairline, preStyle)) {
+        if (fBase.style().applyToPath(&postAllStyle, &fillOrHairline, preStyle, scale)) {
             // run postPathEffect through GrShape to get any reductions that would have occurred
             // to fAppliedFull.
             GrShape(postAllStyle, GrStyle(fillOrHairline)).asPath(&postAllStyle);
 
             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 {
     // 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()));
@@ skipping 150 matching lines @@
     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>
+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.
+    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);
+    // Scale affects the stroke. Though, this can wind up creating a rect when the input is a rect.
+    // In that case we wind up with a pure geometry key and the geometries are the same.
+    SkRRect rrect;
+    if (strokeAndFillCase1.appliedFullStyleShape().asRRect(&rrect)) {
+        // We currently only expect to get here in the rect->rect case.
+        REPORTER_ASSERT(reporter, rrect.isRect());
+        REPORTER_ASSERT(reporter, strokeAndFillCase1.baseShape().asRRect(&rrect) && rrect.isRect());
+        strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
+                                   TestCase::kAllSame_ComparisonExpecation);
+    } else {
+        strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
+                                   TestCase::kSameUpToStroke_ComparisonExpecation);
+    }
+
+    SkPaint strokeAndFillDash = strokeDash;
+    strokeAndFillDash.setStyle(SkPaint::kStrokeAndFill_Style);
+    TestCase strokeAndFillDashCase1(geo, strokeAndFillDash, reporter, kS1);
+    TestCase strokeAndFillDashCase2(geo, strokeAndFillDash, reporter, kS2);
+    // Scale affects the path effect and stroke.
+    strokeAndFillDashCase1.compare(reporter, strokeAndFillDashCase2,
+                               TestCase::kSameUpToPE_ComparisonExpecation);
+}
+
 template <typename GEO, 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);
@@ skipping 432 matching lines @@
     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);
+        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_param<SkRRect, SkPaint::Join>(
                           reporter, rr,
                           [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
@@ skipping 41 matching lines @@
     for (auto testPath : paths) {
         const SkPath& path = testPath.fPath;
         // These tests all assume that the original GrShape for fill and stroke will be the same.
         // However, that is not the case in special cases (e.g. a unclosed rect becomes a RRect
         // GrShape with a fill style but becomes a Path GrShape when stroked).
         if (testPath.fIsRRectForFill == testPath.fIsRRectForStroke) {
             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);
         test_dash_fill(reporter, path);
         // Test modifying various stroke params.
         test_stroke_param<SkPath, SkScalar>(
             reporter, path,
             [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);},
             SkIntToScalar(2), SkIntToScalar(4));
         test_stroke_param<SkPath, SkPaint::Join>(
             reporter, path,
@@ skipping 30 matching lines @@
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif