make rectcontour and nestedrects private
Change-Id: I37b81f3cd96acc310ce78244d427eeb9c7999061
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/241078
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>
Auto-Submit: Mike Reed <reed@google.com>
diff --git a/RELEASE_NOTES.txt b/RELEASE_NOTES.txt
index 6a72f3f..92f55b4 100644
--- a/RELEASE_NOTES.txt
+++ b/RELEASE_NOTES.txt
@@ -4,6 +4,8 @@
-----
+ * Remove isRectContour and ksNestedFillRects from public
+
Milestone 79
* Make the size of program/pipeline caches configurable via
diff --git a/docs/examples/Path_isNestedFillRects.cpp b/docs/examples/Path_isNestedFillRects.cpp
deleted file mode 100644
index e80edeb..0000000
--- a/docs/examples/Path_isNestedFillRects.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019 Google LLC.
-// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
-#include "tools/fiddle/examples.h"
-// HASH=77e4394caf9fa083c19c21c2462efe14
-REG_FIDDLE(Path_isNestedFillRects, 256, 256, true, 0) {
-void draw(SkCanvas* canvas) {
- SkPaint paint;
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setStrokeWidth(5);
- SkPath path;
- path.addRect({10, 20, 30, 40});
- paint.getFillPath(path, &path);
- SkRect rects[2];
- SkPath::Direction directions[2];
- if (path.isNestedFillRects(rects, directions)) {
- for (int i = 0; i < 2; ++i) {
- SkDebugf("%s (%g, %g, %g, %g); direction %s\n", i ? "inner" : "outer",
- rects[i].fLeft, rects[i].fTop, rects[i].fRight, rects[i].fBottom,
- SkPath::kCW_Direction == directions[i] ? "CW" : "CCW");
- }
- } else {
- SkDebugf("is not nested rectangles\n");
- }
-}
-} // END FIDDLE
diff --git a/include/core/SkPath.h b/include/core/SkPath.h
index bcff830..deb7bba 100644
--- a/include/core/SkPath.h
+++ b/include/core/SkPath.h
@@ -1042,19 +1042,6 @@
*/
bool isRect(SkRect* rect, bool* isClosed = nullptr, Direction* direction = nullptr) const;
- /** Returns true if SkPath is equivalent to nested SkRect pair when filled.
- If false, rect and dirs are unchanged.
- If true, rect and dirs are written to if not nullptr:
- setting rect[0] to outer SkRect, and rect[1] to inner SkRect;
- setting dirs[0] to SkPath::Direction of outer SkRect, and dirs[1] to SkPath::Direction of
- inner SkRect.
-
- @param rect storage for SkRect pair; may be nullptr
- @param dirs storage for SkPath::Direction pair; may be nullptr
- @return true if SkPath contains nested SkRect pair
- */
- bool isNestedFillRects(SkRect rect[2], Direction dirs[2] = nullptr) const;
-
/** Adds SkRect to SkPath, appending kMove_Verb, three kLine_Verb, and kClose_Verb,
starting with top-left corner of SkRect; followed by top-right, bottom-right,
and bottom-left if dir is kCW_Direction; or followed by bottom-left,
@@ -1716,9 +1703,6 @@
bool isValidImpl() const;
SkDEBUGCODE(void validateRef() const { fPathRef->validate(); } )
- bool isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts,
- bool* isClosed, Direction* direction, SkRect* rect) const;
-
// called by stroker to see if all points (in the last contour) are equal and worthy of a cap
bool isZeroLengthSincePoint(int startPtIndex) const;
diff --git a/src/core/SkMaskFilter.cpp b/src/core/SkMaskFilter.cpp
index bce1c9d..3973311 100644
--- a/src/core/SkMaskFilter.cpp
+++ b/src/core/SkMaskFilter.cpp
@@ -15,6 +15,7 @@
#include "src/core/SkCachedData.h"
#include "src/core/SkCoverageModePriv.h"
#include "src/core/SkDraw.h"
+#include "src/core/SkPathPriv.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkWriteBuffer.h"
@@ -208,7 +209,7 @@
}
static int countNestedRects(const SkPath& path, SkRect rects[2]) {
- if (path.isNestedFillRects(rects)) {
+ if (SkPathPriv::IsNestedFillRects(path, rects)) {
return 2;
}
return path.isRect(&rects[0]);
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index b122f9d..0847ea5 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -455,184 +455,11 @@
return ((0 != dx) << 0) | ((dx > 0 || dy > 0) << 1);
}
-bool SkPath::isRectContour(bool allowPartial, int* currVerb, const SkPoint** ptsPtr,
- bool* isClosed, Direction* direction, SkRect* rect) const {
- int corners = 0;
- SkPoint closeXY; // used to determine if final line falls on a diagonal
- SkPoint lineStart; // used to construct line from previous point
- const SkPoint* firstPt = nullptr; // first point in the rect (last of first moves)
- const SkPoint* lastPt = nullptr; // last point in the rect (last of lines or first if closed)
- SkPoint firstCorner;
- SkPoint thirdCorner;
- const SkPoint* pts = *ptsPtr;
- const SkPoint* savePts = nullptr; // used to allow caller to iterate through a pair of rects
- lineStart.set(0, 0);
- signed char directions[] = {-1, -1, -1, -1, -1}; // -1 to 3; -1 is uninitialized
- bool closedOrMoved = false;
- bool autoClose = false;
- bool insertClose = false;
- int verbCnt = fPathRef->countVerbs();
- while (*currVerb < verbCnt && (!allowPartial || !autoClose)) {
- uint8_t verb = insertClose ? (uint8_t) kClose_Verb : fPathRef->atVerb(*currVerb);
- switch (verb) {
- case kClose_Verb:
- savePts = pts;
- autoClose = true;
- insertClose = false;
- case kLine_Verb: {
- if (kClose_Verb != verb) {
- lastPt = pts;
- }
- SkPoint lineEnd = kClose_Verb == verb ? *firstPt : *pts++;
- SkVector lineDelta = lineEnd - lineStart;
- if (lineDelta.fX && lineDelta.fY) {
- return false; // diagonal
- }
- if (!lineDelta.isFinite()) {
- return false; // path contains infinity or NaN
- }
- if (lineStart == lineEnd) {
- break; // single point on side OK
- }
- int nextDirection = rect_make_dir(lineDelta.fX, lineDelta.fY); // 0 to 3
- if (0 == corners) {
- directions[0] = nextDirection;
- corners = 1;
- closedOrMoved = false;
- lineStart = lineEnd;
- break;
- }
- if (closedOrMoved) {
- return false; // closed followed by a line
- }
- if (autoClose && nextDirection == directions[0]) {
- break; // colinear with first
- }
- closedOrMoved = autoClose;
- if (directions[corners - 1] == nextDirection) {
- if (3 == corners && kLine_Verb == verb) {
- thirdCorner = lineEnd;
- }
- lineStart = lineEnd;
- break; // colinear segment
- }
- directions[corners++] = nextDirection;
- // opposite lines must point in opposite directions; xoring them should equal 2
- switch (corners) {
- case 2:
- firstCorner = lineStart;
- break;
- case 3:
- if ((directions[0] ^ directions[2]) != 2) {
- return false;
- }
- thirdCorner = lineEnd;
- break;
- case 4:
- if ((directions[1] ^ directions[3]) != 2) {
- return false;
- }
- break;
- default:
- return false; // too many direction changes
- }
- lineStart = lineEnd;
- break;
- }
- case kQuad_Verb:
- case kConic_Verb:
- case kCubic_Verb:
- return false; // quadratic, cubic not allowed
- case kMove_Verb:
- if (allowPartial && !autoClose && directions[0] >= 0) {
- insertClose = true;
- *currVerb -= 1; // try move again afterwards
- goto addMissingClose;
- }
- if (!corners) {
- firstPt = pts;
- } else {
- closeXY = *firstPt - *lastPt;
- if (closeXY.fX && closeXY.fY) {
- return false; // we're diagonal, abort
- }
- }
- lineStart = *pts++;
- closedOrMoved = true;
- break;
- default:
- SkDEBUGFAIL("unexpected verb");
- break;
- }
- *currVerb += 1;
-addMissingClose:
- ;
- }
- // Success if 4 corners and first point equals last
- if (corners < 3 || corners > 4) {
- return false;
- }
- if (savePts) {
- *ptsPtr = savePts;
- }
- // check if close generates diagonal
- closeXY = *firstPt - *lastPt;
- if (closeXY.fX && closeXY.fY) {
- return false;
- }
- if (rect) {
- rect->set(firstCorner, thirdCorner);
- }
- if (isClosed) {
- *isClosed = autoClose;
- }
- if (direction) {
- *direction = directions[0] == ((directions[1] + 1) & 3) ? kCW_Direction : kCCW_Direction;
- }
- return true;
-}
-
bool SkPath::isRect(SkRect* rect, bool* isClosed, Direction* direction) const {
SkDEBUGCODE(this->validate();)
int currVerb = 0;
const SkPoint* pts = fPathRef->points();
- return this->isRectContour(false, &currVerb, &pts, isClosed, direction, rect);
-}
-
-bool SkPath::isNestedFillRects(SkRect rects[2], Direction dirs[2]) const {
- SkDEBUGCODE(this->validate();)
- int currVerb = 0;
- const SkPoint* pts = fPathRef->points();
- Direction testDirs[2];
- SkRect testRects[2];
- if (!isRectContour(true, &currVerb, &pts, nullptr, &testDirs[0], &testRects[0])) {
- return false;
- }
- if (isRectContour(false, &currVerb, &pts, nullptr, &testDirs[1], &testRects[1])) {
- if (testRects[0].contains(testRects[1])) {
- if (rects) {
- rects[0] = testRects[0];
- rects[1] = testRects[1];
- }
- if (dirs) {
- dirs[0] = testDirs[0];
- dirs[1] = testDirs[1];
- }
- return true;
- }
- if (testRects[1].contains(testRects[0])) {
- if (rects) {
- rects[0] = testRects[1];
- rects[1] = testRects[0];
- }
- if (dirs) {
- dirs[0] = testDirs[1];
- dirs[1] = testDirs[0];
- }
- return true;
- }
- }
- return false;
+ return SkPathPriv::IsRectContour(*this, false, &currVerb, &pts, isClosed, direction, rect);
}
bool SkPath::isOval(SkRect* bounds) const {
@@ -3729,3 +3556,181 @@
SkPointPriv::EqualsWithinTolerance(p2, p3) &&
SkPointPriv::EqualsWithinTolerance(p3, p4);
}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool SkPathPriv::IsRectContour(const SkPath& path, bool allowPartial, int* currVerb,
+ const SkPoint** ptsPtr, bool* isClosed, SkPath::Direction* direction,
+ SkRect* rect) {
+ int corners = 0;
+ SkPoint closeXY; // used to determine if final line falls on a diagonal
+ SkPoint lineStart; // used to construct line from previous point
+ const SkPoint* firstPt = nullptr; // first point in the rect (last of first moves)
+ const SkPoint* lastPt = nullptr; // last point in the rect (last of lines or first if closed)
+ SkPoint firstCorner;
+ SkPoint thirdCorner;
+ const SkPoint* pts = *ptsPtr;
+ const SkPoint* savePts = nullptr; // used to allow caller to iterate through a pair of rects
+ lineStart.set(0, 0);
+ signed char directions[] = {-1, -1, -1, -1, -1}; // -1 to 3; -1 is uninitialized
+ bool closedOrMoved = false;
+ bool autoClose = false;
+ bool insertClose = false;
+ int verbCnt = path.fPathRef->countVerbs();
+ while (*currVerb < verbCnt && (!allowPartial || !autoClose)) {
+ uint8_t verb = insertClose ? (uint8_t) SkPath::kClose_Verb : path.fPathRef->atVerb(*currVerb);
+ switch (verb) {
+ case SkPath::kClose_Verb:
+ savePts = pts;
+ autoClose = true;
+ insertClose = false;
+ case SkPath::kLine_Verb: {
+ if (SkPath::kClose_Verb != verb) {
+ lastPt = pts;
+ }
+ SkPoint lineEnd = SkPath::kClose_Verb == verb ? *firstPt : *pts++;
+ SkVector lineDelta = lineEnd - lineStart;
+ if (lineDelta.fX && lineDelta.fY) {
+ return false; // diagonal
+ }
+ if (!lineDelta.isFinite()) {
+ return false; // path contains infinity or NaN
+ }
+ if (lineStart == lineEnd) {
+ break; // single point on side OK
+ }
+ int nextDirection = rect_make_dir(lineDelta.fX, lineDelta.fY); // 0 to 3
+ if (0 == corners) {
+ directions[0] = nextDirection;
+ corners = 1;
+ closedOrMoved = false;
+ lineStart = lineEnd;
+ break;
+ }
+ if (closedOrMoved) {
+ return false; // closed followed by a line
+ }
+ if (autoClose && nextDirection == directions[0]) {
+ break; // colinear with first
+ }
+ closedOrMoved = autoClose;
+ if (directions[corners - 1] == nextDirection) {
+ if (3 == corners && SkPath::kLine_Verb == verb) {
+ thirdCorner = lineEnd;
+ }
+ lineStart = lineEnd;
+ break; // colinear segment
+ }
+ directions[corners++] = nextDirection;
+ // opposite lines must point in opposite directions; xoring them should equal 2
+ switch (corners) {
+ case 2:
+ firstCorner = lineStart;
+ break;
+ case 3:
+ if ((directions[0] ^ directions[2]) != 2) {
+ return false;
+ }
+ thirdCorner = lineEnd;
+ break;
+ case 4:
+ if ((directions[1] ^ directions[3]) != 2) {
+ return false;
+ }
+ break;
+ default:
+ return false; // too many direction changes
+ }
+ lineStart = lineEnd;
+ break;
+ }
+ case SkPath::kQuad_Verb:
+ case SkPath::kConic_Verb:
+ case SkPath::kCubic_Verb:
+ return false; // quadratic, cubic not allowed
+ case SkPath::kMove_Verb:
+ if (allowPartial && !autoClose && directions[0] >= 0) {
+ insertClose = true;
+ *currVerb -= 1; // try move again afterwards
+ goto addMissingClose;
+ }
+ if (!corners) {
+ firstPt = pts;
+ } else {
+ closeXY = *firstPt - *lastPt;
+ if (closeXY.fX && closeXY.fY) {
+ return false; // we're diagonal, abort
+ }
+ }
+ lineStart = *pts++;
+ closedOrMoved = true;
+ break;
+ default:
+ SkDEBUGFAIL("unexpected verb");
+ break;
+ }
+ *currVerb += 1;
+ addMissingClose:
+ ;
+ }
+ // Success if 4 corners and first point equals last
+ if (corners < 3 || corners > 4) {
+ return false;
+ }
+ if (savePts) {
+ *ptsPtr = savePts;
+ }
+ // check if close generates diagonal
+ closeXY = *firstPt - *lastPt;
+ if (closeXY.fX && closeXY.fY) {
+ return false;
+ }
+ if (rect) {
+ rect->set(firstCorner, thirdCorner);
+ }
+ if (isClosed) {
+ *isClosed = autoClose;
+ }
+ if (direction) {
+ *direction = directions[0] == ((directions[1] + 1) & 3) ?
+ SkPath::kCW_Direction : SkPath::kCCW_Direction;
+ }
+ return true;
+}
+
+
+bool SkPathPriv::IsNestedFillRects(const SkPath& path, SkRect rects[2], SkPath::Direction dirs[2]) {
+ SkDEBUGCODE(path.validate();)
+ int currVerb = 0;
+ const SkPoint* pts = path.fPathRef->points();
+ SkPath::Direction testDirs[2];
+ SkRect testRects[2];
+ if (!IsRectContour(path, true, &currVerb, &pts, nullptr, &testDirs[0], &testRects[0])) {
+ return false;
+ }
+ if (IsRectContour(path, false, &currVerb, &pts, nullptr, &testDirs[1], &testRects[1])) {
+ if (testRects[0].contains(testRects[1])) {
+ if (rects) {
+ rects[0] = testRects[0];
+ rects[1] = testRects[1];
+ }
+ if (dirs) {
+ dirs[0] = testDirs[0];
+ dirs[1] = testDirs[1];
+ }
+ return true;
+ }
+ if (testRects[1].contains(testRects[0])) {
+ if (rects) {
+ rects[0] = testRects[1];
+ rects[1] = testRects[0];
+ }
+ if (dirs) {
+ dirs[0] = testDirs[1];
+ dirs[1] = testDirs[0];
+ }
+ return true;
+ }
+ }
+ return false;
+}
diff --git a/src/core/SkPathPriv.h b/src/core/SkPathPriv.h
index 0ad83f4..7fc5966 100644
--- a/src/core/SkPathPriv.h
+++ b/src/core/SkPathPriv.h
@@ -280,6 +280,24 @@
}
return true;
}
+
+ static bool IsRectContour(const SkPath&, bool allowPartial, int* currVerb,
+ const SkPoint** ptsPtr, bool* isClosed, SkPath::Direction* direction,
+ SkRect* rect);
+
+ /** Returns true if SkPath is equivalent to nested SkRect pair when filled.
+ If false, rect and dirs are unchanged.
+ If true, rect and dirs are written to if not nullptr:
+ setting rect[0] to outer SkRect, and rect[1] to inner SkRect;
+ setting dirs[0] to SkPath::Direction of outer SkRect, and dirs[1] to SkPath::Direction of
+ inner SkRect.
+
+ @param rect storage for SkRect pair; may be nullptr
+ @param dirs storage for SkPath::Direction pair; may be nullptr
+ @return true if SkPath contains nested SkRect pair
+ */
+ static bool IsNestedFillRects(const SkPath&, SkRect rect[2],
+ SkPath::Direction dirs[2] = nullptr);
};
// Lightweight variant of SkPath::Iter that only returns segments (e.g. lines/conics).
diff --git a/src/gpu/geometry/GrShape.h b/src/gpu/geometry/GrShape.h
index 09af83f..37f38f8 100644
--- a/src/gpu/geometry/GrShape.h
+++ b/src/gpu/geometry/GrShape.h
@@ -256,7 +256,7 @@
}
SkPath::Direction dirs[2];
- if (!this->path().isNestedFillRects(rects, dirs)) {
+ if (!SkPathPriv::IsNestedFillRects(this->path(), rects, dirs)) {
return false;
}
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 455b0f6..03318bb 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1332,31 +1332,6 @@
return ret_count;
}
-static const char* dir2string(SkPath::Direction dir) {
- static const char* gStr[] = {
- "unknown", "cw", "ccw"
- };
- SkASSERT((unsigned)dir < SK_ARRAY_COUNT(gStr));
- return gStr[dir];
-}
-
-static int lpath_isNestedFillRects(lua_State* L) {
- SkRect rects[2];
- SkPath::Direction dirs[2];
- bool pred = get_obj<SkPath>(L, 1)->isNestedFillRects(rects, dirs);
- int ret_count = 1;
- lua_pushboolean(L, pred);
- if (pred) {
- SkLua lua(L);
- lua.pushRect(rects[0]);
- lua.pushRect(rects[1]);
- lua_pushstring(L, dir2string(dirs[0]));
- lua_pushstring(L, dir2string(dirs[0]));
- ret_count += 4;
- }
- return ret_count;
-}
-
static int lpath_countPoints(lua_State* L) {
lua_pushinteger(L, get_obj<SkPath>(L, 1)->countPoints());
return 1;
@@ -1447,7 +1422,6 @@
{ "isConvex", lpath_isConvex },
{ "isEmpty", lpath_isEmpty },
{ "isRect", lpath_isRect },
- { "isNestedFillRects", lpath_isNestedFillRects },
{ "countPoints", lpath_countPoints },
{ "reset", lpath_reset },
{ "moveTo", lpath_moveTo },
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 81973af..54ef767 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -2457,7 +2457,7 @@
path.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
}
REPORTER_ASSERT(reporter,
- tests[testIndex].fIsNestedRect == path.isNestedFillRects(nullptr));
+ tests[testIndex].fIsNestedRect == SkPathPriv::IsNestedFillRects(path, nullptr));
if (tests[testIndex].fIsNestedRect) {
SkRect expected[2], computed[2];
SkPathPriv::FirstDirection expectedDirs[2];
@@ -2472,7 +2472,7 @@
expectedDirs[0] = SkPathPriv::kCCW_FirstDirection;
}
expectedDirs[1] = tests[testIndex].fDirection;
- REPORTER_ASSERT(reporter, path.isNestedFillRects(computed, computedDirs));
+ REPORTER_ASSERT(reporter, SkPathPriv::IsNestedFillRects(path, computed, computedDirs));
REPORTER_ASSERT(reporter, expected[0] == computed[0]);
REPORTER_ASSERT(reporter, expected[1] == computed[1]);
REPORTER_ASSERT(reporter, expectedDirs[0] == SkPathPriv::AsFirstDirection(computedDirs[0]));
@@ -2494,7 +2494,7 @@
if (!rectFirst) {
path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
}
- REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, move in the middle
path1.reset();
@@ -2512,7 +2512,7 @@
if (!rectFirst) {
path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
}
- REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, move on the edge
path1.reset();
@@ -2527,7 +2527,7 @@
if (!rectFirst) {
path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
}
- REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, quad
path1.reset();
@@ -2545,7 +2545,7 @@
if (!rectFirst) {
path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
}
- REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, cubic
path1.reset();
@@ -2563,13 +2563,13 @@
if (!rectFirst) {
path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
}
- REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
// fail, not nested
path1.reset();
path1.addRect(1, 1, 3, 3, SkPath::kCW_Direction);
path1.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
- REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, !SkPathPriv::IsNestedFillRects(path1, nullptr));
}
// pass, constructed explicitly from manually closed rects specified as moves/lines.
@@ -2584,7 +2584,7 @@
path.lineTo(9, 9);
path.lineTo(1, 9);
path.lineTo(1, 1);
- REPORTER_ASSERT(reporter, path.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, SkPathPriv::IsNestedFillRects(path, nullptr));
// pass, stroke rect
SkPath src, dst;
@@ -2593,7 +2593,7 @@
strokePaint.setStyle(SkPaint::kStroke_Style);
strokePaint.setStrokeWidth(2);
strokePaint.getFillPath(src, &dst);
- REPORTER_ASSERT(reporter, dst.isNestedFillRects(nullptr));
+ REPORTER_ASSERT(reporter, SkPathPriv::IsNestedFillRects(dst, nullptr));
}
static void write_and_read_back(skiatest::Reporter* reporter,
diff --git a/tests/StrokeTest.cpp b/tests/StrokeTest.cpp
index 1adb3a5..e13a775 100644
--- a/tests/StrokeTest.cpp
+++ b/tests/StrokeTest.cpp
@@ -9,6 +9,7 @@
#include "include/core/SkPath.h"
#include "include/core/SkRect.h"
#include "include/core/SkStrokeRec.h"
+#include "src/core/SkPathPriv.h"
#include "src/core/SkStroke.h"
#include "tests/Test.h"
@@ -75,7 +76,7 @@
bool isMiter = SkPaint::kMiter_Join == joins[i];
SkRect nested[2];
- REPORTER_ASSERT(reporter, fillPath.isNestedFillRects(nested) == isMiter);
+ REPORTER_ASSERT(reporter, SkPathPriv::IsNestedFillRects(fillPath, nested) == isMiter);
if (isMiter) {
SkRect inner(r);
inner.inset(width/2, width/2);
diff --git a/tools/fiddle/all_examples.cpp b/tools/fiddle/all_examples.cpp
index aaa07eb..ea8d5fd 100644
--- a/tools/fiddle/all_examples.cpp
+++ b/tools/fiddle/all_examples.cpp
@@ -703,7 +703,6 @@
#include "../../docs/examples/Path_isInverseFillType_2.cpp"
#include "../../docs/examples/Path_isLastContourClosed.cpp"
#include "../../docs/examples/Path_isLine.cpp"
-#include "../../docs/examples/Path_isNestedFillRects.cpp"
#include "../../docs/examples/Path_isOval.cpp"
#include "../../docs/examples/Path_isRRect.cpp"
#include "../../docs/examples/Path_isRect.cpp"
