Make large array of GrShapes in test code heap allocated

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 1024 matching lines @@
         case SkRRect::kRect_Type:
             return (s + 1) & 0b110;
         case SkRRect::kOval_Type:
             return s & 0b110;
         default:
             return s;
     }
 }
 
 void test_rrect(skiatest::Reporter* r, const SkRRect& rrect) {
-    enum {
+    enum Style {
         kFill,
         kStroke,
         kHairline,
         kStrokeAndFill
     };
 
     // SkStrokeRec has no default cons., so init with kFill before calling the setters below.
     SkStrokeRec strokeRecs[4] { SkStrokeRec::kFill_InitStyle, SkStrokeRec::kFill_InitStyle,
                                 SkStrokeRec::kFill_InitStyle, SkStrokeRec::kFill_InitStyle};
     strokeRecs[kFill].setFillStyle();
     strokeRecs[kStroke].setStrokeStyle(2.f);
     strokeRecs[kHairline].setHairlineStyle();
     strokeRecs[kStrokeAndFill].setStrokeStyle(3.f, true);
     sk_sp<SkPathEffect> dashEffect = make_dash();
 
-    GrShape shapes[2 /* inverted           */]
-                  [2 /* direction          */]
-                  [8 /* start index        */]
-                  [SK_ARRAY_COUNT(strokeRecs)]
-                  [2 /* dash               */];
-    for (int inverted = 0; inverted < 2; ++inverted) {
-        for (int ccw = 0; ccw < 2; ++ccw) {
-            for (unsigned s = 0; s < 8; ++s) {
-                for (size_t style = 0; style < SK_ARRAY_COUNT(strokeRecs); ++style) {
-                    for (int dash = 0; dash < 2; ++dash) {
-                        SkPath::Direction dir = ccw ? SkPath::kCCW_Direction
-                                                    : SkPath::kCW_Direction;
+    static constexpr Style kStyleCnt = static_cast<Style>(SK_ARRAY_COUNT(strokeRecs));
+
+    auto index = [](bool inverted,
+                    SkPath::Direction dir,
+                    unsigned start,
+                    Style style,
+                    bool dash) -> int {
+        return inverted * (2 * 8 * kStyleCnt * 2) +
+               dir      * (    8 * kStyleCnt * 2) +
+               start    * (        kStyleCnt * 2) +
+               style    * (                    2) +
+               dash;
+    };
+    static const SkPath::Direction kSecondDirection = static_cast<SkPath::Direction>(1);
+    const int cnt = index(true, kSecondDirection, 7, static_cast<Style>(kStyleCnt - 1), true) + 1;
+    SkAutoTArray<GrShape> shapes(cnt);
+    for (bool inverted : {false, true}) {
+        for (SkPath::Direction dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+            for (unsigned start = 0; start < 8; ++start) {
+                for (Style style : {kFill, kStroke, kHairline, kStrokeAndFill}) {
+                    for (bool dash : {false, true}) {
                         SkPathEffect* pe = dash ? dashEffect.get() : nullptr;
-                        shapes[inverted][ccw][s][style][dash] =
-                                GrShape(rrect, dir, s, SkToBool(inverted),
+                        shapes[index(inverted, dir, start, style, dash)] =
+                                GrShape(rrect, dir, start, SkToBool(inverted),
                                         GrStyle(strokeRecs[style], pe));
                     }
                 }
             }
         }
     }
 
-    const GrShape& exampleFillCase = shapes[0][0][0][kFill][0];
+    static const SkPath::Direction kDir = SkPath::kCW_Direction; // arbitrary
+    const GrShape& exampleFillCase = shapes[index(false, kDir, 0, kFill, false)];
     Key exampleFillCaseKey;
     make_key(&exampleFillCaseKey, exampleFillCase);
 
-    const GrShape& exampleStrokeAndFillCase = shapes[0][0][0][kStrokeAndFill][0];
+    const GrShape& exampleStrokeAndFillCase = shapes[index(false, kDir, 0, kStrokeAndFill, false)];
     Key exampleStrokeAndFillCaseKey;
     make_key(&exampleStrokeAndFillCaseKey, exampleStrokeAndFillCase);
 
-    const GrShape& exampleInvFillCase = shapes[1][0][0][kFill][0];
+    const GrShape& exampleInvFillCase = shapes[index(true, kDir, 0, kFill, false)];
     Key exampleInvFillCaseKey;
     make_key(&exampleInvFillCaseKey, exampleInvFillCase);
 
-    const GrShape& exampleInvStrokeAndFillCase = shapes[1][0][0][kStrokeAndFill][0];
+    const GrShape& exampleInvStrokeAndFillCase =
+            shapes[index(true, kDir, 0, kStrokeAndFill, false)];
     Key exampleInvStrokeAndFillCaseKey;
     make_key(&exampleInvStrokeAndFillCaseKey, exampleInvStrokeAndFillCase);
 
-    const GrShape& exampleStrokeCase = shapes[0][0][0][kStroke][0];
+    const GrShape& exampleStrokeCase = shapes[index(false, kDir, 0, kStroke, false)];
     Key exampleStrokeCaseKey;
     make_key(&exampleStrokeCaseKey, exampleStrokeCase);
 
-    const GrShape& exampleHairlineCase = shapes[0][0][0][kHairline][0];
+    const GrShape& exampleHairlineCase = shapes[index(false, kDir, 0, kHairline, false)];
     Key exampleHairlineCaseKey;
     make_key(&exampleHairlineCaseKey, exampleHairlineCase);
 
     // These are dummy initializations to suppress warnings.
-    SkRRect rr = SkRRect::MakeEmpty();
-    SkPath::Direction dir = SkPath::kCW_Direction;
-    unsigned start = ~0U;
-    bool inv = true;
+    SkRRect queryRR = SkRRect::MakeEmpty();
+    SkPath::Direction queryDir = SkPath::kCW_Direction;
+    unsigned queryStart = ~0U;
+    bool queryInverted = true;
 
-    REPORTER_ASSERT(r, exampleFillCase.asRRect(&rr, &dir, &start, &inv));
-    REPORTER_ASSERT(r, rr == rrect);
-    REPORTER_ASSERT(r, SkPath::kCW_Direction == dir);
-    REPORTER_ASSERT(r, 0 == start);
-    REPORTER_ASSERT(r, !inv);
+    REPORTER_ASSERT(r, exampleFillCase.asRRect(&queryRR, &queryDir, &queryStart, &queryInverted));
+    REPORTER_ASSERT(r, queryRR == rrect);
+    REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+    REPORTER_ASSERT(r, 0 == queryStart);
+    REPORTER_ASSERT(r, !queryInverted);
 
-    REPORTER_ASSERT(r, exampleInvFillCase.asRRect(&rr, &dir, &start, &inv));
-    REPORTER_ASSERT(r, rr == rrect);
-    REPORTER_ASSERT(r, SkPath::kCW_Direction == dir);
-    REPORTER_ASSERT(r, 0 == start);
-    REPORTER_ASSERT(r, inv);
+    REPORTER_ASSERT(r, exampleInvFillCase.asRRect(&queryRR, &queryDir, &queryStart,
+                                                  &queryInverted));
+    REPORTER_ASSERT(r, queryRR == rrect);
+    REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+    REPORTER_ASSERT(r, 0 == queryStart);
+    REPORTER_ASSERT(r, queryInverted);
 
-    REPORTER_ASSERT(r, exampleStrokeAndFillCase.asRRect(&rr, &dir, &start, &inv));
-    REPORTER_ASSERT(r, rr == rrect);
-    REPORTER_ASSERT(r, SkPath::kCW_Direction == dir);
-    REPORTER_ASSERT(r, 0 == start);
-    REPORTER_ASSERT(r, !inv);
+    REPORTER_ASSERT(r, exampleStrokeAndFillCase.asRRect(&queryRR, &queryDir, &queryStart,
+                                                        &queryInverted));
+    REPORTER_ASSERT(r, queryRR == rrect);
+    REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+    REPORTER_ASSERT(r, 0 == queryStart);
+    REPORTER_ASSERT(r, !queryInverted);
 
-    REPORTER_ASSERT(r, exampleInvStrokeAndFillCase.asRRect(&rr, &dir, &start, &inv));
-    REPORTER_ASSERT(r, rr == rrect);
-    REPORTER_ASSERT(r, SkPath::kCW_Direction == dir);
-    REPORTER_ASSERT(r, 0 == start);
-    REPORTER_ASSERT(r, inv);
+    REPORTER_ASSERT(r, exampleInvStrokeAndFillCase.asRRect(&queryRR, &queryDir, &queryStart,
+                                                           &queryInverted));
+    REPORTER_ASSERT(r, queryRR == rrect);
+    REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+    REPORTER_ASSERT(r, 0 == queryStart);
+    REPORTER_ASSERT(r, queryInverted);
 
-    REPORTER_ASSERT(r, exampleHairlineCase.asRRect(&rr, &dir, &start, &inv));
-    REPORTER_ASSERT(r, rr == rrect);
-    REPORTER_ASSERT(r, SkPath::kCW_Direction == dir);
-    REPORTER_ASSERT(r, 0 == start);
-    REPORTER_ASSERT(r, !inv);
+    REPORTER_ASSERT(r, exampleHairlineCase.asRRect(&queryRR, &queryDir, &queryStart,
+                                                   &queryInverted));
+    REPORTER_ASSERT(r, queryRR == rrect);
+    REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+    REPORTER_ASSERT(r, 0 == queryStart);
+    REPORTER_ASSERT(r, !queryInverted);
 
-    REPORTER_ASSERT(r, exampleStrokeCase.asRRect(&rr, &dir, &start, &inv));
-    REPORTER_ASSERT(r, rr == rrect);
-    REPORTER_ASSERT(r, SkPath::kCW_Direction == dir);
-    REPORTER_ASSERT(r, 0 == start);
-    REPORTER_ASSERT(r, !inv);
+    REPORTER_ASSERT(r, exampleStrokeCase.asRRect(&queryRR, &queryDir, &queryStart, &queryInverted));
+    REPORTER_ASSERT(r, queryRR == rrect);
+    REPORTER_ASSERT(r, SkPath::kCW_Direction == queryDir);
+    REPORTER_ASSERT(r, 0 == queryStart);
+    REPORTER_ASSERT(r, !queryInverted);
 
     // Remember that the key reflects the geometry before styling is applied.
     REPORTER_ASSERT(r, exampleFillCaseKey != exampleInvFillCaseKey);
     REPORTER_ASSERT(r, exampleFillCaseKey == exampleStrokeAndFillCaseKey);
     REPORTER_ASSERT(r, exampleFillCaseKey != exampleInvStrokeAndFillCaseKey);
     REPORTER_ASSERT(r, exampleFillCaseKey == exampleStrokeCaseKey);
     REPORTER_ASSERT(r, exampleFillCaseKey == exampleHairlineCaseKey);
     REPORTER_ASSERT(r, exampleInvStrokeAndFillCaseKey == exampleInvFillCaseKey);
 
-    for (int inverted = 0; inverted < 2; ++inverted) {
-        for (int ccw = 0; ccw < 2; ++ccw) {
-            for (unsigned s = 0; s < 8; ++s) {
-                for (int dash = 0; dash < 2; ++dash) {
-                    const GrShape& fillCase = shapes[inverted][ccw][s][kFill][dash];
+    for (bool inverted : {false, true}) {
+        for (SkPath::Direction dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) {
+            for (unsigned start = 0; start < 8; ++start) {
+                for (bool dash : {false, true}) {
+                    const GrShape& fillCase = shapes[index(inverted, dir, start, kFill, dash)];
                     Key fillCaseKey;
                     make_key(&fillCaseKey, fillCase);
 
-                    const GrShape& strokeAndFillCase =
-                            shapes[inverted][ccw][s][kStrokeAndFill][dash];
+                    const GrShape& strokeAndFillCase = shapes[index(inverted, dir, start,
+                                                                    kStrokeAndFill, dash)];
                     Key strokeAndFillCaseKey;
                     make_key(&strokeAndFillCaseKey, strokeAndFillCase);
 
                     // Both fill and stroke-and-fill shapes must respect the inverseness and both
                     // ignore dashing.
                     REPORTER_ASSERT(r, !fillCase.style().pathEffect());
                     REPORTER_ASSERT(r, !strokeAndFillCase.style().pathEffect());
                     TestCase a(fillCase, r);
                     TestCase b(inverted ? exampleInvFillCase : exampleFillCase, r);
                     TestCase c(strokeAndFillCase, r);
                     TestCase d(inverted ? exampleInvStrokeAndFillCase
                                         : exampleStrokeAndFillCase, r);
                     a.compare(r, b, TestCase::kAllSame_ComparisonExpecation);
                     c.compare(r, d, TestCase::kAllSame_ComparisonExpecation);
 
-                    const GrShape& strokeCase = shapes[inverted][ccw][s][kStroke][dash];
-                    const GrShape& hairlineCase = shapes[inverted][ccw][s][kHairline][dash];
+                    const GrShape& strokeCase = shapes[index(inverted, dir, start, kStroke, dash)];
+                    const GrShape& hairlineCase = shapes[index(inverted, dir, start, kHairline,
+                                                               dash)];
 
                     TestCase e(strokeCase, r);
                     TestCase f(exampleStrokeCase, r);
                     TestCase g(hairlineCase, r);
                     TestCase h(exampleHairlineCase, r);
 
                     // Both hairline and stroke shapes must respect the dashing and both
                     // ignore inverseness.
                     if (dash) {
-                        unsigned expectedStart = canonicalize_rrect_start(s, rrect);
+                        unsigned expectedStart = canonicalize_rrect_start(start, rrect);
                         REPORTER_ASSERT(r, strokeCase.style().pathEffect());
                         REPORTER_ASSERT(r, hairlineCase.style().pathEffect());
 
-                        REPORTER_ASSERT(r, strokeCase.asRRect(&rr, &dir, &start, &inv));
-                        REPORTER_ASSERT(r, rr == rrect);
-                        REPORTER_ASSERT(r, (SkPath::kCCW_Direction == dir) == ccw);
-                        REPORTER_ASSERT(r, start == expectedStart);
-                        REPORTER_ASSERT(r, !inv);
-                        REPORTER_ASSERT(r, hairlineCase.asRRect(&rr, &dir, &start, &inv));
-                        REPORTER_ASSERT(r, rr == rrect);
-                        REPORTER_ASSERT(r, (SkPath::kCCW_Direction == dir) == ccw);
-                        REPORTER_ASSERT(r, start == expectedStart);
-                        REPORTER_ASSERT(r, !inv);
+                        REPORTER_ASSERT(r, strokeCase.asRRect(&queryRR, &queryDir, &queryStart,
+                                                              &queryInverted));
+                        REPORTER_ASSERT(r, queryRR == rrect);
+                        REPORTER_ASSERT(r, queryDir == dir);
+                        REPORTER_ASSERT(r, queryStart == expectedStart);
+                        REPORTER_ASSERT(r, !queryInverted);
+                        REPORTER_ASSERT(r, hairlineCase.asRRect(&queryRR, &queryDir, &queryStart,
+                                                                &queryInverted));
+                        REPORTER_ASSERT(r, queryRR == rrect);
+                        REPORTER_ASSERT(r, queryDir == dir);
+                        REPORTER_ASSERT(r, queryStart == expectedStart);
+                        REPORTER_ASSERT(r, !queryInverted);
 
                         // The pre-style case for the dash will match the non-dash example iff the
                         // dir and start match (dir=cw, start=0).
-                        if (0 == expectedStart && 0 == ccw) {
+                        if (0 == expectedStart && SkPath::kCW_Direction == dir) {
                             e.compare(r, f, TestCase::kSameUpToPE_ComparisonExpecation);
                             g.compare(r, h, TestCase::kSameUpToPE_ComparisonExpecation);
                         } else {
                             e.compare(r, f, TestCase::kAllDifferent_ComparisonExpecation);
                             g.compare(r, h, TestCase::kAllDifferent_ComparisonExpecation);
                         }
                     } else {
                         REPORTER_ASSERT(r, !strokeCase.style().pathEffect());
                         REPORTER_ASSERT(r, !hairlineCase.style().pathEffect());
                         e.compare(r, f, TestCase::kAllSame_ComparisonExpecation);
@@ skipping 162 matching lines @@
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif