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;