Add tests for volatile paths to GrShapeTest

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 431 matching lines @@
     peStroke.setStrokeWidth(2.f);
     peStroke.setStyle(SkPaint::kStroke_Style);
     TestCase geoPEStrokeCase(geo, peStroke);
     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);
+    // 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);
+        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()));
+    }
+}
+
 template <typename GEO>
 void test_path_effect_makes_empty_shape(skiatest::Reporter* reporter, const GEO& geo) {
     /**
      * This path effect returns an empty path.
      */
     class EmptyPathEffect : SkPathEffect {
     public:
         bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*,
                         const SkRect* cullR) const override {
             dst->reset();
@@ skipping 125 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);
         }
+        // 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::Cap>(
             reporter, path,
             [](SkPaint* p, SkPaint::Cap c) { p->setStrokeCap(c);},
             SkPaint::kButt_Cap, SkPaint::kRound_Cap);
@@ skipping 23 matching lines @@
         REPORTER_ASSERT(reporter, testPath.fIsRRectForStroke ==
                                   strokePathCase.baseShape().asRRect(&rrect));
         if (testPath.fIsRRectForStroke) {
             REPORTER_ASSERT(reporter, rrect == testPath.fRRect);
             TestCase strokeRRectCase(rrect, strokePaint);
             strokePathCase.compare(reporter, strokeRRectCase,
                                  TestCase::kAllSame_ComparisonExpecation);
         }
     }
 
+    // Test a volatile empty path.
+    test_volatile_path(reporter, SkPath(), true);
+
     test_empty_shape(reporter);
 }
 
 #endif