Nest FX_LOCALE* enums.

Put these inside the classes that use them in their methods.

-- Make enum class.
-- More closely follow style guide.

Change-Id: I5505c287432786e4b46b201aef9529818bf07da4
Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/74030
Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Tom Sepez <tsepez@chromium.org>
diff --git a/fxjs/xfa/cfxjse_formcalc_context.cpp b/fxjs/xfa/cfxjse_formcalc_context.cpp
index 974344f..388b4b8 100644
--- a/fxjs/xfa/cfxjse_formcalc_context.cpp
+++ b/fxjs/xfa/cfxjse_formcalc_context.cpp
@@ -425,21 +425,21 @@
   if (!bsFormat.IsEmpty())
     return WideString::FromUTF8(bsFormat);
 
-  return pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Default);
+  return pLocale->GetDatePattern(LocaleIface::DateTimeSubcategory::kDefault);
 }
 
-FX_LOCALEDATETIMESUBCATEGORY SubCategoryFromInt(int32_t iStyle) {
+LocaleIface::DateTimeSubcategory SubCategoryFromInt(int32_t iStyle) {
   switch (iStyle) {
     case 1:
-      return FX_LOCALEDATETIMESUBCATEGORY_Short;
+      return LocaleIface::DateTimeSubcategory::kShort;
     case 3:
-      return FX_LOCALEDATETIMESUBCATEGORY_Long;
+      return LocaleIface::DateTimeSubcategory::kLong;
     case 4:
-      return FX_LOCALEDATETIMESUBCATEGORY_Full;
+      return LocaleIface::DateTimeSubcategory::kFull;
     case 0:
     case 2:
     default:
-      return FX_LOCALEDATETIMESUBCATEGORY_Medium;
+      return LocaleIface::DateTimeSubcategory::kMedium;
   }
 }
 
@@ -453,7 +453,7 @@
   if (!pLocale)
     return ByteString();
 
-  FX_LOCALEDATETIMESUBCATEGORY category = SubCategoryFromInt(iStyle);
+  LocaleIface::DateTimeSubcategory category = SubCategoryFromInt(iStyle);
   WideString wsLocal = bIsDate ? pLocale->GetDatePattern(category)
                                : pLocale->GetTimePattern(category);
   if (!bStandard)
@@ -2382,11 +2382,12 @@
   }
 
   WideString wsFormat;
-  if (bsFormat.IsEmpty())
-    wsFormat = pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Default);
-  else
+  if (bsFormat.IsEmpty()) {
+    wsFormat =
+        pLocale->GetTimePattern(LocaleIface::DateTimeSubcategory::kDefault);
+  } else {
     wsFormat = WideString::FromUTF8(bsFormat.AsStringView());
-
+  }
   wsFormat = L"time{" + wsFormat + L"}";
   CXFA_LocaleValue localeValue(XFA_VT_TIME,
                                WideString::FromUTF8(bsTime.AsStringView()),
diff --git a/testing/fuzzers/pdf_cfgas_stringformatter_fuzzer.cc b/testing/fuzzers/pdf_cfgas_stringformatter_fuzzer.cc
index 095af86..663958b 100644
--- a/testing/fuzzers/pdf_cfgas_stringformatter_fuzzer.cc
+++ b/testing/fuzzers/pdf_cfgas_stringformatter_fuzzer.cc
@@ -15,9 +15,11 @@
 namespace {
 
 const wchar_t* const kLocales[] = {L"en", L"fr", L"jp", L"zh"};
-const FX_DATETIMETYPE kTypes[] = {FX_DATETIMETYPE_Date, FX_DATETIMETYPE_Time,
-                                  FX_DATETIMETYPE_DateTime,
-                                  FX_DATETIMETYPE_TimeDate};
+const CFGAS_StringFormatter::DateTimeType kTypes[] = {
+    CFGAS_StringFormatter::DateTimeType::kDate,
+    CFGAS_StringFormatter::DateTimeType::kTime,
+    CFGAS_StringFormatter::DateTimeType::kDateTime,
+    CFGAS_StringFormatter::DateTimeType::kTimeDate};
 
 }  // namespace
 
diff --git a/xfa/fgas/crt/cfgas_stringformatter.cpp b/xfa/fgas/crt/cfgas_stringformatter.cpp
index d20cb6d..91f3a39 100644
--- a/xfa/fgas/crt/cfgas_stringformatter.cpp
+++ b/xfa/fgas/crt/cfgas_stringformatter.cpp
@@ -34,32 +34,32 @@
 
 namespace {
 
-struct LocaleDateTimeSubCategoryWithHash {
+struct LocaleDateTimeSubcategoryWithHash {
   uint32_t uHash;  // Hashed as wide string.
-  FX_LOCALEDATETIMESUBCATEGORY eSubCategory;
+  LocaleIface::DateTimeSubcategory eSubCategory;
 };
 
-struct LocaleNumberSubCategoryWithHash {
+struct LocaleNumberSubcategoryWithHash {
   uint32_t uHash;  // Hashed as wide string.
-  FX_LOCALENUMSUBCATEGORY eSubCategory;
+  LocaleIface::NumSubcategory eSubCategory;
 };
 
 #undef SUBC
 #define SUBC(a, b, c) a, c
 
-const LocaleDateTimeSubCategoryWithHash g_FXLocaleDateTimeSubCatData[] = {
-    {SUBC(0x14da2125, "default", FX_LOCALEDATETIMESUBCATEGORY_Default)},
-    {SUBC(0x9041d4b0, "short", FX_LOCALEDATETIMESUBCATEGORY_Short)},
-    {SUBC(0xa084a381, "medium", FX_LOCALEDATETIMESUBCATEGORY_Medium)},
-    {SUBC(0xcdce56b3, "full", FX_LOCALEDATETIMESUBCATEGORY_Full)},
-    {SUBC(0xf6b4afb0, "long", FX_LOCALEDATETIMESUBCATEGORY_Long)},
+constexpr LocaleDateTimeSubcategoryWithHash kLocaleDateTimeSubcategoryData[] = {
+    {SUBC(0x14da2125, "default", LocaleIface::DateTimeSubcategory::kDefault)},
+    {SUBC(0x9041d4b0, "short", LocaleIface::DateTimeSubcategory::kShort)},
+    {SUBC(0xa084a381, "medium", LocaleIface::DateTimeSubcategory::kMedium)},
+    {SUBC(0xcdce56b3, "full", LocaleIface::DateTimeSubcategory::kFull)},
+    {SUBC(0xf6b4afb0, "long", LocaleIface::DateTimeSubcategory::kLong)},
 };
 
-const LocaleNumberSubCategoryWithHash g_FXLocaleNumSubCatData[] = {
-    {SUBC(0x46f95531, "percent", FX_LOCALENUMPATTERN_Percent)},
-    {SUBC(0x4c4e8acb, "currency", FX_LOCALENUMPATTERN_Currency)},
-    {SUBC(0x54034c2f, "decimal", FX_LOCALENUMPATTERN_Decimal)},
-    {SUBC(0x7568e6ae, "integer", FX_LOCALENUMPATTERN_Integer)},
+constexpr LocaleNumberSubcategoryWithHash kLocaleNumSubcategoryData[] = {
+    {SUBC(0x46f95531, "percent", LocaleIface::NumSubcategory::kPercent)},
+    {SUBC(0x4c4e8acb, "currency", LocaleIface::NumSubcategory::kCurrency)},
+    {SUBC(0x54034c2f, "decimal", LocaleIface::NumSubcategory::kDecimal)},
+    {SUBC(0x7568e6ae, "integer", LocaleIface::NumSubcategory::kInteger)},
 };
 
 #undef SUBC
@@ -848,8 +848,8 @@
   return wsPatterns;
 }
 
-FX_LOCALECATEGORY CFGAS_StringFormatter::GetCategory() const {
-  FX_LOCALECATEGORY eCategory = FX_LOCALECATEGORY_Unknown;
+CFGAS_StringFormatter::Category CFGAS_StringFormatter::GetCategory() const {
+  Category eCategory = Category::kUnknown;
   size_t ccf = 0;
   bool bBraceOpen = false;
   while (ccf < m_spPattern.size()) {
@@ -873,23 +873,23 @@
       }
       uint32_t dwHash = FX_HashCode_GetW(wsCategory.AsStringView(), false);
       if (dwHash == FX_LOCALECATEGORY_DateTimeHash)
-        return FX_LOCALECATEGORY_DateTime;
+        return Category::kDateTime;
       if (dwHash == FX_LOCALECATEGORY_TextHash)
-        return FX_LOCALECATEGORY_Text;
+        return Category::kText;
       if (dwHash == FX_LOCALECATEGORY_NumHash)
-        return FX_LOCALECATEGORY_Num;
+        return Category::kNum;
       if (dwHash == FX_LOCALECATEGORY_ZeroHash)
-        return FX_LOCALECATEGORY_Zero;
+        return Category::kZero;
       if (dwHash == FX_LOCALECATEGORY_NullHash)
-        return FX_LOCALECATEGORY_Null;
+        return Category::kNull;
       if (dwHash == FX_LOCALECATEGORY_DateHash) {
-        if (eCategory == FX_LOCALECATEGORY_Time)
-          return FX_LOCALECATEGORY_DateTime;
-        eCategory = FX_LOCALECATEGORY_Date;
+        if (eCategory == Category::kTime)
+          return Category::kDateTime;
+        eCategory = Category::kDate;
       } else if (dwHash == FX_LOCALECATEGORY_TimeHash) {
-        if (eCategory == FX_LOCALECATEGORY_Date)
-          return FX_LOCALECATEGORY_DateTime;
-        eCategory = FX_LOCALECATEGORY_Time;
+        if (eCategory == Category::kDate)
+          return Category::kDateTime;
+        eCategory = Category::kTime;
       }
     } else if (m_spPattern[ccf] == '}') {
       bBraceOpen = false;
@@ -995,8 +995,9 @@
           }
           uint32_t dwSubHash =
               FX_HashCode_GetW(wsSubCategory.AsStringView(), false);
-          FX_LOCALENUMSUBCATEGORY eSubCategory = FX_LOCALENUMPATTERN_Decimal;
-          for (const auto& data : g_FXLocaleNumSubCatData) {
+          LocaleIface::NumSubcategory eSubCategory =
+              LocaleIface::NumSubcategory::kDecimal;
+          for (const auto& data : kLocaleNumSubcategoryData) {
             if (data.uHash == dwSubHash) {
               eSubCategory = data.eSubCategory;
               break;
@@ -1016,9 +1017,8 @@
             *dwStyle |= FX_NUMSTYLE_DotVorv;
           }
           *wsPurgePattern += wsSubCategory;
-          if (eSubCategory == FX_LOCALENUMPATTERN_Percent)
+          if (eSubCategory == LocaleIface::NumSubcategory::kPercent)
             *dwStyle |= FX_NUMSTYLE_Percent;
-
           continue;
         }
         ccf++;
@@ -1539,13 +1539,13 @@
   return true;
 }
 
-FX_DATETIMETYPE CFGAS_StringFormatter::GetDateTimeFormat(
+CFGAS_StringFormatter::DateTimeType CFGAS_StringFormatter::GetDateTimeFormat(
     LocaleIface** pLocale,
     WideString* wsDatePattern,
     WideString* wsTimePattern) const {
   *pLocale = nullptr;
   WideString wsTempPattern;
-  FX_LOCALECATEGORY eCategory = FX_LOCALECATEGORY_Unknown;
+  Category eCategory = Category::kUnknown;
   size_t ccf = 0;
   int32_t iFindCategory = 0;
   bool bBraceOpen = false;
@@ -1568,22 +1568,22 @@
           if (!*pLocale)
             *pLocale = m_pLocaleMgr->GetDefLocale();
 
-          return FX_DATETIMETYPE_DateTime;
+          return DateTimeType::kDateTime;
         }
         wsCategory += m_spPattern[ccf];
         ccf++;
       }
       if (!(iFindCategory & 1) && wsCategory.EqualsASCII("date")) {
         iFindCategory |= 1;
-        eCategory = FX_LOCALECATEGORY_Date;
+        eCategory = Category::kDate;
         if (iFindCategory & 2)
           iFindCategory = 4;
       } else if (!(iFindCategory & 2) && wsCategory.EqualsASCII("time")) {
         iFindCategory |= 2;
-        eCategory = FX_LOCALECATEGORY_Time;
+        eCategory = Category::kTime;
       } else if (wsCategory.EqualsASCII("datetime")) {
         iFindCategory = 3;
-        eCategory = FX_LOCALECATEGORY_DateTime;
+        eCategory = Category::kDateTime;
       } else {
         continue;
       }
@@ -1608,9 +1608,9 @@
 
           uint32_t dwSubHash =
               FX_HashCode_GetW(wsSubCategory.AsStringView(), false);
-          FX_LOCALEDATETIMESUBCATEGORY eSubCategory =
-              FX_LOCALEDATETIMESUBCATEGORY_Medium;
-          for (const auto& data : g_FXLocaleDateTimeSubCatData) {
+          LocaleIface::DateTimeSubcategory eSubCategory =
+              LocaleIface::DateTimeSubcategory::kMedium;
+          for (const auto& data : kLocaleDateTimeSubcategoryData) {
             if (data.uHash == dwSubHash) {
               eSubCategory = data.eSubCategory;
               break;
@@ -1621,15 +1621,15 @@
           ASSERT(*pLocale);
 
           switch (eCategory) {
-            case FX_LOCALECATEGORY_Date:
+            case Category::kDate:
               *wsDatePattern =
                   wsTempPattern + (*pLocale)->GetDatePattern(eSubCategory);
               break;
-            case FX_LOCALECATEGORY_Time:
+            case Category::kTime:
               *wsTimePattern =
                   wsTempPattern + (*pLocale)->GetTimePattern(eSubCategory);
               break;
-            case FX_LOCALECATEGORY_DateTime:
+            case Category::kDateTime:
               *wsDatePattern =
                   wsTempPattern + (*pLocale)->GetDatePattern(eSubCategory);
               *wsTimePattern = (*pLocale)->GetTimePattern(eSubCategory);
@@ -1645,9 +1645,9 @@
     } else if (m_spPattern[ccf] == '}') {
       bBraceOpen = false;
       if (!wsTempPattern.IsEmpty()) {
-        if (eCategory == FX_LOCALECATEGORY_Time)
+        if (eCategory == Category::kTime)
           *wsTimePattern = std::move(wsTempPattern);
-        else if (eCategory == FX_LOCALECATEGORY_Date)
+        else if (eCategory == Category::kDate)
           *wsDatePattern = std::move(wsTempPattern);
         else
           wsTempPattern.clear();
@@ -1659,7 +1659,7 @@
   }
 
   if (!wsTempPattern.IsEmpty()) {
-    if (eCategory == FX_LOCALECATEGORY_Date)
+    if (eCategory == Category::kDate)
       *wsDatePattern += wsTempPattern;
     else
       *wsTimePattern += wsTempPattern;
@@ -1670,11 +1670,11 @@
     wsTimePattern->clear();
     *wsDatePattern = m_wsPattern;
   }
-  return (FX_DATETIMETYPE)iFindCategory;
+  return static_cast<DateTimeType>(iFindCategory);
 }
 
 bool CFGAS_StringFormatter::ParseDateTime(const WideString& wsSrcDateTime,
-                                          FX_DATETIMETYPE eDateTimeType,
+                                          DateTimeType eDateTimeType,
                                           CFX_DateTime* dtValue) const {
   dtValue->Reset();
   if (wsSrcDateTime.IsEmpty() || m_spPattern.empty())
@@ -1683,33 +1683,33 @@
   LocaleIface* pLocale = nullptr;
   WideString wsDatePattern;
   WideString wsTimePattern;
-  FX_DATETIMETYPE eCategory =
+  DateTimeType eCategory =
       GetDateTimeFormat(&pLocale, &wsDatePattern, &wsTimePattern);
   if (!pLocale)
     return false;
 
-  if (eCategory == FX_DATETIMETYPE_Unknown)
+  if (eCategory == DateTimeType::kUnknown)
     eCategory = eDateTimeType;
 
   size_t iStart = 0;
   switch (eCategory) {
-    case FX_DATETIMETYPE_Date:
+    case DateTimeType::kDate:
       return ParseLocaleDate(wsSrcDateTime, wsDatePattern, pLocale, dtValue,
                              &iStart);
-    case FX_DATETIMETYPE_Time:
+    case DateTimeType::kTime:
       return ParseLocaleTime(wsSrcDateTime, wsTimePattern, pLocale, dtValue,
                              &iStart);
-    case FX_DATETIMETYPE_DateTime:
+    case DateTimeType::kDateTime:
       return ParseLocaleDate(wsSrcDateTime, wsTimePattern, pLocale, dtValue,
                              &iStart) &&
              ParseLocaleTime(wsSrcDateTime, wsDatePattern, pLocale, dtValue,
                              &iStart);
-    case FX_DATETIMETYPE_TimeDate:
+    case DateTimeType::kTimeDate:
       return ParseLocaleTime(wsSrcDateTime, wsTimePattern, pLocale, dtValue,
                              &iStart) &&
              ParseLocaleDate(wsSrcDateTime, wsDatePattern, pLocale, dtValue,
                              &iStart);
-    case FX_DATETIMETYPE_Unknown:
+    case DateTimeType::kUnknown:
     default:
       return false;
   }
@@ -2175,7 +2175,7 @@
 }
 
 bool CFGAS_StringFormatter::FormatDateTime(const WideString& wsSrcDateTime,
-                                           FX_DATETIMETYPE eDateTimeType,
+                                           DateTimeType eDateTimeType,
                                            WideString* wsOutput) const {
   if (wsSrcDateTime.IsEmpty() || m_spPattern.empty())
     return false;
@@ -2183,31 +2183,31 @@
   WideString wsDatePattern;
   WideString wsTimePattern;
   LocaleIface* pLocale = nullptr;
-  FX_DATETIMETYPE eCategory =
+  DateTimeType eCategory =
       GetDateTimeFormat(&pLocale, &wsDatePattern, &wsTimePattern);
   if (!pLocale)
     return false;
 
-  if (eCategory == FX_DATETIMETYPE_Unknown) {
-    if (eDateTimeType == FX_DATETIMETYPE_Time) {
+  if (eCategory == DateTimeType::kUnknown) {
+    if (eDateTimeType == DateTimeType::kTime) {
       wsTimePattern = std::move(wsDatePattern);
       wsDatePattern = WideString();
     }
     eCategory = eDateTimeType;
-    if (eCategory == FX_DATETIMETYPE_Unknown)
+    if (eCategory == DateTimeType::kUnknown)
       return false;
   }
 
   CFX_DateTime dt;
   auto iT = wsSrcDateTime.Find(L"T");
   if (!iT.has_value()) {
-    if (eCategory == FX_DATETIMETYPE_Date &&
+    if (eCategory == DateTimeType::kDate &&
         FX_DateFromCanonical(wsSrcDateTime.span(), &dt)) {
       *wsOutput = FormatDateTimeInternal(dt, wsDatePattern, wsTimePattern, true,
                                          pLocale);
       return true;
     }
-    if (eCategory == FX_DATETIMETYPE_Time &&
+    if (eCategory == DateTimeType::kTime &&
         FX_TimeFromCanonical(pLocale, wsSrcDateTime.span(), &dt)) {
       *wsOutput = FormatDateTimeInternal(dt, wsDatePattern, wsTimePattern, true,
                                          pLocale);
@@ -2223,9 +2223,9 @@
 
     if (FX_DateFromCanonical(wsSrcDate, &dt) &&
         FX_TimeFromCanonical(pLocale, wsSrcTime, &dt)) {
-      *wsOutput = FormatDateTimeInternal(dt, wsDatePattern, wsTimePattern,
-                                         eCategory != FX_DATETIMETYPE_TimeDate,
-                                         pLocale);
+      *wsOutput =
+          FormatDateTimeInternal(dt, wsDatePattern, wsTimePattern,
+                                 eCategory != DateTimeType::kTimeDate, pLocale);
       return true;
     }
   }
diff --git a/xfa/fgas/crt/cfgas_stringformatter.h b/xfa/fgas/crt/cfgas_stringformatter.h
index a8a82fd..835ff92 100644
--- a/xfa/fgas/crt/cfgas_stringformatter.h
+++ b/xfa/fgas/crt/cfgas_stringformatter.h
@@ -22,18 +22,38 @@
 
 class CFGAS_StringFormatter {
  public:
+  enum class Category {
+    kUnknown,
+    kDate,
+    kTime,
+    kDateTime,
+    kNum,
+    kText,
+    kZero,
+    kNull,
+  };
+
+  // Note: arithmetic depends on explicit values that do not change.
+  enum class DateTimeType {
+    kUnknown = 0,
+    kDate,
+    kTime,
+    kDateTime,
+    kTimeDate,
+  };
+
   CFGAS_StringFormatter(LocaleMgrIface* pLocaleMgr,
                         const WideString& wsPattern);
   ~CFGAS_StringFormatter();
 
   static std::vector<WideString> SplitOnBars(const WideString& wsFormatString);
 
-  FX_LOCALECATEGORY GetCategory() const;
+  Category GetCategory() const;
 
   bool ParseText(const WideString& wsSrcText, WideString* wsValue) const;
   bool ParseNum(const WideString& wsSrcNum, WideString* wsValue) const;
   bool ParseDateTime(const WideString& wsSrcDateTime,
-                     FX_DATETIMETYPE eDateTimeType,
+                     DateTimeType eDateTimeType,
                      CFX_DateTime* dtValue) const;
   bool ParseZero(const WideString& wsSrcText) const;
   bool ParseNull(const WideString& wsSrcText) const;
@@ -41,7 +61,7 @@
   bool FormatText(const WideString& wsSrcText, WideString* wsOutput) const;
   bool FormatNum(const WideString& wsSrcNum, WideString* wsOutput) const;
   bool FormatDateTime(const WideString& wsSrcDateTime,
-                      FX_DATETIMETYPE eDateTimeType,
+                      DateTimeType eDateTimeType,
                       WideString* wsOutput) const;
   bool FormatZero(WideString* wsOutput) const;
   bool FormatNull(WideString* wsOutput) const;
@@ -51,9 +71,9 @@
   LocaleIface* GetNumericFormat(size_t* iDotIndex,
                                 uint32_t* dwStyle,
                                 WideString* wsPurgePattern) const;
-  FX_DATETIMETYPE GetDateTimeFormat(LocaleIface** pLocale,
-                                    WideString* wsDatePattern,
-                                    WideString* wsTimePattern) const;
+  DateTimeType GetDateTimeFormat(LocaleIface** pLocale,
+                                 WideString* wsDatePattern,
+                                 WideString* wsTimePattern) const;
 
   UnownedPtr<LocaleMgrIface> const m_pLocaleMgr;
   const WideString m_wsPattern;                   // keep pattern string alive.
diff --git a/xfa/fgas/crt/cfgas_stringformatter_unittest.cpp b/xfa/fgas/crt/cfgas_stringformatter_unittest.cpp
index 6c5ec97..d582bb3 100644
--- a/xfa/fgas/crt/cfgas_stringformatter_unittest.cpp
+++ b/xfa/fgas/crt/cfgas_stringformatter_unittest.cpp
@@ -115,9 +115,10 @@
 
   for (size_t i = 0; i < pdfium::size(tests); ++i) {
     WideString result;
-    EXPECT_TRUE(
-        fmt(tests[i].locale, tests[i].pattern)
-            ->FormatDateTime(tests[i].input, FX_DATETIMETYPE_Date, &result));
+    EXPECT_TRUE(fmt(tests[i].locale, tests[i].pattern)
+                    ->FormatDateTime(tests[i].input,
+                                     CFGAS_StringFormatter::DateTimeType::kDate,
+                                     &result));
     EXPECT_STREQ(tests[i].output, result.c_str()) << " TEST: " << i;
   }
 }
@@ -164,9 +165,10 @@
 
   for (size_t i = 0; i < pdfium::size(tests); ++i) {
     WideString result;
-    EXPECT_TRUE(
-        fmt(tests[i].locale, tests[i].pattern)
-            ->FormatDateTime(tests[i].input, FX_DATETIMETYPE_Time, &result));
+    EXPECT_TRUE(fmt(tests[i].locale, tests[i].pattern)
+                    ->FormatDateTime(tests[i].input,
+                                     CFGAS_StringFormatter::DateTimeType::kTime,
+                                     &result));
     EXPECT_STREQ(tests[i].output, result.c_str()) << " TEST: " << i;
   }
 
@@ -196,9 +198,11 @@
 
   for (size_t i = 0; i < pdfium::size(tests); ++i) {
     WideString result;
-    EXPECT_TRUE(fmt(tests[i].locale, tests[i].pattern)
-                    ->FormatDateTime(tests[i].input, FX_DATETIMETYPE_DateTime,
-                                     &result));
+    EXPECT_TRUE(
+        fmt(tests[i].locale, tests[i].pattern)
+            ->FormatDateTime(tests[i].input,
+                             CFGAS_StringFormatter::DateTimeType::kDateTime,
+                             &result));
     EXPECT_STREQ(tests[i].output, result.c_str()) << " TEST: " << i;
   }
 }
@@ -224,9 +228,11 @@
 
   for (size_t i = 0; i < pdfium::size(tests); ++i) {
     WideString result;
-    EXPECT_TRUE(fmt(tests[i].locale, tests[i].pattern)
-                    ->FormatDateTime(tests[i].input, FX_DATETIMETYPE_TimeDate,
-                                     &result));
+    EXPECT_TRUE(
+        fmt(tests[i].locale, tests[i].pattern)
+            ->FormatDateTime(tests[i].input,
+                             CFGAS_StringFormatter::DateTimeType::kTimeDate,
+                             &result));
     EXPECT_STREQ(tests[i].output, result.c_str()) << " TEST: " << i;
   }
 }
@@ -285,9 +291,10 @@
 
   for (size_t i = 0; i < pdfium::size(tests); ++i) {
     CFX_DateTime result;
-    EXPECT_TRUE(
-        fmt(tests[i].locale, tests[i].pattern)
-            ->ParseDateTime(tests[i].input, FX_DATETIMETYPE_Date, &result));
+    EXPECT_TRUE(fmt(tests[i].locale, tests[i].pattern)
+                    ->ParseDateTime(tests[i].input,
+                                    CFGAS_StringFormatter::DateTimeType::kDate,
+                                    &result));
     EXPECT_EQ(tests[i].output, result) << " TEST: " << i;
   }
 }
@@ -313,8 +320,9 @@
 //   for (size_t i = 0; i < pdfium::size(tests); ++i) {
 //     CFX_DateTime result;
 //     EXPECT_TRUE(fmt(tests[i].locale)
-//                     ->ParseDateTime(tests[i].input, tests[i].pattern,
-//                                     FX_DATETIMETYPE_Time, &result));
+//                   ->ParseDateTime(tests[i].input, tests[i].pattern,
+//                                   CFGAS_StringFormatter::DateTimeType::kTime,
+//                                   &result));
 //     EXPECT_EQ(tests[i].output, result) << " TEST: " << i;
 //   }
 // }
@@ -738,20 +746,28 @@
 }
 
 TEST_F(CFGAS_StringFormatterTest, GetCategory) {
-  EXPECT_EQ(FX_LOCALECATEGORY_Unknown,
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kUnknown,
             fmt(L"en", L"'just text'")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Null, fmt(L"en", L"null{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Zero, fmt(L"en", L"zero{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Num, fmt(L"en", L"num{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Text, fmt(L"en", L"text{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_DateTime,
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kNull,
+            fmt(L"en", L"null{}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kZero,
+            fmt(L"en", L"zero{}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kNum,
+            fmt(L"en", L"num{}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kText,
+            fmt(L"en", L"text{}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kDateTime,
             fmt(L"en", L"datetime{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Time, fmt(L"en", L"time{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Date, fmt(L"en", L"date{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_DateTime,
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kTime,
+            fmt(L"en", L"time{}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kDate,
+            fmt(L"en", L"date{}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kDateTime,
             fmt(L"en", L"time{} date{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_DateTime,
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kDateTime,
             fmt(L"en", L"date{} time{}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Num, fmt(L"en", L"num(en_GB){}")->GetCategory());
-  EXPECT_EQ(FX_LOCALECATEGORY_Date, fmt(L"en", L"date.long{}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kNum,
+            fmt(L"en", L"num(en_GB){}")->GetCategory());
+  EXPECT_EQ(CFGAS_StringFormatter::Category::kDate,
+            fmt(L"en", L"date.long{}")->GetCategory());
 }
diff --git a/xfa/fgas/crt/locale_iface.h b/xfa/fgas/crt/locale_iface.h
index b5aecdb..c8884a6 100644
--- a/xfa/fgas/crt/locale_iface.h
+++ b/xfa/fgas/crt/locale_iface.h
@@ -10,42 +10,23 @@
 #include "core/fxcrt/cfx_datetime.h"
 #include "core/fxcrt/fx_string.h"
 
-enum FX_LOCALEDATETIMESUBCATEGORY {
-  FX_LOCALEDATETIMESUBCATEGORY_Default,
-  FX_LOCALEDATETIMESUBCATEGORY_Short,
-  FX_LOCALEDATETIMESUBCATEGORY_Medium,
-  FX_LOCALEDATETIMESUBCATEGORY_Full,
-  FX_LOCALEDATETIMESUBCATEGORY_Long,
-};
-
-enum FX_LOCALENUMSUBCATEGORY {
-  FX_LOCALENUMPATTERN_Percent,
-  FX_LOCALENUMPATTERN_Currency,
-  FX_LOCALENUMPATTERN_Decimal,
-  FX_LOCALENUMPATTERN_Integer,
-};
-
-enum FX_LOCALECATEGORY {
-  FX_LOCALECATEGORY_Unknown,
-  FX_LOCALECATEGORY_Date,
-  FX_LOCALECATEGORY_Time,
-  FX_LOCALECATEGORY_DateTime,
-  FX_LOCALECATEGORY_Num,
-  FX_LOCALECATEGORY_Text,
-  FX_LOCALECATEGORY_Zero,
-  FX_LOCALECATEGORY_Null,
-};
-
-enum FX_DATETIMETYPE {
-  FX_DATETIMETYPE_Unknown,
-  FX_DATETIMETYPE_Date,
-  FX_DATETIMETYPE_Time,
-  FX_DATETIMETYPE_DateTime,
-  FX_DATETIMETYPE_TimeDate,
-};
-
 class LocaleIface {
  public:
+  enum class DateTimeSubcategory {
+    kDefault,
+    kShort,
+    kMedium,
+    kFull,
+    kLong,
+  };
+
+  enum class NumSubcategory {
+    kPercent,
+    kCurrency,
+    kDecimal,
+    kInteger,
+  };
+
   virtual ~LocaleIface() = default;
 
   virtual WideString GetName() const = 0;
@@ -60,11 +41,9 @@
   virtual WideString GetMeridiemName(bool bAM) const = 0;
   virtual FX_TIMEZONE GetTimeZone() const = 0;
   virtual WideString GetEraName(bool bAD) const = 0;
-  virtual WideString GetDatePattern(
-      FX_LOCALEDATETIMESUBCATEGORY eType) const = 0;
-  virtual WideString GetTimePattern(
-      FX_LOCALEDATETIMESUBCATEGORY eType) const = 0;
-  virtual WideString GetNumPattern(FX_LOCALENUMSUBCATEGORY eType) const = 0;
+  virtual WideString GetDatePattern(DateTimeSubcategory eType) const = 0;
+  virtual WideString GetTimePattern(DateTimeSubcategory eType) const = 0;
+  virtual WideString GetNumPattern(NumSubcategory eType) const = 0;
 };
 
 #endif  // XFA_FGAS_CRT_LOCALE_IFACE_H_
diff --git a/xfa/fxfa/parser/cxfa_localevalue.cpp b/xfa/fxfa/parser/cxfa_localevalue.cpp
index ebce1dd..20f3730 100644
--- a/xfa/fxfa/parser/cxfa_localevalue.cpp
+++ b/xfa/fxfa/parser/cxfa_localevalue.cpp
@@ -21,9 +21,10 @@
 
 namespace {
 
-FX_LOCALECATEGORY ValueCategory(FX_LOCALECATEGORY eCategory,
-                                uint32_t dwValueType) {
-  if (eCategory != FX_LOCALECATEGORY_Unknown)
+CFGAS_StringFormatter::Category ValueCategory(
+    CFGAS_StringFormatter::Category eCategory,
+    uint32_t dwValueType) {
+  if (eCategory != CFGAS_StringFormatter::Category::kUnknown)
     return eCategory;
 
   switch (dwValueType) {
@@ -31,17 +32,17 @@
     case XFA_VT_INTEGER:
     case XFA_VT_DECIMAL:
     case XFA_VT_FLOAT:
-      return FX_LOCALECATEGORY_Num;
+      return CFGAS_StringFormatter::Category::kNum;
     case XFA_VT_TEXT:
-      return FX_LOCALECATEGORY_Text;
+      return CFGAS_StringFormatter::Category::kText;
     case XFA_VT_DATE:
-      return FX_LOCALECATEGORY_Date;
+      return CFGAS_StringFormatter::Category::kDate;
     case XFA_VT_TIME:
-      return FX_LOCALECATEGORY_Time;
+      return CFGAS_StringFormatter::Category::kTime;
     case XFA_VT_DATETIME:
-      return FX_LOCALECATEGORY_DateTime;
+      return CFGAS_StringFormatter::Category::kDateTime;
   }
-  return FX_LOCALECATEGORY_Unknown;
+  return CFGAS_StringFormatter::Category::kUnknown;
 }
 
 bool ValueSplitDateTime(const WideString& wsDateTime,
@@ -139,56 +140,60 @@
     auto pFormat =
         std::make_unique<CFGAS_StringFormatter>(m_pLocaleMgr.Get(), wsFormat);
     switch (ValueCategory(pFormat->GetCategory(), m_dwType)) {
-      case FX_LOCALECATEGORY_Null:
+      case CFGAS_StringFormatter::Category::kNull:
         bRet = pFormat->ParseNull(wsValue);
         if (!bRet)
           bRet = wsValue.IsEmpty();
         break;
-      case FX_LOCALECATEGORY_Zero:
+      case CFGAS_StringFormatter::Category::kZero:
         bRet = pFormat->ParseZero(wsValue);
         if (!bRet)
           bRet = wsValue.EqualsASCII("0");
         break;
-      case FX_LOCALECATEGORY_Num: {
+      case CFGAS_StringFormatter::Category::kNum: {
         WideString fNum;
         bRet = pFormat->ParseNum(wsValue, &fNum);
         if (!bRet)
           bRet = pFormat->FormatNum(wsValue, &wsOutput);
         break;
       }
-      case FX_LOCALECATEGORY_Text:
+      case CFGAS_StringFormatter::Category::kText:
         bRet = pFormat->ParseText(wsValue, &wsOutput);
         wsOutput.clear();
         if (!bRet)
           bRet = pFormat->FormatText(wsValue, &wsOutput);
         break;
-      case FX_LOCALECATEGORY_Date: {
+      case CFGAS_StringFormatter::Category::kDate: {
         CFX_DateTime dt;
         bRet = ValidateCanonicalDate(wsValue, &dt);
         if (!bRet) {
-          bRet = pFormat->ParseDateTime(wsValue, FX_DATETIMETYPE_Date, &dt);
+          bRet = pFormat->ParseDateTime(
+              wsValue, CFGAS_StringFormatter::DateTimeType::kDate, &dt);
           if (!bRet) {
-            bRet = pFormat->FormatDateTime(wsValue, FX_DATETIMETYPE_Date,
-                                           &wsOutput);
+            bRet = pFormat->FormatDateTime(
+                wsValue, CFGAS_StringFormatter::DateTimeType::kDate, &wsOutput);
           }
         }
         break;
       }
-      case FX_LOCALECATEGORY_Time: {
+      case CFGAS_StringFormatter::Category::kTime: {
         CFX_DateTime dt;
-        bRet = pFormat->ParseDateTime(wsValue, FX_DATETIMETYPE_Time, &dt);
+        bRet = pFormat->ParseDateTime(
+            wsValue, CFGAS_StringFormatter::DateTimeType::kTime, &dt);
         if (!bRet) {
-          bRet =
-              pFormat->FormatDateTime(wsValue, FX_DATETIMETYPE_Time, &wsOutput);
+          bRet = pFormat->FormatDateTime(
+              wsValue, CFGAS_StringFormatter::DateTimeType::kTime, &wsOutput);
         }
         break;
       }
-      case FX_LOCALECATEGORY_DateTime: {
+      case CFGAS_StringFormatter::Category::kDateTime: {
         CFX_DateTime dt;
-        bRet = pFormat->ParseDateTime(wsValue, FX_DATETIMETYPE_DateTime, &dt);
+        bRet = pFormat->ParseDateTime(
+            wsValue, CFGAS_StringFormatter::DateTimeType::kDateTime, &dt);
         if (!bRet) {
-          bRet = pFormat->FormatDateTime(wsValue, FX_DATETIMETYPE_DateTime,
-                                         &wsOutput);
+          bRet = pFormat->FormatDateTime(
+              wsValue, CFGAS_StringFormatter::DateTimeType::kDateTime,
+              &wsOutput);
         }
         break;
       }
@@ -280,39 +285,40 @@
   bool bRet = false;
   auto pFormat =
       std::make_unique<CFGAS_StringFormatter>(m_pLocaleMgr.Get(), wsFormat);
-  FX_LOCALECATEGORY eCategory = ValueCategory(pFormat->GetCategory(), m_dwType);
+  CFGAS_StringFormatter::Category eCategory =
+      ValueCategory(pFormat->GetCategory(), m_dwType);
   switch (eCategory) {
-    case FX_LOCALECATEGORY_Null:
+    case CFGAS_StringFormatter::Category::kNull:
       if (m_wsValue.IsEmpty())
         bRet = pFormat->FormatNull(&wsResult);
       break;
-    case FX_LOCALECATEGORY_Zero:
+    case CFGAS_StringFormatter::Category::kZero:
       if (m_wsValue.EqualsASCII("0"))
         bRet = pFormat->FormatZero(&wsResult);
       break;
-    case FX_LOCALECATEGORY_Num:
+    case CFGAS_StringFormatter::Category::kNum:
       bRet = pFormat->FormatNum(m_wsValue, &wsResult);
       break;
-    case FX_LOCALECATEGORY_Text:
+    case CFGAS_StringFormatter::Category::kText:
       bRet = pFormat->FormatText(m_wsValue, &wsResult);
       break;
-    case FX_LOCALECATEGORY_Date:
-      bRet =
-          pFormat->FormatDateTime(m_wsValue, FX_DATETIMETYPE_Date, &wsResult);
+    case CFGAS_StringFormatter::Category::kDate:
+      bRet = pFormat->FormatDateTime(
+          m_wsValue, CFGAS_StringFormatter::DateTimeType::kDate, &wsResult);
       break;
-    case FX_LOCALECATEGORY_Time:
-      bRet =
-          pFormat->FormatDateTime(m_wsValue, FX_DATETIMETYPE_Time, &wsResult);
+    case CFGAS_StringFormatter::Category::kTime:
+      bRet = pFormat->FormatDateTime(
+          m_wsValue, CFGAS_StringFormatter::DateTimeType::kTime, &wsResult);
       break;
-    case FX_LOCALECATEGORY_DateTime:
-      bRet = pFormat->FormatDateTime(m_wsValue, FX_DATETIMETYPE_DateTime,
-                                     &wsResult);
+    case CFGAS_StringFormatter::Category::kDateTime:
+      bRet = pFormat->FormatDateTime(
+          m_wsValue, CFGAS_StringFormatter::DateTimeType::kDateTime, &wsResult);
       break;
     default:
       wsResult = m_wsValue;
       bRet = true;
   }
-  if (!bRet && (eCategory != FX_LOCALECATEGORY_Num ||
+  if (!bRet && (eCategory != CFGAS_StringFormatter::Category::kNum ||
                 eValueType != XFA_VALUEPICTURE_Display)) {
     wsResult = m_wsValue;
   }
@@ -556,46 +562,49 @@
     auto pFormat =
         std::make_unique<CFGAS_StringFormatter>(m_pLocaleMgr.Get(), wsFormat);
     switch (ValueCategory(pFormat->GetCategory(), m_dwType)) {
-      case FX_LOCALECATEGORY_Null:
+      case CFGAS_StringFormatter::Category::kNull:
         bRet = pFormat->ParseNull(wsValue);
         if (bRet)
           m_wsValue.clear();
         break;
-      case FX_LOCALECATEGORY_Zero:
+      case CFGAS_StringFormatter::Category::kZero:
         bRet = pFormat->ParseZero(wsValue);
         if (bRet)
           m_wsValue = L"0";
         break;
-      case FX_LOCALECATEGORY_Num: {
+      case CFGAS_StringFormatter::Category::kNum: {
         WideString fNum;
         bRet = pFormat->ParseNum(wsValue, &fNum);
         if (bRet)
           m_wsValue = std::move(fNum);
         break;
       }
-      case FX_LOCALECATEGORY_Text:
+      case CFGAS_StringFormatter::Category::kText:
         bRet = pFormat->ParseText(wsValue, &m_wsValue);
         break;
-      case FX_LOCALECATEGORY_Date: {
+      case CFGAS_StringFormatter::Category::kDate: {
         CFX_DateTime dt;
         bRet = ValidateCanonicalDate(wsValue, &dt);
         if (!bRet) {
-          bRet = pFormat->ParseDateTime(wsValue, FX_DATETIMETYPE_Date, &dt);
+          bRet = pFormat->ParseDateTime(
+              wsValue, CFGAS_StringFormatter::DateTimeType::kDate, &dt);
         }
         if (bRet)
           SetDate(dt);
         break;
       }
-      case FX_LOCALECATEGORY_Time: {
+      case CFGAS_StringFormatter::Category::kTime: {
         CFX_DateTime dt;
-        bRet = pFormat->ParseDateTime(wsValue, FX_DATETIMETYPE_Time, &dt);
+        bRet = pFormat->ParseDateTime(
+            wsValue, CFGAS_StringFormatter::DateTimeType::kTime, &dt);
         if (bRet)
           SetTime(dt);
         break;
       }
-      case FX_LOCALECATEGORY_DateTime: {
+      case CFGAS_StringFormatter::Category::kDateTime: {
         CFX_DateTime dt;
-        bRet = pFormat->ParseDateTime(wsValue, FX_DATETIMETYPE_DateTime, &dt);
+        bRet = pFormat->ParseDateTime(
+            wsValue, CFGAS_StringFormatter::DateTimeType::kDateTime, &dt);
         if (bRet)
           SetDateTime(dt);
         break;
diff --git a/xfa/fxfa/parser/cxfa_node.cpp b/xfa/fxfa/parser/cxfa_node.cpp
index 8b9de5c..641687b 100644
--- a/xfa/fxfa/parser/cxfa_node.cpp
+++ b/xfa/fxfa/parser/cxfa_node.cpp
@@ -4726,13 +4726,17 @@
       uint32_t dwType = widgetValue.GetType();
       switch (dwType) {
         case XFA_VT_DATE:
-          return pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium);
+          return pLocale->GetDatePattern(
+              LocaleIface::DateTimeSubcategory::kMedium);
         case XFA_VT_TIME:
-          return pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium);
+          return pLocale->GetTimePattern(
+              LocaleIface::DateTimeSubcategory::kMedium);
         case XFA_VT_DATETIME:
-          return pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium) +
+          return pLocale->GetDatePattern(
+                     LocaleIface::DateTimeSubcategory::kMedium) +
                  L"T" +
-                 pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium);
+                 pLocale->GetTimePattern(
+                     LocaleIface::DateTimeSubcategory::kMedium);
         case XFA_VT_DECIMAL:
         case XFA_VT_FLOAT:
         default:
@@ -4758,13 +4762,17 @@
       uint32_t dwType = widgetValue.GetType();
       switch (dwType) {
         case XFA_VT_DATE:
-          return pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Short);
+          return pLocale->GetDatePattern(
+              LocaleIface::DateTimeSubcategory::kShort);
         case XFA_VT_TIME:
-          return pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Short);
+          return pLocale->GetTimePattern(
+              LocaleIface::DateTimeSubcategory::kShort);
         case XFA_VT_DATETIME:
-          return pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Short) +
+          return pLocale->GetDatePattern(
+                     LocaleIface::DateTimeSubcategory::kShort) +
                  L"T" +
-                 pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Short);
+                 pLocale->GetTimePattern(
+                     LocaleIface::DateTimeSubcategory::kShort);
         default:
           return WideString();
       }
diff --git a/xfa/fxfa/parser/cxfa_nodelocale.cpp b/xfa/fxfa/parser/cxfa_nodelocale.cpp
index dfa8c3e..9ef9945 100644
--- a/xfa/fxfa/parser/cxfa_nodelocale.cpp
+++ b/xfa/fxfa/parser/cxfa_nodelocale.cpp
@@ -24,15 +24,15 @@
 
 }  // namespace
 
-WideString XFA_PatternToString(FX_LOCALENUMSUBCATEGORY category) {
+WideString XFA_PatternToString(LocaleIface::NumSubcategory category) {
   switch (category) {
-    case FX_LOCALENUMPATTERN_Percent:
+    case LocaleIface::NumSubcategory::kPercent:
       return g_FX_Percent;
-    case FX_LOCALENUMPATTERN_Currency:
+    case LocaleIface::NumSubcategory::kCurrency:
       return g_FX_Currency;
-    case FX_LOCALENUMPATTERN_Decimal:
+    case LocaleIface::NumSubcategory::kDecimal:
       return g_FX_Decimal;
-    case FX_LOCALENUMPATTERN_Integer:
+    case LocaleIface::NumSubcategory::kInteger:
       return g_FX_Integer;
   }
   return WideString();
@@ -96,39 +96,37 @@
   return GetCalendarSymbol(XFA_Element::EraNames, bAD ? 1 : 0, false);
 }
 
-WideString CXFA_NodeLocale::GetDatePattern(
-    FX_LOCALEDATETIMESUBCATEGORY eType) const {
+WideString CXFA_NodeLocale::GetDatePattern(DateTimeSubcategory eType) const {
   switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
+    case DateTimeSubcategory::kShort:
       return GetSymbol(XFA_Element::DatePatterns, L"short");
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
+    case DateTimeSubcategory::kMedium:
+    case DateTimeSubcategory::kDefault:
       return GetSymbol(XFA_Element::DatePatterns, L"med");
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
+    case DateTimeSubcategory::kFull:
       return GetSymbol(XFA_Element::DatePatterns, L"full");
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
+    case DateTimeSubcategory::kLong:
       return GetSymbol(XFA_Element::DatePatterns, L"long");
   }
   return WideString();
 }
 
-WideString CXFA_NodeLocale::GetTimePattern(
-    FX_LOCALEDATETIMESUBCATEGORY eType) const {
+WideString CXFA_NodeLocale::GetTimePattern(DateTimeSubcategory eType) const {
   switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
+    case DateTimeSubcategory::kShort:
       return GetSymbol(XFA_Element::TimePatterns, L"short");
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
+    case DateTimeSubcategory::kMedium:
+    case DateTimeSubcategory::kDefault:
       return GetSymbol(XFA_Element::TimePatterns, L"med");
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
+    case DateTimeSubcategory::kFull:
       return GetSymbol(XFA_Element::TimePatterns, L"full");
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
+    case DateTimeSubcategory::kLong:
       return GetSymbol(XFA_Element::TimePatterns, L"long");
   }
   return WideString();
 }
 
-WideString CXFA_NodeLocale::GetNumPattern(FX_LOCALENUMSUBCATEGORY eType) const {
+WideString CXFA_NodeLocale::GetNumPattern(NumSubcategory eType) const {
   return XFA_PatternToString(eType);
 }
 
diff --git a/xfa/fxfa/parser/cxfa_nodelocale.h b/xfa/fxfa/parser/cxfa_nodelocale.h
index 0755af1..4b3c205 100644
--- a/xfa/fxfa/parser/cxfa_nodelocale.h
+++ b/xfa/fxfa/parser/cxfa_nodelocale.h
@@ -13,7 +13,7 @@
 
 class CXFA_Node;
 
-WideString XFA_PatternToString(FX_LOCALENUMSUBCATEGORY category);
+WideString XFA_PatternToString(LocaleIface::NumSubcategory category);
 
 class CXFA_NodeLocale final : public LocaleIface {
  public:
@@ -34,9 +34,9 @@
   FX_TIMEZONE GetTimeZone() const override;
   WideString GetEraName(bool bAD) const override;
 
-  WideString GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY eType) const override;
-  WideString GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY eType) const override;
-  WideString GetNumPattern(FX_LOCALENUMSUBCATEGORY eType) const override;
+  WideString GetDatePattern(DateTimeSubcategory eType) const override;
+  WideString GetTimePattern(DateTimeSubcategory eType) const override;
+  WideString GetNumPattern(NumSubcategory eType) const override;
 
  private:
   CXFA_Node* GetNodeByName(CXFA_Node* pParent, WideStringView wsName) const;
diff --git a/xfa/fxfa/parser/cxfa_xmllocale.cpp b/xfa/fxfa/parser/cxfa_xmllocale.cpp
index e0370a5..f2b881f 100644
--- a/xfa/fxfa/parser/cxfa_xmllocale.cpp
+++ b/xfa/fxfa/parser/cxfa_xmllocale.cpp
@@ -152,57 +152,55 @@
   return sym_element ? sym_element->GetTextData() : WideString();
 }
 
-WideString CXFA_XMLLocale::GetDatePattern(
-    FX_LOCALEDATETIMESUBCATEGORY eType) const {
+WideString CXFA_XMLLocale::GetDatePattern(DateTimeSubcategory eType) const {
   CFX_XMLElement* patterns = locale_->GetFirstChildNamed(L"datePatterns");
   if (!patterns)
     return WideString();
 
   WideString wsName;
   switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
+    case DateTimeSubcategory::kShort:
       wsName = L"short";
       break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
+    case DateTimeSubcategory::kDefault:
+    case DateTimeSubcategory::kMedium:
       wsName = L"med";
       break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
+    case DateTimeSubcategory::kFull:
       wsName = L"full";
       break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
+    case DateTimeSubcategory::kLong:
       wsName = L"long";
       break;
   }
   return GetPattern(patterns, L"datePattern", wsName.AsStringView());
 }
 
-WideString CXFA_XMLLocale::GetTimePattern(
-    FX_LOCALEDATETIMESUBCATEGORY eType) const {
+WideString CXFA_XMLLocale::GetTimePattern(DateTimeSubcategory eType) const {
   CFX_XMLElement* patterns = locale_->GetFirstChildNamed(L"timePatterns");
   if (!patterns)
     return WideString();
 
   WideString wsName;
   switch (eType) {
-    case FX_LOCALEDATETIMESUBCATEGORY_Short:
+    case DateTimeSubcategory::kShort:
       wsName = L"short";
       break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Default:
-    case FX_LOCALEDATETIMESUBCATEGORY_Medium:
+    case DateTimeSubcategory::kDefault:
+    case DateTimeSubcategory::kMedium:
       wsName = L"med";
       break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Full:
+    case DateTimeSubcategory::kFull:
       wsName = L"full";
       break;
-    case FX_LOCALEDATETIMESUBCATEGORY_Long:
+    case DateTimeSubcategory::kLong:
       wsName = L"long";
       break;
   }
   return GetPattern(patterns, L"timePattern", wsName.AsStringView());
 }
 
-WideString CXFA_XMLLocale::GetNumPattern(FX_LOCALENUMSUBCATEGORY eType) const {
+WideString CXFA_XMLLocale::GetNumPattern(NumSubcategory eType) const {
   CFX_XMLElement* patterns = locale_->GetFirstChildNamed(L"numberPatterns");
   return patterns ? XFA_PatternToString(eType) : WideString();
 }
diff --git a/xfa/fxfa/parser/cxfa_xmllocale.h b/xfa/fxfa/parser/cxfa_xmllocale.h
index 18e1346..8819eb1 100644
--- a/xfa/fxfa/parser/cxfa_xmllocale.h
+++ b/xfa/fxfa/parser/cxfa_xmllocale.h
@@ -38,9 +38,9 @@
   FX_TIMEZONE GetTimeZone() const override;
   WideString GetEraName(bool bAD) const override;
 
-  WideString GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY eType) const override;
-  WideString GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY eType) const override;
-  WideString GetNumPattern(FX_LOCALENUMSUBCATEGORY eType) const override;
+  WideString GetDatePattern(DateTimeSubcategory eType) const override;
+  WideString GetTimePattern(DateTimeSubcategory eType) const override;
+  WideString GetNumPattern(NumSubcategory eType) const override;
 
  private:
   WideString GetPattern(CFX_XMLElement* pElement,
diff --git a/xfa/fxfa/parser/cxfa_xmllocale_unittest.cpp b/xfa/fxfa/parser/cxfa_xmllocale_unittest.cpp
index 395a360..b1f6de5 100644
--- a/xfa/fxfa/parser/cxfa_xmllocale_unittest.cpp
+++ b/xfa/fxfa/parser/cxfa_xmllocale_unittest.cpp
@@ -171,15 +171,15 @@
   ASSERT_TRUE(locale != nullptr);
 
   EXPECT_EQ(L"M/D/YY",
-            locale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Short));
+            locale->GetDatePattern(LocaleIface::DateTimeSubcategory::kShort));
   EXPECT_EQ(L"MMM D, YYYY",
-            locale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Default));
+            locale->GetDatePattern(LocaleIface::DateTimeSubcategory::kDefault));
   EXPECT_EQ(L"MMM D, YYYY",
-            locale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium));
+            locale->GetDatePattern(LocaleIface::DateTimeSubcategory::kMedium));
   EXPECT_EQ(L"EEEE, MMMM D, YYYY",
-            locale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Full));
+            locale->GetDatePattern(LocaleIface::DateTimeSubcategory::kFull));
   EXPECT_EQ(L"MMMM D, YYYY",
-            locale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Long));
+            locale->GetDatePattern(LocaleIface::DateTimeSubcategory::kLong));
 }
 
 TEST(CXFA_XMLLocaleTest, GetTimePattern) {
@@ -187,15 +187,15 @@
   ASSERT_TRUE(locale != nullptr);
 
   EXPECT_EQ(L"h:MM A",
-            locale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Short));
+            locale->GetTimePattern(LocaleIface::DateTimeSubcategory::kShort));
   EXPECT_EQ(L"h:MM:SS A",
-            locale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Default));
+            locale->GetTimePattern(LocaleIface::DateTimeSubcategory::kDefault));
   EXPECT_EQ(L"h:MM:SS A",
-            locale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium));
+            locale->GetTimePattern(LocaleIface::DateTimeSubcategory::kMedium));
   EXPECT_EQ(L"h:MM:SS A Z",
-            locale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Full));
+            locale->GetTimePattern(LocaleIface::DateTimeSubcategory::kFull));
   EXPECT_EQ(L"h:MM:SS A Z",
-            locale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Long));
+            locale->GetTimePattern(LocaleIface::DateTimeSubcategory::kLong));
 }
 
 TEST(CXFA_XMLLocaleTest, GetNumPattern) {
@@ -203,11 +203,11 @@
   ASSERT_TRUE(locale != nullptr);
 
   EXPECT_EQ(L"z,zzz,zzz,zzz,zzz,zzz%",
-            locale->GetNumPattern(FX_LOCALENUMPATTERN_Percent));
+            locale->GetNumPattern(LocaleIface::NumSubcategory::kPercent));
   EXPECT_EQ(L"$z,zzz,zzz,zzz,zzz,zz9.99",
-            locale->GetNumPattern(FX_LOCALENUMPATTERN_Currency));
+            locale->GetNumPattern(LocaleIface::NumSubcategory::kCurrency));
   EXPECT_EQ(L"z,zzz,zzz,zzz,zzz,zz9.zzz",
-            locale->GetNumPattern(FX_LOCALENUMPATTERN_Decimal));
+            locale->GetNumPattern(LocaleIface::NumSubcategory::kDecimal));
   EXPECT_EQ(L"z,zzz,zzz,zzz,zzz,zzz",
-            locale->GetNumPattern(FX_LOCALENUMPATTERN_Integer));
+            locale->GetNumPattern(LocaleIface::NumSubcategory::kInteger));
 }