Add special handling of rectori case for gpu

tests/PathTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
@@ skipping 1304 matching lines @@
             path1.cubicTo(1, .5f, 1, .5f, 1, .5f);
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
     REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
 }
 
 static void test_isNestedRects(skiatest::Reporter* reporter) {
     // passing tests (all moveTo / lineTo...
-    SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
+    SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW
     SkPoint r2[] = {{1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint r3[] = {{1, 1}, {0, 1}, {0, 0}, {1, 0}};
     SkPoint r4[] = {{0, 1}, {0, 0}, {1, 0}, {1, 1}};
-    SkPoint r5[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};
+    SkPoint r5[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}}; // CCW
     SkPoint r6[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint r7[] = {{1, 1}, {1, 0}, {0, 0}, {0, 1}};
     SkPoint r8[] = {{1, 0}, {0, 0}, {0, 1}, {1, 1}};
     SkPoint r9[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
-    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f},
+    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, // CCW
         {1, 0}, {.5f, 0}};
-    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1},
+    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, // CW
         {0, 1}, {0, .5f}};
-    SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}};
-    SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}};
-    SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}};
+    SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}}; // CW
+    SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}}; // CCW
+    SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW
 
     // failing tests
     SkPoint f1[] = {{0, 0}, {1, 0}, {1, 1}}; // too few points
     SkPoint f2[] = {{0, 0}, {1, 1}, {0, 1}, {1, 0}}; // diagonal
     SkPoint f3[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}, {1, 0}}; // wraps
     SkPoint f4[] = {{0, 0}, {1, 0}, {0, 0}, {1, 0}, {1, 1}, {0, 1}}; // backs up
     SkPoint f5[] = {{0, 0}, {1, 0}, {1, 1}, {2, 0}}; // end overshoots
     SkPoint f6[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 2}}; // end overshoots
     SkPoint f7[] = {{0, 0}, {1, 0}, {1, 1}, {0, 2}}; // end overshoots
     SkPoint f8[] = {{0, 0}, {1, 0}, {1, 1}, {1, 0}}; // 'L'
 
     // failing, no close
     SkPoint c1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // close doesn't match
     SkPoint c2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}}; // ditto
 
     size_t testLen[] = {
         sizeof(r1), sizeof(r2), sizeof(r3), sizeof(r4), sizeof(r5), sizeof(r6),
         sizeof(r7), sizeof(r8), sizeof(r9), sizeof(ra), sizeof(rb), sizeof(rc),
         sizeof(rd), sizeof(re),
         sizeof(f1), sizeof(f2), sizeof(f3), sizeof(f4), sizeof(f5), sizeof(f6),
         sizeof(f7), sizeof(f8),
         sizeof(c1), sizeof(c2)
     };
     SkPoint* tests[] = {
         r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re,
         f1, f2, f3, f4, f5, f6, f7, f8,
         c1, c2
     };
+    SkPath::Direction dirs[] = { 
+        SkPath::kCW_Direction, SkPath::kCW_Direction, SkPath::kCW_Direction, 
+        SkPath::kCW_Direction, SkPath::kCCW_Direction, SkPath::kCCW_Direction,
+        SkPath::kCCW_Direction, SkPath::kCCW_Direction, SkPath::kCCW_Direction, 
+        SkPath::kCCW_Direction, SkPath::kCW_Direction, SkPath::kCW_Direction, 
+        SkPath::kCCW_Direction, SkPath::kCW_Direction, SkPath::kUnknown_Direction,
+        SkPath::kUnknown_Direction, SkPath::kUnknown_Direction, SkPath::kUnknown_Direction,
+        SkPath::kUnknown_Direction, SkPath::kUnknown_Direction, SkPath::kUnknown_Direction,
+        SkPath::kUnknown_Direction, SkPath::kUnknown_Direction, SkPath::kUnknown_Direction,
+    };
+    SkASSERT(SK_ARRAY_COUNT(tests) == SK_ARRAY_COUNT(dirs));
+
     const SkPoint* lastPass = re;
     const SkPoint* lastClose = f8;
     const size_t testCount = sizeof(tests) / sizeof(tests[0]);
     size_t index;
     for (int rectFirst = 0; rectFirst <= 1; ++rectFirst) {
         bool fail = false;
         bool close = true;
         for (size_t testIndex = 0; testIndex < testCount; ++testIndex) {
             SkPath path;
             if (rectFirst) {
                 path.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
             }
             path.moveTo(tests[testIndex][0].fX, tests[testIndex][0].fY);
             for (index = 1; index < testLen[testIndex] / sizeof(SkPoint); ++index) {
                 path.lineTo(tests[testIndex][index].fX, tests[testIndex][index].fY);
             }
             if (close) {
                 path.close();
             }
             if (!rectFirst) {
                 path.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
             }
             REPORTER_ASSERT(reporter, fail ^ path.isNestedRects(0));
             if (!fail) {
                 SkRect expected[2], computed[2];
+                SkPath::Direction expectedDirs[2], computedDirs[2];
                 SkRect testBounds;
                 testBounds.set(tests[testIndex], testLen[testIndex] / sizeof(SkPoint));
                 expected[0] = SkRect::MakeLTRB(-1, -1, 2, 2);
                 expected[1] = testBounds;
-                REPORTER_ASSERT(reporter, path.isNestedRects(computed));
+                if (rectFirst) {
+                    expectedDirs[0] = SkPath::kCW_Direction;
+                } else {
+                    expectedDirs[0] = SkPath::kCCW_Direction;
+                }
+                expectedDirs[1] = dirs[testIndex];
+                REPORTER_ASSERT(reporter, path.isNestedRects(computed, computedDirs));
                 REPORTER_ASSERT(reporter, expected[0] == computed[0]);
                 REPORTER_ASSERT(reporter, expected[1] == computed[1]);
+                REPORTER_ASSERT(reporter, expectedDirs[0] == computedDirs[0]);
+                REPORTER_ASSERT(reporter, expectedDirs[1] == computedDirs[1]);
             }
             if (tests[testIndex] == lastPass) {
                 fail = true;
             }
             if (tests[testIndex] == lastClose) {
                 close = false;
             }
         }
 
         // fail, close then line
@@ skipping 978 matching lines @@
     test_addrect_isfinite(reporter);
     test_tricky_cubic();
     test_clipped_cubic();
     test_crbug_170666();
     test_bad_cubic_crbug229478();
     test_bad_cubic_crbug234190();
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Path", PathTestClass, TestPath)