change isRect to return true for 3-sided rectangular paths

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 1420 matching lines @@
     path.reset();
     path.lineTo(100, 100);
     REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(SkRect::MakeXYWH(0, 0, 1, 1)));
 }
 
 static void test_isRect_open_close(skiatest::Reporter* reporter) {
     SkPath path;
     bool isClosed;
 
     path.moveTo(0, 0); path.lineTo(1, 0); path.lineTo(1, 1); path.lineTo(0, 1);
+    path.close();
 
-    if (false) {
-        // I think these should pass, but isRect() doesn't behave
-        // this way... yet
-        REPORTER_ASSERT(reporter, path.isRect(NULL, NULL));
-        REPORTER_ASSERT(reporter, path.isRect(&isClosed, NULL));
-        REPORTER_ASSERT(reporter, !isClosed);
-    }
-
-    path.close();
     REPORTER_ASSERT(reporter, path.isRect(NULL, NULL));
     REPORTER_ASSERT(reporter, path.isRect(&isClosed, NULL));
     REPORTER_ASSERT(reporter, isClosed);
 }
 
 // Simple isRect test is inline TestPath, below.
 // test_isRect provides more extensive testing.
 static void test_isRect(skiatest::Reporter* reporter) {
     test_isRect_open_close(reporter);
 
@@ skipping 20 matching lines @@
     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'
     SkPoint f9[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, 0}, {2, 0}}; // overlaps
     SkPoint fa[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, -1}, {1, -1}}; // non colinear gap
     SkPoint fb[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, 1}}; // falls short
 
-    // 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
+    // no close, but we should detect them as fillably the same as a rect
+    SkPoint c1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
+    SkPoint c2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}};
+    SkPoint c3[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}, {0, 0}}; // hit the start
+
+    // like c2, but we double-back on ourselves
+    SkPoint d1[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}, {0, 2}};
+    // like c2, but we overshoot the start point
+    SkPoint d2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, -1}};
+    SkPoint d3[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, -1}, {0, 0}};
 
     struct IsRectTest {
         SkPoint *fPoints;
         size_t fPointCount;
         bool fClose;
         bool fIsRect;
     } tests[] = {
         { r1, SK_ARRAY_COUNT(r1), true, true },
         { r2, SK_ARRAY_COUNT(r2), true, true },
         { r3, SK_ARRAY_COUNT(r3), true, true },
@@ skipping 15 matching lines @@
         { f3, SK_ARRAY_COUNT(f3), true, false },
         { f4, SK_ARRAY_COUNT(f4), true, false },
         { f5, SK_ARRAY_COUNT(f5), true, false },
         { f6, SK_ARRAY_COUNT(f6), true, false },
         { f7, SK_ARRAY_COUNT(f7), true, false },
         { f8, SK_ARRAY_COUNT(f8), true, false },
         { f9, SK_ARRAY_COUNT(f9), true, false },
         { fa, SK_ARRAY_COUNT(fa), true, false },
         { fb, SK_ARRAY_COUNT(fb), true, false },
 
-        { c1, SK_ARRAY_COUNT(c1), false, false },
-        { c2, SK_ARRAY_COUNT(c2), false, false },
+        { c1, SK_ARRAY_COUNT(c1), false, true },
+        { c2, SK_ARRAY_COUNT(c2), false, true },
+        { c3, SK_ARRAY_COUNT(c3), false, true },
+
+        { d1, SK_ARRAY_COUNT(d1), false, false },
+        { d2, SK_ARRAY_COUNT(d2), false, false },
+        { d3, SK_ARRAY_COUNT(d3), false, false },
     };
 
     const size_t testCount = SK_ARRAY_COUNT(tests);
     size_t index;
     for (size_t testIndex = 0; testIndex < testCount; ++testIndex) {
         SkPath path;
         path.moveTo(tests[testIndex].fPoints[0].fX, tests[testIndex].fPoints[0].fY);
         for (index = 1; index < tests[testIndex].fPointCount; ++index) {
             path.lineTo(tests[testIndex].fPoints[index].fX, tests[testIndex].fPoints[index].fY);
         }
@@ skipping 1698 matching lines @@
         q.conicTo(8, 7, 6, 5, 0.5f);
         q.quadTo(6, 7, 8, 6);
         q.cubicTo(5, 6, 7, 8, 7, 5);
         q.close();
         p.reversePathTo(q);
         SkRect reverseExpected = {-4, -4, 8, 8};
         REPORTER_ASSERT(reporter, p.getBounds() == reverseExpected);
     }
 };
 
-DEF_TEST(Path, reporter) {
+DEF_TEST(Paths, reporter) {
     SkTSize<SkScalar>::Make(3,4);
 
     SkPath  p, empty;
     SkRect  bounds, bounds2;
     test_empty(reporter, p);
 
     REPORTER_ASSERT(reporter, p.getBounds().isEmpty());
 
     // this triggers a code path in SkPath::operator= which is otherwise unexercised
     SkPath& self = p;
@@ skipping 99 matching lines @@
     test_rrect(reporter);
     test_arc(reporter);
     test_arcTo(reporter);
     test_addPath(reporter);
     test_conicTo_special_case(reporter);
     test_get_point(reporter);
     test_contains(reporter);
     PathTest_Private::TestPathTo(reporter);
     PathRefTest_Private::TestPathRef(reporter);
 }