Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2860 insertions, 0 deletions

diff --git a/gfx/thebes/gfxFcPlatformFontList.cpp b/gfx/thebes/gfxFcPlatformFontList.cpp
new file mode 100644
index 0000000000..04703e1284
--- /dev/null
+++ b/gfx/thebes/gfxFcPlatformFontList.cpp
@@ -0,0 +1,2860 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 "mozilla/Logging.h"
+
+#include "gfxFcPlatformFontList.h"
+#include "gfxFont.h"
+#include "gfxFontConstants.h"
+#include "gfxFT2Utils.h"
+#include "gfxPlatform.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+#include "nsGkAtoms.h"
+#include "nsString.h"
+#include "nsStringFwd.h"
+#include "nsUnicodeProperties.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsCharSeparatedTokenizer.h"
+#include "nsXULAppAPI.h"
+#include "SharedFontList-impl.h"
+#include "StandardFonts-linux.inc"
+#include "mozilla/intl/Locale.h"
+
+#include "mozilla/gfx/HelpersCairo.h"
+
+#include <cairo-ft.h>
+#include <fontconfig/fcfreetype.h>
+#include <fontconfig/fontconfig.h>
+#include <harfbuzz/hb.h>
+#include <dlfcn.h>
+#include <unistd.h>
+
+#ifdef MOZ_WIDGET_GTK
+#  include <gdk/gdk.h>
+#  include <gtk/gtk.h>
+#  include "gfxPlatformGtk.h"
+#  include "mozilla/WidgetUtilsGtk.h"
+#endif
+
+#ifdef MOZ_X11
+#  include "mozilla/X11Util.h"
+#endif
+
+#if defined(MOZ_SANDBOX) && defined(XP_LINUX)
+#  include "mozilla/SandboxBrokerPolicyFactory.h"
+#  include "mozilla/SandboxSettings.h"
+#endif
+
+#include FT_MULTIPLE_MASTERS_H
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::unicode;
+using namespace mozilla::intl;
+
+#ifndef FC_POSTSCRIPT_NAME
+#  define FC_POSTSCRIPT_NAME "postscriptname" /* String */
+#endif
+#ifndef FC_VARIABLE
+#  define FC_VARIABLE "variable" /* Bool */
+#endif
+
+#define PRINTING_FC_PROPERTY "gfx.printing"
+
+#define LOG_FONTLIST(args) \
+  MOZ_LOG(gfxPlatform::GetLog(eGfxLog_fontlist), LogLevel::Debug, args)
+#define LOG_FONTLIST_ENABLED() \
+  MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_fontlist), LogLevel::Debug)
+#define LOG_CMAPDATA_ENABLED() \
+  MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_cmapdata), LogLevel::Debug)
+
+static const FcChar8* ToFcChar8Ptr(const char* aStr) {
+  return reinterpret_cast<const FcChar8*>(aStr);
+}
+
+static const char* ToCharPtr(const FcChar8* aStr) {
+  return reinterpret_cast<const char*>(aStr);
+}
+
+// canonical name ==> first en name or first name if no en name
+// This is the required logic for fullname lookups as per CSS3 Fonts spec.
+static uint32_t FindCanonicalNameIndex(FcPattern* aFont,
+                                       const char* aLangField) {
+  uint32_t n = 0, en = 0;
+  FcChar8* lang;
+  while (FcPatternGetString(aFont, aLangField, n, &lang) == FcResultMatch) {
+    // look for 'en' or variants, en-US, en-JP etc.
+    uint32_t len = strlen(ToCharPtr(lang));
+    bool enPrefix = (strncmp(ToCharPtr(lang), "en", 2) == 0);
+    if (enPrefix && (len == 2 || (len > 2 && aLangField[2] == '-'))) {
+      en = n;
+      break;
+    }
+    n++;
+  }
+  return en;
+}
+
+static void GetFaceNames(FcPattern* aFont, const nsACString& aFamilyName,
+                         nsACString& aPostscriptName, nsACString& aFullname) {
+  // get the Postscript name
+  FcChar8* psname;
+  if (FcPatternGetString(aFont, FC_POSTSCRIPT_NAME, 0, &psname) ==
+      FcResultMatch) {
+    aPostscriptName = ToCharPtr(psname);
+  }
+
+  // get the canonical fullname (i.e. en name or first name)
+  uint32_t en = FindCanonicalNameIndex(aFont, FC_FULLNAMELANG);
+  FcChar8* fullname;
+  if (FcPatternGetString(aFont, FC_FULLNAME, en, &fullname) == FcResultMatch) {
+    aFullname = ToCharPtr(fullname);
+  }
+
+  // if have fullname, done
+  if (!aFullname.IsEmpty()) {
+    return;
+  }
+
+  // otherwise, set the fullname to family + style name [en] and use that
+  aFullname = aFamilyName;
+
+  // figure out the en style name
+  en = FindCanonicalNameIndex(aFont, FC_STYLELANG);
+  nsAutoCString style;
+  FcChar8* stylename = nullptr;
+  FcPatternGetString(aFont, FC_STYLE, en, &stylename);
+  if (stylename) {
+    style = ToCharPtr(stylename);
+  }
+
+  if (!style.IsEmpty() && !style.EqualsLiteral("Regular")) {
+    aFullname.Append(' ');
+    aFullname.Append(style);
+  }
+}
+
+static FontWeight MapFcWeight(int aFcWeight) {
+  if (aFcWeight <= (FC_WEIGHT_THIN + FC_WEIGHT_EXTRALIGHT) / 2) {
+    return FontWeight::FromInt(100);
+  }
+  if (aFcWeight <= (FC_WEIGHT_EXTRALIGHT + FC_WEIGHT_LIGHT) / 2) {
+    return FontWeight::FromInt(200);
+  }
+  if (aFcWeight <= (FC_WEIGHT_LIGHT + FC_WEIGHT_BOOK) / 2) {
+    return FontWeight::FromInt(300);
+  }
+  if (aFcWeight <= (FC_WEIGHT_REGULAR + FC_WEIGHT_MEDIUM) / 2) {
+    // This includes FC_WEIGHT_BOOK
+    return FontWeight::FromInt(400);
+  }
+  if (aFcWeight <= (FC_WEIGHT_MEDIUM + FC_WEIGHT_DEMIBOLD) / 2) {
+    return FontWeight::FromInt(500);
+  }
+  if (aFcWeight <= (FC_WEIGHT_DEMIBOLD + FC_WEIGHT_BOLD) / 2) {
+    return FontWeight::FromInt(600);
+  }
+  if (aFcWeight <= (FC_WEIGHT_BOLD + FC_WEIGHT_EXTRABOLD) / 2) {
+    return FontWeight::FromInt(700);
+  }
+  if (aFcWeight <= (FC_WEIGHT_EXTRABOLD + FC_WEIGHT_BLACK) / 2) {
+    return FontWeight::FromInt(800);
+  }
+  if (aFcWeight <= FC_WEIGHT_BLACK) {
+    return FontWeight::FromInt(900);
+  }
+
+  // including FC_WEIGHT_EXTRABLACK
+  return FontWeight::FromInt(901);
+}
+
+// TODO(emilio, jfkthame): I think this can now be more fine-grained.
+static FontStretch MapFcWidth(int aFcWidth) {
+  if (aFcWidth <= (FC_WIDTH_ULTRACONDENSED + FC_WIDTH_EXTRACONDENSED) / 2) {
+    return FontStretch::ULTRA_CONDENSED;
+  }
+  if (aFcWidth <= (FC_WIDTH_EXTRACONDENSED + FC_WIDTH_CONDENSED) / 2) {
+    return FontStretch::EXTRA_CONDENSED;
+  }
+  if (aFcWidth <= (FC_WIDTH_CONDENSED + FC_WIDTH_SEMICONDENSED) / 2) {
+    return FontStretch::CONDENSED;
+  }
+  if (aFcWidth <= (FC_WIDTH_SEMICONDENSED + FC_WIDTH_NORMAL) / 2) {
+    return FontStretch::SEMI_CONDENSED;
+  }
+  if (aFcWidth <= (FC_WIDTH_NORMAL + FC_WIDTH_SEMIEXPANDED) / 2) {
+    return FontStretch::NORMAL;
+  }
+  if (aFcWidth <= (FC_WIDTH_SEMIEXPANDED + FC_WIDTH_EXPANDED) / 2) {
+    return FontStretch::SEMI_EXPANDED;
+  }
+  if (aFcWidth <= (FC_WIDTH_EXPANDED + FC_WIDTH_EXTRAEXPANDED) / 2) {
+    return FontStretch::EXPANDED;
+  }
+  if (aFcWidth <= (FC_WIDTH_EXTRAEXPANDED + FC_WIDTH_ULTRAEXPANDED) / 2) {
+    return FontStretch::EXTRA_EXPANDED;
+  }
+  return FontStretch::ULTRA_EXPANDED;
+}
+
+static void GetFontProperties(FcPattern* aFontPattern, WeightRange* aWeight,
+                              StretchRange* aStretch,
+                              SlantStyleRange* aSlantStyle,
+                              uint16_t* aSize = nullptr) {
+  // weight
+  int weight;
+  if (FcPatternGetInteger(aFontPattern, FC_WEIGHT, 0, &weight) !=
+      FcResultMatch) {
+    weight = FC_WEIGHT_REGULAR;
+  }
+  *aWeight = WeightRange(MapFcWeight(weight));
+
+  // width
+  int width;
+  if (FcPatternGetInteger(aFontPattern, FC_WIDTH, 0, &width) != FcResultMatch) {
+    width = FC_WIDTH_NORMAL;
+  }
+  *aStretch = StretchRange(MapFcWidth(width));
+
+  // italic
+  int slant;
+  if (FcPatternGetInteger(aFontPattern, FC_SLANT, 0, &slant) != FcResultMatch) {
+    slant = FC_SLANT_ROMAN;
+  }
+  if (slant == FC_SLANT_OBLIQUE) {
+    *aSlantStyle = SlantStyleRange(FontSlantStyle::OBLIQUE);
+  } else if (slant > 0) {
+    *aSlantStyle = SlantStyleRange(FontSlantStyle::ITALIC);
+  }
+
+  if (aSize) {
+    // pixel size, or zero if scalable
+    FcBool scalable;
+    if (FcPatternGetBool(aFontPattern, FC_SCALABLE, 0, &scalable) ==
+            FcResultMatch &&
+        scalable) {
+      *aSize = 0;
+    } else {
+      double size;
+      if (FcPatternGetDouble(aFontPattern, FC_PIXEL_SIZE, 0, &size) ==
+          FcResultMatch) {
+        *aSize = uint16_t(NS_round(size));
+      } else {
+        *aSize = 0;
+      }
+    }
+  }
+}
+
+void gfxFontconfigFontEntry::GetUserFontFeatures(FcPattern* aPattern) {
+  int fontFeaturesNum = 0;
+  char* s;
+  hb_feature_t tmpFeature;
+  while (FcResultMatch == FcPatternGetString(aPattern, "fontfeatures",
+                                             fontFeaturesNum, (FcChar8**)&s)) {
+    bool ret = hb_feature_from_string(s, -1, &tmpFeature);
+    if (ret) {
+      mFeatureSettings.AppendElement(
+          (gfxFontFeature){tmpFeature.tag, tmpFeature.value});
+    }
+    fontFeaturesNum++;
+  }
+}
+
+gfxFontconfigFontEntry::gfxFontconfigFontEntry(const nsACString& aFaceName,
+                                               FcPattern* aFontPattern,
+                                               bool aIgnoreFcCharmap)
+    : gfxFT2FontEntryBase(aFaceName),
+      mFontPattern(aFontPattern),
+      mFTFaceInitialized(false),
+      mIgnoreFcCharmap(aIgnoreFcCharmap),
+      mHasVariationsInitialized(false) {
+  GetFontProperties(aFontPattern, &mWeightRange, &mStretchRange, &mStyleRange);
+  GetUserFontFeatures(mFontPattern);
+}
+
+gfxFontEntry* gfxFontconfigFontEntry::Clone() const {
+  MOZ_ASSERT(!IsUserFont(), "we can only clone installed fonts!");
+  return new gfxFontconfigFontEntry(Name(), mFontPattern, mIgnoreFcCharmap);
+}
+
+static already_AddRefed<FcPattern> CreatePatternForFace(FT_Face aFace) {
+  // Use fontconfig to fill out the pattern from the FTFace.
+  // The "file" argument cannot be nullptr (in fontconfig-2.6.0 at
+  // least). The dummy file passed here is removed below.
+  //
+  // When fontconfig scans the system fonts, FcConfigGetBlanks(nullptr)
+  // is passed as the "blanks" argument, which provides that unexpectedly
+  // blank glyphs are elided.  Here, however, we pass nullptr for
+  // "blanks", effectively assuming that, if the font has a blank glyph,
+  // then the author intends any associated character to be rendered
+  // blank.
+  RefPtr<FcPattern> pattern =
+      dont_AddRef(FcFreeTypeQueryFace(aFace, ToFcChar8Ptr(""), 0, nullptr));
+  // given that we have a FT_Face, not really sure this is possible...
+  if (!pattern) {
+    pattern = dont_AddRef(FcPatternCreate());
+  }
+  FcPatternDel(pattern, FC_FILE);
+  FcPatternDel(pattern, FC_INDEX);
+
+  // Make a new pattern and store the face in it so that cairo uses
+  // that when creating a cairo font face.
+  FcPatternAddFTFace(pattern, FC_FT_FACE, aFace);
+
+  return pattern.forget();
+}
+
+static already_AddRefed<SharedFTFace> CreateFaceForPattern(
+    FcPattern* aPattern) {
+  FcChar8* filename;
+  if (FcPatternGetString(aPattern, FC_FILE, 0, &filename) != FcResultMatch) {
+    return nullptr;
+  }
+  int index;
+  if (FcPatternGetInteger(aPattern, FC_INDEX, 0, &index) != FcResultMatch) {
+    index = 0;  // default to 0 if not found in pattern
+  }
+  return Factory::NewSharedFTFace(nullptr, ToCharPtr(filename), index);
+}
+
+gfxFontconfigFontEntry::gfxFontconfigFontEntry(const nsACString& aFaceName,
+                                               WeightRange aWeight,
+                                               StretchRange aStretch,
+                                               SlantStyleRange aStyle,
+                                               RefPtr<SharedFTFace>&& aFace)
+    : gfxFT2FontEntryBase(aFaceName),
+      mFTFace(std::move(aFace)),
+      mFTFaceInitialized(true),
+      mIgnoreFcCharmap(true),
+      mHasVariationsInitialized(false) {
+  mWeightRange = aWeight;
+  mStyleRange = aStyle;
+  mStretchRange = aStretch;
+  mIsDataUserFont = true;
+
+  mFontPattern = CreatePatternForFace(mFTFace->GetFace());
+}
+
+gfxFontconfigFontEntry::gfxFontconfigFontEntry(const nsACString& aFaceName,
+                                               FcPattern* aFontPattern,
+                                               WeightRange aWeight,
+                                               StretchRange aStretch,
+                                               SlantStyleRange aStyle)
+    : gfxFT2FontEntryBase(aFaceName),
+      mFontPattern(aFontPattern),
+      mFTFaceInitialized(false),
+      mHasVariationsInitialized(false) {
+  mWeightRange = aWeight;
+  mStyleRange = aStyle;
+  mStretchRange = aStretch;
+  mIsLocalUserFont = true;
+
+  // The proper setting of mIgnoreFcCharmap is tricky for fonts loaded
+  // via src:local()...
+  // If the local font happens to come from the application fontset,
+  // we want to set it to true so that color/svg fonts will work even
+  // if the default glyphs are blank; but if the local font is a non-
+  // sfnt face (e.g. legacy type 1) then we need to set it to false
+  // because our cmap-reading code will fail and we depend on FT+Fc to
+  // determine the coverage.
+  // We set the flag here, but may flip it the first time TestCharacterMap
+  // is called, at which point we'll look to see whether a 'cmap' is
+  // actually present in the font.
+  mIgnoreFcCharmap = true;
+
+  GetUserFontFeatures(mFontPattern);
+}
+
+typedef FT_Error (*GetVarFunc)(FT_Face, FT_MM_Var**);
+typedef FT_Error (*DoneVarFunc)(FT_Library, FT_MM_Var*);
+static GetVarFunc sGetVar;
+static DoneVarFunc sDoneVar;
+static bool sInitializedVarFuncs = false;
+
+static void InitializeVarFuncs() {
+  if (sInitializedVarFuncs) {
+    return;
+  }
+  sInitializedVarFuncs = true;
+#if MOZ_TREE_FREETYPE
+  sGetVar = &FT_Get_MM_Var;
+  sDoneVar = &FT_Done_MM_Var;
+#else
+  sGetVar = (GetVarFunc)dlsym(RTLD_DEFAULT, "FT_Get_MM_Var");
+  sDoneVar = (DoneVarFunc)dlsym(RTLD_DEFAULT, "FT_Done_MM_Var");
+#endif
+}
+
+gfxFontconfigFontEntry::~gfxFontconfigFontEntry() {
+  if (mMMVar) {
+    // Prior to freetype 2.9, there was no specific function to free the
+    // FT_MM_Var record, and the docs just said to use free().
+    // InitializeVarFuncs must have been called in order for mMMVar to be
+    // non-null here, so we don't need to do it again.
+    if (sDoneVar) {
+      MOZ_ASSERT(mFTFace, "How did mMMVar get set without a face?");
+      (*sDoneVar)(mFTFace->GetFace()->glyph->library, mMMVar);
+    } else {
+      free(mMMVar);
+    }
+  }
+}
+
+nsresult gfxFontconfigFontEntry::ReadCMAP(FontInfoData* aFontInfoData) {
+  // attempt this once, if errors occur leave a blank cmap
+  if (mCharacterMap) {
+    return NS_OK;
+  }
+
+  RefPtr<gfxCharacterMap> charmap;
+  nsresult rv;
+
+  uint32_t uvsOffset = 0;
+  if (aFontInfoData &&
+      (charmap = GetCMAPFromFontInfo(aFontInfoData, uvsOffset))) {
+    rv = NS_OK;
+  } else {
+    uint32_t kCMAP = TRUETYPE_TAG('c', 'm', 'a', 'p');
+    charmap = new gfxCharacterMap();
+    AutoTable cmapTable(this, kCMAP);
+
+    if (cmapTable) {
+      uint32_t cmapLen;
+      const uint8_t* cmapData = reinterpret_cast<const uint8_t*>(
+          hb_blob_get_data(cmapTable, &cmapLen));
+      rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen, *charmap, uvsOffset);
+    } else {
+      rv = NS_ERROR_NOT_AVAILABLE;
+    }
+  }
+  mUVSOffset.exchange(uvsOffset);
+
+  bool setCharMap = true;
+  if (NS_SUCCEEDED(rv)) {
+    gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+    fontlist::FontList* sharedFontList = pfl->SharedFontList();
+    if (!IsUserFont() && mShmemFace) {
+      mShmemFace->SetCharacterMap(sharedFontList, charmap);  // async
+      if (TrySetShmemCharacterMap()) {
+        setCharMap = false;
+      }
+    } else {
+      charmap = pfl->FindCharMap(charmap);
+    }
+    mHasCmapTable = true;
+  } else {
+    // if error occurred, initialize to null cmap
+    charmap = new gfxCharacterMap();
+    mHasCmapTable = false;
+  }
+  if (setCharMap) {
+    if (mCharacterMap.compareExchange(nullptr, charmap.get())) {
+      charmap.get()->AddRef();
+    }
+  }
+
+  LOG_FONTLIST(("(fontlist-cmap) name: %s, size: %zu hash: %8.8x%s\n",
+                mName.get(), charmap->SizeOfIncludingThis(moz_malloc_size_of),
+                charmap->mHash, mCharacterMap == charmap ? " new" : ""));
+  if (LOG_CMAPDATA_ENABLED()) {
+    char prefix[256];
+    SprintfLiteral(prefix, "(cmapdata) name: %.220s", mName.get());
+    charmap->Dump(prefix, eGfxLog_cmapdata);
+  }
+
+  return rv;
+}
+
+static bool HasChar(FcPattern* aFont, FcChar32 aCh) {
+  FcCharSet* charset = nullptr;
+  FcPatternGetCharSet(aFont, FC_CHARSET, 0, &charset);
+  return charset && FcCharSetHasChar(charset, aCh);
+}
+
+bool gfxFontconfigFontEntry::TestCharacterMap(uint32_t aCh) {
+  // For user fonts, or for fonts bundled with the app (which might include
+  // color/svg glyphs where the default glyphs may be blank, and thus confuse
+  // fontconfig/freetype's char map checking), we instead check the cmap
+  // directly for character coverage.
+  if (mIgnoreFcCharmap) {
+    // If it does not actually have a cmap, switch our strategy to use
+    // fontconfig's charmap after all (except for data fonts, which must
+    // always have a cmap to have passed OTS validation).
+    if (!mIsDataUserFont && !HasFontTable(TRUETYPE_TAG('c', 'm', 'a', 'p'))) {
+      mIgnoreFcCharmap = false;
+      // ...and continue with HasChar() below.
+    } else {
+      return gfxFontEntry::TestCharacterMap(aCh);
+    }
+  }
+  // otherwise (for system fonts), use the charmap in the pattern
+  return HasChar(mFontPattern, aCh);
+}
+
+bool gfxFontconfigFontEntry::HasFontTable(uint32_t aTableTag) {
+  if (FTUserFontData* ufd = GetUserFontData()) {
+    if (ufd->FontData()) {
+      return !!gfxFontUtils::FindTableDirEntry(ufd->FontData(), aTableTag);
+    }
+  }
+  return gfxFT2FontEntryBase::FaceHasTable(GetFTFace(), aTableTag);
+}
+
+hb_blob_t* gfxFontconfigFontEntry::GetFontTable(uint32_t aTableTag) {
+  // for data fonts, read directly from the font data
+  if (FTUserFontData* ufd = GetUserFontData()) {
+    if (ufd->FontData()) {
+      return gfxFontUtils::GetTableFromFontData(ufd->FontData(), aTableTag);
+    }
+  }
+
+  return gfxFontEntry::GetFontTable(aTableTag);
+}
+
+double gfxFontconfigFontEntry::GetAspect(uint8_t aSizeAdjustBasis) {
+  using FontSizeAdjust = gfxFont::FontSizeAdjust;
+  if (FontSizeAdjust::Tag(aSizeAdjustBasis) == FontSizeAdjust::Tag::ExHeight ||
+      FontSizeAdjust::Tag(aSizeAdjustBasis) == FontSizeAdjust::Tag::CapHeight) {
+    // try to compute aspect from OS/2 metrics if available
+    AutoTable os2Table(this, TRUETYPE_TAG('O', 'S', '/', '2'));
+    if (os2Table) {
+      uint16_t upem = UnitsPerEm();
+      if (upem != kInvalidUPEM) {
+        uint32_t len;
+        const auto* os2 =
+            reinterpret_cast<const OS2Table*>(hb_blob_get_data(os2Table, &len));
+        if (uint16_t(os2->version) >= 2) {
+          // XXX(jfkthame) Other implementations don't have the check for
+          // values <= 0.1em; should we drop that here? Just require it to be
+          // a positive number?
+          if (FontSizeAdjust::Tag(aSizeAdjustBasis) ==
+              FontSizeAdjust::Tag::ExHeight) {
+            if (len >= offsetof(OS2Table, sxHeight) + sizeof(int16_t) &&
+                int16_t(os2->sxHeight) > 0.1 * upem) {
+              return double(int16_t(os2->sxHeight)) / upem;
+            }
+          }
+          if (FontSizeAdjust::Tag(aSizeAdjustBasis) ==
+              FontSizeAdjust::Tag::CapHeight) {
+            if (len >= offsetof(OS2Table, sCapHeight) + sizeof(int16_t) &&
+                int16_t(os2->sCapHeight) > 0.1 * upem) {
+              return double(int16_t(os2->sCapHeight)) / upem;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // create a font to calculate the requested aspect
+  gfxFontStyle s;
+  s.size = 256.0;  // pick large size to reduce hinting artifacts
+  RefPtr<gfxFont> font = FindOrMakeFont(&s);
+  if (font) {
+    const gfxFont::Metrics& metrics =
+        font->GetMetrics(nsFontMetrics::eHorizontal);
+    if (metrics.emHeight == 0) {
+      return 0;
+    }
+    switch (FontSizeAdjust::Tag(aSizeAdjustBasis)) {
+      case FontSizeAdjust::Tag::ExHeight:
+        return metrics.xHeight / metrics.emHeight;
+      case FontSizeAdjust::Tag::CapHeight:
+        return metrics.capHeight / metrics.emHeight;
+      case FontSizeAdjust::Tag::ChWidth:
+        return metrics.zeroWidth > 0 ? metrics.zeroWidth / metrics.emHeight
+                                     : 0.5;
+      case FontSizeAdjust::Tag::IcWidth:
+      case FontSizeAdjust::Tag::IcHeight: {
+        bool vertical = FontSizeAdjust::Tag(aSizeAdjustBasis) ==
+                        FontSizeAdjust::Tag::IcHeight;
+        gfxFloat advance =
+            font->GetCharAdvance(gfxFont::kWaterIdeograph, vertical);
+        return advance > 0 ? advance / metrics.emHeight : 1.0;
+      }
+      default:
+        break;
+    }
+  }
+
+  MOZ_ASSERT_UNREACHABLE("failed to compute size-adjust aspect");
+  return 0.5;
+}
+
+static void PrepareFontOptions(FcPattern* aPattern, int* aOutLoadFlags,
+                               unsigned int* aOutSynthFlags) {
+  int loadFlags = FT_LOAD_DEFAULT;
+  unsigned int synthFlags = 0;
+
+  // xxx - taken from the gfxFontconfigFonts code, needs to be reviewed
+
+  FcBool printing;
+  if (FcPatternGetBool(aPattern, PRINTING_FC_PROPERTY, 0, &printing) !=
+      FcResultMatch) {
+    printing = FcFalse;
+  }
+
+  // Font options are set explicitly here to improve cairo's caching
+  // behavior and to record the relevant parts of the pattern so that
+  // the pattern can be released.
+  //
+  // Most font_options have already been set as defaults on the FcPattern
+  // with cairo_ft_font_options_substitute(), then user and system
+  // fontconfig configurations were applied.  The resulting font_options
+  // have been recorded on the face during
+  // cairo_ft_font_face_create_for_pattern().
+  //
+  // None of the settings here cause this scaled_font to behave any
+  // differently from how it would behave if it were created from the same
+  // face with default font_options.
+  //
+  // We set options explicitly so that the same scaled_font will be found in
+  // the cairo_scaled_font_map when cairo loads glyphs from a context with
+  // the same font_face, font_matrix, ctm, and surface font_options.
+  //
+  // Unfortunately, _cairo_scaled_font_keys_equal doesn't know about the
+  // font_options on the cairo_ft_font_face, and doesn't consider default
+  // option values to not match any explicit values.
+  //
+  // Even after cairo_set_scaled_font is used to set font_options for the
+  // cairo context, when cairo looks for a scaled_font for the context, it
+  // will look for a font with some option values from the target surface if
+  // any values are left default on the context font_options.  If this
+  // scaled_font is created with default font_options, cairo will not find
+  // it.
+  //
+  // The one option not recorded in the pattern is hint_metrics, which will
+  // affect glyph metrics.  The default behaves as CAIRO_HINT_METRICS_ON.
+  // We should be considering the font_options of the surface on which this
+  // font will be used, but currently we don't have different gfxFonts for
+  // different surface font_options, so we'll create a font suitable for the
+  // Screen. Image and xlib surfaces default to CAIRO_HINT_METRICS_ON.
+
+  // The remaining options have been recorded on the pattern and the face.
+  // _cairo_ft_options_merge has some logic to decide which options from the
+  // scaled_font or from the cairo_ft_font_face take priority in the way the
+  // font behaves.
+  //
+  // In the majority of cases, _cairo_ft_options_merge uses the options from
+  // the cairo_ft_font_face, so sometimes it is not so important which
+  // values are set here so long as they are not defaults, but we'll set
+  // them to the exact values that we expect from the font, to be consistent
+  // and to protect against changes in cairo.
+  //
+  // In some cases, _cairo_ft_options_merge uses some options from the
+  // scaled_font's font_options rather than options on the
+  // cairo_ft_font_face (from fontconfig).
+  // https://bugs.freedesktop.org/show_bug.cgi?id=11838
+  //
+  // Surface font options were set on the pattern in
+  // cairo_ft_font_options_substitute.  If fontconfig has changed the
+  // hint_style then that is what the user (or distribution) wants, so we
+  // use the setting from the FcPattern.
+  //
+  // Fallback values here mirror treatment of defaults in cairo-ft-font.c.
+  FcBool hinting = FcFalse;
+  if (FcPatternGetBool(aPattern, FC_HINTING, 0, &hinting) != FcResultMatch) {
+    hinting = FcTrue;
+  }
+
+  int fc_hintstyle = FC_HINT_NONE;
+  if (!printing && hinting &&
+      FcPatternGetInteger(aPattern, FC_HINT_STYLE, 0, &fc_hintstyle) !=
+          FcResultMatch) {
+    fc_hintstyle = FC_HINT_FULL;
+  }
+  switch (fc_hintstyle) {
+    case FC_HINT_NONE:
+      loadFlags = FT_LOAD_NO_HINTING;
+      break;
+    case FC_HINT_SLIGHT:
+      loadFlags = FT_LOAD_TARGET_LIGHT;
+      break;
+  }
+
+  FcBool fc_antialias;
+  if (FcPatternGetBool(aPattern, FC_ANTIALIAS, 0, &fc_antialias) !=
+      FcResultMatch) {
+    fc_antialias = FcTrue;
+  }
+  if (!fc_antialias) {
+    if (fc_hintstyle != FC_HINT_NONE) {
+      loadFlags = FT_LOAD_TARGET_MONO;
+    }
+    loadFlags |= FT_LOAD_MONOCHROME;
+  } else if (fc_hintstyle == FC_HINT_FULL) {
+    int fc_rgba;
+    if (FcPatternGetInteger(aPattern, FC_RGBA, 0, &fc_rgba) != FcResultMatch) {
+      fc_rgba = FC_RGBA_UNKNOWN;
+    }
+    switch (fc_rgba) {
+      case FC_RGBA_RGB:
+      case FC_RGBA_BGR:
+        loadFlags = FT_LOAD_TARGET_LCD;
+        break;
+      case FC_RGBA_VRGB:
+      case FC_RGBA_VBGR:
+        loadFlags = FT_LOAD_TARGET_LCD_V;
+        break;
+    }
+  }
+
+  if (!FcPatternAllowsBitmaps(aPattern, fc_antialias != FcFalse,
+                              fc_hintstyle != FC_HINT_NONE)) {
+    loadFlags |= FT_LOAD_NO_BITMAP;
+  }
+
+  FcBool autohint;
+  if (FcPatternGetBool(aPattern, FC_AUTOHINT, 0, &autohint) == FcResultMatch &&
+      autohint) {
+    loadFlags |= FT_LOAD_FORCE_AUTOHINT;
+  }
+
+  FcBool embolden;
+  if (FcPatternGetBool(aPattern, FC_EMBOLDEN, 0, &embolden) == FcResultMatch &&
+      embolden) {
+    synthFlags |= CAIRO_FT_SYNTHESIZE_BOLD;
+  }
+
+  *aOutLoadFlags = loadFlags;
+  *aOutSynthFlags = synthFlags;
+}
+
+#ifdef MOZ_X11
+static bool GetXftInt(Display* aDisplay, const char* aName, int* aResult) {
+  if (!aDisplay) {
+    return false;
+  }
+  char* value = XGetDefault(aDisplay, "Xft", aName);
+  if (!value) {
+    return false;
+  }
+  if (FcNameConstant(const_cast<FcChar8*>(ToFcChar8Ptr(value)), aResult)) {
+    return true;
+  }
+  char* end;
+  *aResult = strtol(value, &end, 0);
+  if (end != value) {
+    return true;
+  }
+  return false;
+}
+#endif
+
+static void PreparePattern(FcPattern* aPattern, bool aIsPrinterFont) {
+  FcConfigSubstitute(nullptr, aPattern, FcMatchPattern);
+
+  // This gets cairo_font_options_t for the Screen.  We should have
+  // different font options for printing (no hinting) but we are not told
+  // what we are measuring for.
+  //
+  // If cairo adds support for lcd_filter, gdk will not provide the default
+  // setting for that option.  We could get the default setting by creating
+  // an xlib surface once, recording its font_options, and then merging the
+  // gdk options.
+  //
+  // Using an xlib surface would also be an option to get Screen font
+  // options for non-GTK X11 toolkits, but less efficient than using GDK to
+  // pick up dynamic changes.
+  if (aIsPrinterFont) {
+    cairo_font_options_t* options = cairo_font_options_create();
+    cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE);
+    cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_GRAY);
+    cairo_ft_font_options_substitute(options, aPattern);
+    cairo_font_options_destroy(options);
+    FcPatternAddBool(aPattern, PRINTING_FC_PROPERTY, FcTrue);
+#ifdef MOZ_WIDGET_GTK
+  } else {
+    gfxFcPlatformFontList::PlatformFontList()->SubstituteSystemFontOptions(
+        aPattern);
+#endif  // MOZ_WIDGET_GTK
+  }
+
+  FcDefaultSubstitute(aPattern);
+}
+
+void gfxFontconfigFontEntry::UnscaledFontCache::MoveToFront(size_t aIndex) {
+  if (aIndex > 0) {
+    ThreadSafeWeakPtr<UnscaledFontFontconfig> front =
+        std::move(mUnscaledFonts[aIndex]);
+    for (size_t i = aIndex; i > 0; i--) {
+      mUnscaledFonts[i] = std::move(mUnscaledFonts[i - 1]);
+    }
+    mUnscaledFonts[0] = std::move(front);
+  }
+}
+
+already_AddRefed<UnscaledFontFontconfig>
+gfxFontconfigFontEntry::UnscaledFontCache::Lookup(const std::string& aFile,
+                                                  uint32_t aIndex) {
+  for (size_t i = 0; i < kNumEntries; i++) {
+    RefPtr<UnscaledFontFontconfig> entry(mUnscaledFonts[i]);
+    if (entry && entry->GetFile() == aFile && entry->GetIndex() == aIndex) {
+      MoveToFront(i);
+      return entry.forget();
+    }
+  }
+  return nullptr;
+}
+
+static inline gfxFloat SizeForStyle(gfxFontconfigFontEntry* aEntry,
+                                    const gfxFontStyle& aStyle) {
+  return StyleFontSizeAdjust::Tag(aStyle.sizeAdjustBasis) !=
+                 StyleFontSizeAdjust::Tag::None
+             ? aStyle.GetAdjustedSize(aEntry->GetAspect(aStyle.sizeAdjustBasis))
+             : aStyle.size * aEntry->mSizeAdjust;
+}
+
+static double ChooseFontSize(gfxFontconfigFontEntry* aEntry,
+                             const gfxFontStyle& aStyle) {
+  double requestedSize = SizeForStyle(aEntry, aStyle);
+  double bestDist = -1.0;
+  double bestSize = requestedSize;
+  double size;
+  int v = 0;
+  while (FcPatternGetDouble(aEntry->GetPattern(), FC_PIXEL_SIZE, v, &size) ==
+         FcResultMatch) {
+    ++v;
+    double dist = fabs(size - requestedSize);
+    if (bestDist < 0.0 || dist < bestDist) {
+      bestDist = dist;
+      bestSize = size;
+    }
+  }
+  // If the font has bitmaps but wants to be scaled, then let it scale.
+  if (bestSize >= 0.0) {
+    FcBool scalable;
+    if (FcPatternGetBool(aEntry->GetPattern(), FC_SCALABLE, 0, &scalable) ==
+            FcResultMatch &&
+        scalable) {
+      return requestedSize;
+    }
+  }
+  return bestSize;
+}
+
+gfxFont* gfxFontconfigFontEntry::CreateFontInstance(
+    const gfxFontStyle* aFontStyle) {
+  RefPtr<FcPattern> pattern = dont_AddRef(FcPatternCreate());
+  if (!pattern) {
+    NS_WARNING("Failed to create Fontconfig pattern for font instance");
+    return nullptr;
+  }
+
+  double size = ChooseFontSize(this, *aFontStyle);
+  FcPatternAddDouble(pattern, FC_PIXEL_SIZE, size);
+
+  RefPtr<SharedFTFace> face = GetFTFace();
+  if (!face) {
+    NS_WARNING("Failed to get FreeType face for pattern");
+    return nullptr;
+  }
+  if (HasVariations()) {
+    // For variation fonts, we create a new FT_Face here so that
+    // variation coordinates from the style can be applied without
+    // affecting other font instances created from the same entry
+    // (font resource).
+    // For user fonts: create a new FT_Face from the font data, and then make
+    // a pattern from that.
+    // For system fonts: create a new FT_Face and store it in a copy of the
+    // original mFontPattern.
+    RefPtr<SharedFTFace> varFace = face->GetData()
+                                       ? face->GetData()->CloneFace()
+                                       : CreateFaceForPattern(mFontPattern);
+    if (varFace) {
+      AutoTArray<gfxFontVariation, 8> settings;
+      GetVariationsForStyle(settings, *aFontStyle);
+      gfxFT2FontBase::SetupVarCoords(GetMMVar(), settings, varFace->GetFace());
+      face = std::move(varFace);
+    }
+  }
+
+  PreparePattern(pattern, aFontStyle->printerFont);
+  RefPtr<FcPattern> renderPattern =
+      dont_AddRef(FcFontRenderPrepare(nullptr, pattern, mFontPattern));
+  if (!renderPattern) {
+    NS_WARNING("Failed to prepare Fontconfig pattern for font instance");
+    return nullptr;
+  }
+
+  if (aFontStyle->NeedsSyntheticBold(this)) {
+    FcPatternAddBool(renderPattern, FC_EMBOLDEN, FcTrue);
+  }
+
+  // will synthetic oblique be applied using a transform?
+  if (IsUpright() && !aFontStyle->style.IsNormal() &&
+      aFontStyle->allowSyntheticStyle) {
+    // disable embedded bitmaps (mimics behavior in 90-synthetic.conf)
+    FcPatternDel(renderPattern, FC_EMBEDDED_BITMAP);
+    FcPatternAddBool(renderPattern, FC_EMBEDDED_BITMAP, FcFalse);
+  }
+
+  int loadFlags;
+  unsigned int synthFlags;
+  PrepareFontOptions(renderPattern, &loadFlags, &synthFlags);
+
+  std::string file;
+  int index = 0;
+  if (!face->GetData()) {
+    const FcChar8* fcFile;
+    if (FcPatternGetString(renderPattern, FC_FILE, 0,
+                           const_cast<FcChar8**>(&fcFile)) != FcResultMatch ||
+        FcPatternGetInteger(renderPattern, FC_INDEX, 0, &index) !=
+            FcResultMatch) {
+      NS_WARNING("No file in Fontconfig pattern for font instance");
+      return nullptr;
+    }
+    file = ToCharPtr(fcFile);
+  }
+
+  RefPtr<UnscaledFontFontconfig> unscaledFont =
+      mUnscaledFontCache.Lookup(file, index);
+  if (!unscaledFont) {
+    unscaledFont = mFTFace->GetData() ? new UnscaledFontFontconfig(mFTFace)
+                                      : new UnscaledFontFontconfig(
+                                            std::move(file), index, mFTFace);
+    mUnscaledFontCache.Add(unscaledFont);
+  }
+
+  gfxFont* newFont = new gfxFontconfigFont(
+      unscaledFont, std::move(face), renderPattern, size, this, aFontStyle,
+      loadFlags, (synthFlags & CAIRO_FT_SYNTHESIZE_BOLD) != 0);
+
+  return newFont;
+}
+
+const RefPtr<SharedFTFace>& gfxFontconfigFontEntry::GetFTFace() {
+  if (!mFTFaceInitialized) {
+    mFTFaceInitialized = true;
+    mFTFace = CreateFaceForPattern(mFontPattern);
+  }
+  return mFTFace;
+}
+
+FTUserFontData* gfxFontconfigFontEntry::GetUserFontData() {
+  if (mFTFace && mFTFace->GetData()) {
+    return static_cast<FTUserFontData*>(mFTFace->GetData());
+  }
+  return nullptr;
+}
+
+bool gfxFontconfigFontEntry::HasVariations() {
+  if (mHasVariationsInitialized) {
+    return mHasVariations;
+  }
+  mHasVariationsInitialized = true;
+  mHasVariations = false;
+
+  if (!gfxPlatform::HasVariationFontSupport()) {
+    return mHasVariations;
+  }
+
+  // For installed fonts, query the fontconfig pattern rather than paying
+  // the cost of loading a FT_Face that we otherwise might never need.
+  if (!IsUserFont() || IsLocalUserFont()) {
+    FcBool variable;
+    if ((FcPatternGetBool(mFontPattern, FC_VARIABLE, 0, &variable) ==
+         FcResultMatch) &&
+        variable) {
+      mHasVariations = true;
+    }
+  } else {
+    if (GetFTFace()) {
+      mHasVariations =
+          mFTFace->GetFace()->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS;
+    }
+  }
+
+  return mHasVariations;
+}
+
+FT_MM_Var* gfxFontconfigFontEntry::GetMMVar() {
+  if (mMMVarInitialized) {
+    return mMMVar;
+  }
+  mMMVarInitialized = true;
+  InitializeVarFuncs();
+  if (!sGetVar) {
+    return nullptr;
+  }
+  if (!GetFTFace()) {
+    return nullptr;
+  }
+  if (FT_Err_Ok != (*sGetVar)(mFTFace->GetFace(), &mMMVar)) {
+    mMMVar = nullptr;
+  }
+  return mMMVar;
+}
+
+void gfxFontconfigFontEntry::GetVariationAxes(
+    nsTArray<gfxFontVariationAxis>& aAxes) {
+  if (!HasVariations()) {
+    return;
+  }
+  gfxFT2Utils::GetVariationAxes(GetMMVar(), aAxes);
+}
+
+void gfxFontconfigFontEntry::GetVariationInstances(
+    nsTArray<gfxFontVariationInstance>& aInstances) {
+  if (!HasVariations()) {
+    return;
+  }
+  gfxFT2Utils::GetVariationInstances(this, GetMMVar(), aInstances);
+}
+
+nsresult gfxFontconfigFontEntry::CopyFontTable(uint32_t aTableTag,
+                                               nsTArray<uint8_t>& aBuffer) {
+  NS_ASSERTION(!mIsDataUserFont,
+               "data fonts should be reading tables directly from memory");
+  return gfxFT2FontEntryBase::CopyFaceTable(GetFTFace(), aTableTag, aBuffer);
+}
+
+void gfxFontconfigFontFamily::FindStyleVariationsLocked(
+    FontInfoData* aFontInfoData) {
+  if (mHasStyles) {
+    return;
+  }
+
+  // add font entries for each of the faces
+  uint32_t numFonts = mFontPatterns.Length();
+  NS_ASSERTION(numFonts, "font family containing no faces!!");
+  uint32_t numRegularFaces = 0;
+  for (uint32_t i = 0; i < numFonts; i++) {
+    FcPattern* face = mFontPatterns[i];
+
+    // figure out the psname/fullname and choose which to use as the facename
+    nsAutoCString psname, fullname;
+    GetFaceNames(face, mName, psname, fullname);
+    const nsAutoCString& faceName = !psname.IsEmpty() ? psname : fullname;
+
+    gfxFontconfigFontEntry* fontEntry =
+        new gfxFontconfigFontEntry(faceName, face, mContainsAppFonts);
+
+    if (gfxPlatform::HasVariationFontSupport()) {
+      fontEntry->SetupVariationRanges();
+    }
+
+    AddFontEntryLocked(fontEntry);
+
+    if (fontEntry->IsNormalStyle()) {
+      numRegularFaces++;
+    }
+
+    if (LOG_FONTLIST_ENABLED()) {
+      nsAutoCString weightString;
+      fontEntry->Weight().ToString(weightString);
+      nsAutoCString stretchString;
+      fontEntry->Stretch().ToString(stretchString);
+      nsAutoCString styleString;
+      fontEntry->SlantStyle().ToString(styleString);
+      LOG_FONTLIST(
+          ("(fontlist) added (%s) to family (%s)"
+           " with style: %s weight: %s stretch: %s"
+           " psname: %s fullname: %s",
+           fontEntry->Name().get(), Name().get(), styleString.get(),
+           weightString.get(), stretchString.get(), psname.get(),
+           fullname.get()));
+    }
+  }
+
+  // somewhat arbitrary, but define a family with two or more regular
+  // faces as a family for which intra-family fallback should be used
+  if (numRegularFaces > 1) {
+    mCheckForFallbackFaces = true;
+  }
+  mFaceNamesInitialized = true;
+  mFontPatterns.Clear();
+  SetHasStyles(true);
+
+  CheckForSimpleFamily();
+}
+
+void gfxFontconfigFontFamily::AddFontPattern(FcPattern* aFontPattern,
+                                             bool aSingleName) {
+  NS_ASSERTION(
+      !mHasStyles,
+      "font patterns must not be added to already enumerated families");
+
+  FcBool outline;
+  if (FcPatternGetBool(aFontPattern, FC_OUTLINE, 0, &outline) !=
+          FcResultMatch ||
+      !outline) {
+    mHasNonScalableFaces = true;
+
+    FcBool scalable;
+    if (FcPatternGetBool(aFontPattern, FC_SCALABLE, 0, &scalable) ==
+            FcResultMatch &&
+        scalable) {
+      mForceScalable = true;
+    }
+  }
+
+  if (aSingleName) {
+    mFontPatterns.InsertElementAt(mUniqueNameFaceCount++, aFontPattern);
+  } else {
+    mFontPatterns.AppendElement(aFontPattern);
+  }
+}
+
+static const double kRejectDistance = 10000.0;
+
+// Calculate a distance score representing the size disparity between the
+// requested style's size and the font entry's size.
+static double SizeDistance(gfxFontconfigFontEntry* aEntry,
+                           const gfxFontStyle& aStyle, bool aForceScalable) {
+  double requestedSize = SizeForStyle(aEntry, aStyle);
+  double bestDist = -1.0;
+  double size;
+  int v = 0;
+  while (FcPatternGetDouble(aEntry->GetPattern(), FC_PIXEL_SIZE, v, &size) ==
+         FcResultMatch) {
+    ++v;
+    double dist = fabs(size - requestedSize);
+    if (bestDist < 0.0 || dist < bestDist) {
+      bestDist = dist;
+    }
+  }
+  if (bestDist < 0.0) {
+    // No size means scalable
+    return -1.0;
+  } else if (aForceScalable || 5.0 * bestDist < requestedSize) {
+    // fontconfig prefers a matching family or lang to pixelsize of bitmap
+    // fonts. CSS suggests a tolerance of 20% on pixelsize.
+    return bestDist;
+  } else {
+    // Reject any non-scalable fonts that are not within tolerance.
+    return kRejectDistance;
+  }
+}
+
+void gfxFontconfigFontFamily::FindAllFontsForStyle(
+    const gfxFontStyle& aFontStyle, nsTArray<gfxFontEntry*>& aFontEntryList,
+    bool aIgnoreSizeTolerance) {
+  gfxFontFamily::FindAllFontsForStyle(aFontStyle, aFontEntryList,
+                                      aIgnoreSizeTolerance);
+
+  if (!mHasNonScalableFaces) {
+    return;
+  }
+
+  // Iterate over the the available fonts while compacting any groups
+  // of unscalable fonts with matching styles into a single entry
+  // corresponding to the closest available size. If the closest
+  // available size is rejected for being outside tolerance, then the
+  // entire group will be skipped.
+  size_t skipped = 0;
+  gfxFontconfigFontEntry* bestEntry = nullptr;
+  double bestDist = -1.0;
+  for (size_t i = 0; i < aFontEntryList.Length(); i++) {
+    gfxFontconfigFontEntry* entry =
+        static_cast<gfxFontconfigFontEntry*>(aFontEntryList[i]);
+    double dist =
+        SizeDistance(entry, aFontStyle, mForceScalable || aIgnoreSizeTolerance);
+    // If the entry is scalable or has a style that does not match
+    // the group of unscalable fonts, then start a new group.
+    if (dist < 0.0 || !bestEntry || bestEntry->Stretch() != entry->Stretch() ||
+        bestEntry->Weight() != entry->Weight() ||
+        bestEntry->SlantStyle() != entry->SlantStyle()) {
+      // If the best entry in this group is still outside the tolerance,
+      // then skip the entire group.
+      if (bestDist >= kRejectDistance) {
+        skipped++;
+      }
+      // Remove any compacted entries from the previous group.
+      if (skipped) {
+        i -= skipped;
+        aFontEntryList.RemoveElementsAt(i, skipped);
+        skipped = 0;
+      }
+      // Mark the start of the new group.
+      bestEntry = entry;
+      bestDist = dist;
+    } else {
+      // If this entry more closely matches the requested size than the
+      // current best in the group, then take this entry instead.
+      if (dist < bestDist) {
+        aFontEntryList[i - 1 - skipped] = entry;
+        bestEntry = entry;
+        bestDist = dist;
+      }
+      skipped++;
+    }
+  }
+  // If the best entry in this group is still outside the tolerance,
+  // then skip the entire group.
+  if (bestDist >= kRejectDistance) {
+    skipped++;
+  }
+  // Remove any compacted entries from the current group.
+  if (skipped) {
+    aFontEntryList.TruncateLength(aFontEntryList.Length() - skipped);
+  }
+}
+
+static bool PatternHasLang(const FcPattern* aPattern, const FcChar8* aLang) {
+  FcLangSet* langset;
+
+  if (FcPatternGetLangSet(aPattern, FC_LANG, 0, &langset) != FcResultMatch) {
+    return false;
+  }
+
+  if (FcLangSetHasLang(langset, aLang) != FcLangDifferentLang) {
+    return true;
+  }
+  return false;
+}
+
+bool gfxFontconfigFontFamily::SupportsLangGroup(nsAtom* aLangGroup) const {
+  if (!aLangGroup || aLangGroup == nsGkAtoms::Unicode) {
+    return true;
+  }
+
+  nsAutoCString fcLang;
+  gfxFcPlatformFontList* pfl = gfxFcPlatformFontList::PlatformFontList();
+  pfl->GetSampleLangForGroup(aLangGroup, fcLang);
+  if (fcLang.IsEmpty()) {
+    return true;
+  }
+
+  // Before FindStyleVariations has been called, mFontPatterns will contain
+  // the font patterns.  Afterward, it'll be empty, but mAvailableFonts
+  // will contain the font entries, each of which holds a reference to its
+  // pattern.  We only check the first pattern in each list, because support
+  // for langs is considered to be consistent across all faces in a family.
+  AutoReadLock lock(mLock);
+  FcPattern* fontPattern;
+  if (mFontPatterns.Length()) {
+    fontPattern = mFontPatterns[0];
+  } else if (mAvailableFonts.Length()) {
+    fontPattern = static_cast<gfxFontconfigFontEntry*>(mAvailableFonts[0].get())
+                      ->GetPattern();
+  } else {
+    return true;
+  }
+
+  // is lang included in the underlying pattern?
+  return PatternHasLang(fontPattern, ToFcChar8Ptr(fcLang.get()));
+}
+
+/* virtual */
+gfxFontconfigFontFamily::~gfxFontconfigFontFamily() {
+  // Should not be dropped by stylo
+  MOZ_ASSERT(NS_IsMainThread());
+}
+
+template <typename Func>
+void gfxFontconfigFontFamily::AddFacesToFontList(Func aAddPatternFunc) {
+  AutoReadLock lock(mLock);
+  if (HasStyles()) {
+    for (auto& fe : mAvailableFonts) {
+      if (!fe) {
+        continue;
+      }
+      auto fce = static_cast<gfxFontconfigFontEntry*>(fe.get());
+      aAddPatternFunc(fce->GetPattern(), mContainsAppFonts);
+    }
+  } else {
+    for (auto& pat : mFontPatterns) {
+      aAddPatternFunc(pat, mContainsAppFonts);
+    }
+  }
+}
+
+gfxFontconfigFont::gfxFontconfigFont(
+    const RefPtr<UnscaledFontFontconfig>& aUnscaledFont,
+    RefPtr<SharedFTFace>&& aFTFace, FcPattern* aPattern, gfxFloat aAdjustedSize,
+    gfxFontEntry* aFontEntry, const gfxFontStyle* aFontStyle, int aLoadFlags,
+    bool aEmbolden)
+    : gfxFT2FontBase(aUnscaledFont, std::move(aFTFace), aFontEntry, aFontStyle,
+                     aLoadFlags, aEmbolden),
+      mPattern(aPattern) {
+  mAdjustedSize = aAdjustedSize;
+  InitMetrics();
+}
+
+gfxFontconfigFont::~gfxFontconfigFont() = default;
+
+already_AddRefed<ScaledFont> gfxFontconfigFont::GetScaledFont(
+    const TextRunDrawParams& aRunParams) {
+  if (ScaledFont* scaledFont = mAzureScaledFont) {
+    return do_AddRef(scaledFont);
+  }
+
+  RefPtr<ScaledFont> newScaledFont = Factory::CreateScaledFontForFontconfigFont(
+      GetUnscaledFont(), GetAdjustedSize(), mFTFace, GetPattern());
+  if (!newScaledFont) {
+    return nullptr;
+  }
+
+  InitializeScaledFont(newScaledFont);
+
+  if (mAzureScaledFont.compareExchange(nullptr, newScaledFont.get())) {
+    Unused << newScaledFont.forget();
+  }
+  ScaledFont* scaledFont = mAzureScaledFont;
+  return do_AddRef(scaledFont);
+}
+
+bool gfxFontconfigFont::ShouldHintMetrics() const {
+  return !GetStyle()->printerFont;
+}
+
+gfxFcPlatformFontList::gfxFcPlatformFontList()
+    : mLocalNames(64),
+      mGenericMappings(32),
+      mFcSubstituteCache(64),
+      mLastConfig(nullptr),
+      mAlwaysUseFontconfigGenerics(true) {
+  CheckFamilyList(kBaseFonts_Ubuntu_20_04);
+  CheckFamilyList(kLangFonts_Ubuntu_20_04);
+  CheckFamilyList(kBaseFonts_Fedora_32);
+  mLastConfig = FcConfigGetCurrent();
+  if (XRE_IsParentProcess()) {
+    // if the rescan interval is set, start the timer
+    int rescanInterval = FcConfigGetRescanInterval(nullptr);
+    if (rescanInterval) {
+      NS_NewTimerWithFuncCallback(
+          getter_AddRefs(mCheckFontUpdatesTimer), CheckFontUpdates, this,
+          (rescanInterval + 1) * 1000, nsITimer::TYPE_REPEATING_SLACK,
+          "gfxFcPlatformFontList::gfxFcPlatformFontList");
+      if (!mCheckFontUpdatesTimer) {
+        NS_WARNING("Failure to create font updates timer");
+      }
+    }
+  }
+
+#ifdef MOZ_BUNDLED_FONTS
+  mBundledFontsInitialized = false;
+#endif
+}
+
+gfxFcPlatformFontList::~gfxFcPlatformFontList() {
+  AutoLock lock(mLock);
+
+  if (mCheckFontUpdatesTimer) {
+    mCheckFontUpdatesTimer->Cancel();
+    mCheckFontUpdatesTimer = nullptr;
+  }
+#ifdef MOZ_WIDGET_GTK
+  ClearSystemFontOptions();
+#endif
+}
+
+void gfxFcPlatformFontList::AddFontSetFamilies(FcFontSet* aFontSet,
+                                               const SandboxPolicy* aPolicy,
+                                               bool aAppFonts) {
+  // This iterates over the fonts in a font set and adds in gfxFontFamily
+  // objects for each family. Individual gfxFontEntry objects for each face
+  // are not created here; the patterns are just stored in the family. When
+  // a family is actually used, it will be populated with gfxFontEntry
+  // records and the patterns moved to those.
+
+  if (!aFontSet) {
+    NS_WARNING("AddFontSetFamilies called with a null font set.");
+    return;
+  }
+
+  FcChar8* lastFamilyName = (FcChar8*)"";
+  RefPtr<gfxFontconfigFontFamily> fontFamily;
+  nsAutoCString familyName;
+  for (int f = 0; f < aFontSet->nfont; f++) {
+    FcPattern* pattern = aFontSet->fonts[f];
+
+    // Skip any fonts that aren't readable for us (e.g. due to restrictive
+    // file ownership/permissions).
+    FcChar8* path;
+    if (FcPatternGetString(pattern, FC_FILE, 0, &path) != FcResultMatch) {
+      continue;
+    }
+    if (access(reinterpret_cast<const char*>(path), F_OK | R_OK) != 0) {
+      continue;
+    }
+
+#if defined(MOZ_SANDBOX) && defined(XP_LINUX)
+    // Skip any fonts that will be blocked by the content-process sandbox
+    // policy.
+    if (aPolicy && !(aPolicy->Lookup(reinterpret_cast<const char*>(path)) &
+                     SandboxBroker::Perms::MAY_READ)) {
+      continue;
+    }
+#endif
+
+    AddPatternToFontList(pattern, lastFamilyName, familyName, fontFamily,
+                         aAppFonts);
+  }
+}
+
+void gfxFcPlatformFontList::AddPatternToFontList(
+    FcPattern* aFont, FcChar8*& aLastFamilyName, nsACString& aFamilyName,
+    RefPtr<gfxFontconfigFontFamily>& aFontFamily, bool aAppFonts) {
+  // get canonical name
+  uint32_t cIndex = FindCanonicalNameIndex(aFont, FC_FAMILYLANG);
+  FcChar8* canonical = nullptr;
+  FcPatternGetString(aFont, FC_FAMILY, cIndex, &canonical);
+  if (!canonical) {
+    return;
+  }
+
+  // same as the last one? no need to add a new family, skip
+  if (FcStrCmp(canonical, aLastFamilyName) != 0) {
+    aLastFamilyName = canonical;
+
+    // add new family if one doesn't already exist
+    aFamilyName.Truncate();
+    aFamilyName = ToCharPtr(canonical);
+    nsAutoCString keyName(aFamilyName);
+    ToLowerCase(keyName);
+
+    aFontFamily = static_cast<gfxFontconfigFontFamily*>(
+        mFontFamilies
+            .LookupOrInsertWith(keyName,
+                                [&] {
+                                  FontVisibility visibility =
+                                      aAppFonts
+                                          ? FontVisibility::Base
+                                          : GetVisibilityForFamily(keyName);
+                                  return MakeRefPtr<gfxFontconfigFontFamily>(
+                                      aFamilyName, visibility);
+                                })
+            .get());
+    // Record if the family contains fonts from the app font set
+    // (in which case we won't rely on fontconfig's charmap, due to
+    // bug 1276594).
+    if (aAppFonts) {
+      aFontFamily->SetFamilyContainsAppFonts(true);
+    }
+  }
+
+  // Add pointers to other localized family names. Most fonts
+  // only have a single name, so the first call to GetString
+  // will usually not match
+  FcChar8* otherName;
+  int n = (cIndex == 0 ? 1 : 0);
+  AutoTArray<nsCString, 4> otherFamilyNames;
+  while (FcPatternGetString(aFont, FC_FAMILY, n, &otherName) == FcResultMatch) {
+    otherFamilyNames.AppendElement(nsCString(ToCharPtr(otherName)));
+    n++;
+    if (n == int(cIndex)) {
+      n++;  // skip over canonical name
+    }
+  }
+  if (!otherFamilyNames.IsEmpty()) {
+    AddOtherFamilyNames(aFontFamily, otherFamilyNames);
+  }
+
+  const bool singleName = n == 1;
+
+  MOZ_ASSERT(aFontFamily, "font must belong to a font family");
+  aFontFamily->AddFontPattern(aFont, singleName);
+
+  // map the psname, fullname ==> font family for local font lookups
+  nsAutoCString psname, fullname;
+  GetFaceNames(aFont, aFamilyName, psname, fullname);
+  if (!psname.IsEmpty()) {
+    ToLowerCase(psname);
+    mLocalNames.InsertOrUpdate(psname, RefPtr{aFont});
+  }
+  if (!fullname.IsEmpty()) {
+    ToLowerCase(fullname);
+    mLocalNames.WithEntryHandle(fullname, [&](auto&& entry) {
+      if (entry && !singleName) {
+        return;
+      }
+      entry.InsertOrUpdate(RefPtr{aFont});
+    });
+  }
+}
+
+nsresult gfxFcPlatformFontList::InitFontListForPlatform() {
+#ifdef MOZ_BUNDLED_FONTS
+  if (StaticPrefs::gfx_bundled_fonts_activate_AtStartup() != 0) {
+    ActivateBundledFonts();
+  }
+#endif
+
+  mLocalNames.Clear();
+  mFcSubstituteCache.Clear();
+
+  ClearSystemFontOptions();
+
+  mAlwaysUseFontconfigGenerics = PrefFontListsUseOnlyGenerics();
+  mOtherFamilyNamesInitialized = true;
+
+  mLastConfig = FcConfigGetCurrent();
+
+  if (XRE_IsContentProcess()) {
+    // Content process: use the font list passed from the chrome process,
+    // because we can't rely on fontconfig in the presence of sandboxing;
+    // it may report fonts that we can't actually access.
+
+    FcChar8* lastFamilyName = (FcChar8*)"";
+    RefPtr<gfxFontconfigFontFamily> fontFamily;
+    nsAutoCString familyName;
+
+    // Get font list that was passed during XPCOM startup
+    // or in an UpdateFontList message.
+    auto& fontList = dom::ContentChild::GetSingleton()->SystemFontList();
+
+#ifdef MOZ_WIDGET_GTK
+    UpdateSystemFontOptionsFromIpc(fontList.options());
+#endif
+
+    // For fontconfig versions between 2.10.94 and 2.11.1 inclusive,
+    // we need to escape any leading space in the charset element,
+    // otherwise FcNameParse will fail. :(
+    //
+    // The bug was introduced on 2013-05-24 by
+    //   https://cgit.freedesktop.org/fontconfig/commit/?id=cd9b1033a68816a7acfbba1718ba0aa5888f6ec7
+    //   "Bug 64906 - FcNameParse() should ignore leading whitespace in
+    //   parameters"
+    // because ignoring a leading space in the encoded value of charset
+    // causes erroneous decoding of the whole element.
+    // This first shipped in version 2.10.94, and was eventually fixed as
+    // a side-effect of switching to the "human-readable" representation of
+    // charsets on 2014-07-03 in
+    //   https://cgit.freedesktop.org/fontconfig/commit/?id=e708e97c351d3bc9f7030ef22ac2f007d5114730
+    //   "Change charset parse/unparse format to be human readable"
+    // (with a followup fix next day) which means a leading space is no
+    // longer significant. This fix landed after 2.11.1 had been shipped,
+    // so the first version tag without the bug is 2.11.91.
+    int fcVersion = FcGetVersion();
+    bool fcCharsetParseBug = fcVersion >= 21094 && fcVersion <= 21101;
+
+    for (FontPatternListEntry& fpe : fontList.entries()) {
+      nsCString& patternStr = fpe.pattern();
+      if (fcCharsetParseBug) {
+        int32_t index = patternStr.Find(":charset= ");
+        if (index != kNotFound) {
+          // insert backslash after the =, before the space
+          patternStr.Insert('\\', index + 9);
+        }
+      }
+      FcPattern* pattern = FcNameParse((const FcChar8*)patternStr.get());
+      AddPatternToFontList(pattern, lastFamilyName, familyName, fontFamily,
+                           fpe.appFontFamily());
+      FcPatternDestroy(pattern);
+    }
+
+    LOG_FONTLIST(
+        ("got font list from chrome process: "
+         "%u faces in %u families",
+         (unsigned)fontList.entries().Length(), mFontFamilies.Count()));
+
+    fontList.entries().Clear();
+    return NS_OK;
+  }
+
+  UpdateSystemFontOptions();
+
+  UniquePtr<SandboxPolicy> policy;
+
+#if defined(MOZ_SANDBOX) && defined(XP_LINUX)
+  // If read sandboxing is enabled, create a temporary SandboxPolicy to
+  // check font paths; use a fake PID to avoid picking up any PID-specific
+  // rules by accident.
+  SandboxBrokerPolicyFactory policyFactory;
+  if (GetEffectiveContentSandboxLevel() > 2 &&
+      !PR_GetEnv("MOZ_DISABLE_CONTENT_SANDBOX")) {
+    policy = policyFactory.GetContentPolicy(-1, false);
+  }
+#endif
+
+#ifdef MOZ_BUNDLED_FONTS
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=1745715:
+  // It's important to do this *before* processing the standard system fonts,
+  // so that if a family is present in both font sets, we'll treat it as app-
+  // bundled and therefore always visible.
+  if (StaticPrefs::gfx_bundled_fonts_activate_AtStartup() != 0) {
+    FcFontSet* appFonts = FcConfigGetFonts(nullptr, FcSetApplication);
+    AddFontSetFamilies(appFonts, policy.get(), /* aAppFonts = */ true);
+  }
+#endif
+
+  // iterate over available fonts
+  FcFontSet* systemFonts = FcConfigGetFonts(nullptr, FcSetSystem);
+  AddFontSetFamilies(systemFonts, policy.get(), /* aAppFonts = */ false);
+
+  return NS_OK;
+}
+
+void gfxFcPlatformFontList::ReadSystemFontList(dom::SystemFontList* retValue) {
+  AutoLock lock(mLock);
+
+  // Fontconfig versions below 2.9 drop the FC_FILE element in FcNameUnparse
+  // (see https://bugs.freedesktop.org/show_bug.cgi?id=26718), so when using
+  // an older version, we manually append it to the unparsed pattern.
+#ifdef MOZ_WIDGET_GTK
+  SystemFontOptionsToIpc(retValue->options());
+#endif
+
+  if (FcGetVersion() < 20900) {
+    for (const auto& entry : mFontFamilies) {
+      auto* family = static_cast<gfxFontconfigFontFamily*>(entry.GetWeak());
+      family->AddFacesToFontList([&](FcPattern* aPat, bool aAppFonts) {
+        char* s = (char*)FcNameUnparse(aPat);
+        nsDependentCString patternStr(s);
+        char* file = nullptr;
+        if (FcResultMatch ==
+            FcPatternGetString(aPat, FC_FILE, 0, (FcChar8**)&file)) {
+          patternStr.Append(":file=");
+          patternStr.Append(file);
+        }
+        retValue->entries().AppendElement(
+            FontPatternListEntry(patternStr, aAppFonts));
+        free(s);
+      });
+    }
+  } else {
+    for (const auto& entry : mFontFamilies) {
+      auto* family = static_cast<gfxFontconfigFontFamily*>(entry.GetWeak());
+      family->AddFacesToFontList([&](FcPattern* aPat, bool aAppFonts) {
+        char* s = (char*)FcNameUnparse(aPat);
+        nsDependentCString patternStr(s);
+        retValue->entries().AppendElement(
+            FontPatternListEntry(patternStr, aAppFonts));
+        free(s);
+      });
+    }
+  }
+}
+
+// Per family array of faces.
+class FacesData {
+  using FaceInitArray = AutoTArray<fontlist::Face::InitData, 8>;
+
+  FaceInitArray mFaces;
+
+  // Number of faces that have a single name. Faces that have multiple names are
+  // sorted last.
+  uint32_t mUniqueNameFaceCount = 0;
+
+ public:
+  void Add(fontlist::Face::InitData&& aData, bool aSingleName) {
+    if (aSingleName) {
+      mFaces.InsertElementAt(mUniqueNameFaceCount++, std::move(aData));
+    } else {
+      mFaces.AppendElement(std::move(aData));
+    }
+  }
+
+  const FaceInitArray& Get() const { return mFaces; }
+};
+
+void gfxFcPlatformFontList::InitSharedFontListForPlatform() {
+  mLocalNames.Clear();
+  mFcSubstituteCache.Clear();
+
+  mAlwaysUseFontconfigGenerics = PrefFontListsUseOnlyGenerics();
+  mOtherFamilyNamesInitialized = true;
+
+  mLastConfig = FcConfigGetCurrent();
+
+  if (!XRE_IsParentProcess()) {
+#ifdef MOZ_WIDGET_GTK
+    auto& fontList = dom::ContentChild::GetSingleton()->SystemFontList();
+    UpdateSystemFontOptionsFromIpc(fontList.options());
+#endif
+    // Content processes will access the shared-memory data created by the
+    // parent, so they do not need to query fontconfig for the available
+    // fonts themselves.
+    return;
+  }
+
+#ifdef MOZ_WIDGET_GTK
+  UpdateSystemFontOptions();
+#endif
+
+#ifdef MOZ_BUNDLED_FONTS
+  if (StaticPrefs::gfx_bundled_fonts_activate_AtStartup() != 0) {
+    TimeStamp start = TimeStamp::Now();
+    ActivateBundledFonts();
+    TimeStamp end = TimeStamp::Now();
+    Telemetry::Accumulate(Telemetry::FONTLIST_BUNDLEDFONTS_ACTIVATE,
+                          (end - start).ToMilliseconds());
+  }
+#endif
+
+  UniquePtr<SandboxPolicy> policy;
+
+#if defined(MOZ_CONTENT_SANDBOX) && defined(XP_LINUX)
+  // If read sandboxing is enabled, create a temporary SandboxPolicy to
+  // check font paths; use a fake PID to avoid picking up any PID-specific
+  // rules by accident.
+  SandboxBrokerPolicyFactory policyFactory;
+  if (GetEffectiveContentSandboxLevel() > 2 &&
+      !PR_GetEnv("MOZ_DISABLE_CONTENT_SANDBOX")) {
+    policy = policyFactory.GetContentPolicy(-1, false);
+  }
+#endif
+
+  nsTArray<fontlist::Family::InitData> families;
+
+  nsClassHashtable<nsCStringHashKey, FacesData> faces;
+
+  // Do we need to work around the fontconfig FcNameParse/FcNameUnparse bug
+  // (present in versions between 2.10.94 and 2.11.1 inclusive)? See comment
+  // in InitFontListForPlatform for details.
+  int fcVersion = FcGetVersion();
+  bool fcCharsetParseBug = fcVersion >= 21094 && fcVersion <= 21101;
+
+  auto addPattern = [this, fcCharsetParseBug, &families, &faces](
+                        FcPattern* aPattern, FcChar8*& aLastFamilyName,
+                        nsCString& aFamilyName, bool aAppFont) -> void {
+    // get canonical name
+    uint32_t cIndex = FindCanonicalNameIndex(aPattern, FC_FAMILYLANG);
+    FcChar8* canonical = nullptr;
+    FcPatternGetString(aPattern, FC_FAMILY, cIndex, &canonical);
+    if (!canonical) {
+      return;
+    }
+
+    nsAutoCString keyName;
+    keyName = ToCharPtr(canonical);
+    ToLowerCase(keyName);
+
+    aLastFamilyName = canonical;
+    aFamilyName = ToCharPtr(canonical);
+
+    // Same canonical family name as the last one? Definitely no need to add a
+    // new family record.
+    auto* faceList =
+        faces
+            .LookupOrInsertWith(
+                keyName,
+                [&] {
+                  FontVisibility visibility =
+                      aAppFont ? FontVisibility::Base
+                               : GetVisibilityForFamily(keyName);
+                  families.AppendElement(fontlist::Family::InitData(
+                      keyName, aFamilyName, fontlist::Family::kNoIndex,
+                      visibility,
+                      /*bundled*/ aAppFont, /*badUnderline*/ false));
+                  return MakeUnique<FacesData>();
+                })
+            .get();
+
+    char* s = (char*)FcNameUnparse(aPattern);
+    nsAutoCString descriptor(s);
+    free(s);
+
+    if (fcCharsetParseBug) {
+      // Escape any leading space in charset to work around FcNameParse bug.
+      int32_t index = descriptor.Find(":charset= ");
+      if (index != kNotFound) {
+        // insert backslash after the =, before the space
+        descriptor.Insert('\\', index + 9);
+      }
+    }
+
+    WeightRange weight(FontWeight::NORMAL);
+    StretchRange stretch(FontStretch::NORMAL);
+    SlantStyleRange style(FontSlantStyle::NORMAL);
+    uint16_t size;
+    GetFontProperties(aPattern, &weight, &stretch, &style, &size);
+
+    auto initData = fontlist::Face::InitData{descriptor, 0,       size, false,
+                                             weight,     stretch, style};
+
+    // Add entries for any other localized family names. (Most fonts only have
+    // a single family name, so the first call to GetString will usually fail).
+    FcChar8* otherName;
+    int n = (cIndex == 0 ? 1 : 0);
+    while (FcPatternGetString(aPattern, FC_FAMILY, n, &otherName) ==
+           FcResultMatch) {
+      nsAutoCString otherFamilyName(ToCharPtr(otherName));
+      keyName = otherFamilyName;
+      ToLowerCase(keyName);
+
+      faces
+          .LookupOrInsertWith(
+              keyName,
+              [&] {
+                FontVisibility visibility =
+                    aAppFont ? FontVisibility::Base
+                             : GetVisibilityForFamily(keyName);
+                families.AppendElement(fontlist::Family::InitData(
+                    keyName, otherFamilyName, fontlist::Family::kNoIndex,
+                    visibility,
+                    /*bundled*/ aAppFont, /*badUnderline*/ false));
+
+                return MakeUnique<FacesData>();
+              })
+          .get()
+          ->Add(fontlist::Face::InitData(initData), /* singleName = */ false);
+
+      n++;
+      if (n == int(cIndex)) {
+        n++;  // skip over canonical name
+      }
+    }
+
+    const bool singleName = n == 1;
+    faceList->Add(std::move(initData), singleName);
+
+    // map the psname, fullname ==> font family for local font lookups
+    nsAutoCString psname, fullname;
+    GetFaceNames(aPattern, aFamilyName, psname, fullname);
+    if (!psname.IsEmpty()) {
+      ToLowerCase(psname);
+      mLocalNameTable.InsertOrUpdate(
+          psname, fontlist::LocalFaceRec::InitData(keyName, descriptor));
+    }
+    if (!fullname.IsEmpty()) {
+      ToLowerCase(fullname);
+      if (fullname != psname) {
+        mLocalNameTable.WithEntryHandle(fullname, [&](auto&& entry) {
+          if (entry && !singleName) {
+            // We only override an existing entry if this is the only way to
+            // name this family. This prevents dubious aliases from clobbering
+            // the local name table.
+            return;
+          }
+          entry.InsertOrUpdate(
+              fontlist::LocalFaceRec::InitData(keyName, descriptor));
+        });
+      }
+    }
+  };
+
+  auto addFontSetFamilies = [&addPattern](FcFontSet* aFontSet,
+                                          SandboxPolicy* aPolicy,
+                                          bool aAppFonts) -> void {
+    FcChar8* lastFamilyName = (FcChar8*)"";
+    RefPtr<gfxFontconfigFontFamily> fontFamily;
+    nsAutoCString familyName;
+    for (int f = 0; f < aFontSet->nfont; f++) {
+      FcPattern* pattern = aFontSet->fonts[f];
+
+      // Skip any fonts that aren't readable for us (e.g. due to restrictive
+      // file ownership/permissions).
+      FcChar8* path;
+      if (FcPatternGetString(pattern, FC_FILE, 0, &path) != FcResultMatch) {
+        continue;
+      }
+      if (access(reinterpret_cast<const char*>(path), F_OK | R_OK) != 0) {
+        continue;
+      }
+
+#if defined(MOZ_CONTENT_SANDBOX) && defined(XP_LINUX)
+      // Skip any fonts that will be blocked by the content-process sandbox
+      // policy.
+      if (aPolicy && !(aPolicy->Lookup(reinterpret_cast<const char*>(path)) &
+                       SandboxBroker::Perms::MAY_READ)) {
+        continue;
+      }
+#endif
+
+      // If this is a TrueType or OpenType font, discard the FC_CHARSET object
+      // (which may be very large), because we'll read the 'cmap' directly.
+      // This substantially reduces the pressure on shared memory (bug 1664151)
+      // due to the large font descriptors (serialized patterns).
+      FcChar8* fontFormat;
+      if (FcPatternGetString(pattern, FC_FONTFORMAT, 0, &fontFormat) ==
+              FcResultMatch &&
+          (!FcStrCmp(fontFormat, (const FcChar8*)"TrueType") ||
+           !FcStrCmp(fontFormat, (const FcChar8*)"CFF"))) {
+        FcPattern* clone = FcPatternDuplicate(pattern);
+        FcPatternDel(clone, FC_CHARSET);
+        addPattern(clone, lastFamilyName, familyName, aAppFonts);
+        FcPatternDestroy(clone);
+      } else {
+        addPattern(pattern, lastFamilyName, familyName, aAppFonts);
+      }
+    }
+  };
+
+  // iterate over available fonts
+  FcFontSet* systemFonts = FcConfigGetFonts(nullptr, FcSetSystem);
+  addFontSetFamilies(systemFonts, policy.get(), /* aAppFonts = */ false);
+
+#ifdef MOZ_BUNDLED_FONTS
+  if (StaticPrefs::gfx_bundled_fonts_activate_AtStartup() != 0) {
+    FcFontSet* appFonts = FcConfigGetFonts(nullptr, FcSetApplication);
+    addFontSetFamilies(appFonts, policy.get(), /* aAppFonts = */ true);
+  }
+#endif
+
+  mozilla::fontlist::FontList* list = SharedFontList();
+  list->SetFamilyNames(families);
+
+  for (uint32_t i = 0; i < families.Length(); i++) {
+    list->Families()[i].AddFaces(list, faces.Get(families[i].mKey)->Get());
+  }
+}
+
+gfxFcPlatformFontList::DistroID gfxFcPlatformFontList::GetDistroID() const {
+  // Helper called to initialize sResult the first time this is used.
+  auto getDistroID = []() {
+    DistroID result = DistroID::Unknown;
+    FILE* fp = fopen("/etc/os-release", "r");
+    if (fp) {
+      char buf[512];
+      while (fgets(buf, sizeof(buf), fp)) {
+        if (strncmp(buf, "ID=", 3) == 0) {
+          if (strncmp(buf + 3, "ubuntu", 6) == 0) {
+            result = DistroID::Ubuntu;
+          } else if (strncmp(buf + 3, "fedora", 6) == 0) {
+            result = DistroID::Fedora;
+          }
+          break;
+        }
+      }
+      fclose(fp);
+    }
+    return result;
+  };
+  static DistroID sResult = getDistroID();
+  return sResult;
+}
+
+FontVisibility gfxFcPlatformFontList::GetVisibilityForFamily(
+    const nsACString& aName) const {
+  switch (GetDistroID()) {
+    case DistroID::Ubuntu:
+      if (FamilyInList(aName, kBaseFonts_Ubuntu_20_04)) {
+        return FontVisibility::Base;
+      }
+      if (FamilyInList(aName, kLangFonts_Ubuntu_20_04)) {
+        return FontVisibility::LangPack;
+      }
+      return FontVisibility::User;
+    case DistroID::Fedora:
+      if (FamilyInList(aName, kBaseFonts_Fedora_32)) {
+        return FontVisibility::Base;
+      }
+      return FontVisibility::User;
+    default:
+      // We don't know how to categorize fonts on this system
+      return FontVisibility::Unknown;
+  }
+}
+
+gfxFontEntry* gfxFcPlatformFontList::CreateFontEntry(
+    fontlist::Face* aFace, const fontlist::Family* aFamily) {
+  nsAutoCString desc(aFace->mDescriptor.AsString(SharedFontList()));
+  FcPattern* pattern = FcNameParse((const FcChar8*)desc.get());
+  auto* fe = new gfxFontconfigFontEntry(desc, pattern, true);
+  FcPatternDestroy(pattern);
+  fe->InitializeFrom(aFace, aFamily);
+  return fe;
+}
+
+// For displaying the fontlist in UI, use explicit call to FcFontList. Using
+// FcFontList results in the list containing the localized names as dictated
+// by system defaults.
+static void GetSystemFontList(nsTArray<nsString>& aListOfFonts,
+                              nsAtom* aLangGroup) {
+  aListOfFonts.Clear();
+
+  RefPtr<FcPattern> pat = dont_AddRef(FcPatternCreate());
+  if (!pat) {
+    return;
+  }
+
+  UniquePtr<FcObjectSet> os(FcObjectSetBuild(FC_FAMILY, nullptr));
+  if (!os) {
+    return;
+  }
+
+  // add the lang to the pattern
+  nsAutoCString fcLang;
+  gfxFcPlatformFontList* pfl = gfxFcPlatformFontList::PlatformFontList();
+  pfl->GetSampleLangForGroup(aLangGroup, fcLang,
+                             /*aForFontEnumerationThread*/ true);
+  if (!fcLang.IsEmpty()) {
+    FcPatternAddString(pat, FC_LANG, ToFcChar8Ptr(fcLang.get()));
+  }
+
+  UniquePtr<FcFontSet> fs(FcFontList(nullptr, pat, os.get()));
+  if (!fs) {
+    return;
+  }
+
+  for (int i = 0; i < fs->nfont; i++) {
+    char* family;
+
+    if (FcPatternGetString(fs->fonts[i], FC_FAMILY, 0, (FcChar8**)&family) !=
+        FcResultMatch) {
+      continue;
+    }
+
+    // Remove duplicates...
+    nsAutoString strFamily;
+    AppendUTF8toUTF16(MakeStringSpan(family), strFamily);
+    if (aListOfFonts.Contains(strFamily)) {
+      continue;
+    }
+
+    aListOfFonts.AppendElement(strFamily);
+  }
+
+  aListOfFonts.Sort();
+}
+
+void gfxFcPlatformFontList::GetFontList(nsAtom* aLangGroup,
+                                        const nsACString& aGenericFamily,
+                                        nsTArray<nsString>& aListOfFonts) {
+  // Get the list of font family names using fontconfig
+  GetSystemFontList(aListOfFonts, aLangGroup);
+
+  // Under Linux, the generics "serif", "sans-serif" and "monospace"
+  // are included in the pref fontlist. These map to whatever fontconfig
+  // decides they should be for a given language, rather than one of the
+  // fonts listed in the prefs font lists (e.g. font.name.*, font.name-list.*)
+  bool serif = false, sansSerif = false, monospace = false;
+  if (aGenericFamily.IsEmpty())
+    serif = sansSerif = monospace = true;
+  else if (aGenericFamily.LowerCaseEqualsLiteral("serif"))
+    serif = true;
+  else if (aGenericFamily.LowerCaseEqualsLiteral("sans-serif"))
+    sansSerif = true;
+  else if (aGenericFamily.LowerCaseEqualsLiteral("monospace"))
+    monospace = true;
+  else if (aGenericFamily.LowerCaseEqualsLiteral("cursive") ||
+           aGenericFamily.LowerCaseEqualsLiteral("fantasy"))
+    serif = sansSerif = true;
+  else
+    MOZ_ASSERT_UNREACHABLE("unexpected CSS generic font family");
+
+  // The first in the list becomes the default in
+  // FontBuilder.readFontSelection() if the preference-selected font is not
+  // available, so put system configured defaults first.
+  if (monospace) aListOfFonts.InsertElementAt(0, u"monospace"_ns);
+  if (sansSerif) aListOfFonts.InsertElementAt(0, u"sans-serif"_ns);
+  if (serif) aListOfFonts.InsertElementAt(0, u"serif"_ns);
+}
+
+FontFamily gfxFcPlatformFontList::GetDefaultFontForPlatform(
+    nsPresContext* aPresContext, const gfxFontStyle* aStyle,
+    nsAtom* aLanguage) {
+  // Get the default font by using a fake name to retrieve the first
+  // scalable font that fontconfig suggests for the given language.
+  PrefFontList* prefFonts =
+      FindGenericFamilies(aPresContext, "-moz-default"_ns,
+                          aLanguage ? aLanguage : nsGkAtoms::x_western);
+  NS_ASSERTION(prefFonts, "null list of generic fonts");
+  if (prefFonts && !prefFonts->IsEmpty()) {
+    return (*prefFonts)[0];
+  }
+  return FontFamily();
+}
+
+gfxFontEntry* gfxFcPlatformFontList::LookupLocalFont(
+    nsPresContext* aPresContext, const nsACString& aFontName,
+    WeightRange aWeightForEntry, StretchRange aStretchForEntry,
+    SlantStyleRange aStyleForEntry) {
+  AutoLock lock(mLock);
+
+  nsAutoCString keyName(aFontName);
+  ToLowerCase(keyName);
+
+  if (SharedFontList()) {
+    return LookupInSharedFaceNameList(aPresContext, aFontName, aWeightForEntry,
+                                      aStretchForEntry, aStyleForEntry);
+  }
+
+  // if name is not in the global list, done
+  const auto fontPattern = mLocalNames.Lookup(keyName);
+  if (!fontPattern) {
+    return nullptr;
+  }
+
+  return new gfxFontconfigFontEntry(aFontName, *fontPattern, aWeightForEntry,
+                                    aStretchForEntry, aStyleForEntry);
+}
+
+gfxFontEntry* gfxFcPlatformFontList::MakePlatformFont(
+    const nsACString& aFontName, WeightRange aWeightForEntry,
+    StretchRange aStretchForEntry, SlantStyleRange aStyleForEntry,
+    const uint8_t* aFontData, uint32_t aLength) {
+  RefPtr<FTUserFontData> ufd = new FTUserFontData(aFontData, aLength);
+  RefPtr<SharedFTFace> face = ufd->CloneFace();
+  if (!face) {
+    return nullptr;
+  }
+  return new gfxFontconfigFontEntry(aFontName, aWeightForEntry,
+                                    aStretchForEntry, aStyleForEntry,
+                                    std::move(face));
+}
+
+static bool UseCustomFontconfigLookupsForLocale(const Locale& aLocale) {
+  return aLocale.Script().EqualTo("Hans") || aLocale.Script().EqualTo("Hant") ||
+         aLocale.Script().EqualTo("Jpan") || aLocale.Script().EqualTo("Kore") ||
+         aLocale.Script().EqualTo("Arab");
+}
+
+bool gfxFcPlatformFontList::FindAndAddFamiliesLocked(
+    nsPresContext* aPresContext, StyleGenericFontFamily aGeneric,
+    const nsACString& aFamily, nsTArray<FamilyAndGeneric>* aOutput,
+    FindFamiliesFlags aFlags, gfxFontStyle* aStyle, nsAtom* aLanguage,
+    gfxFloat aDevToCssSize) {
+  nsAutoCString familyName(aFamily);
+  ToLowerCase(familyName);
+
+  if (!(aFlags & FindFamiliesFlags::eQuotedFamilyName)) {
+    // deprecated generic names are explicitly converted to standard generics
+    bool isDeprecatedGeneric = false;
+    if (familyName.EqualsLiteral("sans") ||
+        familyName.EqualsLiteral("sans serif")) {
+      familyName.AssignLiteral("sans-serif");
+      isDeprecatedGeneric = true;
+    } else if (familyName.EqualsLiteral("mono")) {
+      familyName.AssignLiteral("monospace");
+      isDeprecatedGeneric = true;
+    }
+
+    // fontconfig generics? use fontconfig to determine the family for lang
+    if (isDeprecatedGeneric ||
+        mozilla::StyleSingleFontFamily::Parse(familyName).IsGeneric()) {
+      PrefFontList* prefFonts =
+          FindGenericFamilies(aPresContext, familyName, aLanguage);
+      if (prefFonts && !prefFonts->IsEmpty()) {
+        aOutput->AppendElements(*prefFonts);
+        return true;
+      }
+      return false;
+    }
+  }
+
+  // fontconfig allows conditional substitutions in such a way that it's
+  // difficult to distinguish an explicit substitution from other suggested
+  // choices. To sniff out explicit substitutions, compare the substitutions
+  // for "font, -moz-sentinel" to "-moz-sentinel" to sniff out the
+  // substitutions
+  //
+  // Example:
+  //
+  //   serif ==> DejaVu Serif, ...
+  //   Helvetica, serif ==> Helvetica, TeX Gyre Heros, Nimbus Sans L, DejaVu
+  //   Serif
+  //
+  // In this case fontconfig is including Tex Gyre Heros and
+  // Nimbus Sans L as alternatives for Helvetica.
+
+  // Because the FcConfigSubstitute call is quite expensive, we cache the
+  // actual font families found via this process.
+  nsAutoCString cacheKey;
+
+  // For languages that use CJK or Arabic script, we include the language as
+  // part of the cache key because fontconfig may have lang-specific rules that
+  // specify different substitutions. (In theory, this could apply to *any*
+  // language, but it's highly unlikely to matter for non-CJK/Arabic scripts,
+  // and it gets really expensive to do separate lookups for 300+ distinct lang
+  // tags e.g. on wikipedia.org, when they all end up mapping to the same font
+  // list.)
+  // We remember the most recently checked aLanguage atom so that when the same
+  // language is used in many successive calls, we can avoid repeating the
+  // locale code processing every time.
+  if (aLanguage != mPrevLanguage) {
+    GetSampleLangForGroup(aLanguage, mSampleLang);
+    ToLowerCase(mSampleLang);
+    Locale locale;
+    mUseCustomLookups = LocaleParser::TryParse(mSampleLang, locale).isOk() &&
+                        locale.AddLikelySubtags().isOk() &&
+                        UseCustomFontconfigLookupsForLocale(locale);
+    mPrevLanguage = aLanguage;
+  }
+  if (mUseCustomLookups) {
+    cacheKey = mSampleLang;
+    cacheKey.Append(':');
+  }
+
+  cacheKey.Append(familyName);
+  if (const auto& cached = mFcSubstituteCache.Lookup(cacheKey)) {
+    if (cached->IsEmpty()) {
+      return false;
+    }
+    aOutput->AppendElements(*cached);
+    return true;
+  }
+
+  // It wasn't in the cache, so we need to ask fontconfig...
+  const FcChar8* kSentinelName = ToFcChar8Ptr("-moz-sentinel");
+  const FcChar8* terminator = nullptr;
+  RefPtr<FcPattern> sentinelSubst = dont_AddRef(FcPatternCreate());
+  FcPatternAddString(sentinelSubst, FC_FAMILY, kSentinelName);
+  if (!mSampleLang.IsEmpty()) {
+    FcPatternAddString(sentinelSubst, FC_LANG, ToFcChar8Ptr(mSampleLang.get()));
+  }
+  FcConfigSubstitute(nullptr, sentinelSubst, FcMatchPattern);
+
+  // If the sentinel name is still present, we'll use that as the terminator
+  // for the family names we collect; this means that if fontconfig prepends
+  // additional family names (e.g. an emoji font, or lang-specific preferred
+  // font) to all patterns, it won't simply mask all actual requested names.
+  // If the sentinel has been deleted/replaced altogether, then we'll take
+  // the first substitute name as the new terminator.
+  FcChar8* substName;
+  for (int i = 0; FcPatternGetString(sentinelSubst, FC_FAMILY, i, &substName) ==
+                  FcResultMatch;
+       i++) {
+    if (FcStrCmp(substName, kSentinelName) == 0) {
+      terminator = kSentinelName;
+      break;
+    }
+    if (!terminator) {
+      terminator = substName;
+    }
+  }
+
+  // substitutions for font, -moz-sentinel pattern
+  RefPtr<FcPattern> fontWithSentinel = dont_AddRef(FcPatternCreate());
+  FcPatternAddString(fontWithSentinel, FC_FAMILY,
+                     ToFcChar8Ptr(familyName.get()));
+  FcPatternAddString(fontWithSentinel, FC_FAMILY, kSentinelName);
+  if (!mSampleLang.IsEmpty()) {
+    FcPatternAddString(sentinelSubst, FC_LANG, ToFcChar8Ptr(mSampleLang.get()));
+  }
+  FcConfigSubstitute(nullptr, fontWithSentinel, FcMatchPattern);
+
+  // Add all font family matches until reaching the terminator.
+  AutoTArray<FamilyAndGeneric, 10> cachedFamilies;
+  for (int i = 0; FcPatternGetString(fontWithSentinel, FC_FAMILY, i,
+                                     &substName) == FcResultMatch;
+       i++) {
+    if (terminator && FcStrCmp(substName, terminator) == 0) {
+      break;
+    }
+    gfxPlatformFontList::FindAndAddFamiliesLocked(
+        aPresContext, aGeneric, nsDependentCString(ToCharPtr(substName)),
+        &cachedFamilies, aFlags, aStyle, aLanguage);
+  }
+
+  const auto& insertedCachedFamilies =
+      mFcSubstituteCache.InsertOrUpdate(cacheKey, std::move(cachedFamilies));
+
+  if (insertedCachedFamilies.IsEmpty()) {
+    return false;
+  }
+  aOutput->AppendElements(insertedCachedFamilies);
+  return true;
+}
+
+bool gfxFcPlatformFontList::GetStandardFamilyName(const nsCString& aFontName,
+                                                  nsACString& aFamilyName) {
+  aFamilyName.Truncate();
+
+  // The fontconfig list of fonts includes generic family names in the
+  // font list. For these, just use the generic name.
+  if (aFontName.EqualsLiteral("serif") ||
+      aFontName.EqualsLiteral("sans-serif") ||
+      aFontName.EqualsLiteral("monospace")) {
+    aFamilyName.Assign(aFontName);
+    return true;
+  }
+
+  RefPtr<FcPattern> pat = dont_AddRef(FcPatternCreate());
+  if (!pat) {
+    return true;
+  }
+
+  UniquePtr<FcObjectSet> os(FcObjectSetBuild(FC_FAMILY, nullptr));
+  if (!os) {
+    return true;
+  }
+
+  // add the family name to the pattern
+  FcPatternAddString(pat, FC_FAMILY, ToFcChar8Ptr(aFontName.get()));
+
+  UniquePtr<FcFontSet> givenFS(FcFontList(nullptr, pat, os.get()));
+  if (!givenFS) {
+    return true;
+  }
+
+  // See if there is a font face with first family equal to the given family
+  // (needs to be in sync with names coming from GetFontList())
+  nsTArray<nsCString> candidates;
+  for (int i = 0; i < givenFS->nfont; i++) {
+    char* firstFamily;
+
+    if (FcPatternGetString(givenFS->fonts[i], FC_FAMILY, 0,
+                           (FcChar8**)&firstFamily) != FcResultMatch) {
+      continue;
+    }
+
+    nsDependentCString first(firstFamily);
+    if (!candidates.Contains(first)) {
+      candidates.AppendElement(first);
+
+      if (aFontName.Equals(first)) {
+        aFamilyName.Assign(aFontName);
+        return true;
+      }
+    }
+  }
+
+  // Because fontconfig conflates different family name types, need to
+  // double check that the candidate name is not simply a different
+  // name type. For example, if a font with nameID=16 "Minion Pro" and
+  // nameID=21 "Minion Pro Caption" exists, calling FcFontList with
+  // family="Minion Pro" will return a set of patterns some of which
+  // will have a first family of "Minion Pro Caption". Ignore these
+  // patterns and use the first candidate that maps to a font set with
+  // the same number of faces and an identical set of patterns.
+  for (uint32_t j = 0; j < candidates.Length(); ++j) {
+    FcPatternDel(pat, FC_FAMILY);
+    FcPatternAddString(pat, FC_FAMILY, (FcChar8*)candidates[j].get());
+
+    UniquePtr<FcFontSet> candidateFS(FcFontList(nullptr, pat, os.get()));
+    if (!candidateFS) {
+      return true;
+    }
+
+    if (candidateFS->nfont != givenFS->nfont) {
+      continue;
+    }
+
+    bool equal = true;
+    for (int i = 0; i < givenFS->nfont; ++i) {
+      if (!FcPatternEqual(candidateFS->fonts[i], givenFS->fonts[i])) {
+        equal = false;
+        break;
+      }
+    }
+    if (equal) {
+      aFamilyName = candidates[j];
+      return true;
+    }
+  }
+
+  // didn't find localized name, leave family name blank
+  return true;
+}
+
+void gfxFcPlatformFontList::AddGenericFonts(
+    nsPresContext* aPresContext, StyleGenericFontFamily aGenericType,
+    nsAtom* aLanguage, nsTArray<FamilyAndGeneric>& aFamilyList) {
+  const char* generic = GetGenericName(aGenericType);
+  NS_ASSERTION(generic, "weird generic font type");
+  if (!generic) {
+    return;
+  }
+
+  // By default, most font prefs on Linux map to "use fontconfig"
+  // keywords. So only need to explicitly lookup font pref if
+  // non-default settings exist, or if we are the system-ui font, which we deal
+  // with in the base class.
+  const bool isSystemUi = aGenericType == StyleGenericFontFamily::SystemUi;
+  bool usePrefFontList = isSystemUi;
+
+  nsAutoCString genericToLookup(generic);
+  if ((!mAlwaysUseFontconfigGenerics && aLanguage) ||
+      aLanguage == nsGkAtoms::x_math) {
+    nsAtom* langGroup = GetLangGroup(aLanguage);
+    nsAutoCString fontlistValue;
+    mFontPrefs->LookupName(PrefName(generic, langGroup), fontlistValue);
+    if (fontlistValue.IsEmpty()) {
+      // The font name list may have two or more family names as comma
+      // separated list.  In such case, not matching with generic font
+      // name is fine because if the list prefers specific font, we
+      // should try to use the pref with complicated path.
+      mFontPrefs->LookupNameList(PrefName(generic, langGroup), fontlistValue);
+    }
+    if (!fontlistValue.IsEmpty()) {
+      if (!fontlistValue.EqualsLiteral("serif") &&
+          !fontlistValue.EqualsLiteral("sans-serif") &&
+          !fontlistValue.EqualsLiteral("monospace")) {
+        usePrefFontList = true;
+      } else {
+        // serif, sans-serif or monospace was specified
+        genericToLookup = fontlistValue;
+      }
+    }
+  }
+
+  // when pref fonts exist, use standard pref font lookup
+  if (usePrefFontList) {
+    gfxPlatformFontList::AddGenericFonts(aPresContext, aGenericType, aLanguage,
+                                         aFamilyList);
+    if (!isSystemUi) {
+      return;
+    }
+  }
+
+  AutoLock lock(mLock);
+  PrefFontList* prefFonts =
+      FindGenericFamilies(aPresContext, genericToLookup, aLanguage);
+  NS_ASSERTION(prefFonts, "null generic font list");
+  aFamilyList.SetCapacity(aFamilyList.Length() + prefFonts->Length());
+  for (auto& f : *prefFonts) {
+    aFamilyList.AppendElement(FamilyAndGeneric(f, aGenericType));
+  }
+}
+
+void gfxFcPlatformFontList::ClearLangGroupPrefFontsLocked() {
+  ClearGenericMappingsLocked();
+  gfxPlatformFontList::ClearLangGroupPrefFontsLocked();
+  mAlwaysUseFontconfigGenerics = PrefFontListsUseOnlyGenerics();
+}
+
+gfxPlatformFontList::PrefFontList* gfxFcPlatformFontList::FindGenericFamilies(
+    nsPresContext* aPresContext, const nsCString& aGeneric, nsAtom* aLanguage) {
+  // set up name
+  nsAutoCString fcLang;
+  GetSampleLangForGroup(aLanguage, fcLang);
+  ToLowerCase(fcLang);
+
+  nsAutoCString cacheKey(aGeneric);
+  if (fcLang.Length() > 0) {
+    cacheKey.Append('-');
+    // If the script is CJK or Arabic, we cache by lang so that different fonts
+    // various locales can be supported; but otherwise, we cache by script
+    // subtag, to avoid a proliferation of entries for Western & similar
+    // languages.
+    // In theory, this means we could fail to respect custom fontconfig rules
+    // for individual (non-CJK/Arab) languages that share the same script, but
+    // such setups are probably vanishingly rare.
+    Locale locale;
+    if (LocaleParser::TryParse(fcLang, locale).isOk() &&
+        locale.AddLikelySubtags().isOk()) {
+      if (UseCustomFontconfigLookupsForLocale(locale)) {
+        cacheKey.Append(fcLang);
+      } else {
+        cacheKey.Append(locale.Script().Span());
+      }
+    } else {
+      cacheKey.Append(fcLang);
+    }
+  }
+
+  // try to get the family from the cache
+  return mGenericMappings.WithEntryHandle(
+      cacheKey, [&](auto&& entry) -> PrefFontList* {
+        if (!entry) {
+          // if not found, ask fontconfig to pick the appropriate font
+          RefPtr<FcPattern> genericPattern = dont_AddRef(FcPatternCreate());
+          FcPatternAddString(genericPattern, FC_FAMILY,
+                             ToFcChar8Ptr(aGeneric.get()));
+
+          // -- prefer scalable fonts
+          FcPatternAddBool(genericPattern, FC_SCALABLE, FcTrue);
+
+          // -- add the lang to the pattern
+          if (!fcLang.IsEmpty()) {
+            FcPatternAddString(genericPattern, FC_LANG,
+                               ToFcChar8Ptr(fcLang.get()));
+          }
+
+          // -- perform substitutions
+          FcConfigSubstitute(nullptr, genericPattern, FcMatchPattern);
+          FcDefaultSubstitute(genericPattern);
+
+          // -- sort to get the closest matches
+          FcResult result;
+          UniquePtr<FcFontSet> faces(
+              FcFontSort(nullptr, genericPattern, FcFalse, nullptr, &result));
+
+          if (!faces) {
+            return nullptr;
+          }
+
+          // -- select the fonts to be used for the generic
+          auto prefFonts = MakeUnique<PrefFontList>();  // can be empty but in
+                                                        // practice won't happen
+          uint32_t limit = StaticPrefs::
+              gfx_font_rendering_fontconfig_max_generic_substitutions();
+          bool foundFontWithLang = false;
+          for (int i = 0; i < faces->nfont; i++) {
+            FcPattern* font = faces->fonts[i];
+            FcChar8* mappedGeneric = nullptr;
+
+            FcPatternGetString(font, FC_FAMILY, 0, &mappedGeneric);
+            if (mappedGeneric) {
+              mLock.AssertCurrentThreadIn();
+              nsAutoCString mappedGenericName(ToCharPtr(mappedGeneric));
+              AutoTArray<FamilyAndGeneric, 1> genericFamilies;
+              if (gfxPlatformFontList::FindAndAddFamiliesLocked(
+                      aPresContext, StyleGenericFontFamily::None,
+                      mappedGenericName, &genericFamilies,
+                      FindFamiliesFlags(0))) {
+                MOZ_ASSERT(genericFamilies.Length() == 1,
+                           "expected a single family");
+                if (!prefFonts->Contains(genericFamilies[0].mFamily)) {
+                  prefFonts->AppendElement(genericFamilies[0].mFamily);
+                  bool foundLang =
+                      !fcLang.IsEmpty() &&
+                      PatternHasLang(font, ToFcChar8Ptr(fcLang.get()));
+                  foundFontWithLang = foundFontWithLang || foundLang;
+                  // check to see if the list is full
+                  if (prefFonts->Length() >= limit) {
+                    break;
+                  }
+                }
+              }
+            }
+          }
+
+          // if no font in the list matches the lang, trim all but the first one
+          if (!prefFonts->IsEmpty() && !foundFontWithLang) {
+            prefFonts->TruncateLength(1);
+          }
+
+          entry.Insert(std::move(prefFonts));
+        }
+        return entry->get();
+      });
+}
+
+bool gfxFcPlatformFontList::PrefFontListsUseOnlyGenerics() {
+  for (auto iter = mFontPrefs->NameIter(); !iter.Done(); iter.Next()) {
+    // Check whether all font.name prefs map to generic keywords
+    // and that the pref name and keyword match.
+    //   Ex: font.name.serif.ar ==> "serif" (ok)
+    //   Ex: font.name.serif.ar ==> "monospace" (return false)
+    //   Ex: font.name.serif.ar ==> "DejaVu Serif" (return false)
+    //   Ex: font.name.serif.ar ==> "" and
+    //       font.name-list.serif.ar ==> "serif" (ok)
+    //   Ex: font.name.serif.ar ==> "" and
+    //       font.name-list.serif.ar ==> "Something, serif"
+    //                                           (return false)
+    const nsACString* prefValue = &iter.Data();
+    nsAutoCString listValue;
+    if (iter.Data().IsEmpty()) {
+      // The font name list may have two or more family names as comma
+      // separated list.  In such case, not matching with generic font
+      // name is fine because if the list prefers specific font, this
+      // should return false.
+      mFontPrefs->LookupNameList(iter.Key(), listValue);
+      prefValue = &listValue;
+    }
+
+    nsCCharSeparatedTokenizer tokenizer(iter.Key(), '.');
+    const nsDependentCSubstring& generic = tokenizer.nextToken();
+    const nsDependentCSubstring& langGroup = tokenizer.nextToken();
+
+    if (!langGroup.EqualsLiteral("x-math") && !generic.Equals(*prefValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/* static */
+void gfxFcPlatformFontList::CheckFontUpdates(nsITimer* aTimer, void* aThis) {
+  // A content process is not supposed to check this directly;
+  // it will be notified by the parent when the font list changes.
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  // check for font updates
+  FcInitBringUptoDate();
+
+  // update fontlist if current config changed
+  gfxFcPlatformFontList* pfl = static_cast<gfxFcPlatformFontList*>(aThis);
+  FcConfig* current = FcConfigGetCurrent();
+  if (current != pfl->GetLastConfig()) {
+    pfl->UpdateFontList();
+
+    gfxPlatform::ForceGlobalReflow(gfxPlatform::NeedsReframe::Yes);
+    mozilla::dom::ContentParent::NotifyUpdatedFonts(true);
+  }
+}
+
+gfxFontFamily* gfxFcPlatformFontList::CreateFontFamily(
+    const nsACString& aName, FontVisibility aVisibility) const {
+  return new gfxFontconfigFontFamily(aName, aVisibility);
+}
+
+// mapping of moz lang groups ==> default lang
+struct MozLangGroupData {
+  nsAtom* const& mozLangGroup;
+  const char* defaultLang;
+};
+
+const MozLangGroupData MozLangGroups[] = {
+    {nsGkAtoms::x_western, "en"},    {nsGkAtoms::x_cyrillic, "ru"},
+    {nsGkAtoms::x_devanagari, "hi"}, {nsGkAtoms::x_tamil, "ta"},
+    {nsGkAtoms::x_armn, "hy"},       {nsGkAtoms::x_beng, "bn"},
+    {nsGkAtoms::x_cans, "iu"},       {nsGkAtoms::x_ethi, "am"},
+    {nsGkAtoms::x_geor, "ka"},       {nsGkAtoms::x_gujr, "gu"},
+    {nsGkAtoms::x_guru, "pa"},       {nsGkAtoms::x_khmr, "km"},
+    {nsGkAtoms::x_knda, "kn"},       {nsGkAtoms::x_mlym, "ml"},
+    {nsGkAtoms::x_orya, "or"},       {nsGkAtoms::x_sinh, "si"},
+    {nsGkAtoms::x_tamil, "ta"},      {nsGkAtoms::x_telu, "te"},
+    {nsGkAtoms::x_tibt, "bo"},       {nsGkAtoms::Unicode, 0}};
+
+bool gfxFcPlatformFontList::TryLangForGroup(const nsACString& aOSLang,
+                                            nsAtom* aLangGroup,
+                                            nsACString& aFcLang,
+                                            bool aForFontEnumerationThread) {
+  // Truncate at '.' or '@' from aOSLang, and convert '_' to '-'.
+  // aOSLang is in the form "language[_territory][.codeset][@modifier]".
+  // fontconfig takes languages in the form "language-territory".
+  // nsLanguageAtomService takes languages in the form language-subtag,
+  // where subtag may be a territory.  fontconfig and nsLanguageAtomService
+  // handle case-conversion for us.
+  const char *pos, *end;
+  aOSLang.BeginReading(pos);
+  aOSLang.EndReading(end);
+  aFcLang.Truncate();
+  while (pos < end) {
+    switch (*pos) {
+      case '.':
+      case '@':
+        end = pos;
+        break;
+      case '_':
+        aFcLang.Append('-');
+        break;
+      default:
+        aFcLang.Append(*pos);
+    }
+    ++pos;
+  }
+
+  if (!aForFontEnumerationThread) {
+    nsAtom* atom = mLangService->LookupLanguage(aFcLang);
+    return atom == aLangGroup;
+  }
+
+  // If we were called by the font enumeration thread, we can't use
+  // mLangService->LookupLanguage because it is not thread-safe.
+  // Use GetUncachedLanguageGroup to avoid unsafe access to the lang-group
+  // mapping cache hashtable.
+  nsAutoCString lowered(aFcLang);
+  ToLowerCase(lowered);
+  RefPtr<nsAtom> lang = NS_Atomize(lowered);
+  RefPtr<nsAtom> group = mLangService->GetUncachedLanguageGroup(lang);
+  return group.get() == aLangGroup;
+}
+
+void gfxFcPlatformFontList::GetSampleLangForGroup(
+    nsAtom* aLanguage, nsACString& aLangStr, bool aForFontEnumerationThread) {
+  aLangStr.Truncate();
+  if (!aLanguage) {
+    return;
+  }
+
+  // set up lang string
+  const MozLangGroupData* mozLangGroup = nullptr;
+
+  // -- look it up in the list of moz lang groups
+  for (unsigned int i = 0; i < ArrayLength(MozLangGroups); ++i) {
+    if (aLanguage == MozLangGroups[i].mozLangGroup) {
+      mozLangGroup = &MozLangGroups[i];
+      break;
+    }
+  }
+
+  // -- not a mozilla lang group? Just return the BCP47 string
+  //    representation of the lang group
+  if (!mozLangGroup) {
+    // Not a special mozilla language group.
+    // Use aLanguage as a language code.
+    aLanguage->ToUTF8String(aLangStr);
+    return;
+  }
+
+  // -- check the environment for the user's preferred language that
+  //    corresponds to this mozilla lang group.
+  const char* languages = getenv("LANGUAGE");
+  if (languages) {
+    const char separator = ':';
+
+    for (const char* pos = languages; true; ++pos) {
+      if (*pos == '\0' || *pos == separator) {
+        if (languages < pos &&
+            TryLangForGroup(Substring(languages, pos), aLanguage, aLangStr,
+                            aForFontEnumerationThread)) {
+          return;
+        }
+
+        if (*pos == '\0') {
+          break;
+        }
+
+        languages = pos + 1;
+      }
+    }
+  }
+  const char* ctype = setlocale(LC_CTYPE, nullptr);
+  if (ctype && TryLangForGroup(nsDependentCString(ctype), aLanguage, aLangStr,
+                               aForFontEnumerationThread)) {
+    return;
+  }
+
+  if (mozLangGroup->defaultLang) {
+    aLangStr.Assign(mozLangGroup->defaultLang);
+  } else {
+    aLangStr.Truncate();
+  }
+}
+
+#ifdef MOZ_BUNDLED_FONTS
+void gfxFcPlatformFontList::ActivateBundledFonts() {
+  if (!mBundledFontsInitialized) {
+    mBundledFontsInitialized = true;
+    nsCOMPtr<nsIFile> localDir;
+    nsresult rv = NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(localDir));
+    if (NS_FAILED(rv)) {
+      return;
+    }
+    if (NS_FAILED(localDir->Append(u"fonts"_ns))) {
+      return;
+    }
+    bool isDir;
+    if (NS_FAILED(localDir->IsDirectory(&isDir)) || !isDir) {
+      return;
+    }
+    if (NS_FAILED(localDir->GetNativePath(mBundledFontsPath))) {
+      return;
+    }
+  }
+  if (!mBundledFontsPath.IsEmpty()) {
+    FcConfigAppFontAddDir(nullptr, ToFcChar8Ptr(mBundledFontsPath.get()));
+  }
+}
+#endif
+
+#ifdef MOZ_WIDGET_GTK
+/***************************************************************************
+ *
+ * These functions must be last in the file because it uses the system cairo
+ * library.  Above this point the cairo library used is the tree cairo.
+ */
+
+// Tree cairo symbols have different names.  Disable their activation through
+// preprocessor macros.
+#  undef cairo_ft_font_options_substitute
+
+#  undef cairo_font_options_create
+#  undef cairo_font_options_destroy
+#  undef cairo_font_options_copy
+#  undef cairo_font_options_equal
+
+#  undef cairo_font_options_get_antialias
+#  undef cairo_font_options_set_antialias
+#  undef cairo_font_options_get_hint_style
+#  undef cairo_font_options_set_hint_style
+#  undef cairo_font_options_get_lcd_filter
+#  undef cairo_font_options_set_lcd_filter
+#  undef cairo_font_options_get_subpixel_order
+#  undef cairo_font_options_set_subpixel_order
+
+// The system cairo functions are not declared because the include paths cause
+// the gdk headers to pick up the tree cairo.h.
+extern "C" {
+NS_VISIBILITY_DEFAULT void cairo_ft_font_options_substitute(
+    const cairo_font_options_t* options, FcPattern* pattern);
+
+NS_VISIBILITY_DEFAULT cairo_font_options_t* cairo_font_options_copy(
+    const cairo_font_options_t*);
+NS_VISIBILITY_DEFAULT cairo_font_options_t* cairo_font_options_create();
+NS_VISIBILITY_DEFAULT void cairo_font_options_destroy(cairo_font_options_t*);
+NS_VISIBILITY_DEFAULT cairo_bool_t cairo_font_options_equal(
+    const cairo_font_options_t*, const cairo_font_options_t*);
+
+NS_VISIBILITY_DEFAULT cairo_antialias_t
+cairo_font_options_get_antialias(const cairo_font_options_t*);
+NS_VISIBILITY_DEFAULT void cairo_font_options_set_antialias(
+    cairo_font_options_t*, cairo_antialias_t);
+NS_VISIBILITY_DEFAULT cairo_hint_style_t
+cairo_font_options_get_hint_style(const cairo_font_options_t*);
+NS_VISIBILITY_DEFAULT void cairo_font_options_set_hint_style(
+    cairo_font_options_t*, cairo_hint_style_t);
+NS_VISIBILITY_DEFAULT cairo_subpixel_order_t
+cairo_font_options_get_subpixel_order(const cairo_font_options_t*);
+NS_VISIBILITY_DEFAULT void cairo_font_options_set_subpixel_order(
+    cairo_font_options_t*, cairo_subpixel_order_t);
+}
+
+void gfxFcPlatformFontList::ClearSystemFontOptions() {
+  if (mSystemFontOptions) {
+    cairo_font_options_destroy(mSystemFontOptions);
+    mSystemFontOptions = nullptr;
+  }
+}
+
+bool gfxFcPlatformFontList::UpdateSystemFontOptions() {
+  MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
+
+  if (gfxPlatform::IsHeadless()) {
+    return false;
+  }
+
+#  ifdef MOZ_X11
+  {
+    // This one shouldn't change during the X session.
+    int lcdfilter;
+    GdkDisplay* dpy = gdk_display_get_default();
+    if (mozilla::widget::GdkIsX11Display(dpy) &&
+        GetXftInt(GDK_DISPLAY_XDISPLAY(dpy), "lcdfilter", &lcdfilter)) {
+      mFreetypeLcdSetting = lcdfilter;
+    }
+  }
+#  endif  // MOZ_X11
+
+  const cairo_font_options_t* options =
+      gdk_screen_get_font_options(gdk_screen_get_default());
+  if (!options) {
+    bool changed = !!mSystemFontOptions;
+    ClearSystemFontOptions();
+    return changed;
+  }
+
+  cairo_font_options_t* newOptions = cairo_font_options_copy(options);
+
+  if (mSystemFontOptions &&
+      cairo_font_options_equal(mSystemFontOptions, options)) {
+    cairo_font_options_destroy(newOptions);
+    return false;
+  }
+
+  ClearSystemFontOptions();
+  mSystemFontOptions = newOptions;
+  return true;
+}
+
+void gfxFcPlatformFontList::SystemFontOptionsToIpc(
+    dom::SystemFontOptions& aOptions) {
+  aOptions.antialias() =
+      mSystemFontOptions ? cairo_font_options_get_antialias(mSystemFontOptions)
+                         : CAIRO_ANTIALIAS_DEFAULT;
+  aOptions.subpixelOrder() =
+      mSystemFontOptions
+          ? cairo_font_options_get_subpixel_order(mSystemFontOptions)
+          : CAIRO_SUBPIXEL_ORDER_DEFAULT;
+  aOptions.hintStyle() =
+      mSystemFontOptions ? cairo_font_options_get_hint_style(mSystemFontOptions)
+                         : CAIRO_HINT_STYLE_DEFAULT;
+  aOptions.lcdFilter() = mFreetypeLcdSetting;
+}
+
+void gfxFcPlatformFontList::UpdateSystemFontOptionsFromIpc(
+    const dom::SystemFontOptions& aOptions) {
+  ClearSystemFontOptions();
+  mSystemFontOptions = cairo_font_options_create();
+  cairo_font_options_set_antialias(mSystemFontOptions,
+                                   cairo_antialias_t(aOptions.antialias()));
+  cairo_font_options_set_hint_style(mSystemFontOptions,
+                                    cairo_hint_style_t(aOptions.hintStyle()));
+  cairo_font_options_set_subpixel_order(
+      mSystemFontOptions, cairo_subpixel_order_t(aOptions.subpixelOrder()));
+  mFreetypeLcdSetting = aOptions.lcdFilter();
+}
+
+void gfxFcPlatformFontList::SubstituteSystemFontOptions(FcPattern* aPattern) {
+  if (mSystemFontOptions) {
+    cairo_ft_font_options_substitute(mSystemFontOptions, aPattern);
+  }
+
+  if (mFreetypeLcdSetting != -1) {
+    FcValue value;
+    if (FcPatternGet(aPattern, FC_LCD_FILTER, 0, &value) == FcResultNoMatch) {
+      FcPatternAddInteger(aPattern, FC_LCD_FILTER, mFreetypeLcdSetting);
+    }
+  }
+}
+
+#endif  // MOZ_WIDGET_GTK