diff --git a/core/fpdfapi/page/BUILD.gn b/core/fpdfapi/page/BUILD.gn
index 08c1be5..22ca2fb 100644
--- a/core/fpdfapi/page/BUILD.gn
+++ b/core/fpdfapi/page/BUILD.gn
@@ -27,8 +27,8 @@
     "cpdf_contentparser.h",
     "cpdf_devicecs.cpp",
     "cpdf_devicecs.h",
-    "cpdf_dibbase.cpp",
-    "cpdf_dibbase.h",
+    "cpdf_dib.cpp",
+    "cpdf_dib.h",
     "cpdf_dibtransferfunc.cpp",
     "cpdf_dibtransferfunc.h",
     "cpdf_docpagedata.cpp",
diff --git a/core/fpdfapi/page/cpdf_dibbase.cpp b/core/fpdfapi/page/cpdf_dib.cpp
similarity index 91%
rename from core/fpdfapi/page/cpdf_dibbase.cpp
rename to core/fpdfapi/page/cpdf_dib.cpp
index 02038fb..1a1c8f1 100644
--- a/core/fpdfapi/page/cpdf_dibbase.cpp
+++ b/core/fpdfapi/page/cpdf_dib.cpp
@@ -4,7 +4,7 @@
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 
 #include <algorithm>
 #include <memory>
@@ -104,11 +104,11 @@
 
 }  // namespace
 
-CPDF_DIBBase::CPDF_DIBBase() = default;
+CPDF_DIB::CPDF_DIB() = default;
 
-CPDF_DIBBase::~CPDF_DIBBase() = default;
+CPDF_DIB::~CPDF_DIB() = default;
 
-bool CPDF_DIBBase::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream) {
+bool CPDF_DIB::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream) {
   if (!pStream)
     return false;
 
@@ -169,7 +169,7 @@
   return true;
 }
 
-bool CPDF_DIBBase::ContinueToLoadMask() {
+bool CPDF_DIB::ContinueToLoadMask() {
   if (m_bImageMask) {
     SetMaskProperties();
   } else {
@@ -200,7 +200,7 @@
   return true;
 }
 
-CPDF_DIBBase::LoadState CPDF_DIBBase::StartLoadDIBBase(
+CPDF_DIB::LoadState CPDF_DIB::StartLoadDIBBase(
     CPDF_Document* pDoc,
     const CPDF_Stream* pStream,
     bool bHasMask,
@@ -262,8 +262,7 @@
   return LoadState::kSuccess;
 }
 
-CPDF_DIBBase::LoadState CPDF_DIBBase::ContinueLoadDIBBase(
-    PauseIndicatorIface* pPause) {
+CPDF_DIB::LoadState CPDF_DIB::ContinueLoadDIBBase(PauseIndicatorIface* pPause) {
   if (m_Status == LoadState::kContinue)
     return ContinueLoadMaskDIB(pPause);
 
@@ -336,8 +335,8 @@
   return iContinueStatus;
 }
 
-bool CPDF_DIBBase::LoadColorInfo(const CPDF_Dictionary* pFormResources,
-                                 const CPDF_Dictionary* pPageResources) {
+bool CPDF_DIB::LoadColorInfo(const CPDF_Dictionary* pFormResources,
+                             const CPDF_Dictionary* pPageResources) {
   m_bpc_orig = m_pDict->GetIntegerFor("BitsPerComponent");
   if (!IsMaybeValidBitsPerComponent(m_bpc_orig))
     return false;
@@ -398,8 +397,7 @@
   return GetDecodeAndMaskArray(&m_bDefaultDecode, &m_bColorKey);
 }
 
-bool CPDF_DIBBase::GetDecodeAndMaskArray(bool* bDefaultDecode,
-                                         bool* bColorKey) {
+bool CPDF_DIB::GetDecodeAndMaskArray(bool* bDefaultDecode, bool* bColorKey) {
   if (!m_pColorSpace)
     return false;
 
@@ -452,7 +450,7 @@
   return true;
 }
 
-CPDF_DIBBase::LoadState CPDF_DIBBase::CreateDecoder() {
+CPDF_DIB::LoadState CPDF_DIB::CreateDecoder() {
   ByteString decoder = m_pStreamAcc->GetImageDecoder();
   if (decoder.IsEmpty())
     return LoadState::kSuccess;
@@ -506,8 +504,8 @@
   return LoadState::kSuccess;
 }
 
-bool CPDF_DIBBase::CreateDCTDecoder(pdfium::span<const uint8_t> src_span,
-                                    const CPDF_Dictionary* pParams) {
+bool CPDF_DIB::CreateDCTDecoder(pdfium::span<const uint8_t> src_span,
+                                const CPDF_Dictionary* pParams) {
   JpegModule* pJpegModule = fxcodec::ModuleMgr::GetInstance()->GetJpegModule();
   m_pDecoder = pJpegModule->CreateDecoder(
       src_span, m_Width, m_Height, m_nComponents,
@@ -580,7 +578,7 @@
   return true;
 }
 
-RetainPtr<CFX_DIBitmap> CPDF_DIBBase::LoadJpxBitmap() {
+RetainPtr<CFX_DIBitmap> CPDF_DIB::LoadJpxBitmap() {
   std::unique_ptr<CJPX_Decoder> decoder = JpxModule::CreateDecoder(
       m_pStreamAcc->GetSpan(),
       ColorSpaceOptionFromColorSpace(m_pColorSpace.Get()));
@@ -657,7 +655,7 @@
   return pCachedBitmap;
 }
 
-CPDF_DIBBase::LoadState CPDF_DIBBase::StartLoadMask() {
+CPDF_DIB::LoadState CPDF_DIB::StartLoadMask() {
   m_MatteColor = 0XFFFFFFFF;
   m_pMaskStream.Reset(m_pDict->GetStreamFor("SMask"));
   if (!m_pMaskStream) {
@@ -682,8 +680,7 @@
   return StartLoadMaskDIB();
 }
 
-CPDF_DIBBase::LoadState CPDF_DIBBase::ContinueLoadMaskDIB(
-    PauseIndicatorIface* pPause) {
+CPDF_DIB::LoadState CPDF_DIB::ContinueLoadMaskDIB(PauseIndicatorIface* pPause) {
   if (!m_pMask)
     return LoadState::kSuccess;
 
@@ -701,16 +698,16 @@
   return LoadState::kSuccess;
 }
 
-RetainPtr<CPDF_DIBBase> CPDF_DIBBase::DetachMask() {
+RetainPtr<CPDF_DIB> CPDF_DIB::DetachMask() {
   return std::move(m_pMask);
 }
 
-bool CPDF_DIBBase::IsJBigImage() const {
+bool CPDF_DIB::IsJBigImage() const {
   return m_pStreamAcc->GetImageDecoder() == "JBIG2Decode";
 }
 
-CPDF_DIBBase::LoadState CPDF_DIBBase::StartLoadMaskDIB() {
-  m_pMask = pdfium::MakeRetain<CPDF_DIBBase>();
+CPDF_DIB::LoadState CPDF_DIB::StartLoadMaskDIB() {
+  m_pMask = pdfium::MakeRetain<CPDF_DIB>();
   LoadState ret =
       m_pMask->StartLoadDIBBase(m_pDocument.Get(), m_pMaskStream.Get(), false,
                                 nullptr, nullptr, true, 0, false);
@@ -724,7 +721,7 @@
   return LoadState::kSuccess;
 }
 
-void CPDF_DIBBase::LoadPalette() {
+void CPDF_DIB::LoadPalette() {
   if (!m_pColorSpace || m_Family == PDFCS_PATTERN)
     return;
 
@@ -805,7 +802,7 @@
   }
 }
 
-void CPDF_DIBBase::ValidateDictParam() {
+void CPDF_DIB::ValidateDictParam() {
   m_bpc = m_bpc_orig;
   const CPDF_Object* pFilter = m_pDict->GetDirectObjectFor("Filter");
   if (pFilter) {
@@ -838,8 +835,8 @@
     m_bpc = 0;
 }
 
-void CPDF_DIBBase::TranslateScanline24bpp(uint8_t* dest_scan,
-                                          const uint8_t* src_scan) const {
+void CPDF_DIB::TranslateScanline24bpp(uint8_t* dest_scan,
+                                      const uint8_t* src_scan) const {
   if (m_bpc == 0)
     return;
 
@@ -887,7 +884,7 @@
   }
 }
 
-bool CPDF_DIBBase::TranslateScanline24bppDefaultDecode(
+bool CPDF_DIB::TranslateScanline24bppDefaultDecode(
     uint8_t* dest_scan,
     const uint8_t* src_scan) const {
   if (!m_bDefaultDecode)
@@ -949,11 +946,11 @@
   return true;
 }
 
-uint8_t* CPDF_DIBBase::GetBuffer() const {
+uint8_t* CPDF_DIB::GetBuffer() const {
   return m_pCachedBitmap ? m_pCachedBitmap->GetBuffer() : nullptr;
 }
 
-const uint8_t* CPDF_DIBBase::GetScanline(int line) const {
+const uint8_t* CPDF_DIB::GetScanline(int line) const {
   if (m_bpc == 0)
     return nullptr;
 
@@ -1073,17 +1070,17 @@
   return m_pMaskedLine.get();
 }
 
-bool CPDF_DIBBase::SkipToScanline(int line, PauseIndicatorIface* pPause) const {
+bool CPDF_DIB::SkipToScanline(int line, PauseIndicatorIface* pPause) const {
   return m_pDecoder && m_pDecoder->SkipToScanline(line, pPause);
 }
 
-void CPDF_DIBBase::DownSampleScanline(int line,
-                                      uint8_t* dest_scan,
-                                      int dest_bpp,
-                                      int dest_width,
-                                      bool bFlipX,
-                                      int clip_left,
-                                      int clip_width) const {
+void CPDF_DIB::DownSampleScanline(int line,
+                                  uint8_t* dest_scan,
+                                  int dest_bpp,
+                                  int dest_width,
+                                  bool bFlipX,
+                                  int clip_left,
+                                  int clip_width) const {
   if (line < 0 || !dest_scan || dest_bpp <= 0 || dest_width <= 0 ||
       clip_left < 0 || clip_width <= 0) {
     return;
@@ -1137,15 +1134,15 @@
   }
 }
 
-void CPDF_DIBBase::DownSampleScanline1Bit(int orig_Bpp,
-                                          int dest_Bpp,
-                                          uint32_t src_width,
-                                          const uint8_t* pSrcLine,
-                                          uint8_t* dest_scan,
-                                          int dest_width,
-                                          bool bFlipX,
-                                          int clip_left,
-                                          int clip_width) const {
+void CPDF_DIB::DownSampleScanline1Bit(int orig_Bpp,
+                                      int dest_Bpp,
+                                      uint32_t src_width,
+                                      const uint8_t* pSrcLine,
+                                      uint8_t* dest_scan,
+                                      int dest_width,
+                                      bool bFlipX,
+                                      int clip_left,
+                                      int clip_width) const {
   if (m_bColorKey && !m_bImageMask) {
     uint32_t reset_argb = m_pPalette ? m_pPalette.get()[0] : 0xFF000000;
     uint32_t set_argb = m_pPalette ? m_pPalette.get()[1] : 0xFFFFFFFF;
@@ -1196,15 +1193,15 @@
   }
 }
 
-void CPDF_DIBBase::DownSampleScanline8Bit(int orig_Bpp,
-                                          int dest_Bpp,
-                                          uint32_t src_width,
-                                          const uint8_t* pSrcLine,
-                                          uint8_t* dest_scan,
-                                          int dest_width,
-                                          bool bFlipX,
-                                          int clip_left,
-                                          int clip_width) const {
+void CPDF_DIB::DownSampleScanline8Bit(int orig_Bpp,
+                                      int dest_Bpp,
+                                      uint32_t src_width,
+                                      const uint8_t* pSrcLine,
+                                      uint8_t* dest_scan,
+                                      int dest_width,
+                                      bool bFlipX,
+                                      int clip_left,
+                                      int clip_width) const {
   if (m_bpc < 8) {
     uint64_t src_bit_pos = 0;
     for (uint32_t col = 0; col < src_width; col++) {
@@ -1261,15 +1258,15 @@
   }
 }
 
-void CPDF_DIBBase::DownSampleScanline32Bit(int orig_Bpp,
-                                           int dest_Bpp,
-                                           uint32_t src_width,
-                                           const uint8_t* pSrcLine,
-                                           uint8_t* dest_scan,
-                                           int dest_width,
-                                           bool bFlipX,
-                                           int clip_left,
-                                           int clip_width) const {
+void CPDF_DIB::DownSampleScanline32Bit(int orig_Bpp,
+                                       int dest_Bpp,
+                                       uint32_t src_width,
+                                       const uint8_t* pSrcLine,
+                                       uint8_t* dest_scan,
+                                       int dest_width,
+                                       bool bFlipX,
+                                       int clip_left,
+                                       int clip_width) const {
   // last_src_x used to store the last seen src_x position which should be
   // in [0, src_width). Set the initial value to be an invalid src_x value.
   uint32_t last_src_x = src_width;
@@ -1359,12 +1356,12 @@
   }
 }
 
-bool CPDF_DIBBase::TransMask() const {
+bool CPDF_DIB::TransMask() const {
   return m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK &&
          m_Family == PDFCS_DEVICECMYK;
 }
 
-void CPDF_DIBBase::SetMaskProperties() {
+void CPDF_DIB::SetMaskProperties() {
   m_bpp = 1;
   m_bpc = 1;
   m_nComponents = 1;
diff --git a/core/fpdfapi/page/cpdf_dibbase.h b/core/fpdfapi/page/cpdf_dib.h
similarity index 94%
rename from core/fpdfapi/page/cpdf_dibbase.h
rename to core/fpdfapi/page/cpdf_dib.h
index 42c0368..7e7f3cf 100644
--- a/core/fpdfapi/page/cpdf_dibbase.h
+++ b/core/fpdfapi/page/cpdf_dib.h
@@ -4,8 +4,8 @@
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#ifndef CORE_FPDFAPI_PAGE_CPDF_DIBBASE_H_
-#define CORE_FPDFAPI_PAGE_CPDF_DIBBASE_H_
+#ifndef CORE_FPDFAPI_PAGE_CPDF_DIB_H_
+#define CORE_FPDFAPI_PAGE_CPDF_DIB_H_
 
 #include <memory>
 #include <vector>
@@ -39,7 +39,7 @@
 
 #define FPDF_HUGE_IMAGE_SIZE 60000000
 
-class CPDF_DIBBase final : public CFX_DIBBase {
+class CPDF_DIB final : public CFX_DIBBase {
  public:
   enum class LoadState : uint8_t { kFail, kSuccess, kContinue };
 
@@ -72,13 +72,13 @@
                              uint32_t GroupFamily,
                              bool bLoadMask);
   LoadState ContinueLoadDIBBase(PauseIndicatorIface* pPause);
-  RetainPtr<CPDF_DIBBase> DetachMask();
+  RetainPtr<CPDF_DIB> DetachMask();
 
   bool IsJBigImage() const;
 
  private:
-  CPDF_DIBBase();
-  ~CPDF_DIBBase() override;
+  CPDF_DIB();
+  ~CPDF_DIB() override;
 
   LoadState StartLoadMask();
   LoadState StartLoadMaskDIB();
@@ -149,7 +149,7 @@
   std::unique_ptr<uint8_t, FxFreeDeleter> m_pLineBuf;
   std::unique_ptr<uint8_t, FxFreeDeleter> m_pMaskedLine;
   RetainPtr<CFX_DIBitmap> m_pCachedBitmap;
-  RetainPtr<CPDF_DIBBase> m_pMask;
+  RetainPtr<CPDF_DIB> m_pMask;
   RetainPtr<CPDF_StreamAcc> m_pGlobalAcc;
   std::unique_ptr<fxcodec::ScanlineDecoder> m_pDecoder;
 
@@ -160,4 +160,4 @@
   LoadState m_Status = LoadState::kFail;
 };
 
-#endif  // CORE_FPDFAPI_PAGE_CPDF_DIBBASE_H_
+#endif  // CORE_FPDFAPI_PAGE_CPDF_DIB_H_
diff --git a/core/fpdfapi/page/cpdf_image.cpp b/core/fpdfapi/page/cpdf_image.cpp
index 39aa146..ec1e040 100644
--- a/core/fpdfapi/page/cpdf_image.cpp
+++ b/core/fpdfapi/page/cpdf_image.cpp
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "constants/stream_dict_common.h"
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_page.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_boolean.h"
@@ -341,17 +341,17 @@
 }
 
 RetainPtr<CFX_DIBBase> CPDF_Image::LoadDIBBase() const {
-  auto source = pdfium::MakeRetain<CPDF_DIBBase>();
+  auto source = pdfium::MakeRetain<CPDF_DIB>();
   if (!source->Load(m_pDocument.Get(), m_pStream.Get()))
     return nullptr;
 
   if (!source->IsJBigImage())
     return source;
 
-  CPDF_DIBBase::LoadState ret = CPDF_DIBBase::LoadState::kContinue;
-  while (ret == CPDF_DIBBase::LoadState::kContinue)
+  CPDF_DIB::LoadState ret = CPDF_DIB::LoadState::kContinue;
+  while (ret == CPDF_DIB::LoadState::kContinue)
     ret = source->ContinueLoadDIBBase(nullptr);
-  return ret == CPDF_DIBBase::LoadState::kSuccess ? source : nullptr;
+  return ret == CPDF_DIB::LoadState::kSuccess ? source : nullptr;
 }
 
 RetainPtr<CFX_DIBBase> CPDF_Image::DetachBitmap() {
@@ -367,16 +367,16 @@
                                   bool bStdCS,
                                   uint32_t GroupFamily,
                                   bool bLoadMask) {
-  auto source = pdfium::MakeRetain<CPDF_DIBBase>();
-  CPDF_DIBBase::LoadState ret = source->StartLoadDIBBase(
+  auto source = pdfium::MakeRetain<CPDF_DIB>();
+  CPDF_DIB::LoadState ret = source->StartLoadDIBBase(
       m_pDocument.Get(), m_pStream.Get(), true, pFormResource, pPageResource,
       bStdCS, GroupFamily, bLoadMask);
-  if (ret == CPDF_DIBBase::LoadState::kFail) {
+  if (ret == CPDF_DIB::LoadState::kFail) {
     m_pDIBBase.Reset();
     return false;
   }
   m_pDIBBase = source;
-  if (ret == CPDF_DIBBase::LoadState::kContinue)
+  if (ret == CPDF_DIB::LoadState::kContinue)
     return true;
 
   m_pMask = source->DetachMask();
@@ -385,12 +385,12 @@
 }
 
 bool CPDF_Image::Continue(PauseIndicatorIface* pPause) {
-  RetainPtr<CPDF_DIBBase> pSource = m_pDIBBase.As<CPDF_DIBBase>();
-  CPDF_DIBBase::LoadState ret = pSource->ContinueLoadDIBBase(pPause);
-  if (ret == CPDF_DIBBase::LoadState::kContinue)
+  RetainPtr<CPDF_DIB> pSource = m_pDIBBase.As<CPDF_DIB>();
+  CPDF_DIB::LoadState ret = pSource->ContinueLoadDIBBase(pPause);
+  if (ret == CPDF_DIB::LoadState::kContinue)
     return true;
 
-  if (ret == CPDF_DIBBase::LoadState::kSuccess) {
+  if (ret == CPDF_DIB::LoadState::kSuccess) {
     m_pMask = pSource->DetachMask();
     m_MatteColor = pSource->GetMatteColor();
   } else {
diff --git a/core/fpdfapi/page/cpdf_imageobject.cpp b/core/fpdfapi/page/cpdf_imageobject.cpp
index e1c8520..0f6a26b 100644
--- a/core/fpdfapi/page/cpdf_imageobject.cpp
+++ b/core/fpdfapi/page/cpdf_imageobject.cpp
@@ -63,7 +63,7 @@
 RetainPtr<CFX_DIBitmap> CPDF_ImageObject::GetIndependentBitmap() const {
   RetainPtr<CFX_DIBBase> pSource = GetImage()->LoadDIBBase();
 
-  // Clone() is non-virtual, and can't be overloaded by CPDF_DIBBase to
+  // Clone() is non-virtual, and can't be overloaded by CPDF_DIB to
   // return a clone of the subclass as one would typically expect from a
   // such a method. Instead, it only clones the CFX_DIBBase, none of whose
   // members point to objects owned by |this| or the form containing |this|.
diff --git a/core/fpdfapi/render/cpdf_docrenderdata.cpp b/core/fpdfapi/render/cpdf_docrenderdata.cpp
index f49e956..ba702b7e 100644
--- a/core/fpdfapi/render/cpdf_docrenderdata.cpp
+++ b/core/fpdfapi/render/cpdf_docrenderdata.cpp
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "core/fpdfapi/font/cpdf_type3font.h"
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_function.h"
 #include "core/fpdfapi/page/cpdf_transferfunc.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
diff --git a/core/fpdfapi/render/cpdf_imagecacheentry.cpp b/core/fpdfapi/render/cpdf_imagecacheentry.cpp
index 8026b47..c4cd9c6 100644
--- a/core/fpdfapi/render/cpdf_imagecacheentry.cpp
+++ b/core/fpdfapi/render/cpdf_imagecacheentry.cpp
@@ -9,7 +9,7 @@
 #include <memory>
 #include <utility>
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_image.h"
 #include "core/fpdfapi/page/cpdf_page.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
@@ -47,7 +47,7 @@
   return std::move(m_pCurMask);
 }
 
-CPDF_DIBBase::LoadState CPDF_ImageCacheEntry::StartGetCachedBitmap(
+CPDF_DIB::LoadState CPDF_ImageCacheEntry::StartGetCachedBitmap(
     const CPDF_Dictionary* pFormResources,
     CPDF_Dictionary* pPageResources,
     bool bStdCS,
@@ -59,32 +59,31 @@
   if (m_pCachedBitmap) {
     m_pCurBitmap = m_pCachedBitmap;
     m_pCurMask = m_pCachedMask;
-    return CPDF_DIBBase::LoadState::kSuccess;
+    return CPDF_DIB::LoadState::kSuccess;
   }
 
-  m_pCurBitmap = pdfium::MakeRetain<CPDF_DIBBase>();
-  CPDF_DIBBase::LoadState ret =
-      m_pCurBitmap.As<CPDF_DIBBase>()->StartLoadDIBBase(
-          m_pDocument.Get(), m_pImage->GetStream(), true, pFormResources,
-          pPageResources, bStdCS, GroupFamily, bLoadMask);
-  if (ret == CPDF_DIBBase::LoadState::kContinue)
-    return CPDF_DIBBase::LoadState::kContinue;
+  m_pCurBitmap = pdfium::MakeRetain<CPDF_DIB>();
+  CPDF_DIB::LoadState ret = m_pCurBitmap.As<CPDF_DIB>()->StartLoadDIBBase(
+      m_pDocument.Get(), m_pImage->GetStream(), true, pFormResources,
+      pPageResources, bStdCS, GroupFamily, bLoadMask);
+  if (ret == CPDF_DIB::LoadState::kContinue)
+    return CPDF_DIB::LoadState::kContinue;
 
-  if (ret == CPDF_DIBBase::LoadState::kSuccess)
+  if (ret == CPDF_DIB::LoadState::kSuccess)
     ContinueGetCachedBitmap(pRenderStatus);
   else
     m_pCurBitmap.Reset();
-  return CPDF_DIBBase::LoadState::kFail;
+  return CPDF_DIB::LoadState::kFail;
 }
 
 bool CPDF_ImageCacheEntry::Continue(PauseIndicatorIface* pPause,
                                     CPDF_RenderStatus* pRenderStatus) {
-  CPDF_DIBBase::LoadState ret =
-      m_pCurBitmap.As<CPDF_DIBBase>()->ContinueLoadDIBBase(pPause);
-  if (ret == CPDF_DIBBase::LoadState::kContinue)
+  CPDF_DIB::LoadState ret =
+      m_pCurBitmap.As<CPDF_DIB>()->ContinueLoadDIBBase(pPause);
+  if (ret == CPDF_DIB::LoadState::kContinue)
     return true;
 
-  if (ret == CPDF_DIBBase::LoadState::kSuccess)
+  if (ret == CPDF_DIB::LoadState::kSuccess)
     ContinueGetCachedBitmap(pRenderStatus);
   else
     m_pCurBitmap.Reset();
@@ -93,8 +92,8 @@
 
 void CPDF_ImageCacheEntry::ContinueGetCachedBitmap(
     CPDF_RenderStatus* pRenderStatus) {
-  m_MatteColor = m_pCurBitmap.As<CPDF_DIBBase>()->GetMatteColor();
-  m_pCurMask = m_pCurBitmap.As<CPDF_DIBBase>()->DetachMask();
+  m_MatteColor = m_pCurBitmap.As<CPDF_DIB>()->GetMatteColor();
+  m_pCurMask = m_pCurBitmap.As<CPDF_DIB>()->DetachMask();
   CPDF_RenderContext* pContext = pRenderStatus->GetContext();
   CPDF_PageRenderCache* pPageRenderCache = pContext->GetPageCache();
   m_dwTimeCount = pPageRenderCache->GetTimeCount();
diff --git a/core/fpdfapi/render/cpdf_imagecacheentry.h b/core/fpdfapi/render/cpdf_imagecacheentry.h
index f5c8ceb..c3f373e 100644
--- a/core/fpdfapi/render/cpdf_imagecacheentry.h
+++ b/core/fpdfapi/render/cpdf_imagecacheentry.h
@@ -7,7 +7,7 @@
 #ifndef CORE_FPDFAPI_RENDER_CPDF_IMAGECACHEENTRY_H_
 #define CORE_FPDFAPI_RENDER_CPDF_IMAGECACHEENTRY_H_
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/retain_ptr.h"
 #include "core/fxcrt/unowned_ptr.h"
@@ -29,7 +29,7 @@
   uint32_t GetTimeCount() const { return m_dwTimeCount; }
   CPDF_Image* GetImage() const { return m_pImage.Get(); }
 
-  CPDF_DIBBase::LoadState StartGetCachedBitmap(
+  CPDF_DIB::LoadState StartGetCachedBitmap(
       const CPDF_Dictionary* pFormResources,
       CPDF_Dictionary* pPageResources,
       bool bStdCS,
diff --git a/core/fpdfapi/render/cpdf_imageloader.cpp b/core/fpdfapi/render/cpdf_imageloader.cpp
index 23d7522..fac4799 100644
--- a/core/fpdfapi/render/cpdf_imageloader.cpp
+++ b/core/fpdfapi/render/cpdf_imageloader.cpp
@@ -6,7 +6,7 @@
 
 #include "core/fpdfapi/render/cpdf_imageloader.h"
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_image.h"
 #include "core/fpdfapi/page/cpdf_imageobject.h"
 #include "core/fpdfapi/page/cpdf_transferfunc.h"
diff --git a/core/fpdfapi/render/cpdf_imagerenderer.cpp b/core/fpdfapi/render/cpdf_imagerenderer.cpp
index 4f5dde2..4067ebd 100644
--- a/core/fpdfapi/render/cpdf_imagerenderer.cpp
+++ b/core/fpdfapi/render/cpdf_imagerenderer.cpp
@@ -9,7 +9,7 @@
 #include <algorithm>
 #include <memory>
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_docpagedata.h"
 #include "core/fpdfapi/page/cpdf_image.h"
 #include "core/fpdfapi/page/cpdf_imageobject.h"
diff --git a/core/fpdfapi/render/cpdf_pagerendercache.cpp b/core/fpdfapi/render/cpdf_pagerendercache.cpp
index 0814215..ca4f8ee 100644
--- a/core/fpdfapi/render/cpdf_pagerendercache.cpp
+++ b/core/fpdfapi/render/cpdf_pagerendercache.cpp
@@ -87,17 +87,17 @@
     m_pCurImageCacheEntry = pdfium::MakeUnique<CPDF_ImageCacheEntry>(
         m_pPage->GetDocument(), pImage);
   }
-  CPDF_DIBBase::LoadState ret = m_pCurImageCacheEntry->StartGetCachedBitmap(
+  CPDF_DIB::LoadState ret = m_pCurImageCacheEntry->StartGetCachedBitmap(
       pRenderStatus->GetFormResource(), m_pPage->m_pPageResources.Get(), bStdCS,
       GroupFamily, bLoadMask, pRenderStatus);
-  if (ret == CPDF_DIBBase::LoadState::kContinue)
+  if (ret == CPDF_DIB::LoadState::kContinue)
     return true;
 
   m_nTimeCount++;
   if (!m_bCurFindCache)
     m_ImageCache[pStream] = m_pCurImageCacheEntry.Release();
 
-  if (ret == CPDF_DIBBase::LoadState::kFail)
+  if (ret == CPDF_DIB::LoadState::kFail)
     m_nCacheSize += m_pCurImageCacheEntry->EstimateSize();
 
   return false;
diff --git a/core/fpdfapi/render/cpdf_rendershading.cpp b/core/fpdfapi/render/cpdf_rendershading.cpp
index 0ac8043..53fb79a 100644
--- a/core/fpdfapi/render/cpdf_rendershading.cpp
+++ b/core/fpdfapi/render/cpdf_rendershading.cpp
@@ -14,7 +14,7 @@
 #include <vector>
 
 #include "core/fpdfapi/page/cpdf_colorspace.h"
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_function.h"
 #include "core/fpdfapi/page/cpdf_meshstream.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
diff --git a/core/fxge/dib/cstretchengine_unittest.cpp b/core/fxge/dib/cstretchengine_unittest.cpp
index 5bd92a0..8c360e7 100644
--- a/core/fxge/dib/cstretchengine_unittest.cpp
+++ b/core/fxge/dib/cstretchengine_unittest.cpp
@@ -7,7 +7,7 @@
 #include <memory>
 #include <utility>
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
@@ -22,7 +22,7 @@
   dict_obj->SetNewFor<CPDF_Number>("Height", 12500);
   RetainPtr<CPDF_Stream> stream =
       pdfium::MakeRetain<CPDF_Stream>(nullptr, 0, std::move(dict_obj));
-  auto dib_source = pdfium::MakeRetain<CPDF_DIBBase>();
+  auto dib_source = pdfium::MakeRetain<CPDF_DIB>();
   dib_source->Load(nullptr, stream.Get());
   CStretchEngine engine(nullptr, FXDIB_8bppRgb, 500, 500, clip_rect, dib_source,
                         FXDIB_ResampleOptions());
diff --git a/fpdfsdk/fpdf_editimg.cpp b/fpdfsdk/fpdf_editimg.cpp
index 2abe345..ecd11d1 100644
--- a/fpdfsdk/fpdf_editimg.cpp
+++ b/fpdfsdk/fpdf_editimg.cpp
@@ -8,7 +8,7 @@
 
 #include <utility>
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_image.h"
 #include "core/fpdfapi/page/cpdf_imageobject.h"
 #include "core/fpdfapi/page/cpdf_page.h"
@@ -332,11 +332,11 @@
   if (!pPage || !pPage->GetDocument() || !pImg->GetStream())
     return true;
 
-  auto pSource = pdfium::MakeRetain<CPDF_DIBBase>();
-  CPDF_DIBBase::LoadState ret = pSource->StartLoadDIBBase(
+  auto pSource = pdfium::MakeRetain<CPDF_DIB>();
+  CPDF_DIB::LoadState ret = pSource->StartLoadDIBBase(
       pPage->GetDocument(), pImg->GetStream(), false, nullptr,
       pPage->m_pPageResources.Get(), false, 0, false);
-  if (ret == CPDF_DIBBase::LoadState::kFail)
+  if (ret == CPDF_DIB::LoadState::kFail)
     return true;
 
   metadata->bits_per_pixel = pSource->GetBPP();
diff --git a/fpdfsdk/fpdf_thumbnail.cpp b/fpdfsdk/fpdf_thumbnail.cpp
index 818b5f1..5c22c8c 100644
--- a/fpdfsdk/fpdf_thumbnail.cpp
+++ b/fpdfsdk/fpdf_thumbnail.cpp
@@ -6,7 +6,7 @@
 
 #include <vector>
 
-#include "core/fpdfapi/page/cpdf_dibbase.h"
+#include "core/fpdfapi/page/cpdf_dib.h"
 #include "core/fpdfapi/page/cpdf_page.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
@@ -61,11 +61,11 @@
 
   const CPDF_Page* p_page = CPDFPageFromFPDFPage(page);
 
-  auto p_source = pdfium::MakeRetain<CPDF_DIBBase>();
-  const CPDF_DIBBase::LoadState start_status = p_source->StartLoadDIBBase(
+  auto p_source = pdfium::MakeRetain<CPDF_DIB>();
+  const CPDF_DIB::LoadState start_status = p_source->StartLoadDIBBase(
       p_page->GetDocument(), thumb_stream, false, nullptr,
       p_page->m_pPageResources.Get(), false, 0, false);
-  if (start_status == CPDF_DIBBase::LoadState::kFail)
+  if (start_status == CPDF_DIB::LoadState::kFail)
     return nullptr;
 
   auto thumb_bitmap = pdfium::MakeRetain<CFX_DIBitmap>();