Make SkDashPathEffect fail for stroke+fill style (in addition to fill style)

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 372 matching lines @@
     expectations.fPEHasEffect = false;
     expectations.fStrokeApplies = true;
     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 = true;
+    expectations.fPEHasEffect = false;
     expectations.fStrokeApplies = true;
     stroke2RoundBevelAndFillDashCase.testExpectations(reporter, expectations);
     TestCase(geo, stroke2RoundBevelAndFillDash, reporter).compare(
         reporter, stroke2RoundBevelAndFillDashCase, TestCase::kAllSame_ComparisonExpecation);
-
-    stroke2RoundBevelAndFillCase.compare(reporter, stroke2RoundBevelCase,
-                                         TestCase::kSameUpToStroke_ComparisonExpecation);
-    stroke2RoundBevelAndFillDashCase.compare(reporter, stroke2RoundBevelDashCase,
-                                             TestCase::kSameUpToStroke_ComparisonExpecation);
-    stroke2RoundBevelAndFillCase.compare(reporter, stroke2RoundBevelAndFillDashCase,
-                                         TestCase::kSameUpToPE_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.
     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());
@@ skipping 33 matching lines @@
     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. 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, nullptr, nullptr)) {
         // We currently only expect to get here in the rect->rect case.
         REPORTER_ASSERT(reporter, rrect.isRect());
         REPORTER_ASSERT(reporter,
                         strokeAndFillCase1.baseShape().asRRect(&rrect, nullptr, nullptr) &&
                         rrect.isRect());
         strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
                                    TestCase::kAllSame_ComparisonExpecation);
     } else {
         strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
                                    TestCase::kSameUpToStroke_ComparisonExpecation);
+        strokeAndFillDashCase1.compare(reporter, strokeAndFillDashCase2,
+                                       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);
+    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,
                                    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;
@@ skipping 40 matching lines @@
     SkPaint dashA = strokeA, dashB = strokeB;
     dashA.setPathEffect(make_dash());
     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);
     }
-
-    SkPaint dashStrokeAndFillA = dashA, dashStrokeAndFillB = dashB;
-    dashStrokeAndFillA.setStyle(SkPaint::kStrokeAndFill_Style);
-    dashStrokeAndFillB.setStyle(SkPaint::kStrokeAndFill_Style);
-    TestCase dashStrokeAndFillACase(geo, dashStrokeAndFillA, reporter);
-    TestCase dashStrokeAndFillBCase(geo, dashStrokeAndFillB, reporter);
-    if (paramAffectsDashAndStroke) {
-        dashStrokeAndFillACase.compare(reporter, dashStrokeAndFillBCase,
-                                       TestCase::kSameUpToStroke_ComparisonExpecation);
-    } else {
-        dashStrokeAndFillACase.compare(reporter, dashStrokeAndFillBCase,
-                                       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) {
     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) {
@@ skipping 579 matching lines @@
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif