diff --git a/gfx/2d/2D.h b/gfx/2d/2D.h
index ad556e04ed4..30f6d18986c 100644
--- a/gfx/2d/2D.h
+++ b/gfx/2d/2D.h
@@ -31,6 +31,7 @@
 #include "mozilla/StaticMutex.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/ThreadSafeWeakPtr.h"
+#include "mozilla/UniquePtr.h"
 #include "mozilla/gfx/FontData.h"
 #include "nsRegionFwd.h"
 
@@ -1229,81 +1230,25 @@ struct GlyphBuffer {
 };
 
 #ifdef MOZ_ENABLE_FREETYPE
-class SharedFTFace;
-
-/** SharedFTFaceData abstracts data that may be used to back a SharedFTFace.
- * Its main function is to manage the lifetime of the data and ensure that it
- * lasts as long as the face.
- */
-class SharedFTFaceData {
- public:
-  /** Utility for creating a new face from this data. */
-  virtual already_AddRefed<SharedFTFace> CloneFace(int aFaceIndex = 0) {
-    return nullptr;
-  }
-  /** Binds the data's lifetime to the face. */
-  virtual void BindData() = 0;
-  /** Signals that the data is no longer needed by a face. */
-  virtual void ReleaseData() = 0;
-};
-
-/** Wrapper class for ref-counted SharedFTFaceData that handles calling the
- * appropriate ref-counting methods
- */
-template <class T>
-class SharedFTFaceRefCountedData : public SharedFTFaceData {
- public:
-  void BindData() { static_cast<T*>(this)->AddRef(); }
-  void ReleaseData() { static_cast<T*>(this)->Release(); }
-};
-
-// Helper class used for clearing out user font data when FT font
-// face is destroyed. Since multiple faces may use the same data, be
-// careful to assure that the data is only cleared out when all uses
-// expire. The font entry object contains a refptr to FTUserFontData and
-// each FT face created from that font entry contains a refptr to that
-// same FTUserFontData object.
-// This is also attached to FT faces for installed fonts (recording the
-// filename, rather than storing the font data) if variations are present.
-class FTUserFontData final
-    : public mozilla::gfx::SharedFTFaceRefCountedData<FTUserFontData> {
- public:
-  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FTUserFontData)
-
-  explicit FTUserFontData(FontData* aFontData) : mFontData(aFontData) {}
-  explicit FTUserFontData(const char* aFilename) : mFilename(aFilename) {}
-
-  const uint8_t* GetData() const {
-    return mFontData ? mFontData->Data() : nullptr;
-  }
-  uint32_t Length() const { return mFontData ? mFontData->Length() : 0; }
-
-  already_AddRefed<mozilla::gfx::SharedFTFace> CloneFace(
-      int aFaceIndex = 0) override;
-
- private:
-  ~FTUserFontData() = default;
-
-  std::string mFilename;
-  RefPtr<FontData> mFontData;
-};
-
 /** SharedFTFace is a shared wrapper around an FT_Face. It is ref-counted,
  * unlike FT_Face itself, so that it may be shared among many users with
  * RefPtr. Users should take care to lock SharedFTFace before accessing any
  * FT_Face fields that may change to ensure exclusive access to it. It also
- * allows backing data's lifetime to be bound to it via SharedFTFaceData so
- * that the data will not disappear before the face does.
+ * allows backing data's lifetime to be bound to it so that the data will not
+ * disappear before the face does.
  */
 class SharedFTFace : public external::AtomicRefCounted<SharedFTFace> {
  public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(SharedFTFace)
 
-  explicit SharedFTFace(FT_Face aFace, SharedFTFaceData* aData);
+  SharedFTFace(FT_Face aFace, UniquePtr<char[]>&& aFilename, int aFaceIndex);
+  SharedFTFace(FT_Face aFace, FontData* aFontData, int aFaceIndex);
   virtual ~SharedFTFace();
 
   FT_Face GetFace() const { return mFace; }
-  SharedFTFaceData* GetData() const { return mData; }
+  const char* GetFilename() const { return mFilename.get(); }
+  const RefPtr<FontData>& GetFontData() const { return mFontData; }
+  int GetFaceIndex() const { return mFaceIndex; }
 
   /** Locks the face for exclusive access by a given owner. Returns false if
    * the given owner is acquiring the lock for the first time, and true if
@@ -1328,14 +1273,21 @@ class SharedFTFace : public external::AtomicRefCounted<SharedFTFace> {
     }
   }
 
+  already_AddRefed<mozilla::gfx::SharedFTFace> CloneFace();
+
  private:
-  FT_Face mFace;
-  SharedFTFaceData* mData;
-  Mutex mLock;
+  FT_Face mFace = nullptr;
+  // The filename, if used, must have the same lifetime as the FT_Face.
+  UniquePtr<char[]> mFilename;
+  // Since multiple faces may use the same data, use RefPtr to assure that the
+  // data is only cleared out when all uses expire.
+  RefPtr<FontData> mFontData;
+  int mFaceIndex = 0;
+  Mutex mLock{"SharedFTFace::mLock"};
   // Remember the last owner of the lock, even after unlocking, to allow users
   // to avoid reinitializing state on the FT face if the last owner hasn't
   // changed by the next time it is locked with the same owner.
-  Atomic<const void*> mLastLockOwner;
+  Atomic<const void*> mLastLockOwner{nullptr};
 };
 #endif
 
@@ -2445,14 +2397,12 @@ class GFX2D_API Factory {
 
   static FT_Face NewFTFace(FT_Library aFTLibrary, const char* aFileName,
                            int aFaceIndex);
-  static already_AddRefed<SharedFTFace> NewSharedFTFace(FT_Library aFTLibrary,
-                                                        const char* aFilename,
+  static already_AddRefed<SharedFTFace> NewSharedFTFace(const char* aFilename,
                                                         int aFaceIndex);
   static FT_Face NewFTFaceFromData(FT_Library aFTLibrary, const uint8_t* aData,
                                    uint32_t aLength, int aFaceIndex);
   static already_AddRefed<SharedFTFace> NewSharedFTFaceFromData(
-      FT_Library aFTLibrary, FontData* aFontData, int aFaceIndex,
-      SharedFTFaceData* aSharedData = nullptr);
+      FontData* aFontData, int aFaceIndex);
   static void ReleaseFTFace(FT_Face aFace);
   static FT_Error LoadFTGlyph(FT_Face aFace, uint32_t aGlyphIndex,
                               int32_t aFlags);
diff --git a/gfx/2d/Factory.cpp b/gfx/2d/Factory.cpp
index 0183e748653..44e181a2037 100644
--- a/gfx/2d/Factory.cpp
+++ b/gfx/2d/Factory.cpp
@@ -2,6 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include <cstring>
+
 #include "2D.h"
 #include "Swizzle.h"
 
@@ -53,6 +55,7 @@
 #include "PathRecording.h"
 #include "SourceSurfaceRawData.h"
 #include "mozilla/CheckedInt.h"
+#include "mozilla/PodOperations.h"
 
 #ifdef MOZ_ENABLE_FREETYPE
 #  include "ft2build.h"
@@ -117,25 +120,6 @@ namespace mozilla::gfx {
 #ifdef MOZ_ENABLE_FREETYPE
 FT_Library Factory::mFTLibrary = nullptr;
 StaticMutex Factory::mFTLock;
-
-already_AddRefed<SharedFTFace> FTUserFontData::CloneFace(int aFaceIndex) {
-  if (mFontData) {
-    RefPtr<SharedFTFace> face =
-        Factory::NewSharedFTFaceFromData(nullptr, mFontData, aFaceIndex, this);
-    if (!face ||
-        (FT_Select_Charmap(face->GetFace(), FT_ENCODING_UNICODE) != FT_Err_Ok &&
-         FT_Select_Charmap(face->GetFace(), FT_ENCODING_MS_SYMBOL) !=
-             FT_Err_Ok)) {
-      return nullptr;
-    }
-    return face.forget();
-  }
-  FT_Face face = Factory::NewFTFace(nullptr, mFilename.c_str(), aFaceIndex);
-  if (face) {
-    return MakeAndAddRef<SharedFTFace>(face, this);
-  }
-  return nullptr;
-}
 #endif
 
 #ifdef WIN32
@@ -410,12 +394,10 @@ already_AddRefed<NativeFontResource> Factory::CreateNativeFontResource(
       return NativeFontResourceMac::Create(aData, aSize);
 #elif defined(MOZ_WIDGET_GTK)
     case FontType::FONTCONFIG:
-      return NativeFontResourceFontconfig::Create(
-          aData, aSize, static_cast<FT_Library>(aFontContext));
+      return NativeFontResourceFontconfig::Create(aData, aSize);
 #elif defined(MOZ_WIDGET_ANDROID)
     case FontType::FREETYPE:
-      return NativeFontResourceFreeType::Create(
-          aData, aSize, static_cast<FT_Library>(aFontContext));
+      return NativeFontResourceFreeType::Create(aData, aSize);
 #endif
     default:
       gfxWarning()
@@ -486,22 +468,14 @@ void Factory::SetSubpixelOrder(SubpixelOrder aOrder) {
 SubpixelOrder Factory::GetSubpixelOrder() { return mSubpixelOrder; }
 
 #ifdef MOZ_ENABLE_FREETYPE
-SharedFTFace::SharedFTFace(FT_Face aFace, SharedFTFaceData* aData)
-    : mFace(aFace),
-      mData(aData),
-      mLock("SharedFTFace::mLock"),
-      mLastLockOwner(nullptr) {
-  if (mData) {
-    mData->BindData();
-  }
-}
+SharedFTFace::SharedFTFace(FT_Face aFace, UniquePtr<char[]>&& aFilename,
+                           int aFaceIndex)
+    : mFace(aFace), mFilename(std::move(aFilename)), mFaceIndex(aFaceIndex) {}
 
-SharedFTFace::~SharedFTFace() {
-  Factory::ReleaseFTFace(mFace);
-  if (mData) {
-    mData->ReleaseData();
-  }
-}
+SharedFTFace::SharedFTFace(FT_Face aFace, FontData* aFontData, int aFaceIndex)
+    : mFace(aFace), mFontData(aFontData), mFaceIndex(aFaceIndex) {}
+
+SharedFTFace::~SharedFTFace() { Factory::ReleaseFTFace(mFace); }
 
 void Factory::SetFTLibrary(FT_Library aFTLibrary) { mFTLibrary = aFTLibrary; }
 
@@ -545,24 +519,18 @@ FT_Face Factory::NewFTFace(FT_Library aFTLibrary, const char* aFileName,
   return face;
 }
 
-already_AddRefed<SharedFTFace> Factory::NewSharedFTFace(FT_Library aFTLibrary,
-                                                        const char* aFilename,
+already_AddRefed<SharedFTFace> Factory::NewSharedFTFace(const char* aFilename,
                                                         int aFaceIndex) {
-  FT_Face face = NewFTFace(aFTLibrary, aFilename, aFaceIndex);
+  // Allocate filename first so its memory can be passed to FT and SharedFTFace.
+  // Its lifetime must be at least as long as SharedFTFace, which manages it.
+  size_t length = strlen(aFilename) + 1;
+  UniquePtr<char[]> filename = MakeUniqueFallible<char[]>(length);
+  PodCopy(filename.get(), aFilename, length);
+  FT_Face face = NewFTFace(nullptr, filename.get(), aFaceIndex);
   if (!face) {
     return nullptr;
   }
-
-  RefPtr<FTUserFontData> data;
-#  ifdef ANDROID
-  // If the font has variations, we may later need to "clone" it in
-  // UnscaledFontFreeType::CreateScaledFont. To support this, we attach an
-  // FTUserFontData that records the filename used to instantiate the face.
-  if (face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS) {
-    data = new FTUserFontData(aFilename);
-  }
-#  endif
-  return MakeAndAddRef<SharedFTFace>(face, data);
+  return MakeAndAddRef<SharedFTFace>(face, std::move(filename), aFaceIndex);
 }
 
 FT_Face Factory::NewFTFaceFromData(FT_Library aFTLibrary, const uint8_t* aData,
@@ -580,14 +548,28 @@ FT_Face Factory::NewFTFaceFromData(FT_Library aFTLibrary, const uint8_t* aData,
 }
 
 already_AddRefed<SharedFTFace> Factory::NewSharedFTFaceFromData(
-    FT_Library aFTLibrary, FontData* aFontData, int aFaceIndex,
-    SharedFTFaceData* aSharedData) {
-  if (FT_Face face = NewFTFaceFromData(aFTLibrary, aFontData->Data(),
-                                       aFontData->Length(), aFaceIndex)) {
-    return MakeAndAddRef<SharedFTFace>(face, aSharedData);
-  } else {
+    FontData* aFontData, int aFaceIndex) {
+  FT_Face face = NewFTFaceFromData(nullptr, aFontData->Data(),
+                                   aFontData->Length(), aFaceIndex);
+  if (!face) {
+    return nullptr;
+  }
+  if (FT_Select_Charmap(face, FT_ENCODING_UNICODE) != FT_Err_Ok &&
+      FT_Select_Charmap(face, FT_ENCODING_MS_SYMBOL) != FT_Err_Ok) {
+    ReleaseFTFace(face);
     return nullptr;
   }
+  return MakeAndAddRef<SharedFTFace>(face, aFontData, aFaceIndex);
+}
+
+already_AddRefed<SharedFTFace> SharedFTFace::CloneFace() {
+  if (mFontData) {
+    return Factory::NewSharedFTFaceFromData(mFontData, mFaceIndex);
+  }
+  if (mFilename) {
+    return Factory::NewSharedFTFace(mFilename.get(), mFaceIndex);
+  }
+  return nullptr;
 }
 
 void Factory::ReleaseFTFace(FT_Face aFace) {
diff --git a/gfx/2d/NativeFontResourceFreeType.cpp b/gfx/2d/NativeFontResourceFreeType.cpp
index 9a6db068a94..2d6358ad168 100644
--- a/gfx/2d/NativeFontResourceFreeType.cpp
+++ b/gfx/2d/NativeFontResourceFreeType.cpp
@@ -9,16 +9,15 @@
 namespace mozilla::gfx {
 
 NativeFontResourceFreeType::NativeFontResourceFreeType(
-    const uint8_t*&& aFontData, uint32_t aDataLength, FT_Library aFTLibrary)
+    const uint8_t*&& aFontData, uint32_t aDataLength)
     : NativeFontResource(aDataLength),
-      mFontData(MakeRefPtr<FontData>(std::move(aFontData), aDataLength)),
-      mFTLibrary(aFTLibrary) {}
+      mFontData(MakeRefPtr<FontData>(std::move(aFontData), aDataLength)) {}
 
 NativeFontResourceFreeType::~NativeFontResourceFreeType() = default;
 
 template <class T>
 already_AddRefed<T> NativeFontResourceFreeType::CreateInternal(
-    const uint8_t* aFontData, uint32_t aDataLength, FT_Library aFTLibrary) {
+    const uint8_t* aFontData, uint32_t aDataLength) {
   if (!aFontData || !aDataLength) {
     return nullptr;
   }
@@ -28,16 +27,15 @@ already_AddRefed<T> NativeFontResourceFreeType::CreateInternal(
   }
   memcpy(fontData, aFontData, aDataLength);
 
-  RefPtr<T> resource = new T(std::move(static_cast<const uint8_t*>(fontData)),
-                             aDataLength, aFTLibrary);
+  RefPtr<T> resource =
+      new T(std::move(static_cast<const uint8_t*>(fontData)), aDataLength);
   return resource.forget();
 }
 
 #ifdef MOZ_WIDGET_ANDROID
 already_AddRefed<NativeFontResourceFreeType> NativeFontResourceFreeType::Create(
-    const uint8_t* aFontData, uint32_t aDataLength, FT_Library aFTLibrary) {
-  return CreateInternal<NativeFontResourceFreeType>(aFontData, aDataLength,
-                                                    aFTLibrary);
+    const uint8_t* aFontData, uint32_t aDataLength) {
+  return CreateInternal<NativeFontResourceFreeType>(aFontData, aDataLength);
 }
 
 already_AddRefed<UnscaledFont> NativeFontResourceFreeType::CreateUnscaledFont(
@@ -52,22 +50,13 @@ already_AddRefed<UnscaledFont> NativeFontResourceFreeType::CreateUnscaledFont(
 
 already_AddRefed<SharedFTFace> NativeFontResourceFreeType::CloneFace(
     int aFaceIndex) {
-  RefPtr<SharedFTFace> face =
-      Factory::NewSharedFTFaceFromData(mFTLibrary, mFontData, aFaceIndex, this);
-  if (!face ||
-      (FT_Select_Charmap(face->GetFace(), FT_ENCODING_UNICODE) != FT_Err_Ok &&
-       FT_Select_Charmap(face->GetFace(), FT_ENCODING_MS_SYMBOL) !=
-           FT_Err_Ok)) {
-    return nullptr;
-  }
-  return face.forget();
+  return Factory::NewSharedFTFaceFromData(mFontData, aFaceIndex);
 }
 
 #ifdef MOZ_WIDGET_GTK
 NativeFontResourceFontconfig::NativeFontResourceFontconfig(
-    const uint8_t*&& aFontData, uint32_t aDataLength, FT_Library aFTLibrary)
-    : NativeFontResourceFreeType(std::move(aFontData), aDataLength,
-                                 aFTLibrary) {}
+    const uint8_t*&& aFontData, uint32_t aDataLength)
+    : NativeFontResourceFreeType(std::move(aFontData), aDataLength) {}
 
 already_AddRefed<UnscaledFont> NativeFontResourceFontconfig::CreateUnscaledFont(
     uint32_t aIndex, const uint8_t* aInstanceData,
@@ -80,10 +69,8 @@ already_AddRefed<UnscaledFont> NativeFontResourceFontconfig::CreateUnscaledFont(
 
 already_AddRefed<NativeFontResourceFontconfig>
 NativeFontResourceFontconfig::Create(const uint8_t* aFontData,
-                                     uint32_t aDataLength,
-                                     FT_Library aFTLibrary) {
-  return CreateInternal<NativeFontResourceFontconfig>(aFontData, aDataLength,
-                                                      aFTLibrary);
+                                     uint32_t aDataLength) {
+  return CreateInternal<NativeFontResourceFontconfig>(aFontData, aDataLength);
 }
 #endif
 
diff --git a/gfx/2d/NativeFontResourceFreeType.h b/gfx/2d/NativeFontResourceFreeType.h
index 194dac7c74a..9b65eca3fe0 100644
--- a/gfx/2d/NativeFontResourceFreeType.h
+++ b/gfx/2d/NativeFontResourceFreeType.h
@@ -12,16 +12,13 @@
 namespace mozilla {
 namespace gfx {
 
-class NativeFontResourceFreeType
-    : public NativeFontResource,
-      public SharedFTFaceRefCountedData<NativeFontResourceFreeType> {
+class NativeFontResourceFreeType : public NativeFontResource {
... (file diff truncated)