diff --git a/core/fpdfapi/page/cpdf_transferfuncdib.cpp b/core/fpdfapi/page/cpdf_transferfuncdib.cpp
index dc51a86..9ccfb12 100644
--- a/core/fpdfapi/page/cpdf_transferfuncdib.cpp
+++ b/core/fpdfapi/page/cpdf_transferfuncdib.cpp
@@ -27,7 +27,7 @@
   m_bpp = GetBppFromFormat(format);
   m_AlphaFlag = GetAlphaFlagFromFormat(format);
   m_Pitch = (m_Width * m_bpp + 31) / 32 * 4;
-  m_pPalette.reset();
+  m_palette.clear();
   m_Scanline.resize(m_Pitch);
 }
 
diff --git a/core/fxge/dib/cfx_dibbase.cpp b/core/fxge/dib/cfx_dibbase.cpp
index 29ee7be..b50ec24 100644
--- a/core/fxge/dib/cfx_dibbase.cpp
+++ b/core/fxge/dib/cfx_dibbase.cpp
@@ -20,6 +20,7 @@
 #include "core/fxge/dib/cfx_imagestretcher.h"
 #include "core/fxge/dib/cfx_imagetransformer.h"
 #include "third_party/base/notreached.h"
+#include "third_party/base/span.h"
 #include "third_party/base/stl_util.h"
 
 namespace {
@@ -291,7 +292,7 @@
                                const RetainPtr<CFX_DIBBase>& pSrcBitmap,
                                int src_left,
                                int src_top,
-                               uint32_t* dst_plt) {
+                               pdfium::span<uint32_t> dst_plt) {
   ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
                           src_left, src_top);
   const uint32_t* src_plt = pSrcBitmap->GetPaletteData();
@@ -307,7 +308,8 @@
       dst_plt[i] = ArgbEncode(0xff, r, g, b);
     }
   } else {
-    memcpy(dst_plt, src_plt, plt_size * 4);
+    for (size_t i = 0; i < plt_size; ++i)
+      dst_plt[i] = src_plt[i];
   }
 }
 
@@ -318,7 +320,7 @@
                                const RetainPtr<CFX_DIBBase>& pSrcBitmap,
                                int src_left,
                                int src_top,
-                               uint32_t* dst_plt) {
+                               pdfium::span<uint32_t> dst_plt) {
   int bpp = pSrcBitmap->GetBPP() / 8;
   CFX_Palette palette(pSrcBitmap);
   const std::pair<uint32_t, uint32_t>* Luts = palette.GetLuts();
@@ -366,7 +368,8 @@
         }
     }
   }
-  memcpy(dst_plt, pal, sizeof(uint32_t) * 256);
+  for (size_t i = 0; i < 256; ++i)
+    dst_plt[i] = pal[i];
 }
 
 void ConvertBuffer_1bppMask2Rgb(FXDIB_Format dest_format,
@@ -755,22 +758,18 @@
     return;
 
   if (GetBPP() == 1) {
-    m_pPalette.reset(FX_Alloc(uint32_t, 2));
-    if (IsCmykImage()) {
-      m_pPalette.get()[0] = 0xff;
-      m_pPalette.get()[1] = 0;
-    } else {
-      m_pPalette.get()[0] = 0xff000000;
-      m_pPalette.get()[1] = 0xffffffff;
-    }
+    if (IsCmykImage())
+      m_palette = {0xff, 0x00};
+    else
+      m_palette = {0xff000000, 0xffffffff};
   } else if (GetBPP() == 8) {
-    m_pPalette.reset(FX_Alloc(uint32_t, 256));
+    m_palette.resize(256);
     if (IsCmykImage()) {
       for (int i = 0; i < 256; ++i)
-        m_pPalette.get()[i] = 0xff - i;
+        m_palette[i] = 0xff - i;
     } else {
       for (int i = 0; i < 256; ++i)
-        m_pPalette.get()[i] = 0xff000000 | (i * 0x10101);
+        m_palette[i] = 0xff000000 | (i * 0x10101);
     }
   }
 }
@@ -823,7 +822,7 @@
 void CFX_DIBBase::SetPaletteArgb(int index, uint32_t color) {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   BuildPalette();
-  m_pPalette.get()[index] = color;
+  m_palette[index] = color;
 }
 
 int CFX_DIBBase::FindPalette(uint32_t color) const {
@@ -902,14 +901,14 @@
 void CFX_DIBBase::SetPalette(const uint32_t* pSrc) {
   static const uint32_t kPaletteSize = 256;
   if (!pSrc || GetBPP() > 8) {
-    m_pPalette.reset();
+    m_palette.clear();
     return;
   }
   uint32_t pal_size = 1 << GetBPP();
-  if (!m_pPalette)
-    m_pPalette.reset(FX_Alloc(uint32_t, pal_size));
+  if (m_palette.empty())
+    m_palette.resize(pal_size);
   pal_size = std::min(pal_size, kPaletteSize);
-  memcpy(m_pPalette.get(), pSrc, pal_size * sizeof(uint32_t));
+  std::copy(pSrc, pSrc + pal_size, m_palette.begin());
 }
 
 void CFX_DIBBase::GetPalette(uint32_t* pal, int alpha) const {
@@ -1078,13 +1077,13 @@
   }
 
   RetainPtr<CFX_DIBBase> holder(this);
-  std::unique_ptr<uint32_t, FxFreeDeleter> pal_8bpp;
+  std::vector<uint32_t, FxAllocAllocator<uint32_t>> pal_8bpp;
   if (!ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(),
                      m_Width, m_Height, holder, 0, 0, &pal_8bpp)) {
     return nullptr;
   }
-  if (pal_8bpp)
-    pClone->SetPalette(pal_8bpp.get());
+  if (!pal_8bpp.empty())
+    pClone->SetPalette(pal_8bpp.data());
 
   return pClone;
 }
@@ -1226,7 +1225,7 @@
     const RetainPtr<CFX_DIBBase>& pSrcBitmap,
     int src_left,
     int src_top,
-    std::unique_ptr<uint32_t, FxFreeDeleter>* p_pal) {
+    std::vector<uint32_t, FxAllocAllocator<uint32_t>>* pal) {
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   const int bpp = GetBppFromFormat(src_format);
   switch (dest_format) {
@@ -1239,17 +1238,17 @@
       const bool bpp_1_or_8 = (bpp == 1 || bpp == 8);
       if (bpp_1_or_8 && !pSrcBitmap->HasPalette()) {
         return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width,
-                             height, pSrcBitmap, src_left, src_top, p_pal);
+                             height, pSrcBitmap, src_left, src_top, pal);
       }
-      p_pal->reset(FX_Alloc(uint32_t, 256));
+      pal->resize(256);
       if (bpp_1_or_8 && pSrcBitmap->HasPalette()) {
         ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
-                                  pSrcBitmap, src_left, src_top, p_pal->get());
+                                  pSrcBitmap, src_left, src_top, *pal);
         return true;
       }
       if (bpp >= 24) {
         ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
-                                  pSrcBitmap, src_left, src_top, p_pal->get());
+                                  pSrcBitmap, src_left, src_top, *pal);
         return true;
       }
       return false;
diff --git a/core/fxge/dib/cfx_dibbase.h b/core/fxge/dib/cfx_dibbase.h
index 90eada6..e8212b9 100644
--- a/core/fxge/dib/cfx_dibbase.h
+++ b/core/fxge/dib/cfx_dibbase.h
@@ -7,7 +7,7 @@
 #ifndef CORE_FXGE_DIB_CFX_DIBBASE_H_
 #define CORE_FXGE_DIB_CFX_DIBBASE_H_
 
-#include <memory>
+#include <vector>
 
 #include "core/fxcrt/fx_coordinates.h"
 #include "core/fxcrt/fx_memory_wrappers.h"
@@ -55,8 +55,8 @@
     return static_cast<FXDIB_Format>(m_AlphaFlag * 0x100 + m_bpp);
   }
   uint32_t GetPitch() const { return m_Pitch; }
-  bool HasPalette() const { return !!m_pPalette; }
-  const uint32_t* GetPaletteData() const { return m_pPalette.get(); }
+  bool HasPalette() const { return !m_palette.empty(); }
+  const uint32_t* GetPaletteData() const { return m_palette.data(); }
   int GetBPP() const { return m_bpp; }
 
   bool IsAlphaMask() const { return !!(m_AlphaFlag & 1); }
@@ -109,15 +109,16 @@
  protected:
   CFX_DIBBase();
 
-  static bool ConvertBuffer(FXDIB_Format dest_format,
-                            uint8_t* dest_buf,
-                            int dest_pitch,
-                            int width,
-                            int height,
-                            const RetainPtr<CFX_DIBBase>& pSrcBitmap,
-                            int src_left,
-                            int src_top,
-                            std::unique_ptr<uint32_t, FxFreeDeleter>* pal);
+  static bool ConvertBuffer(
+      FXDIB_Format dest_format,
+      uint8_t* dest_buf,
+      int dest_pitch,
+      int width,
+      int height,
+      const RetainPtr<CFX_DIBBase>& pSrcBitmap,
+      int src_left,
+      int src_top,
+      std::vector<uint32_t, FxAllocAllocator<uint32_t>>* pal);
 
   void BuildPalette();
   bool BuildAlphaMask();
@@ -129,8 +130,7 @@
   int m_bpp;
   uint32_t m_AlphaFlag;
   uint32_t m_Pitch;
-  // TODO(weili): Use std::vector for this.
-  std::unique_ptr<uint32_t, FxFreeDeleter> m_pPalette;
+  std::vector<uint32_t, FxAllocAllocator<uint32_t>> m_palette;
 };
 
 #endif  // CORE_FXGE_DIB_CFX_DIBBASE_H_
diff --git a/core/fxge/dib/cfx_dibitmap.cpp b/core/fxge/dib/cfx_dibitmap.cpp
index a8aa1bc..f738edc 100644
--- a/core/fxge/dib/cfx_dibitmap.cpp
+++ b/core/fxge/dib/cfx_dibitmap.cpp
@@ -104,7 +104,7 @@
 
 void CFX_DIBitmap::TakeOver(RetainPtr<CFX_DIBitmap>&& pSrcBitmap) {
   m_pBuffer = std::move(pSrcBitmap->m_pBuffer);
-  m_pPalette = std::move(pSrcBitmap->m_pPalette);
+  m_palette = std::move(pSrcBitmap->m_palette);
   m_pAlphaMask = pSrcBitmap->m_pAlphaMask;
   pSrcBitmap->m_pBuffer = nullptr;
   pSrcBitmap->m_pAlphaMask = nullptr;
@@ -228,12 +228,9 @@
 
   uint8_t* dest_buf =
       m_pBuffer.Get() + dest_top * m_Pitch + dest_left * GetBPP() / 8;
-  std::unique_ptr<uint32_t, FxFreeDeleter> d_plt;
-  if (!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height, pSrcBitmap,
-                     src_left, src_top, &d_plt)) {
-    return false;
-  }
-  return true;
+  std::vector<uint32_t, FxAllocAllocator<uint32_t>> d_plt;
+  return ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height,
+                       pSrcBitmap, src_left, src_top, &d_plt);
 }
 
 void CFX_DIBitmap::TransferWithMultipleBPP(
@@ -724,10 +721,9 @@
     BuildPalette();
     int size = 1 << m_bpp;
     for (int i = 0; i < size; ++i) {
-      int gray = FXRGB2GRAY(FXARGB_R(m_pPalette.get()[i]),
-                            FXARGB_G(m_pPalette.get()[i]),
-                            FXARGB_B(m_pPalette.get()[i]));
-      m_pPalette.get()[i] =
+      int gray = FXRGB2GRAY(FXARGB_R(m_palette[i]), FXARGB_G(m_palette[i]),
+                            FXARGB_B(m_palette[i]));
+      m_palette[i] =
           ArgbEncode(0xff, br + (fr - br) * gray / 255,
                      bg + (fg - bg) * gray / 255, bb + (fb - bb) * gray / 255);
     }
@@ -780,13 +776,11 @@
       uint8_t r;
       uint8_t g;
       uint8_t b;
-      std::tie(r, g, b) =
-          AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette.get()[i]),
-                             FXSYS_GetMValue(m_pPalette.get()[i]),
-                             FXSYS_GetYValue(m_pPalette.get()[i]),
-                             FXSYS_GetKValue(m_pPalette.get()[i]));
+      std::tie(r, g, b) = AdobeCMYK_to_sRGB1(
+          FXSYS_GetCValue(m_palette[i]), FXSYS_GetMValue(m_palette[i]),
+          FXSYS_GetYValue(m_palette[i]), FXSYS_GetKValue(m_palette[i]));
       int gray = 255 - FXRGB2GRAY(r, g, b);
-      m_pPalette.get()[i] =
+      m_palette[i] =
           CmykEncode(bc + (fc - bc) * gray / 255, bm + (fm - bm) * gray / 255,
                      by + (fy - by) * gray / 255, bk + (fk - bk) * gray / 255);
     }
@@ -1267,14 +1261,14 @@
   }
   bool ret = false;
   RetainPtr<CFX_DIBBase> holder(this);
-  std::unique_ptr<uint32_t, FxFreeDeleter> pal_8bpp;
+  std::vector<uint32_t, FxAllocAllocator<uint32_t>> pal_8bpp;
   ret = ConvertBuffer(dest_format, dest_buf.get(), dest_pitch, m_Width,
                       m_Height, holder, 0, 0, &pal_8bpp);
   if (!ret)
     return false;
 
   m_pAlphaMask = pAlphaMask;
-  m_pPalette = std::move(pal_8bpp);
+  m_palette = std::move(pal_8bpp);
   m_pBuffer = std::move(dest_buf);
   m_bpp = GetBppFromFormat(dest_format);
   m_AlphaFlag = GetAlphaFlagFromFormat(dest_format);