Make GrShape use the original path when path effect fails.

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 874 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) {
+    /**
+     * This path effect returns an empty path.
+     */
+    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 {
+            *dst = src;
+        }
+        static sk_sp<SkPathEffect> Make() { return sk_sp<SkPathEffect>(new FailurePathEffect); }
+        Factory getFactory() const override { return nullptr; }
+        void toString(SkString*) const override {}
+    private:
+        FailurePathEffect() {}
+    };
+
+    SkPaint fill;
+    TestCase fillCase(geo, fill, reporter);
+
+    SkPaint pe;
+    pe.setPathEffect(FailurePathEffect::Make());
+    TestCase peCase(geo, pe, reporter);
+
+    SkPaint stroke;
+    stroke.setStrokeWidth(2.f);
+    stroke.setStyle(SkPaint::kStroke_Style);
+    TestCase strokeCase(geo, stroke, reporter);
+
+    SkPaint peStroke = stroke;
+    peStroke.setPathEffect(FailurePathEffect::Make());
+    TestCase peStrokeCase(geo, peStroke, reporter);
+
+    // In general the path effect failure can cause some of the TestCase::compare() tests to fail
+    // for at least two reasons: 1) We will initially treat the shape as unkeyable because of the
+    // path effect, but then when the path effect fails we can key it. 2) GrShape will change its
+    // mind about whether a unclosed rect is actually rect. The path effect initially bars us from
+    // closing it but after the effect fails we can (for the fill+pe case). This causes different
+    // routes through GrShape to have equivalent but different representations of the path (closed
+    // or not) but that fill the same.
+    SkPath a;
+    SkPath b;
+    fillCase.appliedPathEffectShape().asPath(&a);
+    peCase.appliedPathEffectShape().asPath(&b);
+    REPORTER_ASSERT(reporter, paths_fill_same(a, b));
+
+    fillCase.appliedFullStyleShape().asPath(&a);
+    peCase.appliedFullStyleShape().asPath(&b);
+    REPORTER_ASSERT(reporter, paths_fill_same(a, b));
+
+    strokeCase.appliedPathEffectShape().asPath(&a);
+    peStrokeCase.appliedPathEffectShape().asPath(&b);
+    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);
     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());
@@ skipping 51 matching lines @@
                 SkIntToScalar(2), SkIntToScalar(4));
         test_stroke_param<SkRect, SkPaint::Join>(
                 reporter, r,
                 [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
                 SkPaint::kMiter_Join, SkPaint::kRound_Join);
         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);
     }
 
     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);
         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);},
                           SkPaint::kMiter_Join, SkPaint::kRound_Join);
         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);
     }
 
     struct TestPath {
         TestPath(const SkPath& path, bool isRRectFill, bool isRRectStroke ,const SkRRect& rrect)
             : fPath(path)
             , fIsRRectForFill(isRRectFill)
             , fIsRRectForStroke(isRRectStroke)
             , fRRect(rrect) {}
         SkPath  fPath;
@@ skipping 42 matching lines @@
             [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);},
             SkIntToScalar(2), SkIntToScalar(4));
         test_stroke_param<SkPath, SkPaint::Join>(
             reporter, path,
             [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
             SkPaint::kMiter_Join, SkPaint::kRound_Join);
         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);
 
         SkPaint fillPaint;
         TestCase fillPathCase(path, fillPaint, reporter);
         SkRRect rrect;
         REPORTER_ASSERT(reporter, testPath.fIsRRectForFill ==
                                   fillPathCase.baseShape().asRRect(&rrect, nullptr, nullptr));
         if (testPath.fIsRRectForFill) {
             TestCase fillPathCase2(path, fillPaint, reporter);
             REPORTER_ASSERT(reporter, rrect == testPath.fRRect);
@@ skipping 15 matching lines @@
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif