diff --git a/core/fpdfapi/page/cpdf_dib.cpp b/core/fpdfapi/page/cpdf_dib.cpp
index e738232..d85ebae 100644
--- a/core/fpdfapi/page/cpdf_dib.cpp
+++ b/core/fpdfapi/page/cpdf_dib.cpp
@@ -367,13 +367,13 @@
     iDecodeStatus = Jbig2Decoder::ContinueDecode(m_pJbig2Context.get(), pPause);
   }
 
-  if (iDecodeStatus < 0) {
+  if (iDecodeStatus == FXCODEC_STATUS::kError) {
     m_pJbig2Context.reset();
     m_pCachedBitmap.Reset();
     m_pGlobalAcc.Reset();
     return LoadState::kFail;
   }
-  if (iDecodeStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE)
+  if (iDecodeStatus == FXCODEC_STATUS::kDecodeToBeContinued)
     return LoadState::kContinue;
 
   LoadState iContinueStatus = LoadState::kSuccess;
diff --git a/core/fxcodec/fx_codec_def.h b/core/fxcodec/fx_codec_def.h
index 24d21d5..247bf3c 100644
--- a/core/fxcodec/fx_codec_def.h
+++ b/core/fxcodec/fx_codec_def.h
@@ -7,13 +7,13 @@
 #ifndef CORE_FXCODEC_FX_CODEC_DEF_H_
 #define CORE_FXCODEC_FX_CODEC_DEF_H_
 
-enum FXCODEC_STATUS {
-  FXCODEC_STATUS_ERROR = -1,
-  FXCODEC_STATUS_FRAME_READY,
-  FXCODEC_STATUS_FRAME_TOBECONTINUE,
-  FXCODEC_STATUS_DECODE_READY,
-  FXCODEC_STATUS_DECODE_TOBECONTINUE,
-  FXCODEC_STATUS_DECODE_FINISH,
+enum class FXCODEC_STATUS {
+  kError = -1,
+  kFrameReady,
+  kFrameToBeContinued,
+  kDecodeReady,
+  kDecodeToBeContinued,
+  kDecodeFinished,
 };
 
 #ifdef PDF_ENABLE_XFA
diff --git a/core/fxcodec/jbig2/JBig2_Context.cpp b/core/fxcodec/jbig2/JBig2_Context.cpp
index 083e95b..abe0995 100644
--- a/core/fxcodec/jbig2/JBig2_Context.cpp
+++ b/core/fxcodec/jbig2/JBig2_Context.cpp
@@ -94,8 +94,7 @@
       m_nOffset = m_pStream->getOffset();
     }
     nRet = ParseSegmentData(m_pSegment.get(), pPause);
-    if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
-      m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+    if (m_ProcessingStatus == FXCODEC_STATUS::kDecodeToBeContinued) {
       m_PauseStep = 2;
       return JBig2_Result::kSuccess;
     }
@@ -120,7 +119,7 @@
     m_SegmentList.push_back(std::move(m_pSegment));
     if (m_pStream->getByteLeft() > 0 && m_pPage && pPause &&
         pPause->NeedToPauseNow()) {
-      m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProcessingStatus = FXCODEC_STATUS::kDecodeToBeContinued;
       m_PauseStep = 2;
       return JBig2_Result::kSuccess;
     }
@@ -136,7 +135,7 @@
   if (m_pGlobalContext) {
     JBig2_Result nRet = m_pGlobalContext->DecodeSequential(pPause);
     if (nRet != JBig2_Result::kSuccess) {
-      m_ProcessingStatus = FXCODEC_STATUS_ERROR;
+      m_ProcessingStatus = FXCODEC_STATUS::kError;
       return nRet == JBig2_Result::kSuccess;
     }
   }
@@ -145,33 +144,33 @@
   m_bBufSpecified = true;
   if (pPause && pPause->NeedToPauseNow()) {
     m_PauseStep = 1;
-    m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+    m_ProcessingStatus = FXCODEC_STATUS::kDecodeToBeContinued;
     return true;
   }
   return Continue(pPause);
 }
 
 bool CJBig2_Context::Continue(PauseIndicatorIface* pPause) {
-  m_ProcessingStatus = FXCODEC_STATUS_DECODE_READY;
+  m_ProcessingStatus = FXCODEC_STATUS::kDecodeReady;
   JBig2_Result nRet = JBig2_Result::kSuccess;
   if (m_PauseStep == 5) {
-    m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH;
+    m_ProcessingStatus = FXCODEC_STATUS::kDecodeFinished;
     return true;
   }
 
   if (m_PauseStep <= 2)
     nRet = DecodeSequential(pPause);
-  if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE)
+  if (m_ProcessingStatus == FXCODEC_STATUS::kDecodeToBeContinued)
     return nRet == JBig2_Result::kSuccess;
 
   m_PauseStep = 5;
   if (!m_bBufSpecified && nRet == JBig2_Result::kSuccess) {
-    m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH;
+    m_ProcessingStatus = FXCODEC_STATUS::kDecodeFinished;
     return true;
   }
   m_ProcessingStatus = nRet == JBig2_Result::kSuccess
-                           ? FXCODEC_STATUS_DECODE_FINISH
-                           : FXCODEC_STATUS_ERROR;
+                           ? FXCODEC_STATUS::kDecodeFinished
+                           : FXCODEC_STATUS::kError;
   return nRet == JBig2_Result::kSuccess;
 }
 
@@ -280,7 +279,7 @@
 JBig2_Result CJBig2_Context::ParseSegmentData(CJBig2_Segment* pSegment,
                                               PauseIndicatorIface* pPause) {
   JBig2_Result ret = ProcessingParseSegmentData(pSegment, pPause);
-  while (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE &&
+  while (m_ProcessingStatus == FXCODEC_STATUS::kDecodeToBeContinued &&
          m_pStream->getByteLeft() > 0) {
     ret = ProcessingParseSegmentData(pSegment, pPause);
   }
@@ -343,7 +342,7 @@
       }
 
       if (!m_pPage->data()) {
-        m_ProcessingStatus = FXCODEC_STATUS_ERROR;
+        m_ProcessingStatus = FXCODEC_STATUS::kError;
         return JBig2_Result::kFailure;
       }
 
@@ -975,7 +974,7 @@
       state.pPause = pPause;
       m_ProcessingStatus = bStart ? m_pGRD->StartDecodeArith(&state)
                                   : m_pGRD->ContinueDecode(&state);
-      if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
+      if (m_ProcessingStatus == FXCODEC_STATUS::kDecodeToBeContinued) {
         if (pSegment->m_cFlags.s.type != 36) {
           if (!m_bBufSpecified) {
             const auto& pPageInfo = m_PageInfoList.back();
@@ -996,7 +995,7 @@
     m_pArithDecoder.reset();
     m_gbContext.clear();
     if (!pSegment->m_Image) {
-      m_ProcessingStatus = FXCODEC_STATUS_ERROR;
+      m_ProcessingStatus = FXCODEC_STATUS::kError;
       m_pGRD.reset();
       return JBig2_Result::kFailure;
     }
diff --git a/core/fxcodec/jbig2/JBig2_Context.h b/core/fxcodec/jbig2/JBig2_Context.h
index 1375986..15f5f57 100644
--- a/core/fxcodec/jbig2/JBig2_Context.h
+++ b/core/fxcodec/jbig2/JBig2_Context.h
@@ -95,7 +95,7 @@
   bool m_bInPage = false;
   bool m_bBufSpecified = false;
   int32_t m_PauseStep = 10;
-  FXCODEC_STATUS m_ProcessingStatus = FXCODEC_STATUS_FRAME_READY;
+  FXCODEC_STATUS m_ProcessingStatus = FXCODEC_STATUS::kFrameReady;
   std::vector<JBig2ArithCtx> m_gbContext;
   std::unique_ptr<CJBig2_ArithDecoder> m_pArithDecoder;
   std::unique_ptr<CJBig2_GRDProc> m_pGRD;
diff --git a/core/fxcodec/jbig2/JBig2_GrdProc.cpp b/core/fxcodec/jbig2/JBig2_GrdProc.cpp
index 4299e8e..fbb1664 100644
--- a/core/fxcodec/jbig2/JBig2_GrdProc.cpp
+++ b/core/fxcodec/jbig2/JBig2_GrdProc.cpp
@@ -386,17 +386,17 @@
 FXCODEC_STATUS CJBig2_GRDProc::StartDecodeArith(
     ProgressiveArithDecodeState* pState) {
   if (!CJBig2_Image::IsValidImageSize(GBW, GBH)) {
-    m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-    return FXCODEC_STATUS_DECODE_FINISH;
+    m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+    return FXCODEC_STATUS::kDecodeFinished;
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_READY;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeReady;
   std::unique_ptr<CJBig2_Image>* pImage = pState->pImage;
   if (!*pImage)
     *pImage = std::make_unique<CJBig2_Image>(GBW, GBH);
   if (!(*pImage)->data()) {
     *pImage = nullptr;
-    m_ProssiveStatus = FXCODEC_STATUS_ERROR;
-    return FXCODEC_STATUS_ERROR;
+    m_ProgressiveStatus = FXCODEC_STATUS::kError;
+    return FXCODEC_STATUS::kError;
   }
   pImage->get()->Fill(0);
   m_DecodeType = 1;
@@ -436,15 +436,15 @@
       break;
   }
   CJBig2_Image* pImage = pState->pImage->get();
-  m_ProssiveStatus = func(*this, pState);
+  m_ProgressiveStatus = func(*this, pState);
   m_ReplaceRect.left = 0;
   m_ReplaceRect.right = pImage->width();
   m_ReplaceRect.top = iline;
   m_ReplaceRect.bottom = m_loopIndex;
-  if (m_ProssiveStatus == FXCODEC_STATUS_DECODE_FINISH)
+  if (m_ProgressiveStatus == FXCODEC_STATUS::kDecodeFinished)
     m_loopIndex = 0;
 
-  return m_ProssiveStatus;
+  return m_ProgressiveStatus;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::StartDecodeMMR(
@@ -453,8 +453,8 @@
   auto image = std::make_unique<CJBig2_Image>(GBW, GBH);
   if (!image->data()) {
     *pImage = nullptr;
-    m_ProssiveStatus = FXCODEC_STATUS_ERROR;
-    return m_ProssiveStatus;
+    m_ProgressiveStatus = FXCODEC_STATUS::kError;
+    return m_ProgressiveStatus;
   }
   int bitpos = static_cast<int>(pStream->getBitPos());
   bitpos =
@@ -463,19 +463,19 @@
   pStream->setBitPos(bitpos);
   for (uint32_t i = 0; i < image->stride() * GBH; ++i)
     image->data()[i] = ~image->data()[i];
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
   *pImage = std::move(image);
-  return m_ProssiveStatus;
+  return m_ProgressiveStatus;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ContinueDecode(
     ProgressiveArithDecodeState* pState) {
-  if (m_ProssiveStatus != FXCODEC_STATUS_DECODE_TOBECONTINUE)
-    return m_ProssiveStatus;
+  if (m_ProgressiveStatus != FXCODEC_STATUS::kDecodeToBeContinued)
+    return m_ProgressiveStatus;
 
   if (m_DecodeType != 1) {
-    m_ProssiveStatus = FXCODEC_STATUS_ERROR;
-    return m_ProssiveStatus;
+    m_ProgressiveStatus = FXCODEC_STATUS::kError;
+    return m_ProgressiveStatus;
   }
   return ProgressiveDecodeArith(pState);
 }
@@ -496,7 +496,7 @@
   for (; m_loopIndex < height; m_loopIndex++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x9b25]);
     }
@@ -515,7 +515,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -529,7 +529,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -549,7 +549,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -562,7 +562,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -575,12 +575,12 @@
     m_pLine += nStride;
     if (pState->pPause && pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate0Unopt(
@@ -591,7 +591,7 @@
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x9b25]);
     }
@@ -617,7 +617,7 @@
           CONTEXT |= line1 << 12;
           CONTEXT |= pImage->GetPixel(w + GBAT[6], m_loopIndex + GBAT[7]) << 15;
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
         }
@@ -633,12 +633,12 @@
     }
     if (pState->pPause && pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate1Opt3(
@@ -655,7 +655,7 @@
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0795]);
     }
@@ -674,7 +674,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -688,7 +688,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -708,7 +708,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -721,7 +721,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -734,12 +734,12 @@
     m_pLine += nStride;
     if (pState->pPause && pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate1Unopt(
@@ -750,7 +750,7 @@
   for (uint32_t h = 0; h < GBH; h++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0795]);
     }
@@ -774,7 +774,7 @@
           CONTEXT |= line2 << 4;
           CONTEXT |= line1 << 9;
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
         }
@@ -788,12 +788,12 @@
     }
     if (pState->pPause && pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate2Opt3(
@@ -810,7 +810,7 @@
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x00e5]);
     }
@@ -829,7 +829,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -843,7 +843,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -863,7 +863,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -876,7 +876,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -890,12 +890,12 @@
     if (pState->pPause && m_loopIndex % 50 == 0 &&
         pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate2Unopt(
@@ -906,7 +906,7 @@
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x00e5]);
     }
@@ -928,7 +928,7 @@
           CONTEXT |= line2 << 3;
           CONTEXT |= line1 << 7;
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
         }
@@ -944,12 +944,12 @@
     }
     if (pState->pPause && pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate3Opt3(
@@ -965,7 +965,7 @@
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0195]);
     }
@@ -981,7 +981,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -994,7 +994,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -1008,7 +1008,7 @@
           uint8_t cVal = 0;
           for (int32_t k = 7; k >= 0; k--) {
             if (pArithDecoder->IsComplete())
-              return FXCODEC_STATUS_ERROR;
+              return FXCODEC_STATUS::kError;
 
             int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
             cVal |= bVal << k;
@@ -1019,7 +1019,7 @@
         uint8_t cVal1 = 0;
         for (int32_t k = 0; k < nBitsLeft; k++) {
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           int bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
           cVal1 |= bVal << (7 - k);
@@ -1031,12 +1031,12 @@
     m_pLine += nStride;
     if (pState->pPause && pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 FXCODEC_STATUS CJBig2_GRDProc::ProgressiveDecodeArithTemplate3Unopt(
@@ -1047,7 +1047,7 @@
   for (; m_loopIndex < GBH; m_loopIndex++) {
     if (TPGDON) {
       if (pArithDecoder->IsComplete())
-        return FXCODEC_STATUS_ERROR;
+        return FXCODEC_STATUS::kError;
 
       m_LTP = m_LTP ^ pArithDecoder->Decode(&gbContext[0x0195]);
     }
@@ -1066,7 +1066,7 @@
           CONTEXT |= pImage->GetPixel(w + GBAT[0], m_loopIndex + GBAT[1]) << 4;
           CONTEXT |= line1 << 5;
           if (pArithDecoder->IsComplete())
-            return FXCODEC_STATUS_ERROR;
+            return FXCODEC_STATUS::kError;
 
           bVal = pArithDecoder->Decode(&gbContext[CONTEXT]);
         }
@@ -1080,10 +1080,10 @@
     }
     if (pState->pPause && pState->pPause->NeedToPauseNow()) {
       m_loopIndex++;
-      m_ProssiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
-      return FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_ProgressiveStatus = FXCODEC_STATUS::kDecodeToBeContinued;
+      return FXCODEC_STATUS::kDecodeToBeContinued;
     }
   }
-  m_ProssiveStatus = FXCODEC_STATUS_DECODE_FINISH;
-  return FXCODEC_STATUS_DECODE_FINISH;
+  m_ProgressiveStatus = FXCODEC_STATUS::kDecodeFinished;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
diff --git a/core/fxcodec/jbig2/JBig2_GrdProc.h b/core/fxcodec/jbig2/JBig2_GrdProc.h
index 4dd462e..4ffed4a 100644
--- a/core/fxcodec/jbig2/JBig2_GrdProc.h
+++ b/core/fxcodec/jbig2/JBig2_GrdProc.h
@@ -95,7 +95,7 @@
 
   uint32_t m_loopIndex = 0;
   uint8_t* m_pLine = nullptr;
-  FXCODEC_STATUS m_ProssiveStatus;
+  FXCODEC_STATUS m_ProgressiveStatus;
   uint16_t m_DecodeType = 0;
   int m_LTP = 0;
   FX_RECT m_ReplaceRect;
diff --git a/core/fxcodec/jbig2/JBig2_HtrdProc.cpp b/core/fxcodec/jbig2/JBig2_HtrdProc.cpp
index 6eaed7d..dadb925 100644
--- a/core/fxcodec/jbig2/JBig2_HtrdProc.cpp
+++ b/core/fxcodec/jbig2/JBig2_HtrdProc.cpp
@@ -70,7 +70,7 @@
     state.pPause = nullptr;
     FXCODEC_STATUS status = GRD.StartDecodeArith(&state);
     state.pPause = pPause;
-    while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE)
+    while (status == FXCODEC_STATUS::kDecodeToBeContinued)
       status = GRD.ContinueDecode(&state);
     if (!pImage)
       return nullptr;
diff --git a/core/fxcodec/jbig2/JBig2_PddProc.cpp b/core/fxcodec/jbig2/JBig2_PddProc.cpp
index f88c117..c6551a7 100644
--- a/core/fxcodec/jbig2/JBig2_PddProc.cpp
+++ b/core/fxcodec/jbig2/JBig2_PddProc.cpp
@@ -43,7 +43,7 @@
 
   FXCODEC_STATUS status = pGRD->StartDecodeArith(&state);
   state.pPause = pPause;
-  while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE)
+  while (status == FXCODEC_STATUS::kDecodeToBeContinued)
     status = pGRD->ContinueDecode(&state);
   if (!BHDC)
     return nullptr;
diff --git a/core/fxcodec/jbig2/jbig2_decoder.cpp b/core/fxcodec/jbig2/jbig2_decoder.cpp
index adbfbf8..16f4545 100644
--- a/core/fxcodec/jbig2/jbig2_decoder.cpp
+++ b/core/fxcodec/jbig2/jbig2_decoder.cpp
@@ -17,18 +17,18 @@
 
 FXCODEC_STATUS Decode(Jbig2Context* pJbig2Context, bool decode_success) {
   FXCODEC_STATUS status = pJbig2Context->m_pContext->GetProcessingStatus();
-  if (status != FXCODEC_STATUS_DECODE_FINISH)
+  if (status != FXCODEC_STATUS::kDecodeFinished)
     return status;
 
   pJbig2Context->m_pContext.reset();
   if (!decode_success)
-    return FXCODEC_STATUS_ERROR;
+    return FXCODEC_STATUS::kError;
 
   int dword_size = pJbig2Context->m_height * pJbig2Context->m_dest_pitch / 4;
   uint32_t* dword_buf = reinterpret_cast<uint32_t*>(pJbig2Context->m_dest_buf);
   for (int i = 0; i < dword_size; i++)
     dword_buf[i] = ~dword_buf[i];
-  return FXCODEC_STATUS_DECODE_FINISH;
+  return FXCODEC_STATUS::kDecodeFinished;
 }
 
 }  // namespace
diff --git a/core/fxcodec/progressive_decoder.cpp b/core/fxcodec/progressive_decoder.cpp
index bde72ba..4dc6b1a 100644
--- a/core/fxcodec/progressive_decoder.cpp
+++ b/core/fxcodec/progressive_decoder.cpp
@@ -368,7 +368,7 @@
   m_offSet = rcd_pos;
   m_InvalidateGifBuffer = true;
 
-  FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
+  FXCODEC_STATUS error_status = FXCODEC_STATUS::kError;
   if (!GifReadMoreData(&error_status))
     return false;
 
@@ -504,7 +504,7 @@
 #ifdef PDF_ENABLE_XFA_BMP
 bool ProgressiveDecoder::BmpInputImagePositionBuf(uint32_t rcd_pos) {
   m_offSet = rcd_pos;
-  FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
+  FXCODEC_STATUS error_status = FXCODEC_STATUS::kError;
   return BmpReadMoreData(m_pBmpContext.get(), &error_status);
 }
 
@@ -640,7 +640,7 @@
       pBmpContext.get(), &m_SrcWidth, &m_SrcHeight, &m_BmpIsTopBottom,
       &m_SrcComponents, &m_SrcPaletteNumber, &palette, pAttribute);
   while (read_result == BmpDecoder::Status::kContinue) {
-    FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
+    FXCODEC_STATUS error_status = FXCODEC_STATUS::kError;
     if (!BmpReadMoreData(pBmpContext.get(), &error_status)) {
       m_status = error_status;
       return false;
@@ -651,7 +651,7 @@
   }
 
   if (read_result != BmpDecoder::Status::kSuccess) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
 
@@ -670,7 +670,7 @@
       format = FXDIB_Format::kRgb32;
       break;
     default:
-      m_status = FXCODEC_STATUS_ERROR;
+      m_status = FXCODEC_STATUS::kError;
       return false;
   }
 
@@ -680,14 +680,14 @@
       CFX_DIBitmap::CalculatePitchAndSize(m_SrcWidth, m_SrcHeight, format,
                                           kNoPitch);
   if (!needed_data.has_value()) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
 
   uint32_t available_data = m_pFile->GetSize() - m_offSet +
                             BmpDecoder::GetAvailInput(pBmpContext.get());
   if (needed_data.value().size > available_data) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
 
@@ -721,14 +721,14 @@
   m_WeightHorz.CalculateWeights(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0,
                                 m_clipBox.Width(), options);
   m_WeightVert.CalculateWeights(m_sizeY, m_clipBox.Height());
-  m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+  m_status = FXCODEC_STATUS::kDecodeToBeContinued;
   return m_status;
 }
 
 FXCODEC_STATUS ProgressiveDecoder::BmpContinueDecode() {
   BmpDecoder::Status read_res = BmpDecoder::LoadImage(m_pBmpContext.get());
   while (read_res == BmpDecoder::Status::kContinue) {
-    FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
+    FXCODEC_STATUS error_status = FXCODEC_STATUS::kDecodeFinished;
     if (!BmpReadMoreData(m_pBmpContext.get(), &error_status)) {
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
@@ -741,8 +741,8 @@
   m_pDeviceBitmap = nullptr;
   m_pFile = nullptr;
   m_status = read_res == BmpDecoder::Status::kSuccess
-                 ? FXCODEC_STATUS_DECODE_FINISH
-                 : FXCODEC_STATUS_ERROR;
+                 ? FXCODEC_STATUS::kDecodeFinished
+                 : FXCODEC_STATUS::kError;
   return m_status;
 }
 #endif  // PDF_ENABLE_XFA_BMP
@@ -765,7 +765,7 @@
       GifDecoder::ReadHeader(m_pGifContext.get(), &m_SrcWidth, &m_SrcHeight,
                              &m_GifPltNumber, &m_pGifPalette, &m_GifBgIndex);
   while (readResult == GifDecoder::Status::kUnfinished) {
-    FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
+    FXCODEC_STATUS error_status = FXCODEC_STATUS::kError;
     if (!GifReadMoreData(&error_status)) {
       m_pGifContext = nullptr;
       m_status = error_status;
@@ -781,7 +781,7 @@
     return true;
   }
   m_pGifContext = nullptr;
-  m_status = FXCODEC_STATUS_ERROR;
+  m_status = FXCODEC_STATUS::kError;
   return false;
 }
 
@@ -797,7 +797,7 @@
                                 m_clipBox.Width(), options);
   m_WeightVert.CalculateWeights(m_sizeY, m_clipBox.Height());
   m_FrameCur = 0;
-  m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+  m_status = FXCODEC_STATUS::kDecodeToBeContinued;
   return m_status;
 }
 
@@ -805,7 +805,7 @@
   GifDecoder::Status readRes =
       GifDecoder::LoadFrame(m_pGifContext.get(), m_FrameCur);
   while (readRes == GifDecoder::Status::kUnfinished) {
-    FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
+    FXCODEC_STATUS error_status = FXCODEC_STATUS::kDecodeFinished;
     if (!GifReadMoreData(&error_status)) {
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
@@ -818,13 +818,13 @@
   if (readRes == GifDecoder::Status::kSuccess) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
-    m_status = FXCODEC_STATUS_DECODE_FINISH;
+    m_status = FXCODEC_STATUS::kDecodeFinished;
     return m_status;
   }
 
   m_pDeviceBitmap = nullptr;
   m_pFile = nullptr;
-  m_status = FXCODEC_STATUS_ERROR;
+  m_status = FXCODEC_STATUS::kError;
   return m_status;
 }
 
@@ -921,7 +921,7 @@
     CFX_DIBAttribute* pAttribute) {
   m_pJpegContext = JpegProgressiveDecoder::Start();
   if (!m_pJpegContext) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
   JpegProgressiveDecoder::GetInstance()->Input(m_pJpegContext.get(),
@@ -931,7 +931,7 @@
   // the marker indicates a fatal error.
   if (setjmp(JpegProgressiveDecoder::GetJumpMark(m_pJpegContext.get())) == -1) {
     m_pJpegContext.reset();
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
 
@@ -939,7 +939,7 @@
       m_pJpegContext.get(), &m_SrcWidth, &m_SrcHeight, &m_SrcComponents,
       pAttribute);
   while (readResult == 2) {
-    FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
+    FXCODEC_STATUS error_status = FXCODEC_STATUS::kError;
     if (!JpegReadMoreData(&error_status)) {
       m_status = error_status;
       return false;
@@ -954,7 +954,7 @@
     return true;
   }
   m_pJpegContext.reset();
-  m_status = FXCODEC_STATUS_ERROR;
+  m_status = FXCODEC_STATUS::kError;
   return false;
 }
 
@@ -965,14 +965,14 @@
   // the marker indicates a fatal error.
   if (setjmp(JpegProgressiveDecoder::GetJumpMark(m_pJpegContext.get())) == -1) {
     m_pJpegContext.reset();
-    m_status = FXCODEC_STATUS_ERROR;
-    return FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
+    return FXCODEC_STATUS::kError;
   }
 
   bool startStatus =
       JpegProgressiveDecoder::StartScanline(m_pJpegContext.get(), down_scale);
   while (!startStatus) {
-    FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
+    FXCODEC_STATUS error_status = FXCODEC_STATUS::kError;
     if (!JpegReadMoreData(&error_status)) {
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
@@ -1003,7 +1003,7 @@
       break;
   }
   GetTransMethod(pDIBitmap->GetFormat(), m_SrcFormat);
-  m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+  m_status = FXCODEC_STATUS::kDecodeToBeContinued;
   return m_status;
 }
 
@@ -1013,15 +1013,15 @@
   // the marker indicates a fatal error.
   if (setjmp(JpegProgressiveDecoder::GetJumpMark(m_pJpegContext.get())) == -1) {
     m_pJpegContext.reset();
-    m_status = FXCODEC_STATUS_ERROR;
-    return FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
+    return FXCODEC_STATUS::kError;
   }
 
   while (true) {
     bool readRes = JpegProgressiveDecoder::ReadScanline(m_pJpegContext.get(),
                                                         m_DecodeBuf.data());
     while (!readRes) {
-      FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
+      FXCODEC_STATUS error_status = FXCODEC_STATUS::kDecodeFinished;
       if (!JpegReadMoreData(&error_status)) {
         m_pDeviceBitmap = nullptr;
         m_pFile = nullptr;
@@ -1038,7 +1038,7 @@
     if (m_SrcRow >= m_clipBox.bottom) {
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
-      m_status = FXCODEC_STATUS_DECODE_FINISH;
+      m_status = FXCODEC_STATUS::kDecodeFinished;
       return m_status;
     }
     Resample(m_pDeviceBitmap, m_SrcRow, m_DecodeBuf.data(), m_SrcFormat);
@@ -1123,7 +1123,7 @@
     CFX_DIBAttribute* pAttribute) {
   m_pPngContext = PngDecoder::StartDecode(this);
   if (!m_pPngContext) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
   while (PngDecoder::ContinueDecode(m_pPngContext.get(), m_pCodecMemory,
@@ -1132,7 +1132,7 @@
     uint32_t input_size = std::min<uint32_t>(remain_size, kBlockSize);
     if (input_size == 0) {
       m_pPngContext.reset();
-      m_status = FXCODEC_STATUS_ERROR;
+      m_status = FXCODEC_STATUS::kError;
       return false;
     }
     if (m_pCodecMemory && input_size > m_pCodecMemory->GetSize())
@@ -1140,14 +1140,14 @@
 
     if (!m_pFile->ReadBlockAtOffset(m_pCodecMemory->GetBuffer(), m_offSet,
                                     input_size)) {
-      m_status = FXCODEC_STATUS_ERROR;
+      m_status = FXCODEC_STATUS::kError;
       return false;
     }
     m_offSet += input_size;
   }
   m_pPngContext.reset();
   if (m_SrcPassNumber == 0) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
   return true;
@@ -1159,7 +1159,7 @@
   if (!m_pPngContext) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return m_status;
   }
   m_offSet = 0;
@@ -1181,7 +1181,7 @@
     default: {
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
-      m_status = FXCODEC_STATUS_ERROR;
+      m_status = FXCODEC_STATUS::kError;
       return m_status;
     }
   }
@@ -1190,7 +1190,7 @@
   m_DecodeBuf.resize(scanline_size);
   m_WeightHorzOO.CalculateWeights(m_sizeX, m_clipBox.Width());
   m_WeightVert.CalculateWeights(m_sizeY, m_clipBox.Height());
-  m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+  m_status = FXCODEC_STATUS::kDecodeToBeContinued;
   return m_status;
 }
 
@@ -1202,7 +1202,7 @@
       m_pPngContext.reset();
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
-      m_status = FXCODEC_STATUS_DECODE_FINISH;
+      m_status = FXCODEC_STATUS::kDecodeFinished;
       return m_status;
     }
     if (m_pCodecMemory && input_size > m_pCodecMemory->GetSize())
@@ -1213,7 +1213,7 @@
     if (!bResult) {
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
-      m_status = FXCODEC_STATUS_ERROR;
+      m_status = FXCODEC_STATUS::kError;
       return m_status;
     }
     m_offSet += input_size;
@@ -1222,7 +1222,7 @@
     if (!bResult) {
       m_pDeviceBitmap = nullptr;
       m_pFile = nullptr;
-      m_status = FXCODEC_STATUS_ERROR;
+      m_status = FXCODEC_STATUS::kError;
       return m_status;
     }
   }
@@ -1234,7 +1234,7 @@
     CFX_DIBAttribute* pAttribute) {
   m_pTiffContext = TiffDecoder::CreateDecoder(m_pFile);
   if (!m_pTiffContext) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
   int32_t dummy_bpc;
@@ -1245,7 +1245,7 @@
   m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
   if (!ret) {
     m_pTiffContext.reset();
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
   return true;
@@ -1263,10 +1263,10 @@
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
     if (!ret) {
-      m_status = FXCODEC_STATUS_ERROR;
+      m_status = FXCODEC_STATUS::kError;
       return m_status;
     }
-    m_status = FXCODEC_STATUS_DECODE_FINISH;
+    m_status = FXCODEC_STATUS::kDecodeFinished;
     return m_status;
   }
 
@@ -1275,14 +1275,14 @@
   if (!pDIBitmap->GetBuffer()) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return m_status;
   }
   ret = TiffDecoder::Decode(m_pTiffContext.get(), pDIBitmap);
   if (!ret) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return m_status;
   }
   RetainPtr<CFX_DIBitmap> pClipBitmap =
@@ -1293,7 +1293,7 @@
   if (!pClipBitmap) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return m_status;
   }
   RetainPtr<CFX_DIBitmap> pFormatBitmap;
@@ -1366,7 +1366,7 @@
   if (!pFormatBitmap) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return m_status;
   }
 
@@ -1378,14 +1378,14 @@
   if (!pStrechBitmap) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return m_status;
   }
   m_pDeviceBitmap->TransferBitmap(m_startX, m_startY, m_sizeX, m_sizeY,
                                   pStrechBitmap, 0, 0);
   m_pDeviceBitmap = nullptr;
   m_pFile = nullptr;
-  m_status = FXCODEC_STATUS_DECODE_FINISH;
+  m_status = FXCODEC_STATUS::kDecodeFinished;
   return m_status;
 }
 #endif  // PDF_ENABLE_XFA_TIFF
@@ -1402,7 +1402,7 @@
   m_offSet = 0;
   if (!m_pFile->ReadBlockAtOffset(m_pCodecMemory->GetBuffer(), m_offSet,
                                   size)) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     return false;
   }
   m_offSet += size;
@@ -1425,7 +1425,7 @@
     return PngDetectImageTypeInBuffer(pAttribute);
 #endif  // PDF_ENABLE_XFA_PNG
 
-  m_status = FXCODEC_STATUS_ERROR;
+  m_status = FXCODEC_STATUS::kError;
   return false;
 }
 
@@ -1458,7 +1458,7 @@
         std::min<uint32_t>(dwBytesToFetchFromFile, kBlockSize);
     size_t dwNewSize = m_pCodecMemory->GetSize() + dwBytesToFetchFromFile;
     if (!m_pCodecMemory->TryResize(dwNewSize)) {
-      *err_status = FXCODEC_STATUS_ERROR;
+      *err_status = FXCODEC_STATUS::kError;
       return false;
     }
   } else {
@@ -1471,7 +1471,7 @@
   // Append new data past the bytes not yet processed by the codec.
   if (!m_pFile->ReadBlockAtOffset(m_pCodecMemory->GetBuffer() + dwUnconsumed,
                                   m_offSet, dwBytesToFetchFromFile)) {
-    *err_status = FXCODEC_STATUS_ERROR;
+    *err_status = FXCODEC_STATUS::kError;
     return false;
   }
   m_offSet += dwBytesToFetchFromFile;
@@ -1486,16 +1486,16 @@
   DCHECK(pAttribute);
 
   switch (m_status) {
-    case FXCODEC_STATUS_FRAME_READY:
-    case FXCODEC_STATUS_FRAME_TOBECONTINUE:
-    case FXCODEC_STATUS_DECODE_READY:
-    case FXCODEC_STATUS_DECODE_TOBECONTINUE:
-      return FXCODEC_STATUS_ERROR;
+    case FXCODEC_STATUS::kFrameReady:
+    case FXCODEC_STATUS::kFrameToBeContinued:
+    case FXCODEC_STATUS::kDecodeReady:
+    case FXCODEC_STATUS::kDecodeToBeContinued:
+      return FXCODEC_STATUS::kError;
     default:
       break;
   }
   if (!pFile) {
-    m_status = FXCODEC_STATUS_ERROR;
+    m_status = FXCODEC_STATUS::kError;
     m_pFile = nullptr;
     return m_status;
   }
@@ -1510,7 +1510,7 @@
   if (imageType != FXCODEC_IMAGE_UNKNOWN &&
       DetectImageType(imageType, pAttribute)) {
     m_imageType = imageType;
-    m_status = FXCODEC_STATUS_FRAME_READY;
+    m_status = FXCODEC_STATUS::kFrameReady;
     return m_status;
   }
   // If we got here then the image data does not match the requested decoder.
@@ -1522,17 +1522,17 @@
   for (int type = FXCODEC_IMAGE_UNKNOWN + 1; type < FXCODEC_IMAGE_MAX; type++) {
     if (DetectImageType(static_cast<FXCODEC_IMAGE_TYPE>(type), pAttribute)) {
       m_imageType = static_cast<FXCODEC_IMAGE_TYPE>(type);
-      m_status = FXCODEC_STATUS_FRAME_READY;
+      m_status = FXCODEC_STATUS::kFrameReady;
       return m_status;
     }
   }
-  m_status = FXCODEC_STATUS_ERROR;
+  m_status = FXCODEC_STATUS::kError;
   m_pFile = nullptr;
   return m_status;
 }
 
 void ProgressiveDecoder::SetClipBox(FX_RECT* clip) {
-  if (m_status != FXCODEC_STATUS_FRAME_READY)
+  if (m_status != FXCODEC_STATUS::kFrameReady)
     return;
 
   if (clip->IsEmpty()) {
@@ -2026,9 +2026,9 @@
 }
 
 std::pair<FXCODEC_STATUS, size_t> ProgressiveDecoder::GetFrames() {
-  if (!(m_status == FXCODEC_STATUS_FRAME_READY ||
-        m_status == FXCODEC_STATUS_FRAME_TOBECONTINUE)) {
-    return {FXCODEC_STATUS_ERROR, 0};
+  if (!(m_status == FXCODEC_STATUS::kFrameReady ||
+        m_status == FXCODEC_STATUS::kFrameToBeContinued)) {
+    return {FXCODEC_STATUS::kError, 0};
   }
 
   switch (m_imageType) {
@@ -2043,7 +2043,7 @@
     case FXCODEC_IMAGE_TIFF:
 #endif  // PDF_ENABLE_XFA_TIFF
       m_FrameNumber = 1;
-      m_status = FXCODEC_STATUS_DECODE_READY;
+      m_status = FXCODEC_STATUS::kDecodeReady;
       return {m_status, 1};
 #ifdef PDF_ENABLE_XFA_GIF
     case FXCODEC_IMAGE_GIF: {
@@ -2052,7 +2052,7 @@
         std::tie(readResult, m_FrameNumber) =
             GifDecoder::LoadFrameInfo(m_pGifContext.get());
         while (readResult == GifDecoder::Status::kUnfinished) {
-          FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
+          FXCODEC_STATUS error_status = FXCODEC_STATUS::kError;
           if (!GifReadMoreData(&error_status))
             return {error_status, 0};
 
@@ -2060,17 +2060,17 @@
               GifDecoder::LoadFrameInfo(m_pGifContext.get());
         }
         if (readResult == GifDecoder::Status::kSuccess) {
-          m_status = FXCODEC_STATUS_DECODE_READY;
+          m_status = FXCODEC_STATUS::kDecodeReady;
           return {m_status, m_FrameNumber};
         }
         m_pGifContext = nullptr;
-        m_status = FXCODEC_STATUS_ERROR;
+        m_status = FXCODEC_STATUS::kError;
         return {m_status, 0};
       }
     }
 #endif  // PDF_ENABLE_XFA_GIF
     default:
-      return {FXCODEC_STATUS_ERROR, 0};
+      return {FXCODEC_STATUS::kError, 0};
   }
 }
 
@@ -2080,17 +2080,17 @@
     int start_y,
     int size_x,
     int size_y) {
-  if (m_status != FXCODEC_STATUS_DECODE_READY)
-    return FXCODEC_STATUS_ERROR;
+  if (m_status != FXCODEC_STATUS::kDecodeReady)
+    return FXCODEC_STATUS::kError;
 
   if (!pDIBitmap || pDIBitmap->GetBPP() < 8 || m_FrameNumber == 0)
-    return FXCODEC_STATUS_ERROR;
+    return FXCODEC_STATUS::kError;
 
   m_pDeviceBitmap = pDIBitmap;
   if (m_clipBox.IsEmpty())
-    return FXCODEC_STATUS_ERROR;
+    return FXCODEC_STATUS::kError;
   if (size_x <= 0 || size_x > 65535 || size_y <= 0 || size_y > 65535)
-    return FXCODEC_STATUS_ERROR;
+    return FXCODEC_STATUS::kError;
 
   FX_RECT device_rc =
       FX_RECT(start_x, start_y, start_x + size_x, start_y + size_y);
@@ -2099,7 +2099,7 @@
   device_rc.Intersect(
       FX_RECT(0, 0, pDIBitmap->GetWidth(), pDIBitmap->GetHeight()));
   if (device_rc.IsEmpty())
-    return FXCODEC_STATUS_ERROR;
+    return FXCODEC_STATUS::kError;
 
   m_startX = device_rc.left;
   m_startY = device_rc.top;
@@ -2127,7 +2127,7 @@
     }
   }
   if (m_clipBox.IsEmpty()) {
-    return FXCODEC_STATUS_ERROR;
+    return FXCODEC_STATUS::kError;
   }
   switch (m_imageType) {
 #ifdef PDF_ENABLE_XFA_BMP
@@ -2146,17 +2146,17 @@
 #endif  // PDF_ENABLE_XFA_PNG
 #ifdef PDF_ENABLE_XFA_TIFF
     case FXCODEC_IMAGE_TIFF:
-      m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+      m_status = FXCODEC_STATUS::kDecodeToBeContinued;
       return m_status;
 #endif  // PDF_ENABLE_XFA_TIFF
     default:
-      return FXCODEC_STATUS_ERROR;
+      return FXCODEC_STATUS::kError;
   }
 }
 
 FXCODEC_STATUS ProgressiveDecoder::ContinueDecode() {
-  if (m_status != FXCODEC_STATUS_DECODE_TOBECONTINUE)
-    return FXCODEC_STATUS_ERROR;
+  if (m_status != FXCODEC_STATUS::kDecodeToBeContinued)
+    return FXCODEC_STATUS::kError;
 
   switch (m_imageType) {
     case FXCODEC_IMAGE_JPG:
@@ -2178,7 +2178,7 @@
       return TiffContinueDecode();
 #endif  // PDF_ENABLE_XFA_TIFF
     default:
-      return FXCODEC_STATUS_ERROR;
+      return FXCODEC_STATUS::kError;
   }
 }
 
diff --git a/core/fxcodec/progressive_decoder.h b/core/fxcodec/progressive_decoder.h
index c0de047..30be383 100644
--- a/core/fxcodec/progressive_decoder.h
+++ b/core/fxcodec/progressive_decoder.h
@@ -218,7 +218,7 @@
                       double scale_y,
                       int dest_row);
 
-  FXCODEC_STATUS m_status = FXCODEC_STATUS_DECODE_FINISH;
+  FXCODEC_STATUS m_status = FXCODEC_STATUS::kDecodeFinished;
   FXCODEC_IMAGE_TYPE m_imageType = FXCODEC_IMAGE_UNKNOWN;
   RetainPtr<IFX_SeekableReadStream> m_pFile;
   RetainPtr<CFX_DIBitmap> m_pDeviceBitmap;
diff --git a/core/fxcodec/progressive_decoder_unittest.cpp b/core/fxcodec/progressive_decoder_unittest.cpp
index d0c66ac..7de25bf 100644
--- a/core/fxcodec/progressive_decoder_unittest.cpp
+++ b/core/fxcodec/progressive_decoder_unittest.cpp
@@ -376,7 +376,7 @@
     CFX_DIBAttribute attr;
     FXCODEC_STATUS status =
         decoder->LoadImageInfo(source, FXCODEC_IMAGE_GIF, &attr, true);
-    ASSERT_EQ(FXCODEC_STATUS_FRAME_READY, status);
+    ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
 
     ASSERT_EQ(98, decoder->GetWidth());
     ASSERT_EQ(6945, decoder->GetHeight());
@@ -387,14 +387,14 @@
 
     size_t frames;
     std::tie(status, frames) = decoder->GetFrames();
-    ASSERT_EQ(FXCODEC_STATUS_DECODE_READY, status);
+    ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
     ASSERT_EQ(1u, frames);
 
     status = decoder->StartDecode(bitmap, 0, 0, bitmap->GetWidth(),
                                   bitmap->GetHeight());
-    while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE)
+    while (status == FXCODEC_STATUS::kDecodeToBeContinued)
       status = decoder->ContinueDecode();
-    EXPECT_EQ(FXCODEC_STATUS_DECODE_FINISH, status);
+    EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
   }
 }
 #endif  // PDF_ENABLE_XFA_GIF
diff --git a/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc b/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc
index a0fd771..d63c9ee 100644
--- a/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc
+++ b/testing/fuzzers/pdf_codec_jbig2_fuzzer.cc
@@ -40,7 +40,7 @@
       &jbig2_context, &document_context, width, height, {data, size}, 1, {}, 0,
       bitmap->GetBuffer(), bitmap->GetPitch(), nullptr);
 
-  while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE)
+  while (status == FXCODEC_STATUS::kDecodeToBeContinued)
     status = Jbig2Decoder::ContinueDecode(&jbig2_context, nullptr);
   return 0;
 }
diff --git a/testing/fuzzers/xfa_codec_fuzzer.h b/testing/fuzzers/xfa_codec_fuzzer.h
index 8b9d575..faaaa36 100644
--- a/testing/fuzzers/xfa_codec_fuzzer.h
+++ b/testing/fuzzers/xfa_codec_fuzzer.h
@@ -27,7 +27,7 @@
         pdfium::make_span(data, size));
     CFX_DIBAttribute attr;
     FXCODEC_STATUS status = decoder->LoadImageInfo(source, type, &attr, true);
-    if (status != FXCODEC_STATUS_FRAME_READY)
+    if (status != FXCODEC_STATUS::kFrameReady)
       return 0;
 
     // Skipping very large images, since they will take a long time and may lead
@@ -46,12 +46,12 @@
 
     size_t frames;
     std::tie(status, frames) = decoder->GetFrames();
-    if (status != FXCODEC_STATUS_DECODE_READY || frames == 0)
+    if (status != FXCODEC_STATUS::kDecodeReady || frames == 0)
       return 0;
 
     status = decoder->StartDecode(bitmap, 0, 0, bitmap->GetWidth(),
                                   bitmap->GetHeight());
-    while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE)
+    while (status == FXCODEC_STATUS::kDecodeToBeContinued)
       status = decoder->ContinueDecode();
 
     return 0;
diff --git a/xfa/fxfa/cxfa_ffwidget.cpp b/xfa/fxfa/cxfa_ffwidget.cpp
index 60af2bb..8aa5c2e 100644
--- a/xfa/fxfa/cxfa_ffwidget.cpp
+++ b/xfa/fxfa/cxfa_ffwidget.cpp
@@ -185,17 +185,17 @@
   size_t nFrames;
   FXCODEC_STATUS status;
   std::tie(status, nFrames) = pProgressiveDecoder->GetFrames();
-  if (status != FXCODEC_STATUS_DECODE_READY || nFrames == 0)
+  if (status != FXCODEC_STATUS::kDecodeReady || nFrames == 0)
     return nullptr;
 
   status = pProgressiveDecoder->StartDecode(pBitmap, 0, 0, pBitmap->GetWidth(),
                                             pBitmap->GetHeight());
-  if (status == FXCODEC_STATUS_ERROR)
+  if (status == FXCODEC_STATUS::kError)
     return nullptr;
 
-  while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
+  while (status == FXCODEC_STATUS::kDecodeToBeContinued) {
     status = pProgressiveDecoder->ContinueDecode();
-    if (status == FXCODEC_STATUS_ERROR)
+    if (status == FXCODEC_STATUS::kError)
       return nullptr;
   }