diff --git a/core/fpdfapi/edit/cpdf_pagecontentgenerator.cpp b/core/fpdfapi/edit/cpdf_pagecontentgenerator.cpp
index 125d381..e288828 100644
--- a/core/fpdfapi/edit/cpdf_pagecontentgenerator.cpp
+++ b/core/fpdfapi/edit/cpdf_pagecontentgenerator.cpp
@@ -347,16 +347,16 @@
 
     *buf << points[i].m_Point;
 
-    FXPT_TYPE point_type = points[i].m_Type;
-    if (point_type == FXPT_TYPE::MoveTo) {
+    CFX_Path::Point::Type point_type = points[i].m_Type;
+    if (point_type == CFX_Path::Point::Type::kMove) {
       *buf << " m";
-    } else if (point_type == FXPT_TYPE::LineTo) {
+    } else if (point_type == CFX_Path::Point::Type::kLine) {
       *buf << " l";
-    } else if (point_type == FXPT_TYPE::BezierTo) {
+    } else if (point_type == CFX_Path::Point::Type::kBezier) {
       if (i + 2 >= points.size() ||
-          !points[i].IsTypeAndOpen(FXPT_TYPE::BezierTo) ||
-          !points[i + 1].IsTypeAndOpen(FXPT_TYPE::BezierTo) ||
-          points[i + 2].m_Type != FXPT_TYPE::BezierTo) {
+          !points[i].IsTypeAndOpen(CFX_Path::Point::Type::kBezier) ||
+          !points[i + 1].IsTypeAndOpen(CFX_Path::Point::Type::kBezier) ||
+          points[i + 2].m_Type != CFX_Path::Point::Type::kBezier) {
         // If format is not supported, close the path and paint
         *buf << " h";
         break;
diff --git a/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp b/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp
index 844ff89..041384f 100644
--- a/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp
+++ b/core/fpdfapi/edit/cpdf_pagecontentgenerator_unittest.cpp
@@ -68,10 +68,13 @@
   EXPECT_EQ("q 1 0 0 1 0 0 cm 10 5 3 25 re B* Q\n", ByteString(buf));
 
   pPathObj = std::make_unique<CPDF_PathObject>();
-  pPathObj->path().AppendPoint(CFX_PointF(0, 0), FXPT_TYPE::MoveTo);
-  pPathObj->path().AppendPoint(CFX_PointF(5.2f, 0), FXPT_TYPE::LineTo);
-  pPathObj->path().AppendPoint(CFX_PointF(5.2f, 3.78f), FXPT_TYPE::LineTo);
-  pPathObj->path().AppendPointAndClose(CFX_PointF(0, 3.78f), FXPT_TYPE::LineTo);
+  pPathObj->path().AppendPoint(CFX_PointF(0, 0), CFX_Path::Point::Type::kMove);
+  pPathObj->path().AppendPoint(CFX_PointF(5.2f, 0),
+                               CFX_Path::Point::Type::kLine);
+  pPathObj->path().AppendPoint(CFX_PointF(5.2f, 3.78f),
+                               CFX_Path::Point::Type::kLine);
+  pPathObj->path().AppendPointAndClose(CFX_PointF(0, 3.78f),
+                                       CFX_Path::Point::Type::kLine);
   buf.str("");
   TestProcessPath(&generator, &buf, pPathObj.get());
   EXPECT_EQ("q 1 0 0 1 0 0 cm 0 0 5.1999998 3.78 re n Q\n", ByteString(buf));
@@ -118,16 +121,17 @@
 
     pPathObj->set_filltype(CFX_FillRenderOptions::FillType::kWinding);
     pPathObj->path().AppendPoint(CFX_PointF(0.000000000000000000001f, 4.67f),
-                                 FXPT_TYPE::MoveTo);
+                                 CFX_Path::Point::Type::kMove);
     pPathObj->path().AppendPoint(
         CFX_PointF(0.000000000000000000001, 100000000000000.000002),
-        FXPT_TYPE::LineTo);
+        CFX_Path::Point::Type::kLine);
     pPathObj->path().AppendPoint(CFX_PointF(0.0000000000001f, 3.15f),
-                                 FXPT_TYPE::BezierTo);
-    pPathObj->path().AppendPoint(CFX_PointF(3.57f, 2.98f), FXPT_TYPE::BezierTo);
+                                 CFX_Path::Point::Type::kBezier);
+    pPathObj->path().AppendPoint(CFX_PointF(3.57f, 2.98f),
+                                 CFX_Path::Point::Type::kBezier);
     pPathObj->path().AppendPointAndClose(
         CFX_PointF(53.4f, 5000000000000000000.00000000000000004),
-        FXPT_TYPE::BezierTo);
+        CFX_Path::Point::Type::kBezier);
     auto dummy_page_dict = pdfium::MakeRetain<CPDF_Dictionary>();
     auto pTestPage =
         pdfium::MakeRetain<CPDF_Page>(nullptr, dummy_page_dict.Get());
@@ -147,17 +151,26 @@
 TEST_F(CPDF_PageContentGeneratorTest, ProcessPath) {
   auto pPathObj = std::make_unique<CPDF_PathObject>();
   pPathObj->set_filltype(CFX_FillRenderOptions::FillType::kWinding);
-  pPathObj->path().AppendPoint(CFX_PointF(3.102f, 4.67f), FXPT_TYPE::MoveTo);
-  pPathObj->path().AppendPoint(CFX_PointF(5.45f, 0.29f), FXPT_TYPE::LineTo);
-  pPathObj->path().AppendPoint(CFX_PointF(4.24f, 3.15f), FXPT_TYPE::BezierTo);
-  pPathObj->path().AppendPoint(CFX_PointF(4.65f, 2.98f), FXPT_TYPE::BezierTo);
-  pPathObj->path().AppendPoint(CFX_PointF(3.456f, 0.24f), FXPT_TYPE::BezierTo);
-  pPathObj->path().AppendPoint(CFX_PointF(10.6f, 11.15f), FXPT_TYPE::LineTo);
-  pPathObj->path().AppendPoint(CFX_PointF(11, 12.5f), FXPT_TYPE::LineTo);
-  pPathObj->path().AppendPoint(CFX_PointF(11.46f, 12.67f), FXPT_TYPE::BezierTo);
-  pPathObj->path().AppendPoint(CFX_PointF(11.84f, 12.96f), FXPT_TYPE::BezierTo);
+  pPathObj->path().AppendPoint(CFX_PointF(3.102f, 4.67f),
+                               CFX_Path::Point::Type::kMove);
+  pPathObj->path().AppendPoint(CFX_PointF(5.45f, 0.29f),
+                               CFX_Path::Point::Type::kLine);
+  pPathObj->path().AppendPoint(CFX_PointF(4.24f, 3.15f),
+                               CFX_Path::Point::Type::kBezier);
+  pPathObj->path().AppendPoint(CFX_PointF(4.65f, 2.98f),
+                               CFX_Path::Point::Type::kBezier);
+  pPathObj->path().AppendPoint(CFX_PointF(3.456f, 0.24f),
+                               CFX_Path::Point::Type::kBezier);
+  pPathObj->path().AppendPoint(CFX_PointF(10.6f, 11.15f),
+                               CFX_Path::Point::Type::kLine);
+  pPathObj->path().AppendPoint(CFX_PointF(11, 12.5f),
+                               CFX_Path::Point::Type::kLine);
+  pPathObj->path().AppendPoint(CFX_PointF(11.46f, 12.67f),
+                               CFX_Path::Point::Type::kBezier);
+  pPathObj->path().AppendPoint(CFX_PointF(11.84f, 12.96f),
+                               CFX_Path::Point::Type::kBezier);
   pPathObj->path().AppendPointAndClose(CFX_PointF(12, 13.64f),
-                                       FXPT_TYPE::BezierTo);
+                                       CFX_Path::Point::Type::kBezier);
 
   auto dummy_page_dict = pdfium::MakeRetain<CPDF_Dictionary>();
   auto pTestPage =
@@ -177,9 +190,10 @@
   auto pPathObj = std::make_unique<CPDF_PathObject>();
   pPathObj->set_stroke(true);
   pPathObj->set_filltype(CFX_FillRenderOptions::FillType::kWinding);
-  pPathObj->path().AppendPoint(CFX_PointF(1, 2), FXPT_TYPE::MoveTo);
-  pPathObj->path().AppendPoint(CFX_PointF(3, 4), FXPT_TYPE::LineTo);
-  pPathObj->path().AppendPointAndClose(CFX_PointF(5, 6), FXPT_TYPE::LineTo);
+  pPathObj->path().AppendPoint(CFX_PointF(1, 2), CFX_Path::Point::Type::kMove);
+  pPathObj->path().AppendPoint(CFX_PointF(3, 4), CFX_Path::Point::Type::kLine);
+  pPathObj->path().AppendPointAndClose(CFX_PointF(5, 6),
+                                       CFX_Path::Point::Type::kLine);
 
   static const std::vector<float> rgb = {0.5f, 0.7f, 0.35f};
   RetainPtr<CPDF_ColorSpace> pCS =
@@ -338,10 +352,10 @@
 
     // Add a clipping path.
     auto pPath = std::make_unique<CPDF_Path>();
-    pPath->AppendPoint(CFX_PointF(0, 0), FXPT_TYPE::MoveTo);
-    pPath->AppendPoint(CFX_PointF(5, 0), FXPT_TYPE::LineTo);
-    pPath->AppendPoint(CFX_PointF(5, 4), FXPT_TYPE::LineTo);
-    pPath->AppendPointAndClose(CFX_PointF(0, 4), FXPT_TYPE::LineTo);
+    pPath->AppendPoint(CFX_PointF(0, 0), CFX_Path::Point::Type::kMove);
+    pPath->AppendPoint(CFX_PointF(5, 0), CFX_Path::Point::Type::kLine);
+    pPath->AppendPoint(CFX_PointF(5, 4), CFX_Path::Point::Type::kLine);
+    pPath->AppendPointAndClose(CFX_PointF(0, 4), CFX_Path::Point::Type::kLine);
     pTextObj->m_ClipPath.Emplace();
     pTextObj->m_ClipPath.AppendPath(*pPath,
                                     CFX_FillRenderOptions::FillType::kEvenOdd);
diff --git a/core/fpdfapi/page/cpdf_path.cpp b/core/fpdfapi/page/cpdf_path.cpp
index 86fb106..9dd2077 100644
--- a/core/fpdfapi/page/cpdf_path.cpp
+++ b/core/fpdfapi/page/cpdf_path.cpp
@@ -54,13 +54,15 @@
   m_Ref.GetPrivateCopy()->AppendRect(left, bottom, right, top);
 }
 
-void CPDF_Path::AppendPoint(const CFX_PointF& point, FXPT_TYPE type) {
+void CPDF_Path::AppendPoint(const CFX_PointF& point,
+                            CFX_Path::Point::Type type) {
   CFX_Path data;
   data.AppendPoint(point, type);
   Append(data, nullptr);
 }
 
-void CPDF_Path::AppendPointAndClose(const CFX_PointF& point, FXPT_TYPE type) {
+void CPDF_Path::AppendPointAndClose(const CFX_PointF& point,
+                                    CFX_Path::Point::Type type) {
   CFX_Path data;
   data.AppendPointAndClose(point, type);
   Append(data, nullptr);
diff --git a/core/fpdfapi/page/cpdf_path.h b/core/fpdfapi/page/cpdf_path.h
index 57ac3f1..774319e 100644
--- a/core/fpdfapi/page/cpdf_path.h
+++ b/core/fpdfapi/page/cpdf_path.h
@@ -36,8 +36,8 @@
   void Append(const CFX_Path& path, const CFX_Matrix* pMatrix);
   void AppendFloatRect(const CFX_FloatRect& rect);
   void AppendRect(float left, float bottom, float right, float top);
-  void AppendPoint(const CFX_PointF& point, FXPT_TYPE type);
-  void AppendPointAndClose(const CFX_PointF& point, FXPT_TYPE type);
+  void AppendPoint(const CFX_PointF& point, CFX_Path::Point::Type type);
+  void AppendPointAndClose(const CFX_PointF& point, CFX_Path::Point::Type type);
 
   // TODO(tsepez): Remove when all access thru this class.
   const CFX_Path* GetObject() const { return m_Ref.GetObject(); }
diff --git a/core/fpdfapi/page/cpdf_streamcontentparser.cpp b/core/fpdfapi/page/cpdf_streamcontentparser.cpp
index 9b9a06f..633dee6 100644
--- a/core/fpdfapi/page/cpdf_streamcontentparser.cpp
+++ b/core/fpdfapi/page/cpdf_streamcontentparser.cpp
@@ -560,7 +560,7 @@
 }
 
 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
-  AddPathPoint(m_PathStartX, m_PathStartY, FXPT_TYPE::LineTo, true);
+  AddPathPoint(m_PathStartX, m_PathStartY, CFX_Path::Point::Type::kLine, true);
   AddPathObject(CFX_FillRenderOptions::FillType::kEvenOdd, true);
 }
 
@@ -667,9 +667,12 @@
 }
 
 void CPDF_StreamContentParser::Handle_CurveTo_123() {
-  AddPathPoint(GetNumber(5), GetNumber(4), FXPT_TYPE::BezierTo, false);
-  AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
-  AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
+  AddPathPoint(GetNumber(5), GetNumber(4), CFX_Path::Point::Type::kBezier,
+               false);
+  AddPathPoint(GetNumber(3), GetNumber(2), CFX_Path::Point::Type::kBezier,
+               false);
+  AddPathPoint(GetNumber(1), GetNumber(0), CFX_Path::Point::Type::kBezier,
+               false);
 }
 
 void CPDF_StreamContentParser::Handle_ConcatMatrix() {
@@ -900,8 +903,9 @@
     return;
 
   if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY)
-    AddPathPoint(m_PathStartX, m_PathStartY, FXPT_TYPE::LineTo, true);
-  else if (m_PathPoints.back().m_Type != FXPT_TYPE::MoveTo)
+    AddPathPoint(m_PathStartX, m_PathStartY, CFX_Path::Point::Type::kLine,
+                 true);
+  else if (m_PathPoints.back().m_Type != CFX_Path::Point::Type::kMove)
     m_PathPoints.back().m_CloseFigure = true;
 }
 
@@ -943,14 +947,14 @@
   if (m_ParamCount != 2)
     return;
 
-  AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::LineTo, false);
+  AddPathPoint(GetNumber(1), GetNumber(0), CFX_Path::Point::Type::kLine, false);
 }
 
 void CPDF_StreamContentParser::Handle_MoveTo() {
   if (m_ParamCount != 2)
     return;
 
-  AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::MoveTo, false);
+  AddPathPoint(GetNumber(1), GetNumber(0), CFX_Path::Point::Type::kMove, false);
   ParsePathObject();
 }
 
@@ -985,11 +989,11 @@
 }
 
 void CPDF_StreamContentParser::AddPathRect(float x, float y, float w, float h) {
-  AddPathPoint(x, y, FXPT_TYPE::MoveTo, false);
-  AddPathPoint(x + w, y, FXPT_TYPE::LineTo, false);
-  AddPathPoint(x + w, y + h, FXPT_TYPE::LineTo, false);
-  AddPathPoint(x, y + h, FXPT_TYPE::LineTo, false);
-  AddPathPoint(x, y, FXPT_TYPE::LineTo, true);
+  AddPathPoint(x, y, CFX_Path::Point::Type::kMove, false);
+  AddPathPoint(x + w, y, CFX_Path::Point::Type::kLine, false);
+  AddPathPoint(x + w, y + h, CFX_Path::Point::Type::kLine, false);
+  AddPathPoint(x, y + h, CFX_Path::Point::Type::kLine, false);
+  AddPathPoint(x, y, CFX_Path::Point::Type::kLine, true);
 }
 
 void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
@@ -1376,9 +1380,12 @@
 }
 
 void CPDF_StreamContentParser::Handle_CurveTo_23() {
-  AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_TYPE::BezierTo, false);
-  AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
-  AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
+  AddPathPoint(m_PathCurrentX, m_PathCurrentY, CFX_Path::Point::Type::kBezier,
+               false);
+  AddPathPoint(GetNumber(3), GetNumber(2), CFX_Path::Point::Type::kBezier,
+               false);
+  AddPathPoint(GetNumber(1), GetNumber(0), CFX_Path::Point::Type::kBezier,
+               false);
 }
 
 void CPDF_StreamContentParser::Handle_SetLineWidth() {
@@ -1394,9 +1401,12 @@
 }
 
 void CPDF_StreamContentParser::Handle_CurveTo_13() {
-  AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
-  AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
-  AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
+  AddPathPoint(GetNumber(3), GetNumber(2), CFX_Path::Point::Type::kBezier,
+               false);
+  AddPathPoint(GetNumber(1), GetNumber(0), CFX_Path::Point::Type::kBezier,
+               false);
+  AddPathPoint(GetNumber(1), GetNumber(0), CFX_Path::Point::Type::kBezier,
+               false);
 }
 
 void CPDF_StreamContentParser::Handle_NextLineShowText() {
@@ -1414,11 +1424,11 @@
 
 void CPDF_StreamContentParser::AddPathPoint(float x,
                                             float y,
-                                            FXPT_TYPE type,
+                                            CFX_Path::Point::Type type,
                                             bool close) {
   // If the path point is the same move as the previous one and neither of them
   // closes the path, then just skip it.
-  if (!close && type == FXPT_TYPE::MoveTo && !m_PathPoints.empty() &&
+  if (!close && type == CFX_Path::Point::Type::kMove && !m_PathPoints.empty() &&
       !m_PathPoints.back().m_CloseFigure &&
       m_PathPoints.back().m_Type == type && m_PathCurrentX == x &&
       m_PathCurrentY == y) {
@@ -1427,11 +1437,11 @@
 
   m_PathCurrentX = x;
   m_PathCurrentY = y;
-  if (type == FXPT_TYPE::MoveTo && !close) {
+  if (type == CFX_Path::Point::Type::kMove && !close) {
     m_PathStartX = x;
     m_PathStartY = y;
     if (!m_PathPoints.empty() &&
-        m_PathPoints.back().IsTypeAndOpen(FXPT_TYPE::MoveTo)) {
+        m_PathPoints.back().IsTypeAndOpen(CFX_Path::Point::Type::kMove)) {
       m_PathPoints.back().m_Point = CFX_PointF(x, y);
       return;
     }
@@ -1462,7 +1472,7 @@
     return;
   }
 
-  if (path_points.back().IsTypeAndOpen(FXPT_TYPE::MoveTo))
+  if (path_points.back().IsTypeAndOpen(CFX_Path::Point::Type::kMove))
     path_points.pop_back();
 
   CPDF_Path path;
@@ -1559,30 +1569,40 @@
         if (len == 1) {
           switch (strc[0]) {
             case kPathOperatorSubpath:
-              AddPathPoint(params[0], params[1], FXPT_TYPE::MoveTo, false);
+              AddPathPoint(params[0], params[1], CFX_Path::Point::Type::kMove,
+                           false);
               nParams = 0;
               break;
             case kPathOperatorLine:
-              AddPathPoint(params[0], params[1], FXPT_TYPE::LineTo, false);
+              AddPathPoint(params[0], params[1], CFX_Path::Point::Type::kLine,
+                           false);
               nParams = 0;
               break;
             case kPathOperatorCubicBezier1:
-              AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
-              AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
-              AddPathPoint(params[4], params[5], FXPT_TYPE::BezierTo, false);
+              AddPathPoint(params[0], params[1], CFX_Path::Point::Type::kBezier,
+                           false);
+              AddPathPoint(params[2], params[3], CFX_Path::Point::Type::kBezier,
+                           false);
+              AddPathPoint(params[4], params[5], CFX_Path::Point::Type::kBezier,
+                           false);
               nParams = 0;
               break;
             case kPathOperatorCubicBezier2:
-              AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_TYPE::BezierTo,
+              AddPathPoint(m_PathCurrentX, m_PathCurrentY,
+                           CFX_Path::Point::Type::kBezier, false);
+              AddPathPoint(params[0], params[1], CFX_Path::Point::Type::kBezier,
                            false);
-              AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
-              AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
+              AddPathPoint(params[2], params[3], CFX_Path::Point::Type::kBezier,
+                           false);
               nParams = 0;
               break;
             case kPathOperatorCubicBezier3:
-              AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
-              AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
-              AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
+              AddPathPoint(params[0], params[1], CFX_Path::Point::Type::kBezier,
+                           false);
+              AddPathPoint(params[2], params[3], CFX_Path::Point::Type::kBezier,
+                           false);
+              AddPathPoint(params[2], params[3], CFX_Path::Point::Type::kBezier,
+                           false);
               nParams = 0;
               break;
             case kPathOperatorClosePath:
diff --git a/core/fpdfapi/page/cpdf_streamcontentparser.h b/core/fpdfapi/page/cpdf_streamcontentparser.h
index 218a801..cf95937 100644
--- a/core/fpdfapi/page/cpdf_streamcontentparser.h
+++ b/core/fpdfapi/page/cpdf_streamcontentparser.h
@@ -108,7 +108,7 @@
 
   void OnChangeTextMatrix();
   void ParsePathObject();
-  void AddPathPoint(float x, float y, FXPT_TYPE type, bool close);
+  void AddPathPoint(float x, float y, CFX_Path::Point::Type type, bool close);
   void AddPathRect(float x, float y, float w, float h);
   void AddPathObject(CFX_FillRenderOptions::FillType fill_type, bool bStroke);
   CPDF_ImageObject* AddImage(RetainPtr<CPDF_Stream> pStream);
diff --git a/core/fpdfapi/render/cpdf_rendershading.cpp b/core/fpdfapi/render/cpdf_rendershading.cpp
index 852e123..8fb867b 100644
--- a/core/fpdfapi/render/cpdf_rendershading.cpp
+++ b/core/fpdfapi/render/cpdf_rendershading.cpp
@@ -793,8 +793,9 @@
   patch.bNoPathSmooth = bNoPathSmooth;
 
   for (int i = 0; i < 13; i++) {
-    patch.path.AppendPoint(CFX_PointF(),
-                           i == 0 ? FXPT_TYPE::MoveTo : FXPT_TYPE::BezierTo);
+    patch.path.AppendPoint(CFX_PointF(), i == 0
+                                             ? CFX_Path::Point::Type::kMove
+                                             : CFX_Path::Point::Type::kBezier);
   }
 
   CFX_PointF coords[16];
diff --git a/core/fxge/agg/fx_agg_driver.cpp b/core/fxge/agg/fx_agg_driver.cpp
index e37998d..05343f2 100644
--- a/core/fxge/agg/fx_agg_driver.cpp
+++ b/core/fxge/agg/fx_agg_driver.cpp
@@ -974,18 +974,18 @@
       pos = pObject2Device->Transform(pos);
 
     pos = HardClip(pos);
-    FXPT_TYPE point_type = points[i].m_Type;
-    if (point_type == FXPT_TYPE::MoveTo) {
+    CFX_Path::Point::Type point_type = points[i].m_Type;
+    if (point_type == CFX_Path::Point::Type::kMove) {
       agg_path.move_to(pos.x, pos.y);
-    } else if (point_type == FXPT_TYPE::LineTo) {
-      if (i > 0 && points[i - 1].IsTypeAndOpen(FXPT_TYPE::MoveTo) &&
+    } else if (point_type == CFX_Path::Point::Type::kLine) {
+      if (i > 0 && points[i - 1].IsTypeAndOpen(CFX_Path::Point::Type::kMove) &&
           (i == points.size() - 1 ||
-           points[i + 1].IsTypeAndOpen(FXPT_TYPE::MoveTo)) &&
+           points[i + 1].IsTypeAndOpen(CFX_Path::Point::Type::kMove)) &&
           points[i].m_Point == points[i - 1].m_Point) {
         pos.x += 1;
       }
       agg_path.line_to(pos.x, pos.y);
-    } else if (point_type == FXPT_TYPE::BezierTo) {
+    } else if (point_type == CFX_Path::Point::Type::kBezier) {
       if (i > 0 && i + 2 < points.size()) {
         CFX_PointF pos0 = points[i - 1].m_Point;
         CFX_PointF pos2 = points[i + 1].m_Point;
diff --git a/core/fxge/cfx_drawutils.cpp b/core/fxge/cfx_drawutils.cpp
index b213516..fe37685 100644
--- a/core/fxge/cfx_drawutils.cpp
+++ b/core/fxge/cfx_drawutils.cpp
@@ -19,16 +19,16 @@
   DCHECK(render_device);
   CFX_Path path;
   path.AppendPoint(CFX_PointF(view_bounding_box.left, view_bounding_box.top),
-                   FXPT_TYPE::MoveTo);
+                   CFX_Path::Point::Type::kMove);
   path.AppendPoint(CFX_PointF(view_bounding_box.left, view_bounding_box.bottom),
-                   FXPT_TYPE::LineTo);
+                   CFX_Path::Point::Type::kLine);
   path.AppendPoint(
       CFX_PointF(view_bounding_box.right, view_bounding_box.bottom),
-      FXPT_TYPE::LineTo);
+      CFX_Path::Point::Type::kLine);
   path.AppendPoint(CFX_PointF(view_bounding_box.right, view_bounding_box.top),
-                   FXPT_TYPE::LineTo);
+                   CFX_Path::Point::Type::kLine);
   path.AppendPoint(CFX_PointF(view_bounding_box.left, view_bounding_box.top),
-                   FXPT_TYPE::LineTo);
+                   CFX_Path::Point::Type::kLine);
 
   CFX_GraphStateData graph_state_data;
   graph_state_data.m_DashArray = {1.0f};
diff --git a/core/fxge/cfx_font.cpp b/core/fxge/cfx_font.cpp
index ed87968..472e7a7 100644
--- a/core/fxge/cfx_font.cpp
+++ b/core/fxge/cfx_font.cpp
@@ -64,12 +64,14 @@
     pdfium::span<const CFX_Path::Point> points = param->m_pPath->GetPoints();
     size = points.size();
 
-    if (size >= 2 && points[size - 2].IsTypeAndOpen(FXPT_TYPE::MoveTo) &&
+    if (size >= 2 &&
+        points[size - 2].IsTypeAndOpen(CFX_Path::Point::Type::kMove) &&
         points[size - 2].m_Point == points[size - 1].m_Point) {
       size -= 2;
     }
-    if (size >= 4 && points[size - 4].IsTypeAndOpen(FXPT_TYPE::MoveTo) &&
-        points[size - 3].IsTypeAndOpen(FXPT_TYPE::BezierTo) &&
+    if (size >= 4 &&
+        points[size - 4].IsTypeAndOpen(CFX_Path::Point::Type::kMove) &&
+        points[size - 3].IsTypeAndOpen(CFX_Path::Point::Type::kBezier) &&
         points[size - 3].m_Point == points[size - 4].m_Point &&
         points[size - 2].m_Point == points[size - 4].m_Point &&
         points[size - 1].m_Point == points[size - 4].m_Point) {
@@ -88,7 +90,7 @@
   param->m_pPath->ClosePath();
   param->m_pPath->AppendPoint(
       CFX_PointF(to->x / param->m_CoordUnit, to->y / param->m_CoordUnit),
-      FXPT_TYPE::MoveTo);
+      CFX_Path::Point::Type::kMove);
 
   param->m_CurX = to->x;
   param->m_CurY = to->y;
@@ -100,7 +102,7 @@
 
   param->m_pPath->AppendPoint(
       CFX_PointF(to->x / param->m_CoordUnit, to->y / param->m_CoordUnit),
-      FXPT_TYPE::LineTo);
+      CFX_Path::Point::Type::kLine);
 
   param->m_CurX = to->x;
   param->m_CurY = to->y;
@@ -115,16 +117,16 @@
                      param->m_CoordUnit,
                  (param->m_CurY + (control->y - param->m_CurY) * 2 / 3) /
                      param->m_CoordUnit),
-      FXPT_TYPE::BezierTo);
+      CFX_Path::Point::Type::kBezier);
 
   param->m_pPath->AppendPoint(
       CFX_PointF((control->x + (to->x - control->x) / 3) / param->m_CoordUnit,
                  (control->y + (to->y - control->y) / 3) / param->m_CoordUnit),
-      FXPT_TYPE::BezierTo);
+      CFX_Path::Point::Type::kBezier);
 
   param->m_pPath->AppendPoint(
       CFX_PointF(to->x / param->m_CoordUnit, to->y / param->m_CoordUnit),
-      FXPT_TYPE::BezierTo);
+      CFX_Path::Point::Type::kBezier);
 
   param->m_CurX = to->x;
   param->m_CurY = to->y;
@@ -139,15 +141,15 @@
 
   param->m_pPath->AppendPoint(CFX_PointF(control1->x / param->m_CoordUnit,
                                          control1->y / param->m_CoordUnit),
-                              FXPT_TYPE::BezierTo);
+                              CFX_Path::Point::Type::kBezier);
 
   param->m_pPath->AppendPoint(CFX_PointF(control2->x / param->m_CoordUnit,
                                          control2->y / param->m_CoordUnit),
-                              FXPT_TYPE::BezierTo);
+                              CFX_Path::Point::Type::kBezier);
 
   param->m_pPath->AppendPoint(
       CFX_PointF(to->x / param->m_CoordUnit, to->y / param->m_CoordUnit),
-      FXPT_TYPE::BezierTo);
+      CFX_Path::Point::Type::kBezier);
 
   param->m_CurX = to->x;
   param->m_CurY = to->y;
diff --git a/core/fxge/cfx_path.cpp b/core/fxge/cfx_path.cpp
index 5d4b29b..ee5ce2d 100644
--- a/core/fxge/cfx_path.cpp
+++ b/core/fxge/cfx_path.cpp
@@ -28,7 +28,7 @@
   }
 
   for (size_t i = 1; i < points.size(); ++i) {
-    if (points[i].m_Type != FXPT_TYPE::LineTo)
+    if (points[i].m_Type != CFX_Path::Point::Type::kLine)
       return false;
   }
   return true;
@@ -82,7 +82,7 @@
 
     // If the line does not move, skip this point.
     const auto& point = *it;
-    if (point.m_Type == FXPT_TYPE::LineTo && !point.m_CloseFigure &&
+    if (point.m_Type == CFX_Path::Point::Type::kLine && !point.m_CloseFigure &&
         !normalized.back().m_CloseFigure &&
         point.m_Point == normalized.back().m_Point) {
       continue;
@@ -247,7 +247,7 @@
 
 CFX_Path::Point::Point() = default;
 
-CFX_Path::Point::Point(const CFX_PointF& point, FXPT_TYPE type, bool close)
+CFX_Path::Point::Point(const CFX_PointF& point, Type type, bool close)
     : m_Point(point), m_Type(type), m_CloseFigure(close) {}
 
 CFX_Path::Point::Point(const Point& other) = default;
@@ -286,20 +286,20 @@
     m_Points[i].m_Point = matrix->Transform(m_Points[i].m_Point);
 }
 
-void CFX_Path::AppendPoint(const CFX_PointF& point, FXPT_TYPE type) {
+void CFX_Path::AppendPoint(const CFX_PointF& point, Point::Type type) {
   m_Points.push_back(Point(point, type, /*close=*/false));
 }
 
-void CFX_Path::AppendPointAndClose(const CFX_PointF& point, FXPT_TYPE type) {
+void CFX_Path::AppendPointAndClose(const CFX_PointF& point, Point::Type type) {
   m_Points.push_back(Point(point, type, /*close=*/true));
 }
 
 void CFX_Path::AppendLine(const CFX_PointF& pt1, const CFX_PointF& pt2) {
   if (m_Points.empty() || fabs(m_Points.back().m_Point.x - pt1.x) > 0.001 ||
       fabs(m_Points.back().m_Point.y - pt1.y) > 0.001) {
-    AppendPoint(pt1, FXPT_TYPE::MoveTo);
+    AppendPoint(pt1, CFX_Path::Point::Type::kMove);
   }
-  AppendPoint(pt2, FXPT_TYPE::LineTo);
+  AppendPoint(pt2, CFX_Path::Point::Type::kLine);
 }
 
 void CFX_Path::AppendFloatRect(const CFX_FloatRect& rect) {
@@ -339,7 +339,7 @@
   int iMiddlePoint = 0;
   bool bJoin;
   while (iPoint < m_Points.size()) {
-    if (m_Points[iPoint].IsTypeAndOpen(FXPT_TYPE::MoveTo)) {
+    if (m_Points[iPoint].IsTypeAndOpen(CFX_Path::Point::Type::kMove)) {
       if (iPoint + 1 == m_Points.size())
         break;
 
@@ -347,13 +347,13 @@
       iEndPoint = iPoint;
       bJoin = false;
     } else {
-      if (m_Points[iPoint].IsTypeAndOpen(FXPT_TYPE::BezierTo)) {
+      if (m_Points[iPoint].IsTypeAndOpen(CFX_Path::Point::Type::kBezier)) {
         rect.UpdateRect(m_Points[iPoint].m_Point);
         rect.UpdateRect(m_Points[iPoint + 1].m_Point);
         iPoint += 2;
       }
       if (iPoint == m_Points.size() - 1 ||
-          m_Points[iPoint + 1].IsTypeAndOpen(FXPT_TYPE::MoveTo)) {
+          m_Points[iPoint + 1].IsTypeAndOpen(CFX_Path::Point::Type::kMove)) {
         iStartPoint = iPoint - 1;
         iEndPoint = iPoint;
         bJoin = false;
diff --git a/core/fxge/cfx_path.h b/core/fxge/cfx_path.h
index c3a1c53..4f8da08 100644
--- a/core/fxge/cfx_path.h
+++ b/core/fxge/cfx_path.h
@@ -14,23 +14,23 @@
 #include "core/fxcrt/retain_ptr.h"
 #include "third_party/base/optional.h"
 
-enum class FXPT_TYPE : uint8_t { LineTo, BezierTo, MoveTo };
-
 class CFX_Path {
  public:
   class Point {
    public:
+    enum class Type : uint8_t { kLine, kBezier, kMove };
+
     Point();
-    Point(const CFX_PointF& point, FXPT_TYPE type, bool close);
+    Point(const CFX_PointF& point, Type type, bool close);
     Point(const Point& other);
     ~Point();
 
-    bool IsTypeAndOpen(FXPT_TYPE type) const {
+    bool IsTypeAndOpen(Type type) const {
       return m_Type == type && !m_CloseFigure;
     }
 
     CFX_PointF m_Point;
-    FXPT_TYPE m_Type;
+    Type m_Type;
     bool m_CloseFigure;
   };
 
@@ -41,7 +41,7 @@
 
   void Clear();
 
-  FXPT_TYPE GetType(int index) const { return m_Points[index].m_Type; }
+  Point::Type GetType(int index) const { return m_Points[index].m_Type; }
   bool IsClosingFigure(int index) const {
     return m_Points[index].m_CloseFigure;
   }
@@ -62,8 +62,8 @@
   void AppendFloatRect(const CFX_FloatRect& rect);
   void AppendRect(float left, float bottom, float right, float top);
   void AppendLine(const CFX_PointF& pt1, const CFX_PointF& pt2);
-  void AppendPoint(const CFX_PointF& point, FXPT_TYPE type);
-  void AppendPointAndClose(const CFX_PointF& point, FXPT_TYPE type);
+  void AppendPoint(const CFX_PointF& point, Point::Type type);
+  void AppendPointAndClose(const CFX_PointF& point, Point::Type type);
   void ClosePath();
 
  private:
diff --git a/core/fxge/cfx_path_unittest.cpp b/core/fxge/cfx_path_unittest.cpp
index 5ffe212..b601079 100644
--- a/core/fxge/cfx_path_unittest.cpp
+++ b/core/fxge/cfx_path_unittest.cpp
@@ -28,10 +28,10 @@
   EXPECT_EQ(CFX_FloatRect(), path.GetBoundingBox());
 
   // 4 points without a closed path makes a rect.
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({1, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({1, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({1, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({1, 0}, CFX_Path::Point::Type::kLine);
   EXPECT_EQ(4u, path.GetPoints().size());
   EXPECT_TRUE(path.IsRect());
   rect = path.GetRect(nullptr);
@@ -96,14 +96,14 @@
 
 TEST(CFX_Path, Hexagon) {
   CFX_Path path;
-  path.AppendPoint({1, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({3, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 2}, FXPT_TYPE::LineTo);
-  path.AppendPoint({1, 2}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
+  path.AppendPoint({1, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({3, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 2}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({1, 2}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
   ASSERT_EQ(6u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(5));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(5));
   EXPECT_FALSE(path.IsClosingFigure(5));
   EXPECT_FALSE(path.IsRect());
   EXPECT_FALSE(path.GetRect(nullptr).has_value());
@@ -111,7 +111,7 @@
 
   path.ClosePath();
   ASSERT_EQ(6u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(5));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(5));
   EXPECT_TRUE(path.IsClosingFigure(5));
   EXPECT_FALSE(path.IsRect());
   EXPECT_FALSE(path.GetRect(nullptr).has_value());
@@ -119,20 +119,20 @@
   // Calling ClosePath() repeatedly makes no difference.
   path.ClosePath();
   ASSERT_EQ(6u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(5));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(5));
   EXPECT_TRUE(path.IsClosingFigure(5));
   EXPECT_FALSE(path.IsRect());
   EXPECT_FALSE(path.GetRect(nullptr).has_value());
 
   // A hexagon with the same start/end point is still not a rectangle.
   path.Clear();
-  path.AppendPoint({1, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({3, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 2}, FXPT_TYPE::LineTo);
-  path.AppendPoint({1, 2}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({1, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({1, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({3, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 2}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({1, 2}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({1, 0}, CFX_Path::Point::Type::kLine);
   EXPECT_FALSE(path.IsRect());
   EXPECT_FALSE(path.GetRect(nullptr).has_value());
   EXPECT_EQ(CFX_FloatRect(0, 0, 3, 2), path.GetBoundingBox());
@@ -144,7 +144,7 @@
   path.AppendLine({0, 1}, {1, 1});
   path.AppendLine({1, 1}, {1, 0});
   ASSERT_EQ(4u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(3));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(3));
   EXPECT_FALSE(path.IsClosingFigure(3));
   EXPECT_TRUE(path.IsRect());
   Optional<CFX_FloatRect> rect = path.GetRect(nullptr);
@@ -159,7 +159,7 @@
 
   path.ClosePath();
   ASSERT_EQ(4u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(3));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(3));
   EXPECT_TRUE(path.IsClosingFigure(3));
   EXPECT_TRUE(path.IsRect());
   rect = path.GetRect(nullptr);
@@ -169,18 +169,18 @@
   // Calling ClosePath() repeatedly makes no difference.
   path.ClosePath();
   ASSERT_EQ(4u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(3));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(3));
   EXPECT_TRUE(path.IsClosingFigure(3));
   EXPECT_TRUE(path.IsRect());
   rect = path.GetRect(nullptr);
   ASSERT_TRUE(rect.has_value());
   EXPECT_EQ(CFX_FloatRect(0, 0, 1, 1), rect.value());
 
-  path.AppendPointAndClose({0, 0}, FXPT_TYPE::LineTo);
+  path.AppendPointAndClose({0, 0}, CFX_Path::Point::Type::kLine);
   ASSERT_EQ(5u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(3));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(3));
   EXPECT_TRUE(path.IsClosingFigure(3));
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(4));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(4));
   EXPECT_TRUE(path.IsClosingFigure(4));
   EXPECT_TRUE(path.IsRect());
   rect = path.GetRect(nullptr);
@@ -190,13 +190,13 @@
 
 TEST(CFX_Path, FivePointRect) {
   CFX_Path path;
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
   ASSERT_EQ(5u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(4));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(4));
   EXPECT_FALSE(path.IsClosingFigure(4));
   EXPECT_TRUE(path.IsRect());
   Optional<CFX_FloatRect> rect = path.GetRect(nullptr);
@@ -205,7 +205,7 @@
 
   path.ClosePath();
   ASSERT_EQ(5u, path.GetPoints().size());
-  EXPECT_EQ(FXPT_TYPE::LineTo, path.GetType(4));
+  EXPECT_EQ(CFX_Path::Point::Type::kLine, path.GetType(4));
   EXPECT_TRUE(path.IsClosingFigure(4));
   EXPECT_TRUE(path.IsRect());
   rect = path.GetRect(nullptr);
@@ -215,12 +215,12 @@
 
 TEST(CFX_Path, SixPlusPointRect) {
   CFX_Path path;
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
   EXPECT_TRUE(path.IsRect());
   Optional<CFX_FloatRect> rect = path.GetRect(nullptr);
   ASSERT_TRUE(rect.has_value());
@@ -228,19 +228,19 @@
   EXPECT_EQ(CFX_FloatRect(0, 0, 2, 1), path.GetBoundingBox());
 
   path.Clear();
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
   EXPECT_TRUE(path.IsRect());
   rect = path.GetRect(nullptr);
   ASSERT_TRUE(rect.has_value());
@@ -250,11 +250,11 @@
 
 TEST(CFX_Path, NotRect) {
   CFX_Path path;
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0.1f}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0.1f}, CFX_Path::Point::Type::kLine);
   EXPECT_FALSE(path.IsRect());
   Optional<CFX_FloatRect> rect = path.GetRect(nullptr);
   EXPECT_FALSE(rect.has_value());
@@ -267,62 +267,62 @@
   EXPECT_EQ(CFX_FloatRect(0, 0, 2, 1), path.GetBoundingBox());
 
   path.Clear();
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({3, 1}, FXPT_TYPE::LineTo);
-  path.AppendPointAndClose({0, 1}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({3, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPointAndClose({0, 1}, CFX_Path::Point::Type::kLine);
   EXPECT_FALSE(path.IsRect());
   rect = path.GetRect(nullptr);
   EXPECT_FALSE(rect.has_value());
   EXPECT_EQ(CFX_FloatRect(0, 0, 3, 1), path.GetBoundingBox());
 
   path.Clear();
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 1}, FXPT_TYPE::LineTo);
-  path.AppendPointAndClose({0, 1}, FXPT_TYPE::MoveTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPointAndClose({0, 1}, CFX_Path::Point::Type::kMove);
   EXPECT_FALSE(path.IsRect());
   rect = path.GetRect(nullptr);
   EXPECT_FALSE(rect.has_value());
   EXPECT_EQ(CFX_FloatRect(0, 0, 2, 1), path.GetBoundingBox());
 
   path.Clear();
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({3, 0}, FXPT_TYPE::LineTo);
-  path.AppendPointAndClose({0, 1}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({3, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPointAndClose({0, 1}, CFX_Path::Point::Type::kLine);
   EXPECT_FALSE(path.IsRect());
   rect = path.GetRect(nullptr);
   EXPECT_FALSE(rect.has_value());
   EXPECT_EQ(CFX_FloatRect(0, 0, 3, 1), path.GetBoundingBox());
 
   path.Clear();
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
   EXPECT_FALSE(path.IsRect());
   rect = path.GetRect(nullptr);
   EXPECT_FALSE(rect.has_value());
   EXPECT_EQ(CFX_FloatRect(0, 0, 2, 1), path.GetBoundingBox());
 
   path.Clear();
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
   EXPECT_FALSE(path.IsRect());
   rect = path.GetRect(nullptr);
   EXPECT_FALSE(rect.has_value());
   EXPECT_EQ(CFX_FloatRect(0, 0, 2, 1), path.GetBoundingBox());
 
   path.Clear();
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({2, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({2, 2}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({2, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({2, 2}, CFX_Path::Point::Type::kLine);
   EXPECT_FALSE(path.IsRect());
   rect = path.GetRect(nullptr);
   EXPECT_FALSE(rect.has_value());
@@ -335,11 +335,11 @@
 TEST(CFX_Path, EmptyRect) {
   // Document existing behavior where an empty rect is still considered a rect.
   CFX_Path path;
-  path.AppendPoint({0, 0}, FXPT_TYPE::MoveTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 1}, FXPT_TYPE::LineTo);
-  path.AppendPoint({0, 0}, FXPT_TYPE::LineTo);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kMove);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 1}, CFX_Path::Point::Type::kLine);
+  path.AppendPoint({0, 0}, CFX_Path::Point::Type::kLine);
   EXPECT_TRUE(path.IsRect());
   Optional<CFX_FloatRect> rect = path.GetRect(nullptr);
   ASSERT_TRUE(rect.has_value());
@@ -349,7 +349,7 @@
 
 TEST(CFX_Path, Append) {
   CFX_Path path;
-  path.AppendPoint({5, 6}, FXPT_TYPE::MoveTo);
+  path.AppendPoint({5, 6}, CFX_Path::Point::Type::kMove);
   ASSERT_EQ(1u, path.GetPoints().size());
   EXPECT_EQ(CFX_PointF(5, 6), path.GetPoint(0));
 
diff --git a/core/fxge/cfx_renderdevice.cpp b/core/fxge/cfx_renderdevice.cpp
index d60b341..02ebac7 100644
--- a/core/fxge/cfx_renderdevice.cpp
+++ b/core/fxge/cfx_renderdevice.cpp
@@ -326,10 +326,11 @@
   if (points.size() != 2 && points.size() != 3)
     return false;
 
-  if (points[0].m_Type != FXPT_TYPE::MoveTo ||
-      points[1].m_Type != FXPT_TYPE::LineTo ||
-      (points.size() == 3 && (points[2].m_Type != FXPT_TYPE::LineTo ||
-                              points[0].m_Point != points[2].m_Point))) {
+  if (points[0].m_Type != CFX_Path::Point::Type::kMove ||
+      points[1].m_Type != CFX_Path::Point::Type::kLine ||
+      (points.size() == 3 &&
+       (points[2].m_Type != CFX_Path::Point::Type::kLine ||
+        points[0].m_Point != points[2].m_Point))) {
     return false;
   }
 
@@ -347,8 +348,8 @@
       point = CFX_PointF(static_cast<int>(point.x) + 0.5f,
                          static_cast<int>(point.y) + 0.5f);
     }
-    new_path->AppendPoint(point,
-                          i == 0 ? FXPT_TYPE::MoveTo : FXPT_TYPE::LineTo);
+    new_path->AppendPoint(point, i == 0 ? CFX_Path::Point::Type::kMove
+                                        : CFX_Path::Point::Type::kLine);
   }
   if (adjust && matrix)
     *set_identity = true;
@@ -370,14 +371,16 @@
   CFX_Path temp_path;
   for (int i = 0; i < mid; i++) {
     if (!(points[mid - i - 1].m_Point == points[mid + i + 1].m_Point &&
-          points[mid - i - 1].m_Type != FXPT_TYPE::BezierTo &&
-          points[mid + i + 1].m_Type != FXPT_TYPE::BezierTo)) {
+          points[mid - i - 1].m_Type != CFX_Path::Point::Type::kBezier &&
+          points[mid + i + 1].m_Type != CFX_Path::Point::Type::kBezier)) {
       zero_area = false;
       break;
     }
 
-    temp_path.AppendPoint(points[mid - i].m_Point, FXPT_TYPE::MoveTo);
-    temp_path.AppendPoint(points[mid - i - 1].m_Point, FXPT_TYPE::LineTo);
+    temp_path.AppendPoint(points[mid - i].m_Point,
+                          CFX_Path::Point::Type::kMove);
+    temp_path.AppendPoint(points[mid - i - 1].m_Point,
+                          CFX_Path::Point::Type::kLine);
   }
   if (!zero_area)
     return false;
@@ -426,22 +429,23 @@
     return true;
 
   for (size_t i = 0; i < points.size(); i++) {
-    FXPT_TYPE point_type = points[i].m_Type;
-    if (point_type == FXPT_TYPE::MoveTo) {
+    CFX_Path::Point::Type point_type = points[i].m_Type;
+    if (point_type == CFX_Path::Point::Type::kMove) {
       DCHECK_EQ(0, i);
       continue;
     }
 
-    if (point_type == FXPT_TYPE::BezierTo) {
+    if (point_type == CFX_Path::Point::Type::kBezier) {
       i += 2;
       DCHECK(i < points.size());
       continue;
     }
 
-    DCHECK_EQ(point_type, FXPT_TYPE::LineTo);
+    DCHECK_EQ(point_type, CFX_Path::Point::Type::kLine);
     int next_index = (i + 1) % (points.size());
     const CFX_Path::Point& next = points[next_index];
-    if (next.m_Type == FXPT_TYPE::BezierTo || next.m_Type == FXPT_TYPE::MoveTo)
+    if (next.m_Type == CFX_Path::Point::Type::kBezier ||
+        next.m_Type == CFX_Path::Point::Type::kMove)
       continue;
 
     const CFX_Path::Point& prev = points[i - 1];
@@ -451,8 +455,8 @@
                       fabs(cur.m_Point.y - next.m_Point.y);
       const CFX_Path::Point& start = use_prev ? prev : cur;
       const CFX_Path::Point& end = use_prev ? points[next_index - 1] : next;
-      new_path->AppendPoint(start.m_Point, FXPT_TYPE::MoveTo);
-      new_path->AppendPoint(end.m_Point, FXPT_TYPE::LineTo);
+      new_path->AppendPoint(start.m_Point, CFX_Path::Point::Type::kMove);
+      new_path->AppendPoint(end.m_Point, CFX_Path::Point::Type::kLine);
       continue;
     }
 
@@ -462,8 +466,8 @@
                       fabs(cur.m_Point.x - next.m_Point.x);
       const CFX_Path::Point& start = use_prev ? prev : cur;
       const CFX_Path::Point& end = use_prev ? points[next_index - 1] : next;
-      new_path->AppendPoint(start.m_Point, FXPT_TYPE::MoveTo);
-      new_path->AppendPoint(end.m_Point, FXPT_TYPE::LineTo);
+      new_path->AppendPoint(start.m_Point, CFX_Path::Point::Type::kMove);
+      new_path->AppendPoint(end.m_Point, CFX_Path::Point::Type::kLine);
       continue;
     }
   }
@@ -694,8 +698,8 @@
     bool adjust = !!m_pDeviceDriver->GetDriverType();
     std::vector<CFX_Path::Point> sub_path;
     for (size_t i = 0; i < points.size(); i++) {
-      FXPT_TYPE point_type = points[i].m_Type;
-      if (point_type == FXPT_TYPE::MoveTo) {
+      CFX_Path::Point::Type point_type = points[i].m_Type;
+      if (point_type == CFX_Path::Point::Type::kMove) {
         // Process the exisitng sub path.
         DrawZeroAreaPath(sub_path, pObject2Device, adjust,
                          fill_options.aliased_path, fill_color, fill_alpha,
@@ -707,7 +711,7 @@
         continue;
       }
 
-      if (point_type == FXPT_TYPE::BezierTo) {
+      if (point_type == CFX_Path::Point::Type::kBezier) {
         sub_path.push_back(points[i]);
         sub_path.push_back(points[i + 1]);
         sub_path.push_back(points[i + 2]);
@@ -715,7 +719,7 @@
         continue;
       }
 
-      DCHECK_EQ(point_type, FXPT_TYPE::LineTo);
+      DCHECK_EQ(point_type, CFX_Path::Point::Type::kLine);
       sub_path.push_back(points[i]);
       continue;
     }
@@ -834,8 +838,8 @@
   }
   CFX_GraphStateData graph_state;
   CFX_Path path;
-  path.AppendPoint(ptMoveTo, FXPT_TYPE::MoveTo);
-  path.AppendPoint(ptLineTo, FXPT_TYPE::LineTo);
+  path.AppendPoint(ptMoveTo, CFX_Path::Point::Type::kMove);
+  path.AppendPoint(ptLineTo, CFX_Path::Point::Type::kLine);
   return m_pDeviceDriver->DrawPath(&path, nullptr, &graph_state, 0, color,
                                    fill_options, blend_type);
 }
@@ -1281,9 +1285,9 @@
                                     const FX_COLORREF& color) {
   DCHECK(!points.empty());
   CFX_Path path;
-  path.AppendPoint(points[0], FXPT_TYPE::MoveTo);
+  path.AppendPoint(points[0], CFX_Path::Point::Type::kMove);
   for (size_t i = 1; i < points.size(); ++i)
-    path.AppendPoint(points[i], FXPT_TYPE::LineTo);
+    path.AppendPoint(points[i], CFX_Path::Point::Type::kLine);
 
   DrawPath(&path, &mtUser2Device, nullptr, color, 0,
            CFX_FillRenderOptions::EvenOddOptions());
@@ -1308,8 +1312,8 @@
                                       const FX_COLORREF& color,
                                       float fWidth) {
   CFX_Path path;
-  path.AppendPoint(ptMoveTo, FXPT_TYPE::MoveTo);
-  path.AppendPoint(ptLineTo, FXPT_TYPE::LineTo);
+  path.AppendPoint(ptMoveTo, CFX_Path::Point::Type::kMove);
+  path.AppendPoint(ptLineTo, CFX_Path::Point::Type::kLine);
 
   CFX_GraphStateData gsd;
   gsd.m_LineWidth = fWidth;
@@ -1403,15 +1407,15 @@
 
       CFX_Path path;
       path.AppendPoint(CFX_PointF(fLeft + fHalfWidth, fBottom + fHalfWidth),
-                       FXPT_TYPE::MoveTo);
+                       CFX_Path::Point::Type::kMove);
       path.AppendPoint(CFX_PointF(fLeft + fHalfWidth, fTop - fHalfWidth),
-                       FXPT_TYPE::LineTo);
+                       CFX_Path::Point::Type::kLine);
       path.AppendPoint(CFX_PointF(fRight - fHalfWidth, fTop - fHalfWidth),
-                       FXPT_TYPE::LineTo);
+                       CFX_Path::Point::Type::kLine);
       path.AppendPoint(CFX_PointF(fRight - fHalfWidth, fBottom + fHalfWidth),
-                       FXPT_TYPE::LineTo);
+                       CFX_Path::Point::Type::kLine);
       path.AppendPoint(CFX_PointF(fLeft + fHalfWidth, fBottom + fHalfWidth),
-                       FXPT_TYPE::LineTo);
+                       CFX_Path::Point::Type::kLine);
       DrawPath(&path, pUser2Device, &gsd, 0, color.ToFXColor(nTransparency),
                CFX_FillRenderOptions::WindingOptions());
       break;
@@ -1424,21 +1428,22 @@
       CFX_Path path_left_top;
       path_left_top.AppendPoint(
           CFX_PointF(fLeft + fHalfWidth, fBottom + fHalfWidth),
-          FXPT_TYPE::MoveTo);
+          CFX_Path::Point::Type::kMove);
       path_left_top.AppendPoint(
-          CFX_PointF(fLeft + fHalfWidth, fTop - fHalfWidth), FXPT_TYPE::LineTo);
+          CFX_PointF(fLeft + fHalfWidth, fTop - fHalfWidth),
+          CFX_Path::Point::Type::kLine);
       path_left_top.AppendPoint(
           CFX_PointF(fRight - fHalfWidth, fTop - fHalfWidth),
-          FXPT_TYPE::LineTo);
+          CFX_Path::Point::Type::kLine);
       path_left_top.AppendPoint(CFX_PointF(fRight - fWidth, fTop - fWidth),
-                                FXPT_TYPE::LineTo);
+                                CFX_Path::Point::Type::kLine);
       path_left_top.AppendPoint(CFX_PointF(fLeft + fWidth, fTop - fWidth),
-                                FXPT_TYPE::LineTo);
+                                CFX_Path::Point::Type::kLine);
       path_left_top.AppendPoint(CFX_PointF(fLeft + fWidth, fBottom + fWidth),
-                                FXPT_TYPE::LineTo);
+                                CFX_Path::Point::Type::kLine);
       path_left_top.AppendPoint(
           CFX_PointF(fLeft + fHalfWidth, fBottom + fHalfWidth),
-          FXPT_TYPE::LineTo);
+          CFX_Path::Point::Type::kLine);
       DrawPath(&path_left_top, pUser2Device, &gsd,
                crLeftTop.ToFXColor(nTransparency), 0,
                CFX_FillRenderOptions::EvenOddOptions());
@@ -1446,22 +1451,24 @@
       CFX_Path path_right_bottom;
       path_right_bottom.AppendPoint(
           CFX_PointF(fRight - fHalfWidth, fTop - fHalfWidth),
-          FXPT_TYPE::MoveTo);
+          CFX_Path::Point::Type::kMove);
       path_right_bottom.AppendPoint(
           CFX_PointF(fRight - fHalfWidth, fBottom + fHalfWidth),
-          FXPT_TYPE::LineTo);
+          CFX_Path::Point::Type::kLine);
       path_right_bottom.AppendPoint(
           CFX_PointF(fLeft + fHalfWidth, fBottom + fHalfWidth),
-          FXPT_TYPE::LineTo);
+          CFX_Path::Point::Type::kLine);
       path_right_bottom.AppendPoint(
-          CFX_PointF(fLeft + fWidth, fBottom + fWidth), FXPT_TYPE::LineTo);
+          CFX_PointF(fLeft + fWidth, fBottom + fWidth),
+          CFX_Path::Point::Type::kLine);
       path_right_bottom.AppendPoint(
-          CFX_PointF(fRight - fWidth, fBottom + fWidth), FXPT_TYPE::LineTo);
+          CFX_PointF(fRight - fWidth, fBottom + fWidth),
+          CFX_Path::Point::Type::kLine);
       path_right_bottom.AppendPoint(CFX_PointF(fRight - fWidth, fTop - fWidth),
-                                    FXPT_TYPE::LineTo);
+                                    CFX_Path::Point::Type::kLine);
       path_right_bottom.AppendPoint(
           CFX_PointF(fRight - fHalfWidth, fTop - fHalfWidth),
-          FXPT_TYPE::LineTo);
+          CFX_Path::Point::Type::kLine);
       DrawPath(&path_right_bottom, pUser2Device, &gsd,
                crRightBottom.ToFXColor(nTransparency), 0,
                CFX_FillRenderOptions::EvenOddOptions());
@@ -1480,9 +1487,9 @@
 
       CFX_Path path;
       path.AppendPoint(CFX_PointF(fLeft, fBottom + fHalfWidth),
-                       FXPT_TYPE::MoveTo);
+                       CFX_Path::Point::Type::kMove);
       path.AppendPoint(CFX_PointF(fRight, fBottom + fHalfWidth),
-                       FXPT_TYPE::LineTo);
+                       CFX_Path::Point::Type::kLine);
       DrawPath(&path, pUser2Device, &gsd, 0, color.ToFXColor(nTransparency),
                CFX_FillRenderOptions::EvenOddOptions());
       break;
diff --git a/core/fxge/skia/fx_skia_device.cpp b/core/fxge/skia/fx_skia_device.cpp
index 1601c65..adb3596 100644
--- a/core/fxge/skia/fx_skia_device.cpp
+++ b/core/fxge/skia/fx_skia_device.cpp
@@ -330,12 +330,12 @@
   pdfium::span<const CFX_Path::Point> points = pPath->GetPoints();
   for (size_t i = 0; i < points.size(); ++i) {
     const CFX_PointF& point = points[i].m_Point;
-    FXPT_TYPE point_type = points[i].m_Type;
-    if (point_type == FXPT_TYPE::MoveTo) {
+    CFX_Path::Point::Type point_type = points[i].m_Type;
+    if (point_type == CFX_Path::Point::Type::kMove) {
       sk_path.moveTo(point.x, point.y);
-    } else if (point_type == FXPT_TYPE::LineTo) {
+    } else if (point_type == CFX_Path::Point::Type::kLine) {
       sk_path.lineTo(point.x, point.y);
-    } else if (point_type == FXPT_TYPE::BezierTo) {
+    } else if (point_type == CFX_Path::Point::Type::kBezier) {
       const CFX_PointF& point2 = points[i + 1].m_Point;
       const CFX_PointF& point3 = points[i + 2].m_Point;
       sk_path.cubicTo(point.x, point.y, point2.x, point2.y, point3.x, point3.y);
diff --git a/core/fxge/win32/cfx_psrenderer.cpp b/core/fxge/win32/cfx_psrenderer.cpp
index 9d50617..e82aec8 100644
--- a/core/fxge/win32/cfx_psrenderer.cpp
+++ b/core/fxge/win32/cfx_psrenderer.cpp
@@ -114,7 +114,7 @@
   size_t size = pPath->GetPoints().size();
 
   for (size_t i = 0; i < size; i++) {
-    FXPT_TYPE type = pPath->GetType(i);
+    CFX_Path::Point::Type type = pPath->GetType(i);
     bool closing = pPath->IsClosingFigure(i);
     CFX_PointF pos = pPath->GetPoint(i);
     if (pObject2Device)
@@ -122,15 +122,15 @@
 
     buf << pos.x << " " << pos.y;
     switch (type) {
-      case FXPT_TYPE::MoveTo:
+      case CFX_Path::Point::Type::kMove:
         buf << " m ";
         break;
-      case FXPT_TYPE::LineTo:
+      case CFX_Path::Point::Type::kLine:
         buf << " l ";
         if (closing)
           buf << "h ";
         break;
-      case FXPT_TYPE::BezierTo: {
+      case CFX_Path::Point::Type::kBezier: {
         CFX_PointF pos1 = pPath->GetPoint(i + 1);
         CFX_PointF pos2 = pPath->GetPoint(i + 2);
         if (pObject2Device) {
@@ -531,15 +531,15 @@
   for (size_t p = 0; p < TransformedPath.GetPoints().size(); p++) {
     CFX_PointF point = TransformedPath.GetPoint(p);
     switch (TransformedPath.GetType(p)) {
-      case FXPT_TYPE::MoveTo: {
+      case CFX_Path::Point::Type::kMove: {
         buf << point.x << " " << point.y << " m\n";
         break;
       }
-      case FXPT_TYPE::LineTo: {
+      case CFX_Path::Point::Type::kLine: {
         buf << point.x << " " << point.y << " l\n";
         break;
       }
-      case FXPT_TYPE::BezierTo: {
+      case CFX_Path::Point::Type::kBezier: {
         CFX_PointF point1 = TransformedPath.GetPoint(p + 1);
         CFX_PointF point2 = TransformedPath.GetPoint(p + 2);
         buf << point.x << " " << point.y << " " << point1.x << " " << point1.y
diff --git a/core/fxge/win32/cgdi_device_driver.cpp b/core/fxge/win32/cgdi_device_driver.cpp
index 597894b..6201c84 100644
--- a/core/fxge/win32/cgdi_device_driver.cpp
+++ b/core/fxge/win32/cgdi_device_driver.cpp
@@ -116,15 +116,15 @@
       pos = pMatrix->Transform(pos);
 
     CFX_Point screen(FXSYS_roundf(pos.x), FXSYS_roundf(pos.y));
-    FXPT_TYPE point_type = points[i].m_Type;
-    if (point_type == FXPT_TYPE::MoveTo) {
+    CFX_Path::Point::Type point_type = points[i].m_Type;
+    if (point_type == CFX_Path::Point::Type::kMove) {
       MoveToEx(hDC, screen.x, screen.y, nullptr);
-    } else if (point_type == FXPT_TYPE::LineTo) {
+    } else if (point_type == CFX_Path::Point::Type::kLine) {
       if (points[i].m_Point == points[i - 1].m_Point)
         screen.x++;
 
       LineTo(hDC, screen.x, screen.y);
-    } else if (point_type == FXPT_TYPE::BezierTo) {
+    } else if (point_type == CFX_Path::Point::Type::kBezier) {
       POINT lppt[3];
       lppt[0].x = screen.x;
       lppt[0].y = screen.y;
diff --git a/core/fxge/win32/cgdi_plus_ext.cpp b/core/fxge/win32/cgdi_plus_ext.cpp
index b2e3834..9be3371 100644
--- a/core/fxge/win32/cgdi_plus_ext.cpp
+++ b/core/fxge/win32/cgdi_plus_ext.cpp
@@ -715,17 +715,17 @@
     if (pos.y < -50000.0f)
       gp_points[i].Y = -50000.0f;
 
-    FXPT_TYPE point_type = points[i].m_Type;
-    if (point_type == FXPT_TYPE::MoveTo) {
+    CFX_Path::Point::Type point_type = points[i].m_Type;
+    if (point_type == CFX_Path::Point::Type::kMove) {
       gp_types[i] = Gdiplus::PathPointTypeStart;
       nSubPathes++;
       bSubClose = false;
       startpoint = i;
-    } else if (point_type == FXPT_TYPE::LineTo) {
+    } else if (point_type == CFX_Path::Point::Type::kLine) {
       gp_types[i] = Gdiplus::PathPointTypeLine;
-      if (points[i - 1].IsTypeAndOpen(FXPT_TYPE::MoveTo) &&
+      if (points[i - 1].IsTypeAndOpen(CFX_Path::Point::Type::kMove) &&
           (i == points.size() - 1 ||
-           points[i + 1].IsTypeAndOpen(FXPT_TYPE::MoveTo)) &&
+           points[i + 1].IsTypeAndOpen(CFX_Path::Point::Type::kMove)) &&
           gp_points[i].Y == gp_points[i - 1].Y &&
           gp_points[i].X == gp_points[i - 1].X) {
         gp_points[i].X += 0.01f;
@@ -735,7 +735,7 @@
           gp_points[i].Y != gp_points[i - 1].Y) {
         bSmooth = true;
       }
-    } else if (point_type == FXPT_TYPE::BezierTo) {
+    } else if (point_type == CFX_Path::Point::Type::kBezier) {
       gp_types[i] = Gdiplus::PathPointTypeBezier;
       bSmooth = true;
     }
diff --git a/fpdfsdk/fpdf_edit_embeddertest.cpp b/fpdfsdk/fpdf_edit_embeddertest.cpp
index 346bb6c..5577a12 100644
--- a/fpdfsdk/fpdf_edit_embeddertest.cpp
+++ b/fpdfsdk/fpdf_edit_embeddertest.cpp
@@ -413,8 +413,8 @@
   EXPECT_EQ(0u, B);
   EXPECT_EQ(128u, A);
 
-  // Make sure the path has 5 points (1 FXPT_TYPE::MoveTo and 4
-  // FXPT_TYPE::LineTo).
+  // Make sure the path has 5 points (1 CFX_Path::Point::Type::kMove and 4
+  // CFX_Path::Point::Type::kLine).
   ASSERT_EQ(5, FPDFPath_CountSegments(green_rect));
   // Verify actual coordinates.
   FPDF_PATHSEGMENT segment = FPDFPath_GetPathSegment(green_rect, 0);
@@ -466,8 +466,8 @@
   EXPECT_TRUE(FPDFPath_LineTo(black_path, 300, 100));
   EXPECT_TRUE(FPDFPath_Close(black_path));
 
-  // Make sure the path has 3 points (1 FXPT_TYPE::MoveTo and 2
-  // FXPT_TYPE::LineTo).
+  // Make sure the path has 3 points (1 CFX_Path::Point::Type::kMove and 2
+  // CFX_Path::Point::Type::kLine).
   ASSERT_EQ(3, FPDFPath_CountSegments(black_path));
   // Verify actual coordinates.
   segment = FPDFPath_GetPathSegment(black_path, 0);
diff --git a/fpdfsdk/fpdf_editpath.cpp b/fpdfsdk/fpdf_editpath.cpp
index e65982a..035fa83 100644
--- a/fpdfsdk/fpdf_editpath.cpp
+++ b/fpdfsdk/fpdf_editpath.cpp
@@ -30,12 +30,15 @@
 static_assert(CFX_GraphStateData::LineJoinBevel == FPDF_LINEJOIN_BEVEL,
               "CFX_GraphStateData::LineJoinBevel value mismatch");
 
-static_assert(static_cast<int>(FXPT_TYPE::LineTo) == FPDF_SEGMENT_LINETO,
-              "FXPT_TYPE::LineTo value mismatch");
-static_assert(static_cast<int>(FXPT_TYPE::BezierTo) == FPDF_SEGMENT_BEZIERTO,
-              "FXPT_TYPE::BezierTo value mismatch");
-static_assert(static_cast<int>(FXPT_TYPE::MoveTo) == FPDF_SEGMENT_MOVETO,
-              "FXPT_TYPE::MoveTo value mismatch");
+static_assert(static_cast<int>(CFX_Path::Point::Type::kLine) ==
+                  FPDF_SEGMENT_LINETO,
+              "CFX_Path::Point::Type::kLine value mismatch");
+static_assert(static_cast<int>(CFX_Path::Point::Type::kBezier) ==
+                  FPDF_SEGMENT_BEZIERTO,
+              "CFX_Path::Point::Type::kBezier value mismatch");
+static_assert(static_cast<int>(CFX_Path::Point::Type::kMove) ==
+                  FPDF_SEGMENT_MOVETO,
+              "CFX_Path::Point::Type::kMove value mismatch");
 
 namespace {
 
@@ -49,7 +52,7 @@
 FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPageObj_CreateNewPath(float x,
                                                                     float y) {
   auto pPathObj = std::make_unique<CPDF_PathObject>();
-  pPathObj->path().AppendPoint(CFX_PointF(x, y), FXPT_TYPE::MoveTo);
+  pPathObj->path().AppendPoint(CFX_PointF(x, y), CFX_Path::Point::Type::kMove);
   pPathObj->DefaultStates();
 
   // Caller takes ownership.
@@ -95,7 +98,7 @@
   if (!pPathObj)
     return false;
 
-  pPathObj->path().AppendPoint(CFX_PointF(x, y), FXPT_TYPE::MoveTo);
+  pPathObj->path().AppendPoint(CFX_PointF(x, y), CFX_Path::Point::Type::kMove);
   pPathObj->SetDirty(true);
   return true;
 }
@@ -107,7 +110,7 @@
   if (!pPathObj)
     return false;
 
-  pPathObj->path().AppendPoint(CFX_PointF(x, y), FXPT_TYPE::LineTo);
+  pPathObj->path().AppendPoint(CFX_PointF(x, y), CFX_Path::Point::Type::kLine);
   pPathObj->SetDirty(true);
   return true;
 }
@@ -124,9 +127,9 @@
     return false;
 
   CPDF_Path& cpath = pPathObj->path();
-  cpath.AppendPoint(CFX_PointF(x1, y1), FXPT_TYPE::BezierTo);
-  cpath.AppendPoint(CFX_PointF(x2, y2), FXPT_TYPE::BezierTo);
-  cpath.AppendPoint(CFX_PointF(x3, y3), FXPT_TYPE::BezierTo);
+  cpath.AppendPoint(CFX_PointF(x1, y1), CFX_Path::Point::Type::kBezier);
+  cpath.AppendPoint(CFX_PointF(x2, y2), CFX_Path::Point::Type::kBezier);
+  cpath.AppendPoint(CFX_PointF(x3, y3), CFX_Path::Point::Type::kBezier);
   pPathObj->SetDirty(true);
   return true;
 }
diff --git a/fpdfsdk/fpdf_transformpage.cpp b/fpdfsdk/fpdf_transformpage.cpp
index 9f6ed57..81d3c98 100644
--- a/fpdfsdk/fpdf_transformpage.cpp
+++ b/fpdfsdk/fpdf_transformpage.cpp
@@ -78,10 +78,10 @@
 
   for (size_t i = 0; i < points.size(); ++i) {
     buf << points[i].m_Point.x << " " << points[i].m_Point.y;
-    FXPT_TYPE point_type = points[i].m_Type;
-    if (point_type == FXPT_TYPE::MoveTo) {
+    CFX_Path::Point::Type point_type = points[i].m_Type;
+    if (point_type == CFX_Path::Point::Type::kMove) {
       buf << " m\n";
-    } else if (point_type == FXPT_TYPE::BezierTo) {
+    } else if (point_type == CFX_Path::Point::Type::kBezier) {
       buf << " " << points[i + 1].m_Point.x << " " << points[i + 1].m_Point.y
           << " " << points[i + 2].m_Point.x << " " << points[i + 2].m_Point.y;
       buf << " c";
@@ -90,7 +90,7 @@
       buf << "\n";
 
       i += 2;
-    } else if (point_type == FXPT_TYPE::LineTo) {
+    } else if (point_type == CFX_Path::Point::Type::kLine) {
       buf << " l";
       if (points[i].m_CloseFigure)
         buf << " h";
diff --git a/fpdfsdk/pwl/cpwl_caret.cpp b/fpdfsdk/pwl/cpwl_caret.cpp
index cf5e726..efc7404 100644
--- a/fpdfsdk/pwl/cpwl_caret.cpp
+++ b/fpdfsdk/pwl/cpwl_caret.cpp
@@ -42,8 +42,10 @@
   }
 
   CFX_Path path;
-  path.AppendPoint(CFX_PointF(fCaretX, fCaretBottom), FXPT_TYPE::MoveTo);
-  path.AppendPoint(CFX_PointF(fCaretX, fCaretTop), FXPT_TYPE::LineTo);
+  path.AppendPoint(CFX_PointF(fCaretX, fCaretBottom),
+                   CFX_Path::Point::Type::kMove);
+  path.AppendPoint(CFX_PointF(fCaretX, fCaretTop),
+                   CFX_Path::Point::Type::kLine);
 
   CFX_GraphStateData gsd;
   gsd.m_LineWidth = m_fWidth;
diff --git a/fpdfsdk/pwl/cpwl_cbbutton.cpp b/fpdfsdk/pwl/cpwl_cbbutton.cpp
index 47ed807..bea9785 100644
--- a/fpdfsdk/pwl/cpwl_cbbutton.cpp
+++ b/fpdfsdk/pwl/cpwl_cbbutton.cpp
@@ -46,10 +46,10 @@
   CFX_PointF pt3(ptCenter.x, ptCenter.y - kComboBoxTriangleQuarterLength);
 
   CFX_Path path;
-  path.AppendPoint(pt1, FXPT_TYPE::MoveTo);
-  path.AppendPoint(pt2, FXPT_TYPE::LineTo);
-  path.AppendPoint(pt3, FXPT_TYPE::LineTo);
-  path.AppendPoint(pt1, FXPT_TYPE::LineTo);
+  path.AppendPoint(pt1, CFX_Path::Point::Type::kMove);
+  path.AppendPoint(pt2, CFX_Path::Point::Type::kLine);
+  path.AppendPoint(pt3, CFX_Path::Point::Type::kLine);
+  path.AppendPoint(pt1, CFX_Path::Point::Type::kLine);
 
   pDevice->DrawPath(&path, &mtUser2Device, nullptr,
                     PWL_DEFAULT_BLACKCOLOR.ToFXColor(GetTransparency()), 0,
diff --git a/fpdfsdk/pwl/cpwl_edit.cpp b/fpdfsdk/pwl/cpwl_edit.cpp
index 24f3de1..8478511 100644
--- a/fpdfsdk/pwl/cpwl_edit.cpp
+++ b/fpdfsdk/pwl/cpwl_edit.cpp
@@ -193,8 +193,8 @@
     for (int32_t i = 0; i < nCharArray - 1; ++i) {
       bottom.x = rcClient.left + width * (i + 1);
       top.x = bottom.x;
-      path.AppendPoint(bottom, FXPT_TYPE::MoveTo);
-      path.AppendPoint(top, FXPT_TYPE::LineTo);
+      path.AppendPoint(bottom, CFX_Path::Point::Type::kMove);
+      path.AppendPoint(top, CFX_Path::Point::Type::kLine);
     }
     if (!path.GetPoints().empty()) {
       pDevice->DrawPath(&path, &mtUser2Device, &gsd, 0,
diff --git a/xfa/fgas/graphics/cfgas_gepath.cpp b/xfa/fgas/graphics/cfgas_gepath.cpp
index 81c70f9..39ca530 100644
--- a/xfa/fgas/graphics/cfgas_gepath.cpp
+++ b/xfa/fgas/graphics/cfgas_gepath.cpp
@@ -21,19 +21,19 @@
 }
 
 void CFGAS_GEPath::MoveTo(const CFX_PointF& point) {
-  path_.AppendPoint(point, FXPT_TYPE::MoveTo);
+  path_.AppendPoint(point, CFX_Path::Point::Type::kMove);
 }
 
 void CFGAS_GEPath::LineTo(const CFX_PointF& point) {
-  path_.AppendPoint(point, FXPT_TYPE::LineTo);
+  path_.AppendPoint(point, CFX_Path::Point::Type::kLine);
 }
 
 void CFGAS_GEPath::BezierTo(const CFX_PointF& c1,
                             const CFX_PointF& c2,
                             const CFX_PointF& to) {
-  path_.AppendPoint(c1, FXPT_TYPE::BezierTo);
-  path_.AppendPoint(c2, FXPT_TYPE::BezierTo);
-  path_.AppendPoint(to, FXPT_TYPE::BezierTo);
+  path_.AppendPoint(c1, CFX_Path::Point::Type::kBezier);
+  path_.AppendPoint(c2, CFX_Path::Point::Type::kBezier);
+  path_.AppendPoint(to, CFX_Path::Point::Type::kBezier);
 }
 
 void CFGAS_GEPath::ArcTo(const CFX_PointF& pos,
@@ -61,20 +61,20 @@
   CFX_PointF bezier;
   bezier.x = pos.x + (size.width * ((points[0].x * cs) - (points[0].y * sn)));
   bezier.y = pos.y + (size.height * ((points[0].x * sn) + (points[0].y * cs)));
-  path_.AppendPoint(bezier, FXPT_TYPE::BezierTo);
+  path_.AppendPoint(bezier, CFX_Path::Point::Type::kBezier);
 
   bezier.x = pos.x + (size.width * ((points[1].x * cs) - (points[1].y * sn)));
   bezier.y = pos.y + (size.height * ((points[1].x * sn) + (points[1].y * cs)));
-  path_.AppendPoint(bezier, FXPT_TYPE::BezierTo);
+  path_.AppendPoint(bezier, CFX_Path::Point::Type::kBezier);
 
   bezier.x = pos.x + (size.width * cos(start_angle + sweep_angle));
   bezier.y = pos.y + (size.height * sin(start_angle + sweep_angle));
-  path_.AppendPoint(bezier, FXPT_TYPE::BezierTo);
+  path_.AppendPoint(bezier, CFX_Path::Point::Type::kBezier);
 }
 
 void CFGAS_GEPath::AddLine(const CFX_PointF& p1, const CFX_PointF& p2) {
-  path_.AppendPoint(p1, FXPT_TYPE::MoveTo);
-  path_.AppendPoint(p2, FXPT_TYPE::LineTo);
+  path_.AppendPoint(p1, CFX_Path::Point::Type::kMove);
+  path_.AppendPoint(p2, CFX_Path::Point::Type::kLine);
 }
 
 void CFGAS_GEPath::AddRectangle(float left,
@@ -109,7 +109,7 @@
   CFX_PointF pos(original_pos.x + size.width, original_pos.y + size.height);
   path_.AppendPoint(pos + CFX_PointF(size.width * cos(start_angle),
                                      size.height * sin(start_angle)),
-                    FXPT_TYPE::MoveTo);
+                    CFX_Path::Point::Type::kMove);
 
   float total_sweep = 0;
   float local_sweep = 0;