Remove shift from FX_CHARTYPE enum values

The shift is an artifact of the underlying representation and should
be hidden from the code that uses it.

Make an enum class while we are at it.

Change-Id: I8fb112f042e8a36447785a4d5a1353536c9b154c
Reviewed-on: https://pdfium-review.googlesource.com/c/47970
Commit-Queue: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
diff --git a/core/fxcrt/fx_arabic.cpp b/core/fxcrt/fx_arabic.cpp
index 6d049bd..00e4f67 100644
--- a/core/fxcrt/fx_arabic.cpp
+++ b/core/fxcrt/fx_arabic.cpp
@@ -146,7 +146,7 @@
                                  wchar_t* wChar,
                                  FX_CHARTYPE* eType) {
   if (!pTC) {
-    *eType = FX_CHARTYPE_Unknown;
+    *eType = FX_CHARTYPE::kUnknown;
     *wChar = 0xFEFF;
     return nullptr;
   }
@@ -154,8 +154,8 @@
   *eType = pTC->GetCharType();
   *wChar = static_cast<wchar_t>(pTC->char_code());
   const FX_ARBFORMTABLE* pFT = GetArabicFormTable(*wChar);
-  if (!pFT || *eType >= FX_CHARTYPE_ArabicNormal)
-    *eType = FX_CHARTYPE_Unknown;
+  if (!pFT || *eType >= FX_CHARTYPE::kArabicNormal)
+    *eType = FX_CHARTYPE::kUnknown;
 
   return pFT;
 }
@@ -188,33 +188,33 @@
   FX_CHARTYPE eCur;
   wchar_t wCur;
   const FX_ARBFORMTABLE* ft = ParseChar(cur, &wCur, &eCur);
-  if (eCur < FX_CHARTYPE_ArabicAlef || eCur >= FX_CHARTYPE_ArabicNormal)
+  if (eCur < FX_CHARTYPE::kArabicAlef || eCur >= FX_CHARTYPE::kArabicNormal)
     return wCur;
 
   FX_CHARTYPE ePrev;
   wchar_t wPrev;
   ParseChar(prev, &wPrev, &ePrev);
-  if (wPrev == 0x0644 && eCur == FX_CHARTYPE_ArabicAlef)
+  if (wPrev == 0x0644 && eCur == FX_CHARTYPE::kArabicAlef)
     return 0xFEFF;
 
   FX_CHARTYPE eNext;
   wchar_t wNext;
   ParseChar(next, &wNext, &eNext);
-  bool bAlef = (eNext == FX_CHARTYPE_ArabicAlef && wCur == 0x644);
-  if (ePrev < FX_CHARTYPE_ArabicAlef) {
+  bool bAlef = (eNext == FX_CHARTYPE::kArabicAlef && wCur == 0x644);
+  if (ePrev < FX_CHARTYPE::kArabicAlef) {
     if (bAlef)
       return GetArabicFromAlefTable(wNext);
-    return (eNext < FX_CHARTYPE_ArabicAlef) ? ft->wIsolated : ft->wInitial;
+    return (eNext < FX_CHARTYPE::kArabicAlef) ? ft->wIsolated : ft->wInitial;
   }
 
   if (bAlef) {
     wCur = GetArabicFromAlefTable(wNext);
-    return (ePrev != FX_CHARTYPE_ArabicDistortion) ? wCur : ++wCur;
+    return (ePrev != FX_CHARTYPE::kArabicDistortion) ? wCur : ++wCur;
   }
 
-  if (ePrev == FX_CHARTYPE_ArabicAlef || ePrev == FX_CHARTYPE_ArabicSpecial)
-    return (eNext < FX_CHARTYPE_ArabicAlef) ? ft->wIsolated : ft->wInitial;
-  return (eNext < FX_CHARTYPE_ArabicAlef) ? ft->wFinal : ft->wMedial;
+  if (ePrev == FX_CHARTYPE::kArabicAlef || ePrev == FX_CHARTYPE::kArabicSpecial)
+    return (eNext < FX_CHARTYPE::kArabicAlef) ? ft->wIsolated : ft->wInitial;
+  return (eNext < FX_CHARTYPE::kArabicAlef) ? ft->wFinal : ft->wMedial;
 }
 
 }  // namespace arabic
diff --git a/core/fxcrt/fx_unicode.cpp b/core/fxcrt/fx_unicode.cpp
index b125118..2e36df1 100644
--- a/core/fxcrt/fx_unicode.cpp
+++ b/core/fxcrt/fx_unicode.cpp
@@ -153,11 +153,9 @@
 }
 
 #ifdef PDF_ENABLE_XFA
-static_assert(FX_CHARTYPEBITS == kCharTypeBitPos, "positions must match");
-
 FX_CHARTYPE GetCharTypeFromProp(uint32_t prop) {
-  uint32_t result = (prop & kCharTypeBitMask);
-  ASSERT(result <= FX_CHARTYPE_Arabic);
+  uint32_t result = (prop & kCharTypeBitMask) >> kCharTypeBitPos;
+  ASSERT(result <= static_cast<uint32_t>(FX_CHARTYPE::kArabic));
   return static_cast<FX_CHARTYPE>(result);
 }
 
diff --git a/core/fxcrt/fx_unicode.h b/core/fxcrt/fx_unicode.h
index 6392c01..fc7f385 100644
--- a/core/fxcrt/fx_unicode.h
+++ b/core/fxcrt/fx_unicode.h
@@ -56,22 +56,20 @@
 
 #ifdef PDF_ENABLE_XFA
 
-constexpr uint32_t FX_CHARTYPEBITS = 11;
-
-enum FX_CHARTYPE {
-  FX_CHARTYPE_Unknown = 0,
-  FX_CHARTYPE_Tab = (1 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_Space = (2 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_Control = (3 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_Combination = (4 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_Numeric = (5 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_Normal = (6 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_ArabicAlef = (7 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_ArabicSpecial = (8 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_ArabicDistortion = (9 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_ArabicNormal = (10 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_ArabicForm = (11 << FX_CHARTYPEBITS),
-  FX_CHARTYPE_Arabic = (12 << FX_CHARTYPEBITS),
+enum class FX_CHARTYPE : uint8_t {
+  kUnknown = 0,
+  kTab,
+  kSpace,
+  kControl,
+  kCombination,
+  kNumeric,
+  kNormal,
+  kArabicAlef,
+  kArabicSpecial,
+  kArabicDistortion,
+  kArabicNormal,
+  kArabicForm,
+  kArabic,
 };
 
 FX_CHARTYPE GetCharTypeFromProp(uint32_t prop);
diff --git a/xfa/fgas/layout/cfx_break.cpp b/xfa/fgas/layout/cfx_break.cpp
index 35c637a..aaad1dc 100644
--- a/xfa/fgas/layout/cfx_break.cpp
+++ b/xfa/fgas/layout/cfx_break.cpp
@@ -23,7 +23,7 @@
 CFX_Break::~CFX_Break() = default;
 
 void CFX_Break::Reset() {
-  m_eCharType = FX_CHARTYPE_Unknown;
+  m_eCharType = FX_CHARTYPE::kUnknown;
   m_Line[0].Clear();
   m_Line[1].Clear();
 }
@@ -83,7 +83,7 @@
 }
 
 FX_CHARTYPE CFX_Break::GetUnifiedCharType(FX_CHARTYPE chartype) const {
-  return chartype >= FX_CHARTYPE_ArabicAlef ? FX_CHARTYPE_Arabic : chartype;
+  return chartype >= FX_CHARTYPE::kArabicAlef ? FX_CHARTYPE::kArabic : chartype;
 }
 
 void CFX_Break::FontChanged() {
@@ -151,7 +151,7 @@
   while (iStart > -1) {
     CFX_Char* pTC = &tca[iStart--];
     if (((bRichText && pTC->m_iCharWidth < 0) || bOmitChar) &&
-        pTC->GetCharType() == FX_CHARTYPE_Combination) {
+        pTC->GetCharType() == FX_CHARTYPE::kCombination) {
       continue;
     }
     if (--index < 0)
diff --git a/xfa/fgas/layout/cfx_break.h b/xfa/fgas/layout/cfx_break.h
index ee33340..1de0800 100644
--- a/xfa/fgas/layout/cfx_break.h
+++ b/xfa/fgas/layout/cfx_break.h
@@ -72,7 +72,7 @@
   bool HasLine() const { return m_iReadyLineIndex >= 0; }
   FX_CHARTYPE GetUnifiedCharType(FX_CHARTYPE dwType) const;
 
-  FX_CHARTYPE m_eCharType = FX_CHARTYPE_Unknown;
+  FX_CHARTYPE m_eCharType = FX_CHARTYPE::kUnknown;
   bool m_bSingleLine = false;
   bool m_bCombText = false;
   uint32_t m_dwIdentity = 0;
diff --git a/xfa/fgas/layout/cfx_rtfbreak.cpp b/xfa/fgas/layout/cfx_rtfbreak.cpp
index 9f34e676..b598e9b 100644
--- a/xfa/fgas/layout/cfx_rtfbreak.cpp
+++ b/xfa/fgas/layout/cfx_rtfbreak.cpp
@@ -79,11 +79,12 @@
   pCurChar->m_pUserData = m_pUserData;
 
   CFX_BreakType dwRet1 = CFX_BreakType::None;
-  if (chartype != FX_CHARTYPE_Combination &&
+  if (chartype != FX_CHARTYPE::kCombination &&
       GetUnifiedCharType(m_eCharType) != GetUnifiedCharType(chartype) &&
-      m_eCharType != FX_CHARTYPE_Unknown &&
+      m_eCharType != FX_CHARTYPE::kUnknown &&
       m_pCurLine->GetLineEnd() > m_iLineWidth + m_iTolerance &&
-      (m_eCharType != FX_CHARTYPE_Space || chartype != FX_CHARTYPE_Control)) {
+      (m_eCharType != FX_CHARTYPE::kSpace ||
+       chartype != FX_CHARTYPE::kControl)) {
     dwRet1 = EndBreak(CFX_BreakType::Line);
     if (!m_pCurLine->m_LineChars.empty())
       pCurChar = &m_pCurLine->m_LineChars.back();
@@ -91,27 +92,27 @@
 
   CFX_BreakType dwRet2 = CFX_BreakType::None;
   switch (chartype) {
-    case FX_CHARTYPE_Tab:
+    case FX_CHARTYPE::kTab:
       AppendChar_Tab(pCurChar);
       break;
-    case FX_CHARTYPE_Control:
+    case FX_CHARTYPE::kControl:
       dwRet2 = AppendChar_Control(pCurChar);
       break;
-    case FX_CHARTYPE_Combination:
+    case FX_CHARTYPE::kCombination:
       AppendChar_Combination(pCurChar);
       break;
-    case FX_CHARTYPE_ArabicAlef:
-    case FX_CHARTYPE_ArabicSpecial:
-    case FX_CHARTYPE_ArabicDistortion:
-    case FX_CHARTYPE_ArabicNormal:
-    case FX_CHARTYPE_ArabicForm:
-    case FX_CHARTYPE_Arabic:
+    case FX_CHARTYPE::kArabicAlef:
+    case FX_CHARTYPE::kArabicSpecial:
+    case FX_CHARTYPE::kArabicDistortion:
+    case FX_CHARTYPE::kArabicNormal:
+    case FX_CHARTYPE::kArabicForm:
+    case FX_CHARTYPE::kArabic:
       dwRet2 = AppendChar_Arabic(pCurChar);
       break;
-    case FX_CHARTYPE_Unknown:
-    case FX_CHARTYPE_Space:
-    case FX_CHARTYPE_Numeric:
-    case FX_CHARTYPE_Normal:
+    case FX_CHARTYPE::kUnknown:
+    case FX_CHARTYPE::kSpace:
+    case FX_CHARTYPE::kNumeric:
+    case FX_CHARTYPE::kNormal:
     default:
       dwRet2 = AppendChar_Others(pCurChar);
       break;
@@ -131,10 +132,10 @@
   iCharWidth *= m_iHorizontalScale;
   iCharWidth /= 100;
   CFX_Char* pLastChar = GetLastChar(0, false, true);
-  if (pLastChar && pLastChar->GetCharType() > FX_CHARTYPE_Combination)
+  if (pLastChar && pLastChar->GetCharType() > FX_CHARTYPE::kCombination)
     iCharWidth *= -1;
   else
-    m_eCharType = FX_CHARTYPE_Combination;
+    m_eCharType = FX_CHARTYPE::kCombination;
 
   int32_t iCharWidthValid = iCharWidth.ValueOrDefault(0);
   pCurChar->m_iCharWidth = iCharWidthValid;
@@ -199,15 +200,15 @@
   CFX_Char* pLastChar = nullptr;
   wchar_t wForm;
   bool bAlef = false;
-  if (m_eCharType >= FX_CHARTYPE_ArabicAlef &&
-      m_eCharType <= FX_CHARTYPE_ArabicDistortion) {
+  if (m_eCharType >= FX_CHARTYPE::kArabicAlef &&
+      m_eCharType <= FX_CHARTYPE::kArabicDistortion) {
     pLastChar = GetLastChar(1, false, true);
     if (pLastChar) {
       m_pCurLine->m_iWidth -= pLastChar->m_iCharWidth;
       CFX_Char* pPrevChar = GetLastChar(2, false, true);
       wForm = pdfium::arabic::GetFormChar(pLastChar, pPrevChar, pCurChar);
       bAlef = (wForm == 0xFEFF &&
-               pLastChar->GetCharType() == FX_CHARTYPE_ArabicAlef);
+               pLastChar->GetCharType() == FX_CHARTYPE::kArabicAlef);
       FX_SAFE_INT32 iCharWidth;
       int32_t iCharWidthOut;
       if (m_pFont->GetCharWidth(wForm, &iCharWidthOut) ||
@@ -290,7 +291,7 @@
     return CFX_BreakType::None;
 
   m_pCurLine->m_iWidth = checked_width.ValueOrDie();
-  if (chartype != FX_CHARTYPE_Space &&
+  if (chartype != FX_CHARTYPE::kSpace &&
       m_pCurLine->GetLineEnd() > m_iLineWidth + m_iTolerance) {
     return EndBreak(CFX_BreakType::Line);
   }
@@ -339,7 +340,7 @@
   m_pCurLine->m_iStart = m_iLineStart;
 
   CFX_Char* pTC = GetLastChar(0, false, true);
-  m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE_Unknown;
+  m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE::kUnknown;
   return dwStatus;
 }
 
@@ -351,9 +352,9 @@
     const CFX_Char* tc =
         m_pCurLine->GetChar(m_pCurLine->m_LineChars.size() - 1);
     switch (tc->GetCharType()) {
-      case FX_CHARTYPE_Tab:
-      case FX_CHARTYPE_Control:
-      case FX_CHARTYPE_Space:
+      case FX_CHARTYPE::kTab:
+      case FX_CHARTYPE::kControl:
+      case FX_CHARTYPE::kSpace:
         break;
       default:
         SplitTextLine(m_pCurLine.Get(), pNextLine, !m_bPagination && bAllChars);
@@ -422,7 +423,7 @@
     for (size_t i = 0; i < m_pCurLine->m_LineChars.size(); ++i) {
       pTC = &chars[i];
       pTC->m_iBidiPos = static_cast<int32_t>(i);
-      if (pTC->GetCharType() != FX_CHARTYPE_Control)
+      if (pTC->GetCharType() != FX_CHARTYPE::kControl)
         iBidiNum = i;
       if (i == 0)
         pTC->m_iBidiLevel = 1;
@@ -522,9 +523,9 @@
         ++iGapChars;
 
       if (!bFind || !bAllChars) {
-        uint32_t dwCharType = tc->GetCharType();
-        if (dwCharType == FX_CHARTYPE_Space ||
-            dwCharType == FX_CHARTYPE_Control) {
+        FX_CHARTYPE dwCharType = tc->GetCharType();
+        if (dwCharType == FX_CHARTYPE::kSpace ||
+            dwCharType == FX_CHARTYPE::kControl) {
           if (!bFind) {
             int32_t iCharWidth = tc->m_iCharWidth;
             if (bAllChars && iCharWidth > 0)
@@ -708,7 +709,7 @@
   curChars[iCharPos - 1].m_nBreakType = FX_LBT_UNKNOWN;
 
   for (size_t i = 0; i < pNextLine->m_LineChars.size(); ++i) {
-    if (pNextLine->m_LineChars[i].GetCharType() >= FX_CHARTYPE_ArabicAlef) {
+    if (pNextLine->m_LineChars[i].GetCharType() >= FX_CHARTYPE::kArabicAlef) {
       pCurLine->m_iArabicChars--;
       pNextLine->m_iArabicChars++;
     }
@@ -753,23 +754,23 @@
     wchar_t wch = pText->pStr[i];
     int32_t iWidth = pText->pWidths[i];
     uint32_t dwProps = FX_GetUnicodeProperties(wch);
-    uint32_t dwCharType = GetCharTypeFromProp(dwProps);
+    FX_CHARTYPE dwCharType = GetCharTypeFromProp(dwProps);
     if (iWidth == 0) {
-      if (dwCharType == FX_CHARTYPE_ArabicAlef)
+      if (dwCharType == FX_CHARTYPE::kArabicAlef)
         wPrev = 0xFEFF;
       continue;
     }
 
     uint32_t iCharWidth = abs(iWidth);
-    bool bEmptyChar =
-        (dwCharType >= FX_CHARTYPE_Tab && dwCharType <= FX_CHARTYPE_Control);
+    bool bEmptyChar = (dwCharType >= FX_CHARTYPE::kTab &&
+                       dwCharType <= FX_CHARTYPE::kControl);
     if (!bEmptyChar)
       ++iCount;
 
     if (pCharPos) {
       iCharWidth /= iFontSize;
       wchar_t wForm = wch;
-      if (dwCharType >= FX_CHARTYPE_ArabicAlef) {
+      if (dwCharType >= FX_CHARTYPE::kArabicAlef) {
         if (i + 1 < pText->iLength) {
           wNext = pText->pStr[i + 1];
           if (pText->pWidths[i + 1] < 0 && i + 2 < pText->iLength)
@@ -797,12 +798,12 @@
       }
 
       float fCharWidth = fFontSize * iCharWidth / 1000.0f;
-      if (bRTLPiece && dwCharType != FX_CHARTYPE_Combination)
+      if (bRTLPiece && dwCharType != FX_CHARTYPE::kCombination)
         fX -= fCharWidth;
 
       if (!bEmptyChar)
         pCharPos->m_Origin = CFX_PointF(fX, fY);
-      if (!bRTLPiece && dwCharType != FX_CHARTYPE_Combination)
+      if (!bRTLPiece && dwCharType != FX_CHARTYPE::kCombination)
         fX += fCharWidth;
 
       if (!bEmptyChar) {
diff --git a/xfa/fgas/layout/cfx_txtbreak.cpp b/xfa/fgas/layout/cfx_txtbreak.cpp
index 6e8c794..b7ede87 100644
--- a/xfa/fgas/layout/cfx_txtbreak.cpp
+++ b/xfa/fgas/layout/cfx_txtbreak.cpp
@@ -18,8 +18,8 @@
 namespace {
 
 bool IsCtrlCode(wchar_t ch) {
-  uint32_t dwRet = GetCharTypeFromProp(FX_GetUnicodeProperties(ch));
-  return dwRet == FX_CHARTYPE_Tab || dwRet == FX_CHARTYPE_Control;
+  FX_CHARTYPE dwRet = GetCharTypeFromProp(FX_GetUnicodeProperties(ch));
+  return dwRet == FX_CHARTYPE::kTab || dwRet == FX_CHARTYPE::kControl;
 }
 
 }  // namespace
@@ -93,11 +93,11 @@
 }
 
 void CFX_TxtBreak::AppendChar_Tab(CFX_Char* pCurChar) {
-  m_eCharType = FX_CHARTYPE_Tab;
+  m_eCharType = FX_CHARTYPE::kTab;
 }
 
 CFX_BreakType CFX_TxtBreak::AppendChar_Control(CFX_Char* pCurChar) {
-  m_eCharType = FX_CHARTYPE_Control;
+  m_eCharType = FX_CHARTYPE::kControl;
   CFX_BreakType dwRet = CFX_BreakType::None;
   if (!m_bSingleLine) {
     wchar_t wch = pCurChar->char_code();
@@ -129,8 +129,8 @@
   wchar_t wForm;
   CFX_Char* pLastChar = nullptr;
   bool bAlef = false;
-  if (!m_bCombText && m_eCharType >= FX_CHARTYPE_ArabicAlef &&
-      m_eCharType <= FX_CHARTYPE_ArabicDistortion) {
+  if (!m_bCombText && m_eCharType >= FX_CHARTYPE::kArabicAlef &&
+      m_eCharType <= FX_CHARTYPE::kArabicDistortion) {
     FX_SAFE_INT32 iCharWidth = 0;
     pLastChar = GetLastChar(1, true, false);
     if (pLastChar) {
@@ -141,7 +141,7 @@
       CFX_Char* pPrevChar = GetLastChar(2, true, false);
       wForm = pdfium::arabic::GetFormChar(pLastChar, pPrevChar, pCurChar);
       bAlef = (wForm == 0xFEFF &&
-               pLastChar->GetCharType() == FX_CHARTYPE_ArabicAlef);
+               pLastChar->GetCharType() == FX_CHARTYPE::kArabicAlef);
       int32_t iCharWidthOut;
       m_pFont->GetCharWidth(wForm, &iCharWidthOut);
       iCharWidth = iCharWidthOut;
@@ -215,7 +215,7 @@
   int32_t iCharWidthValid = iCharWidth.ValueOrDefault(0);
   pCurChar->m_iCharWidth = iCharWidthValid;
   iLineWidth += iCharWidthValid;
-  if (!m_bSingleLine && chartype != FX_CHARTYPE_Space &&
+  if (!m_bSingleLine && chartype != FX_CHARTYPE::kSpace &&
       iLineWidth > m_iLineWidth + m_iTolerance) {
     return EndBreak(CFX_BreakType::Line);
   }
@@ -232,11 +232,12 @@
   pCurChar->m_dwCharStyles = m_iAlignment | (1 << 8);
 
   CFX_BreakType dwRet1 = CFX_BreakType::None;
-  if (chartype != FX_CHARTYPE_Combination &&
+  if (chartype != FX_CHARTYPE::kCombination &&
       GetUnifiedCharType(m_eCharType) != GetUnifiedCharType(chartype) &&
-      m_eCharType != FX_CHARTYPE_Unknown &&
+      m_eCharType != FX_CHARTYPE::kUnknown &&
       m_pCurLine->m_iWidth > m_iLineWidth + m_iTolerance && !m_bSingleLine &&
-      (m_eCharType != FX_CHARTYPE_Space || chartype != FX_CHARTYPE_Control)) {
+      (m_eCharType != FX_CHARTYPE::kSpace ||
+       chartype != FX_CHARTYPE::kControl)) {
     dwRet1 = EndBreak(CFX_BreakType::Line);
     if (!m_pCurLine->m_LineChars.empty())
       pCurChar = &m_pCurLine->m_LineChars.back();
@@ -251,27 +252,27 @@
     EndBreak(dwRet2);
   } else {
     switch (chartype) {
-      case FX_CHARTYPE_Tab:
+      case FX_CHARTYPE::kTab:
         AppendChar_Tab(pCurChar);
         break;
-      case FX_CHARTYPE_Control:
+      case FX_CHARTYPE::kControl:
         dwRet2 = AppendChar_Control(pCurChar);
         break;
-      case FX_CHARTYPE_Combination:
+      case FX_CHARTYPE::kCombination:
         AppendChar_Combination(pCurChar);
         break;
-      case FX_CHARTYPE_ArabicAlef:
-      case FX_CHARTYPE_ArabicSpecial:
-      case FX_CHARTYPE_ArabicDistortion:
-      case FX_CHARTYPE_ArabicNormal:
-      case FX_CHARTYPE_ArabicForm:
-      case FX_CHARTYPE_Arabic:
+      case FX_CHARTYPE::kArabicAlef:
+      case FX_CHARTYPE::kArabicSpecial:
+      case FX_CHARTYPE::kArabicDistortion:
+      case FX_CHARTYPE::kArabicNormal:
+      case FX_CHARTYPE::kArabicForm:
+      case FX_CHARTYPE::kArabic:
         dwRet2 = AppendChar_Arabic(pCurChar);
         break;
-      case FX_CHARTYPE_Unknown:
-      case FX_CHARTYPE_Space:
-      case FX_CHARTYPE_Numeric:
-      case FX_CHARTYPE_Normal:
+      case FX_CHARTYPE::kUnknown:
+      case FX_CHARTYPE::kSpace:
+      case FX_CHARTYPE::kNumeric:
+      case FX_CHARTYPE::kNormal:
       default:
         dwRet2 = AppendChar_Others(pCurChar);
         break;
@@ -287,9 +288,9 @@
   if (!m_bSingleLine && m_pCurLine->m_iWidth > m_iLineWidth + m_iTolerance) {
     pTC = m_pCurLine->GetChar(m_pCurLine->m_LineChars.size() - 1);
     switch (pTC->GetCharType()) {
-      case FX_CHARTYPE_Tab:
-      case FX_CHARTYPE_Control:
-      case FX_CHARTYPE_Space:
+      case FX_CHARTYPE::kTab:
+      case FX_CHARTYPE::kControl:
+      case FX_CHARTYPE::kSpace:
         break;
       default:
         SplitTextLine(m_pCurLine.Get(), pNextLine, bAllChars);
@@ -318,7 +319,7 @@
     for (size_t i = 0; i < m_pCurLine->m_LineChars.size(); ++i) {
       pTC = &chars[i];
       pTC->m_iBidiPos = static_cast<int32_t>(i);
-      if (pTC->GetCharType() != FX_CHARTYPE_Control)
+      if (pTC->GetCharType() != FX_CHARTYPE::kControl)
         iBidiNum = i;
       if (i == 0)
         pTC->m_iBidiLevel = 1;
@@ -429,7 +430,8 @@
         iGapChars++;
       if (!bFind || !bAllChars) {
         FX_CHARTYPE chartype = pTC->GetCharType();
-        if (chartype == FX_CHARTYPE_Space || chartype == FX_CHARTYPE_Control) {
+        if (chartype == FX_CHARTYPE::kSpace ||
+            chartype == FX_CHARTYPE::kControl) {
           if (!bFind && bAllChars && pTC->m_iCharWidth > 0)
             iNetWidth -= pTC->m_iCharWidth;
         } else {
@@ -517,7 +519,7 @@
 
   m_pCurLine = pNextLine;
   CFX_Char* pTC = GetLastChar(0, false, false);
-  m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE_Unknown;
+  m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE::kUnknown;
 
   return dwStatus;
 }
@@ -641,7 +643,7 @@
   pTC->m_nBreakType = FX_LBT_UNKNOWN;
   int32_t iWidth = 0;
   for (size_t i = 0; i < pNextLine->m_LineChars.size(); ++i) {
-    if (pNextLine->m_LineChars[i].GetCharType() >= FX_CHARTYPE_ArabicAlef) {
+    if (pNextLine->m_LineChars[i].GetCharType() >= FX_CHARTYPE::kArabicAlef) {
       pCurLine->m_iArabicChars--;
       pNextLine->m_iArabicChars++;
     }
@@ -714,13 +716,13 @@
 
     uint32_t dwProps = FX_GetUnicodeProperties(wch);
     FX_CHARTYPE chartype = GetCharTypeFromProp(dwProps);
-    if (chartype == FX_CHARTYPE_ArabicAlef && iWidth == 0) {
+    if (chartype == FX_CHARTYPE::kArabicAlef && iWidth == 0) {
       wPrev = 0xFEFF;
       wLast = wch;
       continue;
     }
 
-    if (chartype >= FX_CHARTYPE_ArabicAlef) {
+    if (chartype >= FX_CHARTYPE::kArabicAlef) {
       if (i < iLength) {
         if (pEngine) {
           iNext = i + 1;
@@ -728,7 +730,7 @@
             int32_t iNextAbsolute = iNext + pTxtRun->iStart;
             wNext = pEngine->GetChar(iNextAbsolute);
             dwProps = FX_GetUnicodeProperties(wNext);
-            if (GetCharTypeFromProp(dwProps) != FX_CHARTYPE_Combination)
+            if (GetCharTypeFromProp(dwProps) != FX_CHARTYPE::kCombination)
               break;
 
             iNext++;
@@ -744,7 +746,7 @@
 
             wNext = pStr[j];
             dwProps = FX_GetUnicodeProperties(wNext);
-          } while (GetCharTypeFromProp(dwProps) == FX_CHARTYPE_Combination);
+          } while (GetCharTypeFromProp(dwProps) == FX_CHARTYPE::kCombination);
           if (i + j >= iLength)
             wNext = 0xFEFF;
         }
@@ -754,7 +756,7 @@
 
       wForm = pdfium::arabic::GetFormChar(wch, wPrev, wNext);
       bLam = (wPrev == 0x0644 && wch == 0x0644 && wNext == 0x0647);
-    } else if (chartype == FX_CHARTYPE_Combination) {
+    } else if (chartype == FX_CHARTYPE::kCombination) {
       wForm = wch;
       if (wch >= 0x064C && wch <= 0x0651) {
         if (bShadda) {
@@ -787,7 +789,7 @@
       } else {
         bShadda = false;
       }
-    } else if (chartype == FX_CHARTYPE_Numeric) {
+    } else if (chartype == FX_CHARTYPE::kNumeric) {
       wForm = wch;
     } else if (wch == L'.') {
       wForm = wch;
@@ -798,13 +800,13 @@
     } else {
       wForm = wch;
     }
-    if (chartype != FX_CHARTYPE_Combination)
+    if (chartype != FX_CHARTYPE::kCombination)
       bShadda = false;
-    if (chartype < FX_CHARTYPE_ArabicAlef)
+    if (chartype < FX_CHARTYPE::kArabicAlef)
       bLam = false;
 
     bool bEmptyChar =
-        (chartype >= FX_CHARTYPE_Tab && chartype <= FX_CHARTYPE_Control);
+        (chartype >= FX_CHARTYPE::kTab && chartype <= FX_CHARTYPE::kControl);
     if (wForm == 0xFEFF)
       bEmptyChar = true;
 
@@ -840,7 +842,7 @@
       wForm = (wchar_t)formChars[j].wForm;
       iCharWidth = formChars[j].iWidth;
       if (j > 0) {
-        chartype = FX_CHARTYPE_Combination;
+        chartype = FX_CHARTYPE::kCombination;
         wch = wForm;
         wLast = (wchar_t)formChars[j - 1].wForm;
       }
@@ -855,7 +857,7 @@
       }
 
       fCharWidth = fFontSize * iCharWidth / 1000.0f;
-      if (bRTLPiece && chartype != FX_CHARTYPE_Combination)
+      if (bRTLPiece && chartype != FX_CHARTYPE::kCombination)
         fX -= fCharWidth;
 
       if (!bEmptyChar || (bEmptyChar && !bSkipSpace)) {
@@ -868,7 +870,7 @@
           pCharPos->m_Origin.x += fOffset;
         }
 
-        if (chartype == FX_CHARTYPE_Combination) {
+        if (chartype == FX_CHARTYPE::kCombination) {
           FX_RECT rtBBox;
           if (pFont->GetCharBBox(wForm, &rtBBox)) {
             pCharPos->m_Origin.y =
@@ -876,7 +878,7 @@
           }
           if (wForm == wch && wLast != 0xFEFF) {
             uint32_t dwLastProps = FX_GetUnicodeProperties(wLast);
-            if (GetCharTypeFromProp(dwLastProps) == FX_CHARTYPE_Combination) {
+            if (GetCharTypeFromProp(dwLastProps) == FX_CHARTYPE::kCombination) {
               FX_RECT rtBox;
               if (pFont->GetCharBBox(wLast, &rtBox))
                 pCharPos->m_Origin.y -= fFontSize * rtBox.Height() / iMaxHeight;
@@ -884,7 +886,7 @@
           }
         }
       }
-      if (!bRTLPiece && chartype != FX_CHARTYPE_Combination)
+      if (!bRTLPiece && chartype != FX_CHARTYPE::kCombination)
         fX += fCharWidth;
 
       if (!bEmptyChar || (bEmptyChar && !bSkipSpace)) {