remove dead code around old SkPath enums
Change-Id: I8dc06da48e881d3a9c40b47c799afe27bdcce819
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/257689
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>
diff --git a/docs/examples/Path_getFillType.cpp b/docs/examples/Path_getFillType.cpp
index f4e1cc7..915ce1f 100644
--- a/docs/examples/Path_getFillType.cpp
+++ b/docs/examples/Path_getFillType.cpp
@@ -6,9 +6,9 @@
void draw(SkCanvas* canvas) {
SkPath path;
SkDebugf("default path fill type is %s\n",
- path.getNewFillType() == SkPathFillType::kWinding ? "kWinding" :
- path.getNewFillType() == SkPathFillType::kEvenOdd ? "kEvenOdd" :
- path.getNewFillType() == SkPathFillType::kInverseWinding ? "kInverseWinding" :
+ path.getFillType() == SkPathFillType::kWinding ? "kWinding" :
+ path.getFillType() == SkPathFillType::kEvenOdd ? "kEvenOdd" :
+ path.getFillType() == SkPathFillType::kInverseWinding ? "kInverseWinding" :
"kInverseEvenOdd");
}
} // END FIDDLE
diff --git a/include/core/SkPath.h b/include/core/SkPath.h
index c78e889..993b327 100644
--- a/include/core/SkPath.h
+++ b/include/core/SkPath.h
@@ -41,26 +41,6 @@
class SK_API SkPath {
public:
-#ifdef SK_SUPPORT_LEGACY_PATH_DIRECTION_ENUM
- /** \enum SkPath::Direction
- Direction describes whether contour is clockwise or counterclockwise.
- When SkPath contains multiple overlapping contours, Direction together with
- FillType determines whether overlaps are filled or form holes.
-
- Direction also determines how contour is measured. For instance, dashing
- measures along SkPath to determine where to start and stop stroke; Direction
- will change dashed results as it steps clockwise or counterclockwise.
-
- Closed contours like SkRect, SkRRect, circle, and oval added with
- kCW_Direction travel clockwise; the same added with kCCW_Direction
- travel counterclockwise.
- */
- enum Direction : int {
- kCW_Direction = static_cast<int>(SkPathDirection::kCW),
- kCCW_Direction = static_cast<int>(SkPathDirection::kCCW)
- };
-#endif
-
/** Constructs an empty SkPath. By default, SkPath has no verbs, no SkPoint, and no weights.
SkPath::FillType is set to kWinding_FillType.
@@ -165,71 +145,6 @@
*/
bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
-#ifdef SK_SUPPORT_LEGACY_PATH_FILLTYPE_ENUM
- /** \enum SkPath::FillType
- FillType selects the rule used to fill SkPath. SkPath set to kWinding_FillType
- fills if the sum of contour edges is not zero, where clockwise edges add one, and
- counterclockwise edges subtract one. SkPath set to kEvenOdd_FillType fills if the
- number of contour edges is odd. Each FillType has an inverse variant that
- reverses the rule:
- kInverseWinding_FillType fills where the sum of contour edges is zero;
- kInverseEvenOdd_FillType fills where the number of contour edges is even.
- */
- enum FillType {
- kWinding_FillType = static_cast<int>(SkPathFillType::kWinding),
- kEvenOdd_FillType = static_cast<int>(SkPathFillType::kEvenOdd),
- kInverseWinding_FillType = static_cast<int>(SkPathFillType::kInverseWinding),
- kInverseEvenOdd_FillType = static_cast<int>(SkPathFillType::kInverseEvenOdd)
- };
-
- /** Returns FillType, the rule used to fill SkPath. FillType of a new SkPath is
- kWinding_FillType.
-
- @return one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType,
- kInverseEvenOdd_FillType
- */
- FillType getFillType() const { return (FillType)fFillType; }
-
- /** Sets FillType, the rule used to fill SkPath. While there is no check
- that ft is legal, values outside of FillType are not supported.
-
- @param ft one of: kWinding_FillType, kEvenOdd_FillType, kInverseWinding_FillType,
- kInverseEvenOdd_FillType
- */
- void setFillType(FillType ft) {
- fFillType = SkToU8(ft);
- }
-
- /** Returns true if fill is inverted and SkPath with fill represents area outside
- of its geometric bounds.
-
- @param fill one of: kWinding_FillType, kEvenOdd_FillType,
- kInverseWinding_FillType, kInverseEvenOdd_FillType
- @return true if SkPath fills outside its bounds
- */
- static bool IsInverseFillType(FillType fill) {
- static_assert(0 == kWinding_FillType, "fill_type_mismatch");
- static_assert(1 == kEvenOdd_FillType, "fill_type_mismatch");
- static_assert(2 == kInverseWinding_FillType, "fill_type_mismatch");
- static_assert(3 == kInverseEvenOdd_FillType, "fill_type_mismatch");
- return (fill & 2) != 0;
- }
-
- /** Returns equivalent SkPath::FillType representing SkPath fill inside its bounds.
- .
-
- @param fill one of: kWinding_FillType, kEvenOdd_FillType,
- kInverseWinding_FillType, kInverseEvenOdd_FillType
- @return fill, or kWinding_FillType or kEvenOdd_FillType if fill is inverted
- */
- static FillType ConvertToNonInverseFillType(FillType fill) {
- static_assert(0 == kWinding_FillType, "fill_type_mismatch");
- static_assert(1 == kEvenOdd_FillType, "fill_type_mismatch");
- static_assert(2 == kInverseWinding_FillType, "fill_type_mismatch");
- static_assert(3 == kInverseEvenOdd_FillType, "fill_type_mismatch");
- return (FillType)(fill & 1);
- }
-#else
/** Returns FillType, the rule used to fill SkPath. FillType of a new SkPath is
kWinding_FillType.
@@ -237,9 +152,9 @@
kInverseEvenOdd_FillType
*/
SkPathFillType getFillType() const { return (SkPathFillType)fFillType; }
-#endif
+
// Temporary method -- remove when we've switched to the new enum
- SkPathFillType getNewFillType() const { return (SkPathFillType)this->getFillType(); }
+// SkPathFillType getNewFillType() const { return (SkPathFillType)this->getFillType(); }
/** Sets FillType, the rule used to fill SkPath. While there is no check
that ft is legal, values outside of FillType are not supported.
@@ -255,7 +170,7 @@
@return true if FillType is kInverseWinding_FillType or kInverseEvenOdd_FillType
*/
- bool isInverseFillType() const { return SkPathFillType_IsInverse(this->getNewFillType()); }
+ bool isInverseFillType() const { return SkPathFillType_IsInverse(this->getFillType()); }
/** Replaces FillType with its inverse. The inverse of FillType describes the area
unmodified by the original FillType.
@@ -301,32 +216,6 @@
return SkPathConvexityType::kConvex == this->getConvexityType();
}
-#ifdef SK_SUPPORT_LEGACY_PATH_DIRECTION_ENUM
- /** \enum SkPath::Convexity
- SkPath is convex if it contains one contour and contour loops no more than
- 360 degrees, and contour angles all have same Direction. Convex SkPath
- may have better performance and require fewer resources on GPU surface.
-
- SkPath is concave when either at least one Direction change is clockwise and
- another is counterclockwise, or the sum of the changes in Direction is not 360
- degrees.
-
- Initially SkPath Convexity is kUnknown_Convexity. SkPath Convexity is computed
- if needed by destination SkSurface.
- */
- enum Convexity : uint8_t {
- kUnknown_Convexity = static_cast<int>(SkPathConvexityType::kUnknown),
- kConvex_Convexity = static_cast<int>(SkPathConvexityType::kConvex),
- kConcave_Convexity = static_cast<int>(SkPathConvexityType::kConcave),
- };
-
- Convexity getConvexity() const { return (Convexity)this->getConvexityType(); }
- Convexity getConvexityOrUnknown() const { return (Convexity)this->getConvexityTypeOrUnknown(); }
- void setConvexity(Convexity convexity) {
- this->setConvexityType((SkPathConvexityType)convexity);
- }
-#endif
-
/** Returns true if this path is recognized as an oval or circle.
bounds receives bounds of oval.
@@ -1795,58 +1684,6 @@
*/
bool isValid() const { return this->isValidImpl() && fPathRef->isValid(); }
-#ifdef SK_SUPPORT_LEGACY_PATH_DIRECTION_ENUM
- SkPath& arcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc,
- Direction sweep, SkScalar x, SkScalar y) {
- return this->arcTo(rx, ry, xAxisRotate, largeArc, (SkPathDirection)sweep, x, y);
- }
- SkPath& arcTo(const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, Direction sweep,
- const SkPoint xy) {
- return this->arcTo(r.fX, r.fY, xAxisRotate, largeArc, (SkPathDirection)sweep, xy.fX, xy.fY);
- }
- SkPath& rArcTo(SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc,
- Direction sweep, SkScalar dx, SkScalar dy) {
- return this->rArcTo(rx, ry, xAxisRotate, largeArc, (SkPathDirection)sweep, dx, dy);
- }
- bool isRect(SkRect* rect, bool* isClosed, Direction* direction) const {
- return this->isRect(rect, isClosed, (SkPathDirection*)direction);
- }
- bool isRect(SkRect* rect, bool* isClosed, nullptr_t) const {
- return this->isRect(rect, isClosed);
- }
- SkPath& addRect(const SkRect& rect, Direction dir) {
- return this->addRect(rect, (SkPathDirection)dir);
- }
- SkPath& addRect(const SkRect& rect, Direction dir, unsigned start) {
- return this->addRect(rect, (SkPathDirection)dir, start);
- }
- SkPath& addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom,
- Direction dir) {
- return this->addRect(left, top, right, bottom, (SkPathDirection)dir);
- }
- SkPath& addOval(const SkRect& oval, Direction dir) {
- return addOval(oval, (SkPathDirection)dir);
- }
- SkPath& addOval(const SkRect& oval, Direction dir, unsigned start) {
- return this->addOval(oval, (SkPathDirection)dir, start);
- }
- SkPath& addCircle(SkScalar x, SkScalar y, SkScalar radius, Direction dir) {
- return this->addCircle(x, y, radius, (SkPathDirection)dir);
- }
- SkPath& addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, Direction dir) {
- return this->addRoundRect(rect, rx, ry, (SkPathDirection)dir);
- }
- SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[], Direction dir) {
- return this->addRoundRect(rect, radii, (SkPathDirection)dir);
- }
- SkPath& addRRect(const SkRRect& rrect, Direction dir) {
- return this->addRRect(rrect, (SkPathDirection)dir);
- }
- SkPath& addRRect(const SkRRect& rrect, Direction dir, unsigned start) {
- return this->addRRect(rrect, (SkPathDirection)dir, start);
- }
-#endif
-
private:
sk_sp<SkPathRef> fPathRef;
int fLastMoveToIndex;
diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index 4192dfe..78e0e6c 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -242,7 +242,7 @@
};
inline GrFillRule GrFillRuleForSkPath(const SkPath& path) {
- switch (path.getNewFillType()) {
+ switch (path.getFillType()) {
case SkPathFillType::kWinding:
case SkPathFillType::kInverseWinding:
return GrFillRule::kNonzero;
diff --git a/modules/pathkit/pathkit_wasm_bindings.cpp b/modules/pathkit/pathkit_wasm_bindings.cpp
index 34358d5..2ac4675 100644
--- a/modules/pathkit/pathkit_wasm_bindings.cpp
+++ b/modules/pathkit/pathkit_wasm_bindings.cpp
@@ -356,9 +356,9 @@
}
JSString GetFillTypeString(const SkPath& path) {
- if (path.getNewFillType() == SkPathFillType::kWinding) {
+ if (path.getFillType() == SkPathFillType::kWinding) {
return emscripten::val("nonzero");
- } else if (path.getNewFillType() == SkPathFillType::kEvenOdd) {
+ } else if (path.getFillType() == SkPathFillType::kEvenOdd) {
return emscripten::val("evenodd");
} else {
SkDebugf("warning: can't translate inverted filltype to HTML Canvas\n");
diff --git a/modules/sksg/include/SkSGPath.h b/modules/sksg/include/SkSGPath.h
index d8ffcbe..167fea1 100644
--- a/modules/sksg/include/SkSGPath.h
+++ b/modules/sksg/include/SkSGPath.h
@@ -31,11 +31,11 @@
// SG_MAPPED_ATTRIBUTE(FillType, SkPathFillType, fPath)
SkPathFillType getFillType() const {
- return fPath.getNewFillType();
+ return fPath.getFillType();
}
void setFillType(SkPathFillType fillType) {
- if (fillType != fPath.getNewFillType()) {
+ if (fillType != fPath.getFillType()) {
fPath.setFillType(fillType);
this->invalidate();
}
diff --git a/modules/sksg/src/SkSGPath.cpp b/modules/sksg/src/SkSGPath.cpp
index 7ca5a04..a67eed8 100644
--- a/modules/sksg/src/SkSGPath.cpp
+++ b/modules/sksg/src/SkSGPath.cpp
@@ -30,7 +30,7 @@
SkRect Path::onRevalidate(InvalidationController*, const SkMatrix&) {
SkASSERT(this->hasInval());
- const auto ft = fPath.getNewFillType();
+ const auto ft = fPath.getFillType();
return (ft == SkPathFillType::kWinding || ft == SkPathFillType::kEvenOdd)
// "Containing" fills have finite bounds.
? fPath.computeTightBounds()
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 0ddeca8..23be078 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -2948,8 +2948,8 @@
break;
}
} while (!done);
- bool evenOddFill = SkPathFillType::kEvenOdd == this->getNewFillType()
- || SkPathFillType::kInverseEvenOdd == this->getNewFillType();
+ bool evenOddFill = SkPathFillType::kEvenOdd == this->getFillType()
+ || SkPathFillType::kInverseEvenOdd == this->getFillType();
if (evenOddFill) {
w &= 1;
}
diff --git a/src/core/SkScan_AAAPath.cpp b/src/core/SkScan_AAAPath.cpp
index 416df89..3612f05 100644
--- a/src/core/SkScan_AAAPath.cpp
+++ b/src/core/SkScan_AAAPath.cpp
@@ -1934,7 +1934,7 @@
aaa_walk_edges(&headEdge,
&tailEdge,
- path.getNewFillType(),
+ path.getFillType(),
blitter,
start_y,
stop_y,
diff --git a/src/core/SkScan_Path.cpp b/src/core/SkScan_Path.cpp
index cacc228..130d542 100644
--- a/src/core/SkScan_Path.cpp
+++ b/src/core/SkScan_Path.cpp
@@ -470,7 +470,7 @@
if (path.isConvex() && (nullptr == proc) && count >= 2) {
walk_simple_edges(&headEdge, blitter, start_y, stop_y);
} else {
- walk_edges(&headEdge, path.getNewFillType(), blitter, start_y, stop_y, proc,
+ walk_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, proc,
shiftedClip.right());
}
}
diff --git a/src/gpu/GrDistanceFieldGenFromVector.cpp b/src/gpu/GrDistanceFieldGenFromVector.cpp
index 11e375c..8637ffd 100644
--- a/src/gpu/GrDistanceFieldGenFromVector.cpp
+++ b/src/gpu/GrDistanceFieldGenFromVector.cpp
@@ -763,7 +763,7 @@
workingPath = path;
}
- if (!IsDistanceFieldSupportedFillType(workingPath.getNewFillType())) {
+ if (!IsDistanceFieldSupportedFillType(workingPath.getFillType())) {
return false;
}
@@ -829,7 +829,7 @@
kOutside = 1
} dfSign;
- switch (workingPath.getNewFillType()) {
+ switch (workingPath.getFillType()) {
case SkPathFillType::kWinding:
dfSign = windingNumber ? kInside : kOutside;
break;
diff --git a/src/gpu/GrTessellator.cpp b/src/gpu/GrTessellator.cpp
index 863e864..32037fe 100644
--- a/src/gpu/GrTessellator.cpp
+++ b/src/gpu/GrTessellator.cpp
@@ -2272,14 +2272,14 @@
Poly* path_to_polys(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds,
int contourCnt, SkArenaAlloc& alloc, bool antialias, bool* isLinear,
VertexList* outerMesh) {
- SkPathFillType fillType = path.getNewFillType();
+ SkPathFillType fillType = path.getFillType();
if (SkPathFillType_IsInverse(fillType)) {
contourCnt++;
}
std::unique_ptr<VertexList[]> contours(new VertexList[contourCnt]);
path_to_contours(path, tolerance, clipBounds, contours.get(), alloc, isLinear);
- return contours_to_polys(contours.get(), contourCnt, path.getNewFillType(), path.getBounds(),
+ return contours_to_polys(contours.get(), contourCnt, path.getFillType(), path.getBounds(),
antialias, outerMesh, alloc);
}
@@ -2343,7 +2343,7 @@
VertexList outerMesh;
Poly* polys = path_to_polys(path, tolerance, clipBounds, contourCnt, alloc, antialias,
isLinear, &outerMesh);
- SkPathFillType fillType = antialias ? SkPathFillType::kWinding : path.getNewFillType();
+ SkPathFillType fillType = antialias ? SkPathFillType::kWinding : path.getFillType();
int64_t count64 = count_points(polys, fillType);
if (antialias) {
count64 += count_outer_mesh_points(outerMesh);
@@ -2381,7 +2381,7 @@
bool isLinear;
Poly* polys = path_to_polys(path, tolerance, clipBounds, contourCnt, alloc, false, &isLinear,
nullptr);
- SkPathFillType fillType = path.getNewFillType();
+ SkPathFillType fillType = path.getFillType();
int64_t count64 = count_points(polys, fillType);
if (0 == count64 || count64 > SK_MaxS32) {
*verts = nullptr;
diff --git a/src/gpu/ccpr/GrCCFiller.cpp b/src/gpu/ccpr/GrCCFiller.cpp
index a4a3cfd..a349863 100644
--- a/src/gpu/ccpr/GrCCFiller.cpp
+++ b/src/gpu/ccpr/GrCCFiller.cpp
@@ -139,7 +139,7 @@
// When counting winding numbers in the stencil buffer, it works to use even/odd for the fan
// tessellation (where applicable). But we need to strip out inverse fill info because
// inverse-ness gets accounted for later on.
- fan.setFillType(SkPathFillType_ConvertToNonInverse(originalPath.getNewFillType()));
+ fan.setFillType(SkPathFillType_ConvertToNonInverse(originalPath.getFillType()));
}
SkASSERT(Verb::kBeginPath == verbs[verbsIdx]);
for (int i = verbsIdx + 1; i < verbs.count(); ++i) {
@@ -204,7 +204,7 @@
}
int weight = abs(tessWinding);
- if (SkPathFillType::kEvenOdd == fan.getNewFillType()) {
+ if (SkPathFillType::kEvenOdd == fan.getFillType()) {
SkASSERT(Algorithm::kCoverageCount != algorithm); // Covg. count always uses winding.
if (weight != 1) {
// The tessellator doesn't wrap weights modulo 2 when we request even/odd fill type.
diff --git a/src/gpu/geometry/GrShape.h b/src/gpu/geometry/GrShape.h
index ea87986..7278bb2 100644
--- a/src/gpu/geometry/GrShape.h
+++ b/src/gpu/geometry/GrShape.h
@@ -260,7 +260,7 @@
return false;
}
- if (SkPathFillType::kWinding == this->path().getNewFillType() && dirs[0] == dirs[1]) {
+ if (SkPathFillType::kWinding == this->path().getFillType() && dirs[0] == dirs[1]) {
// The two rects need to be wound opposite to each other
return false;
}
diff --git a/src/gpu/gl/GrGLPath.cpp b/src/gpu/gl/GrGLPath.cpp
index 798d8fd..4e2801a 100644
--- a/src/gpu/gl/GrGLPath.cpp
+++ b/src/gpu/gl/GrGLPath.cpp
@@ -315,7 +315,7 @@
fShouldFill = stroke.isFillStyle() ||
stroke.getStyle() == SkStrokeRec::kStrokeAndFill_Style;
- fFillType = convert_skpath_filltype(skPath->getNewFillType());
+ fFillType = convert_skpath_filltype(skPath->getFillType());
fBounds = skPath->getBounds();
SkScalar radius = stroke.getInflationRadius();
fBounds.outset(radius, radius);
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index 8f86c6a..492bf65 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -545,7 +545,7 @@
}
lastPassIsBounds = false;
} else {
- switch (path.getNewFillType()) {
+ switch (path.getFillType()) {
case SkPathFillType::kInverseEvenOdd:
reverse = true;
// fallthrough
diff --git a/src/pathops/SkOpBuilder.cpp b/src/pathops/SkOpBuilder.cpp
index 8a9eccd..b14baff 100644
--- a/src/pathops/SkOpBuilder.cpp
+++ b/src/pathops/SkOpBuilder.cpp
@@ -36,7 +36,7 @@
}
bool SkOpBuilder::FixWinding(SkPath* path) {
- SkPathFillType fillType = path->getNewFillType();
+ SkPathFillType fillType = path->getFillType();
if (fillType == SkPathFillType::kInverseEvenOdd) {
fillType = SkPathFillType::kInverseWinding;
} else if (fillType == SkPathFillType::kEvenOdd) {
diff --git a/src/pathops/SkPathOpsAsWinding.cpp b/src/pathops/SkPathOpsAsWinding.cpp
index 3f7050d..abf6af7 100644
--- a/src/pathops/SkPathOpsAsWinding.cpp
+++ b/src/pathops/SkPathOpsAsWinding.cpp
@@ -377,7 +377,7 @@
if (!path.isFinite()) {
return false;
}
- SkPathFillType fillType = path.getNewFillType();
+ SkPathFillType fillType = path.getFillType();
if (fillType == SkPathFillType::kWinding
|| fillType == SkPathFillType::kInverseWinding ) {
return set_result_path(result, path, fillType);
diff --git a/src/pathops/SkPathOpsDebug.cpp b/src/pathops/SkPathOpsDebug.cpp
index b610e9b..b104424 100644
--- a/src/pathops/SkPathOpsDebug.cpp
+++ b/src/pathops/SkPathOpsDebug.cpp
@@ -2927,7 +2927,7 @@
return;
}
#endif
- SkPathFillType fillType = path.getNewFillType();
+ SkPathFillType fillType = path.getFillType();
SkASSERT(fillType >= SkPathFillType::kWinding && fillType <= SkPathFillType::kInverseEvenOdd);
if (includeDeclaration) {
SkDebugf(" SkPath %s;\n", name);
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 615dc14..08d1e4e 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -505,7 +505,7 @@
maskDevice->makeFormXObjectFromDevice(dstMaskBounds, true), false,
SkPDFGraphicState::kLuminosity_SMaskMode, fDocument), content.stream());
SkPDFUtils::AppendRectangle(SkRect::Make(dstMaskBounds), content.stream());
- SkPDFUtils::PaintPath(SkPaint::kFill_Style, path.getNewFillType(), content.stream());
+ SkPDFUtils::PaintPath(SkPaint::kFill_Style, path.getFillType(), content.stream());
this->clearMaskOnGraphicState(content.stream());
}
@@ -592,7 +592,7 @@
paint->getStrokeCap() != SkPaint::kSquare_Cap);
SkPDFUtils::EmitPath(*pathPtr, paint->getStyle(), consumeDegeratePathSegments, content.stream(),
tolerance);
- SkPDFUtils::PaintPath(paint->getStyle(), pathPtr->getNewFillType(), content.stream());
+ SkPDFUtils::PaintPath(paint->getStyle(), pathPtr->getFillType(), content.stream());
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index 502050f..e908f50 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -595,7 +595,7 @@
if (path && !path->isEmpty()) {
setGlyphWidthAndBoundingBox(glyph->advanceX(), glyphBBox, &content);
SkPDFUtils::EmitPath(*path, SkPaint::kFill_Style, &content);
- SkPDFUtils::PaintPath(SkPaint::kFill_Style, path->getNewFillType(), &content);
+ SkPDFUtils::PaintPath(SkPaint::kFill_Style, path->getFillType(), &content);
} else {
auto pimg = to_image(gID, &smallGlyphs);
if (!pimg.fImage) {
diff --git a/src/pdf/SkPDFGraphicStackState.cpp b/src/pdf/SkPDFGraphicStackState.cpp
index af2fa19..23e9b55 100644
--- a/src/pdf/SkPDFGraphicStackState.cpp
+++ b/src/pdf/SkPDFGraphicStackState.cpp
@@ -104,7 +104,7 @@
static void append_clip_path(const SkPath& clipPath, SkWStream* wStream) {
SkPDFUtils::EmitPath(clipPath, SkPaint::kFill_Style, wStream);
- SkPathFillType clipFill = clipPath.getNewFillType();
+ SkPathFillType clipFill = clipPath.getFillType();
NOT_IMPLEMENTED(clipFill == SkPathFillType::kInverseEvenOdd, false);
NOT_IMPLEMENTED(clipFill == SkPathFillType::kInverseWinding, false);
if (clipFill == SkPathFillType::kEvenOdd) {
diff --git a/src/pdf/SkPDFUtils.cpp b/src/pdf/SkPDFUtils.cpp
index f00362e..56689ef 100644
--- a/src/pdf/SkPDFUtils.cpp
+++ b/src/pdf/SkPDFUtils.cpp
@@ -132,7 +132,7 @@
if (path.isRect(&rect, &isClosed, &direction) &&
isClosed &&
(SkPathDirection::kCW == direction ||
- SkPathFillType::kEvenOdd == path.getNewFillType()))
+ SkPathFillType::kEvenOdd == path.getFillType()))
{
SkPDFUtils::AppendRectangle(rect, content);
return;
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index 62b6f6f..3f21c04 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -727,7 +727,7 @@
const auto& p = e->getDeviceSpacePath();
AutoElement path("path", fWriter);
path.addPathAttributes(p);
- if (p.getNewFillType() == SkPathFillType::kEvenOdd) {
+ if (p.getFillType() == SkPathFillType::kEvenOdd) {
path.addAttribute("clip-rule", "evenodd");
}
} break;
@@ -851,7 +851,7 @@
elem.addPathAttributes(path);
// TODO: inverse fill types?
- if (path.getNewFillType() == SkPathFillType::kEvenOdd) {
+ if (path.getFillType() == SkPathFillType::kEvenOdd) {
elem.addAttribute("fill-rule", "evenodd");
}
}
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index a42489d..bba28f9 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1262,7 +1262,7 @@
}
static int lpath_getFillType(lua_State* L) {
- SkPathFillType fill = get_obj<SkPath>(L, 1)->getNewFillType();
+ SkPathFillType fill = get_obj<SkPath>(L, 1)->getFillType();
SkLua(L).pushString(fill_type_to_str(fill));
return 1;
}
diff --git a/src/xps/SkXPSDevice.cpp b/src/xps/SkXPSDevice.cpp
index 554c58c..d0ebcaf 100644
--- a/src/xps/SkXPSDevice.cpp
+++ b/src/xps/SkXPSDevice.cpp
@@ -1606,7 +1606,7 @@
//Set the fill rule.
SkPath* xpsCompatiblePath = fillablePath;
XPS_FILL_RULE xpsFillRule;
- switch (fillablePath->getNewFillType()) {
+ switch (fillablePath->getFillType()) {
case SkPathFillType::kWinding:
xpsFillRule = XPS_FILL_RULE_NONZERO;
break;
diff --git a/tests/GrShapeTest.cpp b/tests/GrShapeTest.cpp
index 01bb540..f9c7cf8 100644
--- a/tests/GrShapeTest.cpp
+++ b/tests/GrShapeTest.cpp
@@ -145,8 +145,8 @@
ignoreInversenessDifference = (canDropInverse1 != canDropInverse2);
}
bool ignoreWindingVsEvenOdd = false;
- if (SkPathFillType_ConvertToNonInverse(pathA.getNewFillType()) !=
- SkPathFillType_ConvertToNonInverse(pathB.getNewFillType())) {
+ if (SkPathFillType_ConvertToNonInverse(pathA.getFillType()) !=
+ SkPathFillType_ConvertToNonInverse(pathB.getFillType())) {
bool aCanChange = can_interchange_winding_and_even_odd_fill(a);
bool bCanChange = can_interchange_winding_and_even_odd_fill(b);
if (aCanChange != bCanChange) {
@@ -163,8 +163,8 @@
REPORTER_ASSERT(r, a.inverseFilled() == pA.isInverseFillType());
REPORTER_ASSERT(r, b.inverseFilled() == pB.isInverseFillType());
if (ignoreInversenessDifference) {
- pA.setFillType(SkPathFillType_ConvertToNonInverse(pathA.getNewFillType()));
- pB.setFillType(SkPathFillType_ConvertToNonInverse(pathB.getNewFillType()));
+ pA.setFillType(SkPathFillType_ConvertToNonInverse(pathA.getFillType()));
+ pB.setFillType(SkPathFillType_ConvertToNonInverse(pathB.getFillType()));
}
if (ignoreWindingVsEvenOdd) {
pA.setFillType(pA.isInverseFillType() ? SkPathFillType::kInverseEvenOdd
@@ -425,10 +425,10 @@
PathGeo(const SkPath& path, Invert invert) : fPath(path) {
SkASSERT(!path.isInverseFillType());
if (Invert::kYes == invert) {
- if (fPath.getNewFillType() == SkPathFillType::kEvenOdd) {
+ if (fPath.getFillType() == SkPathFillType::kEvenOdd) {
fPath.setFillType(SkPathFillType::kInverseEvenOdd);
} else {
- SkASSERT(fPath.getNewFillType() == SkPathFillType::kWinding);
+ SkASSERT(fPath.getFillType() == SkPathFillType::kWinding);
fPath.setFillType(SkPathFillType::kInverseWinding);
}
}
@@ -572,7 +572,7 @@
}
// The bounds API explicitly calls out that it does not consider inverseness.
SkPath p = path;
- p.setFillType(SkPathFillType_ConvertToNonInverse(path.getNewFillType()));
+ p.setFillType(SkPathFillType_ConvertToNonInverse(path.getFillType()));
REPORTER_ASSERT(r, test_bounds_by_rasterizing(p, bounds));
}
diff --git a/tests/PathOpsAsWindingTest.cpp b/tests/PathOpsAsWindingTest.cpp
index 327b633..f122678 100644
--- a/tests/PathOpsAsWindingTest.cpp
+++ b/tests/PathOpsAsWindingTest.cpp
@@ -61,7 +61,7 @@
test.setFillType(SkPathFillType::kEvenOdd);
REPORTER_ASSERT(reporter, AsWinding(test, &result));
REPORTER_ASSERT(reporter, result.isEmpty());
- REPORTER_ASSERT(reporter, result.getNewFillType() == SkPathFillType::kWinding);
+ REPORTER_ASSERT(reporter, result.getFillType() == SkPathFillType::kWinding);
// if test is convex
test.addCircle(5, 5, 10);
REPORTER_ASSERT(reporter, AsWinding(test, &result));
@@ -132,7 +132,7 @@
}
SkPath original = test;
REPORTER_ASSERT(reporter, AsWinding(test, &result));
- REPORTER_ASSERT(reporter, result.getNewFillType() == SkPathFillType::kWinding);
+ REPORTER_ASSERT(reporter, result.getFillType() == SkPathFillType::kWinding);
test.reset();
if (aFirst) {
test.addRect(rectA, dirA);
@@ -148,7 +148,7 @@
REPORTER_ASSERT(reporter, test == result);
// test that result may be input
REPORTER_ASSERT(reporter, AsWinding(original, &original));
- REPORTER_ASSERT(reporter, original.getNewFillType() == SkPathFillType::kWinding);
+ REPORTER_ASSERT(reporter, original.getFillType() == SkPathFillType::kWinding);
REPORTER_ASSERT(reporter, original == result);
}
}
@@ -170,7 +170,7 @@
}
test.setFillType(SkPathFillType::kEvenOdd);
REPORTER_ASSERT(reporter, AsWinding(test, &result));
- REPORTER_ASSERT(reporter, result.getNewFillType() == SkPathFillType::kWinding);
+ REPORTER_ASSERT(reporter, result.getFillType() == SkPathFillType::kWinding);
for (SkScalar x = rectA.fLeft - 1; x <= rectA.fRight + 1; ++x) {
for (SkScalar y = rectA.fTop - 1; y <= rectA.fBottom + 1; ++y) {
bool evenOddContains = test.contains(x, y);
diff --git a/tests/PathOpsSimplifyFailTest.cpp b/tests/PathOpsSimplifyFailTest.cpp
index 7503c55..a2b05f9 100644
--- a/tests/PathOpsSimplifyFailTest.cpp
+++ b/tests/PathOpsSimplifyFailTest.cpp
@@ -63,7 +63,7 @@
bool success = Simplify(path, &result);
REPORTER_ASSERT(reporter, !success);
REPORTER_ASSERT(reporter, result.isEmpty());
- REPORTER_ASSERT(reporter, result.getNewFillType() == SkPathFillType::kWinding);
+ REPORTER_ASSERT(reporter, result.getFillType() == SkPathFillType::kWinding);
reporter->bumpTestCount();
}
@@ -88,7 +88,7 @@
result.setFillType(SkPathFillType::kWinding);
bool success = Simplify(path, &result);
REPORTER_ASSERT(reporter, success);
- REPORTER_ASSERT(reporter, result.getNewFillType() != SkPathFillType::kWinding);
+ REPORTER_ASSERT(reporter, result.getFillType() != SkPathFillType::kWinding);
reporter->bumpTestCount();
}
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 713d7d4..54526fe 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -3583,7 +3583,7 @@
REPORTER_ASSERT(reporter, 0 == p.countVerbs());
REPORTER_ASSERT(reporter, 0 == p.getSegmentMasks());
REPORTER_ASSERT(reporter, p.isConvex());
- REPORTER_ASSERT(reporter, p.getNewFillType() == SkPathFillType::kWinding);
+ REPORTER_ASSERT(reporter, p.getFillType() == SkPathFillType::kWinding);
REPORTER_ASSERT(reporter, !p.isInverseFillType());
REPORTER_ASSERT(reporter, p == empty);
REPORTER_ASSERT(reporter, !(p != empty));
diff --git a/tools/debugger/DrawCommand.cpp b/tools/debugger/DrawCommand.cpp
index 36b1e67..1d5e88f 100644
--- a/tools/debugger/DrawCommand.cpp
+++ b/tools/debugger/DrawCommand.cpp
@@ -522,7 +522,7 @@
void DrawCommand::MakeJsonPath(SkJSONWriter& writer, const SkPath& path) {
writer.beginObject();
- switch (path.getNewFillType()) {
+ switch (path.getFillType()) {
case SkPathFillType::kWinding:
writer.appendString(DEBUGCANVAS_ATTRIBUTE_FILLTYPE, DEBUGCANVAS_FILLTYPE_WINDING);
break;
