diff --git a/core/fxcodec/gif/cfx_gif.h b/core/fxcodec/gif/cfx_gif.h
index 3565c7b..97a7422 100644
--- a/core/fxcodec/gif/cfx_gif.h
+++ b/core/fxcodec/gif/cfx_gif.h
@@ -12,8 +12,6 @@
 
 #include "core/fxcrt/fx_memory_wrappers.h"
 
-class CFX_GifContext;
-
 extern const char kGifSignature87[];
 extern const char kGifSignature89[];
 
@@ -111,13 +109,6 @@
 };
 #pragma pack()
 
-enum class CFX_GifDecodeStatus {
-  Error,
-  Success,
-  Unfinished,
-  InsufficientDestSize,  // Only used internally by CGifLZWDecoder::Decode()
-};
-
 struct CFX_GifImage {
   CFX_GifImage();
   ~CFX_GifImage();
diff --git a/core/fxcodec/gif/cfx_gifcontext.cpp b/core/fxcodec/gif/cfx_gifcontext.cpp
index 0022a2c..66dea4b 100644
--- a/core/fxcodec/gif/cfx_gifcontext.cpp
+++ b/core/fxcodec/gif/cfx_gifcontext.cpp
@@ -50,23 +50,23 @@
       delay_time, user_input, trans_index, disposal_method, interlace);
 }
 
-CFX_GifDecodeStatus CFX_GifContext::ReadHeader() {
-  CFX_GifDecodeStatus status = ReadGifSignature();
-  if (status != CFX_GifDecodeStatus::Success)
+GifDecoder::Status CFX_GifContext::ReadHeader() {
+  GifDecoder::Status status = ReadGifSignature();
+  if (status != GifDecoder::Status::kSuccess)
     return status;
   return ReadLogicalScreenDescriptor();
 }
 
-CFX_GifDecodeStatus CFX_GifContext::GetFrame() {
-  CFX_GifDecodeStatus ret = CFX_GifDecodeStatus::Success;
+GifDecoder::Status CFX_GifContext::GetFrame() {
+  GifDecoder::Status ret = GifDecoder::Status::kSuccess;
   while (true) {
     switch (decode_status_) {
       case GIF_D_STATUS_TAIL:
-        return CFX_GifDecodeStatus::Success;
+        return GifDecoder::Status::kSuccess;
       case GIF_D_STATUS_SIG: {
         uint8_t signature;
         if (!ReadAllOrNone(&signature, sizeof(signature)))
-          return CFX_GifDecodeStatus::Unfinished;
+          return GifDecoder::Status::kUnfinished;
 
         switch (signature) {
           case GIF_SIG_EXTENSION:
@@ -77,7 +77,7 @@
             continue;
           case GIF_SIG_TRAILER:
             SaveDecodingStatus(GIF_D_STATUS_TAIL);
-            return CFX_GifDecodeStatus::Success;
+            return GifDecoder::Status::kSuccess;
           default:
             if (!input_buffer_->IsEOF()) {
               // The Gif File has non_standard Tag!
@@ -85,13 +85,13 @@
               continue;
             }
             // The Gif File Doesn't have Trailer Tag!
-            return CFX_GifDecodeStatus::Success;
+            return GifDecoder::Status::kSuccess;
         }
       }
       case GIF_D_STATUS_EXT: {
         uint8_t extension;
         if (!ReadAllOrNone(&extension, sizeof(extension)))
-          return CFX_GifDecodeStatus::Unfinished;
+          return GifDecoder::Status::kUnfinished;
 
         switch (extension) {
           case GIF_BLOCK_CE:
@@ -115,7 +115,7 @@
       }
       case GIF_D_STATUS_IMG_INFO: {
         ret = DecodeImageInfo();
-        if (ret != CFX_GifDecodeStatus::Success)
+        if (ret != GifDecoder::Status::kSuccess)
           return ret;
 
         continue;
@@ -125,13 +125,13 @@
         size_t read_marker = input_buffer_->GetPosition();
 
         if (!ReadAllOrNone(&img_data_size, sizeof(img_data_size)))
-          return CFX_GifDecodeStatus::Unfinished;
+          return GifDecoder::Status::kUnfinished;
 
         while (img_data_size != GIF_BLOCK_TERMINAL) {
           if (!input_buffer_->Seek(input_buffer_->GetPosition() +
                                    img_data_size)) {
             input_buffer_->Seek(read_marker);
-            return CFX_GifDecodeStatus::Unfinished;
+            return GifDecoder::Status::kUnfinished;
           }
 
           // This saving of the scan state on partial reads is why
@@ -139,7 +139,7 @@
           SaveDecodingStatus(GIF_D_STATUS_IMG_DATA);
           read_marker = input_buffer_->GetPosition();
           if (!ReadAllOrNone(&img_data_size, sizeof(img_data_size)))
-            return CFX_GifDecodeStatus::Unfinished;
+            return GifDecoder::Status::kUnfinished;
         }
 
         SaveDecodingStatus(GIF_D_STATUS_SIG);
@@ -147,26 +147,26 @@
       }
       default: {
         ret = DecodeExtension();
-        if (ret != CFX_GifDecodeStatus::Success)
+        if (ret != GifDecoder::Status::kSuccess)
           return ret;
         break;
       }
     }
   }
-  return CFX_GifDecodeStatus::Success;
+  return GifDecoder::Status::kSuccess;
 }
 
-CFX_GifDecodeStatus CFX_GifContext::LoadFrame(int32_t frame_num) {
+GifDecoder::Status CFX_GifContext::LoadFrame(int32_t frame_num) {
   if (!pdfium::IndexInBounds(images_, frame_num))
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
 
   CFX_GifImage* gif_image = images_[static_cast<size_t>(frame_num)].get();
   if (gif_image->image_info.height == 0)
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
 
   uint32_t gif_img_row_bytes = gif_image->image_info.width;
   if (gif_img_row_bytes == 0)
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
 
   if (decode_status_ == GIF_D_STATUS_TAIL) {
     gif_image->row_buffer.resize(gif_img_row_bytes);
@@ -186,7 +186,7 @@
           gif_image->image_info.local_flags.interlace);
       if (!bRes) {
         gif_image->row_buffer.clear();
-        return CFX_GifDecodeStatus::Error;
+        return GifDecoder::Status::kError;
       }
     } else {
       bool bRes = GetRecordPosition(
@@ -202,13 +202,13 @@
           gif_image->image_info.local_flags.interlace);
       if (!bRes) {
         gif_image->row_buffer.clear();
-        return CFX_GifDecodeStatus::Error;
+        return GifDecoder::Status::kError;
       }
     }
 
     if (gif_image->code_exp > GIF_MAX_LZW_EXP) {
       gif_image->row_buffer.clear();
-      return CFX_GifDecodeStatus::Error;
+      return GifDecoder::Status::kError;
     }
 
     img_row_offset_ = 0;
@@ -224,13 +224,13 @@
 
   if (decode_status_ == GIF_D_STATUS_IMG_DATA) {
     if (!ReadAllOrNone(&img_data_size, sizeof(img_data_size)))
-      return CFX_GifDecodeStatus::Unfinished;
+      return GifDecoder::Status::kUnfinished;
 
     if (img_data_size != GIF_BLOCK_TERMINAL) {
       img_data.resize(img_data_size);
       if (!ReadAllOrNone(img_data.data(), img_data_size)) {
         input_buffer_->Seek(read_marker);
-        return CFX_GifDecodeStatus::Unfinished;
+        return GifDecoder::Status::kUnfinished;
       }
 
       if (!lzw_decompressor_.get()) {
@@ -240,36 +240,36 @@
       SaveDecodingStatus(GIF_D_STATUS_IMG_DATA);
       img_row_offset_ += img_row_avail_size_;
       img_row_avail_size_ = gif_img_row_bytes - img_row_offset_;
-      CFX_GifDecodeStatus ret =
+      GifDecoder::Status ret =
           lzw_decompressor_.get()
               ? lzw_decompressor_->Decode(
                     img_data.data(), img_data_size,
                     gif_image->row_buffer.data() + img_row_offset_,
                     &img_row_avail_size_)
-              : CFX_GifDecodeStatus::Error;
-      if (ret == CFX_GifDecodeStatus::Error) {
+              : GifDecoder::Status::kError;
+      if (ret == GifDecoder::Status::kError) {
         DecodingFailureAtTailCleanup(gif_image);
-        return CFX_GifDecodeStatus::Error;
+        return GifDecoder::Status::kError;
       }
 
-      while (ret != CFX_GifDecodeStatus::Error) {
-        if (ret == CFX_GifDecodeStatus::Success) {
+      while (ret != GifDecoder::Status::kError) {
+        if (ret == GifDecoder::Status::kSuccess) {
           ReadScanline(gif_image->row_num, gif_image->row_buffer.data());
           gif_image->row_buffer.clear();
           SaveDecodingStatus(GIF_D_STATUS_TAIL);
-          return CFX_GifDecodeStatus::Success;
+          return GifDecoder::Status::kSuccess;
         }
 
-        if (ret == CFX_GifDecodeStatus::Unfinished) {
+        if (ret == GifDecoder::Status::kUnfinished) {
           read_marker = input_buffer_->GetPosition();
           if (!ReadAllOrNone(&img_data_size, sizeof(img_data_size)))
-            return CFX_GifDecodeStatus::Unfinished;
+            return GifDecoder::Status::kUnfinished;
 
           if (img_data_size != GIF_BLOCK_TERMINAL) {
             img_data.resize(img_data_size);
             if (!ReadAllOrNone(img_data.data(), img_data_size)) {
               input_buffer_->Seek(read_marker);
-              return CFX_GifDecodeStatus::Unfinished;
+              return GifDecoder::Status::kUnfinished;
             }
 
             if (!lzw_decompressor_.get()) {
@@ -284,11 +284,11 @@
                             img_data.data(), img_data_size,
                             gif_image->row_buffer.data() + img_row_offset_,
                             &img_row_avail_size_)
-                      : CFX_GifDecodeStatus::Error;
+                      : GifDecoder::Status::kError;
           }
         }
 
-        if (ret == CFX_GifDecodeStatus::InsufficientDestSize) {
+        if (ret == GifDecoder::Status::kInsufficientDestSize) {
           if (gif_image->image_info.local_flags.interlace) {
             ReadScanline(gif_image->row_num, gif_image->row_buffer.data());
             gif_image->row_num += kGifInterlaceStep[img_pass_num_];
@@ -297,7 +297,7 @@
               img_pass_num_++;
               if (img_pass_num_ == pdfium::size(kGifInterlaceStep)) {
                 DecodingFailureAtTailCleanup(gif_image);
-                return CFX_GifDecodeStatus::Error;
+                return GifDecoder::Status::kError;
               }
               gif_image->row_num = kGifInterlaceStep[img_pass_num_] / 2;
             }
@@ -311,19 +311,19 @@
                           img_data.data(), img_data_size,
                           gif_image->row_buffer.data() + img_row_offset_,
                           &img_row_avail_size_)
-                    : CFX_GifDecodeStatus::Error;
+                    : GifDecoder::Status::kError;
         }
 
-        if (ret == CFX_GifDecodeStatus::InsufficientDestSize ||
-            ret == CFX_GifDecodeStatus::Error) {
+        if (ret == GifDecoder::Status::kInsufficientDestSize ||
+            ret == GifDecoder::Status::kError) {
           DecodingFailureAtTailCleanup(gif_image);
-          return CFX_GifDecodeStatus::Error;
+          return GifDecoder::Status::kError;
         }
       }
     }
     SaveDecodingStatus(GIF_D_STATUS_TAIL);
   }
-  return CFX_GifDecodeStatus::Error;
+  return GifDecoder::Status::kError;
 }
 
 void CFX_GifContext::SetInputBuffer(RetainPtr<CFX_CodecMemory> codec_memory) {
@@ -351,30 +351,30 @@
   return true;
 }
 
-CFX_GifDecodeStatus CFX_GifContext::ReadGifSignature() {
+GifDecoder::Status CFX_GifContext::ReadGifSignature() {
   CFX_GifHeader header;
   if (!ReadAllOrNone(reinterpret_cast<uint8_t*>(&header), 6))
-    return CFX_GifDecodeStatus::Unfinished;
+    return GifDecoder::Status::kUnfinished;
 
   if (strncmp(header.signature, kGifSignature87, 6) != 0 &&
       strncmp(header.signature, kGifSignature89, 6) != 0) {
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
   }
 
-  return CFX_GifDecodeStatus::Success;
+  return GifDecoder::Status::kSuccess;
 }
 
-CFX_GifDecodeStatus CFX_GifContext::ReadLogicalScreenDescriptor() {
+GifDecoder::Status CFX_GifContext::ReadLogicalScreenDescriptor() {
   CFX_GifLocalScreenDescriptor lsd;
   size_t read_marker = input_buffer_->GetPosition();
 
   if (!ReadAllOrNone(reinterpret_cast<uint8_t*>(&lsd), sizeof(lsd)))
-    return CFX_GifDecodeStatus::Unfinished;
+    return GifDecoder::Status::kUnfinished;
 
   if (lsd.global_flags.global_pal) {
     uint32_t palette_count = unsigned(2 << lsd.global_flags.pal_bits);
     if (lsd.bc_index >= palette_count)
-      return CFX_GifDecodeStatus::Error;
+      return GifDecoder::Status::kError;
     bc_index_ = lsd.bc_index;
 
     uint32_t palette_size = palette_count * sizeof(CFX_GifPalette);
@@ -383,7 +383,7 @@
                        palette_size)) {
       // Roll back the read for the LSD
       input_buffer_->Seek(read_marker);
-      return CFX_GifDecodeStatus::Unfinished;
+      return GifDecoder::Status::kUnfinished;
     }
 
     global_palette_exp_ = lsd.global_flags.pal_bits;
@@ -397,40 +397,40 @@
   height_ = static_cast<int>(
       FXWORD_GET_LSBFIRST(reinterpret_cast<uint8_t*>(&lsd.height)));
 
-  return CFX_GifDecodeStatus::Success;
+  return GifDecoder::Status::kSuccess;
 }
 
 void CFX_GifContext::SaveDecodingStatus(int32_t status) {
   decode_status_ = status;
 }
 
-CFX_GifDecodeStatus CFX_GifContext::DecodeExtension() {
+GifDecoder::Status CFX_GifContext::DecodeExtension() {
   size_t read_marker = input_buffer_->GetPosition();
 
   switch (decode_status_) {
     case GIF_D_STATUS_EXT_CE: {
       if (!ScanForTerminalMarker()) {
         input_buffer_->Seek(read_marker);
-        return CFX_GifDecodeStatus::Unfinished;
+        return GifDecoder::Status::kUnfinished;
       }
       break;
     }
     case GIF_D_STATUS_EXT_PTE: {
       CFX_GifPlainTextExtension gif_pte;
       if (!ReadAllOrNone(reinterpret_cast<uint8_t*>(&gif_pte), sizeof(gif_pte)))
-        return CFX_GifDecodeStatus::Unfinished;
+        return GifDecoder::Status::kUnfinished;
 
       graphic_control_extension_ = nullptr;
       if (!ScanForTerminalMarker()) {
         input_buffer_->Seek(read_marker);
-        return CFX_GifDecodeStatus::Unfinished;
+        return GifDecoder::Status::kUnfinished;
       }
       break;
     }
     case GIF_D_STATUS_EXT_GCE: {
       CFX_GifGraphicControlExtension gif_gce;
       if (!ReadAllOrNone(reinterpret_cast<uint8_t*>(&gif_gce), sizeof(gif_gce)))
-        return CFX_GifDecodeStatus::Unfinished;
+        return GifDecoder::Status::kUnfinished;
 
       if (!graphic_control_extension_.get())
         graphic_control_extension_ =
@@ -447,23 +447,23 @@
         graphic_control_extension_ = nullptr;
       if (!ScanForTerminalMarker()) {
         input_buffer_->Seek(read_marker);
-        return CFX_GifDecodeStatus::Unfinished;
+        return GifDecoder::Status::kUnfinished;
       }
     }
   }
 
   SaveDecodingStatus(GIF_D_STATUS_SIG);
-  return CFX_GifDecodeStatus::Success;
+  return GifDecoder::Status::kSuccess;
 }
 
-CFX_GifDecodeStatus CFX_GifContext::DecodeImageInfo() {
+GifDecoder::Status CFX_GifContext::DecodeImageInfo() {
   if (width_ <= 0 || height_ <= 0)
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
 
   size_t read_marker = input_buffer_->GetPosition();
   CFX_GifImageInfo img_info;
   if (!ReadAllOrNone(reinterpret_cast<uint8_t*>(&img_info), sizeof(img_info)))
-    return CFX_GifDecodeStatus::Unfinished;
+    return GifDecoder::Status::kUnfinished;
 
   auto gif_image = std::make_unique<CFX_GifImage>();
   gif_image->image_info.left =
@@ -477,7 +477,7 @@
   gif_image->image_info.local_flags = img_info.local_flags;
   if (gif_image->image_info.left + gif_image->image_info.width > width_ ||
       gif_image->image_info.top + gif_image->image_info.height > height_)
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
 
   CFX_GifLocalFlags* gif_img_info_lf = &img_info.local_flags;
   if (gif_img_info_lf->local_pal) {
@@ -487,7 +487,7 @@
     if (!ReadAllOrNone(reinterpret_cast<uint8_t*>(loc_pal.data()),
                        loc_pal_count * sizeof(CFX_GifPalette))) {
       input_buffer_->Seek(read_marker);
-      return CFX_GifDecodeStatus::Unfinished;
+      return GifDecoder::Status::kUnfinished;
     }
 
     gif_image->local_palettes = std::move(loc_pal);
@@ -496,7 +496,7 @@
   uint8_t code_size;
   if (!ReadAllOrNone(&code_size, sizeof(code_size))) {
     input_buffer_->Seek(read_marker);
-    return CFX_GifDecodeStatus::Unfinished;
+    return GifDecoder::Status::kUnfinished;
   }
 
   gif_image->code_exp = code_size;
@@ -509,7 +509,7 @@
       // in the palette being used.
       if (graphic_control_extension_->trans_index >=
           (2 << GetPaletteExp(gif_image.get()))) {
-        return CFX_GifDecodeStatus::Error;
+        return GifDecoder::Status::kError;
       }
     }
     gif_image->image_GCE = std::move(graphic_control_extension_);
@@ -518,7 +518,7 @@
 
   images_.push_back(std::move(gif_image));
   SaveDecodingStatus(GIF_D_STATUS_IMG_DATA);
-  return CFX_GifDecodeStatus::Success;
+  return GifDecoder::Status::kSuccess;
 }
 
 void CFX_GifContext::DecodingFailureAtTailCleanup(CFX_GifImage* gif_image) {
diff --git a/core/fxcodec/gif/cfx_gifcontext.h b/core/fxcodec/gif/cfx_gifcontext.h
index 9298cb9..27d882f 100644
--- a/core/fxcodec/gif/cfx_gifcontext.h
+++ b/core/fxcodec/gif/cfx_gifcontext.h
@@ -39,9 +39,9 @@
                          int32_t trans_index,
                          int32_t disposal_method,
                          bool interlace);
-  CFX_GifDecodeStatus ReadHeader();
-  CFX_GifDecodeStatus GetFrame();
-  CFX_GifDecodeStatus LoadFrame(int32_t frame_num);
+  GifDecoder::Status ReadHeader();
+  GifDecoder::Status GetFrame();
+  GifDecoder::Status LoadFrame(int32_t frame_num);
   void SetInputBuffer(RetainPtr<CFX_CodecMemory> codec_memory);
   uint32_t GetAvailInput() const;
   size_t GetFrameNum() const { return images_.size(); }
@@ -64,15 +64,15 @@
 
  protected:
   bool ReadAllOrNone(uint8_t* dest, uint32_t size);
-  CFX_GifDecodeStatus ReadGifSignature();
-  CFX_GifDecodeStatus ReadLogicalScreenDescriptor();
+  GifDecoder::Status ReadGifSignature();
+  GifDecoder::Status ReadLogicalScreenDescriptor();
 
   RetainPtr<CFX_CodecMemory> input_buffer_;
 
  private:
   void SaveDecodingStatus(int32_t status);
-  CFX_GifDecodeStatus DecodeExtension();
-  CFX_GifDecodeStatus DecodeImageInfo();
+  GifDecoder::Status DecodeExtension();
+  GifDecoder::Status DecodeImageInfo();
   void DecodingFailureAtTailCleanup(CFX_GifImage* gif_image);
   bool ScanForTerminalMarker();
   uint8_t GetPaletteExp(CFX_GifImage* gif_image) const;
diff --git a/core/fxcodec/gif/cfx_gifcontext_unittest.cpp b/core/fxcodec/gif/cfx_gifcontext_unittest.cpp
index 4cbeeb5..f9de186 100644
--- a/core/fxcodec/gif/cfx_gifcontext_unittest.cpp
+++ b/core/fxcodec/gif/cfx_gifcontext_unittest.cpp
@@ -88,7 +88,7 @@
   {
     uint8_t data[1];
     context.SetTestInputBuffer({data, 0});
-    EXPECT_EQ(CFX_GifDecodeStatus::Unfinished, context.ReadGifSignature());
+    EXPECT_EQ(GifDecoder::Status::kUnfinished, context.ReadGifSignature());
     EXPECT_EQ(0u, context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -96,14 +96,14 @@
   {
     uint8_t data[] = {'G', 'I', 'F'};
     context.SetTestInputBuffer(data);
-    EXPECT_EQ(CFX_GifDecodeStatus::Unfinished, context.ReadGifSignature());
+    EXPECT_EQ(GifDecoder::Status::kUnfinished, context.ReadGifSignature());
     EXPECT_EQ(0u, context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
   {
     uint8_t data[] = {'N', 'O', 'T', 'G', 'I', 'F'};
     context.SetTestInputBuffer(data);
-    EXPECT_EQ(CFX_GifDecodeStatus::Error, context.ReadGifSignature());
+    EXPECT_EQ(GifDecoder::Status::kError, context.ReadGifSignature());
     EXPECT_EQ(6u, context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -111,7 +111,7 @@
   {
     uint8_t data[] = {'G', 'I', 'F', '8', '0', 'a'};
     context.SetTestInputBuffer(data);
-    EXPECT_EQ(CFX_GifDecodeStatus::Error, context.ReadGifSignature());
+    EXPECT_EQ(GifDecoder::Status::kError, context.ReadGifSignature());
     EXPECT_EQ(6u, context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -119,7 +119,7 @@
   {
     uint8_t data[] = {'G', 'I', 'F', '9', '2', 'a'};
     context.SetTestInputBuffer(data);
-    EXPECT_EQ(CFX_GifDecodeStatus::Error, context.ReadGifSignature());
+    EXPECT_EQ(GifDecoder::Status::kError, context.ReadGifSignature());
     EXPECT_EQ(6u, context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -127,7 +127,7 @@
   {
     uint8_t data[] = {'G', 'I', 'F', '8', '7', 'a'};
     context.SetTestInputBuffer(data);
-    EXPECT_EQ(CFX_GifDecodeStatus::Success, context.ReadGifSignature());
+    EXPECT_EQ(GifDecoder::Status::kSuccess, context.ReadGifSignature());
     EXPECT_EQ(6u, context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -135,7 +135,7 @@
   {
     uint8_t data[] = {'G', 'I', 'F', '8', '9', 'a'};
     context.SetTestInputBuffer(data);
-    EXPECT_EQ(CFX_GifDecodeStatus::Success, context.ReadGifSignature());
+    EXPECT_EQ(GifDecoder::Status::kSuccess, context.ReadGifSignature());
     EXPECT_EQ(6u, context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -146,7 +146,7 @@
   {
     uint8_t data[1];
     context.SetTestInputBuffer({data, 0});
-    EXPECT_EQ(CFX_GifDecodeStatus::Unfinished,
+    EXPECT_EQ(GifDecoder::Status::kUnfinished,
               context.ReadLogicalScreenDescriptor());
     context.SetTestInputBuffer({});
   }
@@ -156,7 +156,7 @@
     memset(&lsd, 0, sizeof(CFX_GifLocalScreenDescriptor));
     context.SetTestInputBuffer(lsd);
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Success,
+    EXPECT_EQ(GifDecoder::Status::kSuccess,
               context.ReadLogicalScreenDescriptor());
 
     EXPECT_EQ(sizeof(CFX_GifLocalScreenDescriptor),
@@ -172,7 +172,7 @@
                                                          0x00, 0x01, 0x02};
     context.SetTestInputBuffer(lsd);
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Success,
+    EXPECT_EQ(GifDecoder::Status::kSuccess,
               context.ReadLogicalScreenDescriptor());
 
     EXPECT_EQ(sizeof(CFX_GifLocalScreenDescriptor),
@@ -188,7 +188,7 @@
                                                          0x80, 0x01, 0x02};
     context.SetTestInputBuffer(lsd);
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Unfinished,
+    EXPECT_EQ(GifDecoder::Status::kUnfinished,
               context.ReadLogicalScreenDescriptor());
 
     EXPECT_EQ(0u, context.InputBuffer()->GetPosition());
@@ -204,7 +204,7 @@
     context.SetTestInputBuffer(
         {reinterpret_cast<uint8_t*>(&data), sizeof(data)});
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Success,
+    EXPECT_EQ(GifDecoder::Status::kSuccess,
               context.ReadLogicalScreenDescriptor());
 
     EXPECT_EQ(sizeof(data), context.InputBuffer()->GetPosition());
@@ -232,7 +232,7 @@
     context.SetTestInputBuffer(
         {reinterpret_cast<uint8_t*>(&data), sizeof(data)});
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Error, context.ReadHeader());
+    EXPECT_EQ(GifDecoder::Status::kError, context.ReadHeader());
     EXPECT_EQ(sizeof(data.signature), context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -242,7 +242,7 @@
     context.SetTestInputBuffer(
         {reinterpret_cast<uint8_t*>(&signature), sizeof(signature)});
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Unfinished, context.ReadHeader());
+    EXPECT_EQ(GifDecoder::Status::kUnfinished, context.ReadHeader());
     EXPECT_EQ(sizeof(signature), context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -256,7 +256,7 @@
     context.SetTestInputBuffer(
         {reinterpret_cast<uint8_t*>(&data), sizeof(data)});
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Success, context.ReadHeader());
+    EXPECT_EQ(GifDecoder::Status::kSuccess, context.ReadHeader());
     EXPECT_EQ(sizeof(data), context.InputBuffer()->GetPosition());
     EXPECT_EQ(0x000A, context.width_);
     EXPECT_EQ(0x0F00, context.height_);
@@ -273,7 +273,7 @@
     context.SetTestInputBuffer(
         {reinterpret_cast<uint8_t*>(&data), sizeof(data)});
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Unfinished, context.ReadHeader());
+    EXPECT_EQ(GifDecoder::Status::kUnfinished, context.ReadHeader());
     EXPECT_EQ(sizeof(data.signature), context.InputBuffer()->GetPosition());
     context.SetTestInputBuffer({});
   }
@@ -289,7 +289,7 @@
     context.SetTestInputBuffer(
         {reinterpret_cast<uint8_t*>(&data), sizeof(data)});
 
-    EXPECT_EQ(CFX_GifDecodeStatus::Success, context.ReadHeader());
+    EXPECT_EQ(GifDecoder::Status::kSuccess, context.ReadHeader());
     EXPECT_EQ(sizeof(data), context.InputBuffer()->GetPosition());
     EXPECT_EQ(0x000A, context.width_);
     EXPECT_EQ(0x0F00, context.height_);
diff --git a/core/fxcodec/gif/cfx_lzwdecompressor.cpp b/core/fxcodec/gif/cfx_lzwdecompressor.cpp
index ccf5c12..3b8fa62 100644
--- a/core/fxcodec/gif/cfx_lzwdecompressor.cpp
+++ b/core/fxcodec/gif/cfx_lzwdecompressor.cpp
@@ -35,15 +35,15 @@
 
 CFX_LZWDecompressor::~CFX_LZWDecompressor() = default;
 
-CFX_GifDecodeStatus CFX_LZWDecompressor::Decode(const uint8_t* src_buf,
-                                                uint32_t src_size,
-                                                uint8_t* dest_buf,
-                                                uint32_t* dest_size) {
+GifDecoder::Status CFX_LZWDecompressor::Decode(const uint8_t* src_buf,
+                                               uint32_t src_size,
+                                               uint8_t* dest_buf,
+                                               uint32_t* dest_size) {
   if (!src_buf || src_size == 0 || !dest_buf || !dest_size)
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
 
   if (*dest_size == 0)
-    return CFX_GifDecodeStatus::InsufficientDestSize;
+    return GifDecoder::Status::kInsufficientDestSize;
 
   next_in_ = src_buf;
   avail_in_ = src_size;
@@ -54,7 +54,7 @@
   if (decompressed_next_ != 0) {
     uint32_t extracted_size = ExtractData(dest_buf, *dest_size);
     if (decompressed_next_ != 0)
-      return CFX_GifDecodeStatus::InsufficientDestSize;
+      return GifDecoder::Status::kInsufficientDestSize;
 
     dest_buf += extracted_size;
     i += extracted_size;
@@ -62,17 +62,17 @@
 
   while (i <= *dest_size && (avail_in_ > 0 || bits_left_ >= code_size_cur_)) {
     if (code_size_cur_ > GIF_MAX_LZW_EXP)
-      return CFX_GifDecodeStatus::Error;
+      return GifDecoder::Status::kError;
 
     if (avail_in_ > 0) {
       if (bits_left_ > 31)
-        return CFX_GifDecodeStatus::Error;
+        return GifDecoder::Status::kError;
 
       FX_SAFE_UINT32 safe_code = *next_in_++;
       safe_code <<= bits_left_;
       safe_code |= code_store_;
       if (!safe_code.IsValid())
-        return CFX_GifDecodeStatus::Error;
+        return GifDecoder::Status::kError;
 
       code_store_ = safe_code.ValueOrDie();
       --avail_in_;
@@ -90,7 +90,7 @@
       }
       if (code == code_end_) {
         *dest_size = i;
-        return CFX_GifDecodeStatus::Success;
+        return GifDecoder::Status::kSuccess;
       }
 
       if (code_old_ != static_cast<uint16_t>(-1)) {
@@ -98,12 +98,12 @@
           if (code == code_next_) {
             AddCode(code_old_, code_first_);
             if (!DecodeString(code))
-              return CFX_GifDecodeStatus::Error;
+              return GifDecoder::Status::kError;
           } else if (code > code_next_) {
-            return CFX_GifDecodeStatus::Error;
+            return GifDecoder::Status::kError;
           } else {
             if (!DecodeString(code))
-              return CFX_GifDecodeStatus::Error;
+              return GifDecoder::Status::kError;
 
             uint8_t append_char = decompressed_[decompressed_next_ - 1];
             AddCode(code_old_, append_char);
@@ -111,13 +111,13 @@
         }
       } else {
         if (!DecodeString(code))
-          return CFX_GifDecodeStatus::Error;
+          return GifDecoder::Status::kError;
       }
 
       code_old_ = code;
       uint32_t extracted_size = ExtractData(dest_buf, *dest_size - i);
       if (decompressed_next_ != 0)
-        return CFX_GifDecodeStatus::InsufficientDestSize;
+        return GifDecoder::Status::kInsufficientDestSize;
 
       dest_buf += extracted_size;
       i += extracted_size;
@@ -125,10 +125,10 @@
   }
 
   if (avail_in_ != 0)
-    return CFX_GifDecodeStatus::Error;
+    return GifDecoder::Status::kError;
 
   *dest_size = i;
-  return CFX_GifDecodeStatus::Unfinished;
+  return GifDecoder::Status::kUnfinished;
 }
 
 void CFX_LZWDecompressor::ClearTable() {
diff --git a/core/fxcodec/gif/cfx_lzwdecompressor.h b/core/fxcodec/gif/cfx_lzwdecompressor.h
index e6d2c02..979686c 100644
--- a/core/fxcodec/gif/cfx_lzwdecompressor.h
+++ b/core/fxcodec/gif/cfx_lzwdecompressor.h
@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "core/fxcodec/gif/cfx_gif.h"
+#include "core/fxcodec/gif/gif_decoder.h"
 #include "core/fxcrt/fx_memory_wrappers.h"
 
 class CFX_LZWDecompressor {
@@ -25,10 +26,10 @@
                                                      uint8_t code_exp);
   ~CFX_LZWDecompressor();
 
-  CFX_GifDecodeStatus Decode(const uint8_t* src_buf,
-                             uint32_t src_size,
-                             uint8_t* dest_buf,
-                             uint32_t* dest_size);
+  GifDecoder::Status Decode(const uint8_t* src_buf,
+                            uint32_t src_size,
+                            uint8_t* dest_buf,
+                            uint32_t* dest_size);
 
   // Used by unittests, should not be called in production code.
   uint32_t ExtractDataForTest(uint8_t* dest_buf, uint32_t dest_size) {
diff --git a/core/fxcodec/gif/cfx_lzwdecompressor_unittest.cpp b/core/fxcodec/gif/cfx_lzwdecompressor_unittest.cpp
index ac824ac4..e952fa0 100644
--- a/core/fxcodec/gif/cfx_lzwdecompressor_unittest.cpp
+++ b/core/fxcodec/gif/cfx_lzwdecompressor_unittest.cpp
@@ -92,19 +92,19 @@
   uint32_t output_size = pdfium::size(output_data);
 
   EXPECT_EQ(
-      CFX_GifDecodeStatus::Error,
+      GifDecoder::Status::kError,
       decompressor->Decode(nullptr, image_size, output_data, &output_size));
-  EXPECT_EQ(CFX_GifDecodeStatus::Error,
+  EXPECT_EQ(GifDecoder::Status::kError,
             decompressor->Decode(image_data, 0, output_data, &output_size));
   EXPECT_EQ(
-      CFX_GifDecodeStatus::Error,
+      GifDecoder::Status::kError,
       decompressor->Decode(image_data, image_size, nullptr, &output_size));
-  EXPECT_EQ(CFX_GifDecodeStatus::Error,
+  EXPECT_EQ(GifDecoder::Status::kError,
             decompressor->Decode(image_data, image_size, output_data, nullptr));
 
   output_size = 0;
   EXPECT_EQ(
-      CFX_GifDecodeStatus::InsufficientDestSize,
+      GifDecoder::Status::kInsufficientDestSize,
       decompressor->Decode(image_data, image_size, output_data, &output_size));
 }
 
@@ -123,7 +123,7 @@
   uint32_t output_size = pdfium::size(output_data);
 
   EXPECT_EQ(
-      CFX_GifDecodeStatus::Success,
+      GifDecoder::Status::kSuccess,
       decompressor->Decode(image_data, image_size, output_data, &output_size));
 
   EXPECT_EQ(pdfium::size(output_data), output_size);
@@ -155,7 +155,7 @@
   uint32_t output_size = pdfium::size(output_data);
 
   EXPECT_EQ(
-      CFX_GifDecodeStatus::Success,
+      GifDecoder::Status::kSuccess,
       decompressor->Decode(kImageData, image_size, output_data, &output_size));
 
   EXPECT_EQ(pdfium::size(output_data), output_size);
@@ -189,7 +189,7 @@
   uint32_t output_size = pdfium::size(output_data);
 
   EXPECT_EQ(
-      CFX_GifDecodeStatus::Success,
+      GifDecoder::Status::kSuccess,
       decompressor->Decode(kImageData, image_size, output_data, &output_size));
 
   EXPECT_EQ(pdfium::size(output_data), output_size);
@@ -214,6 +214,6 @@
   uint32_t output_size = pdfium::size(output_data);
 
   EXPECT_EQ(
-      CFX_GifDecodeStatus::Error,
+      GifDecoder::Status::kError,
       decompressor->Decode(kImageData, image_size, output_data, &output_size));
 }
diff --git a/core/fxcodec/gif/gif_decoder.cpp b/core/fxcodec/gif/gif_decoder.cpp
index 2a46aa3..1b285c4 100644
--- a/core/fxcodec/gif/gif_decoder.cpp
+++ b/core/fxcodec/gif/gif_decoder.cpp
@@ -20,7 +20,7 @@
 }
 
 // static
-CFX_GifDecodeStatus GifDecoder::ReadHeader(
+GifDecoder::Status GifDecoder::ReadHeader(
     ProgressiveDecoderIface::Context* pContext,
     int* width,
     int* height,
@@ -28,8 +28,8 @@
     CFX_GifPalette** pal_pp,
     int* bg_index) {
   auto* context = static_cast<CFX_GifContext*>(pContext);
-  CFX_GifDecodeStatus ret = context->ReadHeader();
-  if (ret != CFX_GifDecodeStatus::Success)
+  Status ret = context->ReadHeader();
+  if (ret != Status::kSuccess)
     return ret;
 
   *width = context->width_;
@@ -38,21 +38,21 @@
   *pal_pp = context->global_palette_.empty() ? nullptr
                                              : context->global_palette_.data();
   *bg_index = context->bc_index_;
-  return CFX_GifDecodeStatus::Success;
+  return Status::kSuccess;
 }
 
 // static
-std::pair<CFX_GifDecodeStatus, size_t> GifDecoder::LoadFrameInfo(
+std::pair<GifDecoder::Status, size_t> GifDecoder::LoadFrameInfo(
     ProgressiveDecoderIface::Context* pContext) {
   auto* context = static_cast<CFX_GifContext*>(pContext);
-  CFX_GifDecodeStatus ret = context->GetFrame();
-  if (ret != CFX_GifDecodeStatus::Success)
+  Status ret = context->GetFrame();
+  if (ret != Status::kSuccess)
     return {ret, 0};
-  return {CFX_GifDecodeStatus::Success, context->GetFrameNum()};
+  return {Status::kSuccess, context->GetFrameNum()};
 }
 
 // static
-CFX_GifDecodeStatus GifDecoder::LoadFrame(
+GifDecoder::Status GifDecoder::LoadFrame(
     ProgressiveDecoderIface::Context* pContext,
     size_t frame_num) {
   return static_cast<CFX_GifContext*>(pContext)->LoadFrame(frame_num);
diff --git a/core/fxcodec/gif/gif_decoder.h b/core/fxcodec/gif/gif_decoder.h
index 2aaa601..9a4df57 100644
--- a/core/fxcodec/gif/gif_decoder.h
+++ b/core/fxcodec/gif/gif_decoder.h
@@ -24,6 +24,13 @@
 
 class GifDecoder {
  public:
+  enum class Status {
+    kError,
+    kSuccess,
+    kUnfinished,
+    kInsufficientDestSize,  // Only used internally by CGifLZWDecoder::Decode()
+  };
+
   class Delegate {
    public:
     virtual void GifRecordCurrentPosition(uint32_t& cur_pos) = 0;
@@ -41,18 +48,16 @@
 
   static std::unique_ptr<ProgressiveDecoderIface::Context> StartDecode(
       Delegate* pDelegate);
-  static CFX_GifDecodeStatus ReadHeader(
-      ProgressiveDecoderIface::Context* context,
-      int* width,
-      int* height,
-      int* pal_num,
-      CFX_GifPalette** pal_pp,
-      int* bg_index);
-  static std::pair<CFX_GifDecodeStatus, size_t> LoadFrameInfo(
+  static Status ReadHeader(ProgressiveDecoderIface::Context* context,
+                           int* width,
+                           int* height,
+                           int* pal_num,
+                           CFX_GifPalette** pal_pp,
+                           int* bg_index);
+  static std::pair<Status, size_t> LoadFrameInfo(
       ProgressiveDecoderIface::Context* context);
-  static CFX_GifDecodeStatus LoadFrame(
-      ProgressiveDecoderIface::Context* context,
-      size_t frame_num);
+  static Status LoadFrame(ProgressiveDecoderIface::Context* context,
+                          size_t frame_num);
   static FX_FILESIZE GetAvailInput(ProgressiveDecoderIface::Context* context);
   static bool Input(ProgressiveDecoderIface::Context* context,
                     RetainPtr<CFX_CodecMemory> codec_memory,
diff --git a/core/fxcodec/progressive_decoder.cpp b/core/fxcodec/progressive_decoder.cpp
index 14a9569..1ddbcd0 100644
--- a/core/fxcodec/progressive_decoder.cpp
+++ b/core/fxcodec/progressive_decoder.cpp
@@ -829,10 +829,10 @@
   m_pGifContext = GifDecoder::StartDecode(this);
   GifDecoder::Input(m_pGifContext.get(), m_pCodecMemory, nullptr);
   m_SrcComponents = 1;
-  CFX_GifDecodeStatus readResult =
+  GifDecoder::Status readResult =
       GifDecoder::ReadHeader(m_pGifContext.get(), &m_SrcWidth, &m_SrcHeight,
                              &m_GifPltNumber, &m_pGifPalette, &m_GifBgIndex);
-  while (readResult == CFX_GifDecodeStatus::Unfinished) {
+  while (readResult == GifDecoder::Status::kUnfinished) {
     FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_FORMAT;
     if (!GifReadMoreData(&error_status)) {
       m_pGifContext = nullptr;
@@ -843,7 +843,7 @@
         GifDecoder::ReadHeader(m_pGifContext.get(), &m_SrcWidth, &m_SrcHeight,
                                &m_GifPltNumber, &m_pGifPalette, &m_GifBgIndex);
   }
-  if (readResult == CFX_GifDecodeStatus::Success) {
+  if (readResult == GifDecoder::Status::kSuccess) {
     m_SrcBPC = 8;
     m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
     return true;
@@ -867,9 +867,9 @@
 }
 
 FXCODEC_STATUS ProgressiveDecoder::GifContinueDecode() {
-  CFX_GifDecodeStatus readRes =
+  GifDecoder::Status readRes =
       GifDecoder::LoadFrame(m_pGifContext.get(), m_FrameCur);
-  while (readRes == CFX_GifDecodeStatus::Unfinished) {
+  while (readRes == GifDecoder::Status::kUnfinished) {
     FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
     if (!GifReadMoreData(&error_status)) {
       m_pDeviceBitmap = nullptr;
@@ -880,7 +880,7 @@
     readRes = GifDecoder::LoadFrame(m_pGifContext.get(), m_FrameCur);
   }
 
-  if (readRes == CFX_GifDecodeStatus::Success) {
+  if (readRes == GifDecoder::Status::kSuccess) {
     m_pDeviceBitmap = nullptr;
     m_pFile = nullptr;
     m_status = FXCODEC_STATUS_DECODE_FINISH;
@@ -2117,10 +2117,10 @@
 #ifdef PDF_ENABLE_XFA_GIF
     case FXCODEC_IMAGE_GIF: {
       while (true) {
-        CFX_GifDecodeStatus readResult;
+        GifDecoder::Status readResult;
         std::tie(readResult, m_FrameNumber) =
             GifDecoder::LoadFrameInfo(m_pGifContext.get());
-        while (readResult == CFX_GifDecodeStatus::Unfinished) {
+        while (readResult == GifDecoder::Status::kUnfinished) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_READ;
           if (!GifReadMoreData(&error_status))
             return {error_status, 0};
@@ -2128,7 +2128,7 @@
           std::tie(readResult, m_FrameNumber) =
               GifDecoder::LoadFrameInfo(m_pGifContext.get());
         }
-        if (readResult == CFX_GifDecodeStatus::Success) {
+        if (readResult == GifDecoder::Status::kSuccess) {
           m_status = FXCODEC_STATUS_DECODE_READY;
           return {m_status, m_FrameNumber};
         }
diff --git a/testing/fuzzers/pdf_lzw_fuzzer.cc b/testing/fuzzers/pdf_lzw_fuzzer.cc
index e4d993e..e868ae4 100644
--- a/testing/fuzzers/pdf_lzw_fuzzer.cc
+++ b/testing/fuzzers/pdf_lzw_fuzzer.cc
@@ -27,7 +27,7 @@
     // This cast should be safe since the caller is checking for overflow on
     // the initial data.
     uint32_t dest_size = static_cast<uint32_t>(dest_buf.size());
-    if (CFX_GifDecodeStatus::InsufficientDestSize !=
+    if (GifDecoder::Status::kInsufficientDestSize !=
         decompressor->Decode(src_buf, src_size, dest_buf.data(), &dest_size)) {
       return;
     }