diff --git a/core/fxge/cfx_font.cpp b/core/fxge/cfx_font.cpp
index 35a829a..e656c82 100644
--- a/core/fxge/cfx_font.cpp
+++ b/core/fxge/cfx_font.cpp
@@ -378,7 +378,7 @@
   m_pFontDataAllocation =
       std::vector<uint8_t>(src_span.begin(), src_span.end());
   m_Face =
-      CFX_GEModule::Get()->GetFontMgr()->GetFixedFace(m_pFontDataAllocation, 0);
+      CFX_GEModule::Get()->GetFontMgr()->NewFixedFace(m_pFontDataAllocation, 0);
   m_bEmbedded = true;
   m_FontData = m_pFontDataAllocation;
   return !!m_Face;
diff --git a/core/fxge/cfx_fontmapper.cpp b/core/fxge/cfx_fontmapper.cpp
index fd736ba..03425ea 100644
--- a/core/fxge/cfx_fontmapper.cpp
+++ b/core/fxge/cfx_fontmapper.cpp
@@ -349,7 +349,7 @@
     Optional<pdfium::span<const uint8_t>> font_data =
         m_pFontMgr->GetBuiltinFont(iBaseFont);
     if (font_data.has_value()) {
-      m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(font_data.value(), 0);
+      m_FoxitFaces[iBaseFont] = m_pFontMgr->NewFixedFace(font_data.value(), 0);
       return m_FoxitFaces[iBaseFont];
     }
   }
@@ -362,14 +362,14 @@
     pSubstFont->m_Family = "Chrome Serif";
     if (!m_MMFaces[1]) {
       m_MMFaces[1] =
-          m_pFontMgr->GetFixedFace(m_pFontMgr->GetBuiltinFont(14).value(), 0);
+          m_pFontMgr->NewFixedFace(m_pFontMgr->GetBuiltinFont(14).value(), 0);
     }
     return m_MMFaces[1];
   }
   pSubstFont->m_Family = "Chrome Sans";
   if (!m_MMFaces[0]) {
     m_MMFaces[0] =
-        m_pFontMgr->GetFixedFace(m_pFontMgr->GetBuiltinFont(15).value(), 0);
+        m_pFontMgr->NewFixedFace(m_pFontMgr->GetBuiltinFont(15).value(), 0);
   }
   return m_MMFaces[0];
 }
@@ -701,7 +701,7 @@
                                                   int weight,
                                                   bool bItalic,
                                                   uint32_t font_size) {
-  uint8_t* pIgnore = nullptr;
+  const uint8_t* pIgnore = nullptr;
   RetainPtr<CFX_Face> face =
       m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, &pIgnore);
   if (face)
diff --git a/core/fxge/cfx_fontmgr.cpp b/core/fxge/cfx_fontmgr.cpp
index 828f0dc..c261d8f 100644
--- a/core/fxge/cfx_fontmgr.cpp
+++ b/core/fxge/cfx_fontmgr.cpp
@@ -60,14 +60,12 @@
   return ByteString::Format("%d:%d", ttc_size, checksum);
 }
 
-int GetTTCIndex(const uint8_t* pFontData,
-                uint32_t ttc_size,
-                uint32_t font_offset) {
-  const uint8_t* p = pFontData + 8;
+int GetTTCIndex(pdfium::span<const uint8_t> pFontData, uint32_t font_offset) {
+  const uint8_t* p = pFontData.data() + 8;
   uint32_t nfont = GET_TT_LONG(p);
   uint32_t index;
   for (index = 0; index < nfont; index++) {
-    p = pFontData + 12 + index * 4;
+    p = pFontData.data() + 12 + index * 4;
     if (GET_TT_LONG(p) == font_offset)
       break;
   }
@@ -109,13 +107,13 @@
 RetainPtr<CFX_Face> CFX_FontMgr::GetCachedFace(const ByteString& face_name,
                                                int weight,
                                                bool bItalic,
-                                               uint8_t** pFontData) {
+                                               const uint8_t** pFontData) {
   auto it = m_FaceMap.find(KeyNameFromFace(face_name, weight, bItalic));
   if (it == m_FaceMap.end())
     return nullptr;
 
   CTTFontDesc* pFontDesc = it->second.get();
-  *pFontData = pFontDesc->FontData();
+  *pFontData = pFontDesc->FontData().data();
   return pdfium::WrapRetain(pFontDesc->GetFace(0));
 }
 
@@ -126,11 +124,11 @@
     std::unique_ptr<uint8_t, FxFreeDeleter> pData,
     uint32_t size,
     int face_index) {
-  RetainPtr<CFX_Face> face = GetFixedFace({pData.get(), size}, face_index);
+  RetainPtr<CFX_Face> face = NewFixedFace({pData.get(), size}, face_index);
   if (!face)
     return nullptr;
 
-  auto pFontDesc = pdfium::MakeUnique<CTTFontDesc>(std::move(pData));
+  auto pFontDesc = pdfium::MakeUnique<CTTFontDesc>(std::move(pData), size);
   pFontDesc->SetFace(0, face.Get());
   m_FaceMap[KeyNameFromFace(face_name, weight, bItalic)] = std::move(pFontDesc);
   return face;
@@ -144,7 +142,8 @@
     return nullptr;
 
   CTTFontDesc* pFontDesc = it->second.get();
-  int face_index = GetTTCIndex(pFontDesc->FontData(), ttc_size, font_offset);
+  int face_index =
+      GetTTCIndex(pFontDesc->FontData().first(ttc_size), font_offset);
   return pdfium::WrapRetain(pFontDesc->GetFace(face_index));
 }
 
@@ -161,14 +160,15 @@
     pFontDesc = it->second.get();
 
   if (!pFontDesc) {
-    auto pNewDesc = pdfium::MakeUnique<CTTFontDesc>(std::move(pData));
+    auto pNewDesc = pdfium::MakeUnique<CTTFontDesc>(std::move(pData), size);
     pFontDesc = pNewDesc.get();
     m_FaceMap[keyname] = std::move(pNewDesc);
   }
 
-  int face_index = GetTTCIndex(pFontDesc->FontData(), ttc_size, font_offset);
-  RetainPtr<CFX_Face> face = GetFixedFace(
-      {pFontDesc->FontData(), static_cast<size_t>(ttc_size)}, face_index);
+  int face_index =
+      GetTTCIndex(pFontDesc->FontData().first(ttc_size), font_offset);
+  RetainPtr<CFX_Face> face =
+      NewFixedFace(pFontDesc->FontData().first(ttc_size), face_index);
   if (!face)
     return nullptr;
 
@@ -176,7 +176,7 @@
   return face;
 }
 
-RetainPtr<CFX_Face> CFX_FontMgr::GetFixedFace(pdfium::span<const uint8_t> span,
+RetainPtr<CFX_Face> CFX_FontMgr::NewFixedFace(pdfium::span<const uint8_t> span,
                                               int face_index) {
   RetainPtr<CFX_Face> face = CFX_Face::New(m_FTLibrary.get(), span, face_index);
   if (!face)
diff --git a/core/fxge/cfx_fontmgr.h b/core/fxge/cfx_fontmgr.h
index bbbad92..83fa08e 100644
--- a/core/fxge/cfx_fontmgr.h
+++ b/core/fxge/cfx_fontmgr.h
@@ -32,7 +32,7 @@
   RetainPtr<CFX_Face> GetCachedFace(const ByteString& face_name,
                                     int weight,
                                     bool bItalic,
-                                    uint8_t** pFontData);
+                                    const uint8_t** pFontData);
   RetainPtr<CFX_Face> AddCachedFace(
       const ByteString& face_name,
       int weight,
@@ -49,7 +49,7 @@
       std::unique_ptr<uint8_t, FxFreeDeleter> pData,
       uint32_t size,
       uint32_t font_offset);
-  RetainPtr<CFX_Face> GetFixedFace(pdfium::span<const uint8_t> span,
+  RetainPtr<CFX_Face> NewFixedFace(pdfium::span<const uint8_t> span,
                                    int face_index);
   void SetSystemFontInfo(std::unique_ptr<SystemFontInfoIface> pFontInfo);
   RetainPtr<CFX_Face> FindSubstFont(const ByteString& face_name,
diff --git a/core/fxge/cttfontdesc.cpp b/core/fxge/cttfontdesc.cpp
index 27bc770..42c8a60 100644
--- a/core/fxge/cttfontdesc.cpp
+++ b/core/fxge/cttfontdesc.cpp
@@ -10,9 +10,9 @@
 
 #include "core/fxge/cfx_face.h"
 
-CTTFontDesc::CTTFontDesc(std::unique_ptr<uint8_t, FxFreeDeleter> pData)
-    : m_pFontData(std::move(pData)) {
-}
+CTTFontDesc::CTTFontDesc(std::unique_ptr<uint8_t, FxFreeDeleter> pData,
+                         size_t size)
+    : m_pFontData(std::move(pData)), m_Size(size) {}
 
 CTTFontDesc::~CTTFontDesc() = default;
 
diff --git a/core/fxge/cttfontdesc.h b/core/fxge/cttfontdesc.h
index 31a0520..ac57d69 100644
--- a/core/fxge/cttfontdesc.h
+++ b/core/fxge/cttfontdesc.h
@@ -12,20 +12,24 @@
 #include "core/fxcrt/fx_memory.h"
 #include "core/fxcrt/fx_system.h"
 #include "core/fxcrt/observed_ptr.h"
+#include "third_party/base/span.h"
 
 class CFX_Face;
 
 class CTTFontDesc {
  public:
-  explicit CTTFontDesc(std::unique_ptr<uint8_t, FxFreeDeleter> pData);
+  CTTFontDesc(std::unique_ptr<uint8_t, FxFreeDeleter> pData, size_t size);
   ~CTTFontDesc();
 
-  uint8_t* FontData() const { return m_pFontData.get(); }
+  pdfium::span<const uint8_t> FontData() const {
+    return {m_pFontData.get(), m_Size};
+  }
   void SetFace(size_t index, CFX_Face* face);
   CFX_Face* GetFace(size_t index) const;
 
  private:
   std::unique_ptr<uint8_t, FxFreeDeleter> const m_pFontData;
+  const size_t m_Size;
   ObservedPtr<CFX_Face> m_TTCFaces[16];
 };
 
