Add isEmpty() query to GrShape and improve comments.

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 65 matching lines @@
         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);
+        REPORTER_ASSERT(r, fAppliedFull.isEmpty() == fAppliedPEThenStroke.isEmpty());
+
+        SkPath path;
+        fBase.asPath(&path);
+        REPORTER_ASSERT(r, path.isEmpty() == fBase.isEmpty());
+        fAppliedPE.asPath(&path);

[robertphillips, 2016/05/11 21:38:40]

Couldn't we have a PE for which this isn't true?
Is that worthwhile to test?

[bsalomon, 2016/05/11 21:47:49]

This is asserting that after applying the PE the emptiness of the applied-shape
must agree with the emptiness of the path the applied-shape returns (not the
original).

There is a path effect in this file that turns empty shapes into non-empty
shapes but it isn't applied to the empty shape. I'll make a follow up CL that
does that.

+        REPORTER_ASSERT(r, path.isEmpty() == fAppliedPE.isEmpty());
+        fAppliedFull.asPath(&path);
+        REPORTER_ASSERT(r, path.isEmpty() == fAppliedFull.isEmpty());
 
         // 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,
                                                 scale)) {
@@ skipping 67 matching lines @@
         case kAllDifferent_ComparisonExpecation:
             REPORTER_ASSERT(reporter, fBaseKey != that.fBaseKey);
             REPORTER_ASSERT(reporter, fAppliedPEKey != that.fAppliedPEKey);
             REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey);
             break;
         case kSameUpToPE_ComparisonExpecation:
             REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey);
             fBase.asPath(&a);
             that.fBase.asPath(&b);
             REPORTER_ASSERT(reporter, a == b);
+            REPORTER_ASSERT(reporter, fBase.isEmpty() == that.fBase.isEmpty());
             REPORTER_ASSERT(reporter, fAppliedPEKey != that.fAppliedPEKey);
             REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey);
             break;
         case kSameUpToStroke_ComparisonExpecation:
             REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey);
             fBase.asPath(&a);
             that.fBase.asPath(&b);
             REPORTER_ASSERT(reporter, a == b);
+            REPORTER_ASSERT(reporter, fBase.isEmpty() == that.fBase.isEmpty());
             REPORTER_ASSERT(reporter, fAppliedPEKey == that.fAppliedPEKey);
             fAppliedPE.asPath(&a);
             that.fAppliedPE.asPath(&b);
             REPORTER_ASSERT(reporter, a == b);
+            REPORTER_ASSERT(reporter, fAppliedPE.isEmpty() == that.fAppliedPE.isEmpty());
             REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey);
             break;
         case kAllSame_ComparisonExpecation:
             REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey);
             fBase.asPath(&a);
             that.fBase.asPath(&b);
             REPORTER_ASSERT(reporter, a == b);
+            REPORTER_ASSERT(reporter, fBase.isEmpty() == that.fBase.isEmpty());
             REPORTER_ASSERT(reporter, fAppliedPEKey == that.fAppliedPEKey);
             fAppliedPE.asPath(&a);
             that.fAppliedPE.asPath(&b);
             REPORTER_ASSERT(reporter, a == b);
+            REPORTER_ASSERT(reporter, fAppliedPE.isEmpty() == that.fAppliedPE.isEmpty());
             REPORTER_ASSERT(reporter, fAppliedFullKey == that.fAppliedFullKey);
             fAppliedFull.asPath(&a);
             that.fAppliedFull.asPath(&b);
             REPORTER_ASSERT(reporter, a == b);
+            REPORTER_ASSERT(reporter, fAppliedFull.isEmpty() == that.fAppliedFull.isEmpty());
             break;
     }
 }
 }  // namespace
 
 static sk_sp<SkPathEffect> make_dash() {
     static const SkScalar kIntervals[] = { 0.25, 3.f, 0.5, 2.f };
     static const SkScalar kPhase = 0.75;
     return SkDashPathEffect::Make(kIntervals, SK_ARRAY_COUNT(kIntervals), kPhase);
 }
@@ skipping 528 matching lines @@
         Factory getFactory() const override { return nullptr; }
         void toString(SkString*) const override {}
     private:
         EmptyPathEffect() {}
     };
 
     SkPath emptyPath;
     GrShape emptyShape(emptyPath);
     Key emptyKey;
     make_key(&emptyKey, emptyShape);
+    REPORTER_ASSERT(reporter, emptyShape.isEmpty());
 
     SkPaint pe;
     pe.setPathEffect(EmptyPathEffect::Make());
     TestCase geoCase(geo, pe, reporter);
     REPORTER_ASSERT(reporter, geoCase.appliedFullStyleKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoCase.appliedPathEffectKey() == emptyKey);
     REPORTER_ASSERT(reporter, geoCase.appliedPathEffectThenStrokeKey() == emptyKey);
+    REPORTER_ASSERT(reporter, geoCase.appliedPathEffectShape().isEmpty());
+    REPORTER_ASSERT(reporter, geoCase.appliedFullStyleShape().isEmpty());
 
     SkPaint peStroke;
     peStroke.setPathEffect(EmptyPathEffect::Make());
     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());
 }
 
 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());
     TestCase::SelfExpectations expectations;
     expectations.fStrokeApplies = false;
     expectations.fPEHasEffect = false;
     // This will test whether applying style preserves emptiness
     fillEmptyCase.testExpectations(reporter, expectations);
 
     // Stroking an empty path should have no effect
@@ skipping 140 matching lines @@
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif