Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 2242 insertions, 0 deletions

diff --git a/gfx/thebes/gfxMacPlatformFontList.mm b/gfx/thebes/gfxMacPlatformFontList.mm
new file mode 100644
index 0000000000..b95c6fa1d1
--- /dev/null
+++ b/gfx/thebes/gfxMacPlatformFontList.mm
@@ -0,0 +1,2242 @@
+/* -*- Mode: ObjC; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: BSD
+ *
+ * Copyright (C) 2006-2009 Mozilla Corporation.  All rights reserved.
+ *
+ * Contributor(s):
+ *   Vladimir Vukicevic <vladimir@pobox.com>
+ *   Masayuki Nakano <masayuki@d-toybox.com>
+ *   John Daggett <jdaggett@mozilla.com>
+ *   Jonathan Kew <jfkthame@gmail.com>
+ *
+ * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include "mozilla/Logging.h"
+
+#include <algorithm>
+
+#import <AppKit/AppKit.h>
+
+#include "gfxFontConstants.h"
+#include "gfxPlatformMac.h"
+#include "gfxMacPlatformFontList.h"
+#include "gfxMacFont.h"
+#include "gfxUserFontSet.h"
+#include "SharedFontList-impl.h"
+
+#include "harfbuzz/hb.h"
+
+#include "AppleUtils.h"
+#include "MainThreadUtils.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsCharTraits.h"
+#include "nsCocoaFeatures.h"
+#include "nsCocoaUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsTArray.h"
+
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/FontPropertyTypes.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/gfx/2D.h"
+
+#include <unistd.h>
+#include <time.h>
+#include <dlfcn.h>
+
+#include "StandardFonts-macos.inc"
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+// Building with newer macOS SDKs can cause a bunch of font-family names to be hidden
+// from the Core Text API we use to enumerate available fonts. Because some content still
+// benefits from having these names recognized, we forcibly include them in the list.
+// Some day we might want to drop support for these.
+#define USE_DEPRECATED_FONT_FAMILY_NAMES 1
+
+#if USE_DEPRECATED_FONT_FAMILY_NAMES
+// List generated by diffing the arrays returned by CTFontManagerCopyAvailableFontFamilyNames()
+// when built with MACOSX_DEPLOYMENT_TARGET=10.12 vs 11.0, to identify the font family names
+// that Core Text is treating as "deprecated" and hiding from the app on newer systems.
+constexpr nsLiteralCString kDeprecatedFontFamilies[] = {
+    // Dot-prefixed font families are supposed to be hidden from the user-visible
+    // font list anyhow, so we don't need to add them here.
+    //  ".Al Bayan PUA"_ns,
+    //  ".Al Nile PUA"_ns,
+    //  ".Al Tarikh PUA"_ns,
+    //  ".Apple Color Emoji UI"_ns,
+    //  ".Apple SD Gothic NeoI"_ns,
+    //  ".Aqua Kana"_ns,
+    //  ".Arial Hebrew Desk Interface"_ns,
+    //  ".Baghdad PUA"_ns,
+    //  ".Beirut PUA"_ns,
+    //  ".Damascus PUA"_ns,
+    //  ".DecoType Naskh PUA"_ns,
+    //  ".Diwan Kufi PUA"_ns,
+    //  ".Farah PUA"_ns,
+    //  ".Geeza Pro Interface"_ns,
+    //  ".Geeza Pro PUA"_ns,
+    //  ".Helvetica LT MM"_ns,
+    //  ".Hiragino Kaku Gothic Interface"_ns,
+    //  ".Hiragino Sans GB Interface"_ns,
+    //  ".Keyboard"_ns,
+    //  ".KufiStandardGK PUA"_ns,
+    //  ".LastResort"_ns,
+    //  ".Lucida Grande UI"_ns,
+    //  ".Muna PUA"_ns,
+    //  ".Nadeem PUA"_ns,
+    //  ".New York"_ns,
+    //  ".Noto Nastaliq Urdu UI"_ns,
+    //  ".PingFang HK"_ns,
+    //  ".PingFang SC"_ns,
+    //  ".PingFang TC"_ns,
+    //  ".Sana PUA"_ns,
+    //  ".Savoye LET CC."_ns,
+    //  ".SF Arabic"_ns,
+    //  ".SF Compact Rounded"_ns,
+    //  ".SF Compact"_ns,
+    //  ".SF NS Mono"_ns,
+    //  ".SF NS Rounded"_ns,
+    //  ".SF NS"_ns,
+    //  ".Times LT MM"_ns,
+    "Hiragino Kaku Gothic Pro"_ns,
+    "Hiragino Kaku Gothic ProN"_ns,
+    "Hiragino Kaku Gothic Std"_ns,
+    "Hiragino Kaku Gothic StdN"_ns,
+    "Hiragino Maru Gothic Pro"_ns,
+    "Hiragino Mincho Pro"_ns,
+    "Iowan Old Style"_ns,
+    "Noto Sans Adlam"_ns,
+    "Noto Sans Armenian"_ns,
+    "Noto Sans Avestan"_ns,
+    "Noto Sans Bamum"_ns,
+    "Noto Sans Bassa Vah"_ns,
+    "Noto Sans Batak"_ns,
+    "Noto Sans Bhaiksuki"_ns,
+    "Noto Sans Brahmi"_ns,
+    "Noto Sans Buginese"_ns,
+    "Noto Sans Buhid"_ns,
+    "Noto Sans Carian"_ns,
+    "Noto Sans Caucasian Albanian"_ns,
+    "Noto Sans Chakma"_ns,
+    "Noto Sans Cham"_ns,
+    "Noto Sans Coptic"_ns,
+    "Noto Sans Cuneiform"_ns,
+    "Noto Sans Cypriot"_ns,
+    "Noto Sans Duployan"_ns,
+    "Noto Sans Egyptian Hieroglyphs"_ns,
+    "Noto Sans Elbasan"_ns,
+    "Noto Sans Glagolitic"_ns,
+    "Noto Sans Gothic"_ns,
+    "Noto Sans Gunjala Gondi"_ns,
+    "Noto Sans Hanifi Rohingya"_ns,
+    "Noto Sans Hanunoo"_ns,
+    "Noto Sans Hatran"_ns,
+    "Noto Sans Imperial Aramaic"_ns,
+    "Noto Sans Inscriptional Pahlavi"_ns,
+    "Noto Sans Inscriptional Parthian"_ns,
+    "Noto Sans Javanese"_ns,
+    "Noto Sans Kaithi"_ns,
+    "Noto Sans Kayah Li"_ns,
+    "Noto Sans Kharoshthi"_ns,
+    "Noto Sans Khojki"_ns,
+    "Noto Sans Khudawadi"_ns,
+    "Noto Sans Lepcha"_ns,
+    "Noto Sans Limbu"_ns,
+    "Noto Sans Linear A"_ns,
+    "Noto Sans Linear B"_ns,
+    "Noto Sans Lisu"_ns,
+    "Noto Sans Lycian"_ns,
+    "Noto Sans Lydian"_ns,
+    "Noto Sans Mahajani"_ns,
+    "Noto Sans Mandaic"_ns,
+    "Noto Sans Manichaean"_ns,
+    "Noto Sans Marchen"_ns,
+    "Noto Sans Masaram Gondi"_ns,
+    "Noto Sans Meetei Mayek"_ns,
+    "Noto Sans Mende Kikakui"_ns,
+    "Noto Sans Meroitic"_ns,
+    "Noto Sans Miao"_ns,
+    "Noto Sans Modi"_ns,
+    "Noto Sans Mongolian"_ns,
+    "Noto Sans Mro"_ns,
+    "Noto Sans Multani"_ns,
+    "Noto Sans Nabataean"_ns,
+    "Noto Sans New Tai Lue"_ns,
+    "Noto Sans Newa"_ns,
+    "Noto Sans NKo"_ns,
+    "Noto Sans Ol Chiki"_ns,
+    "Noto Sans Old Hungarian"_ns,
+    "Noto Sans Old Italic"_ns,
+    "Noto Sans Old North Arabian"_ns,
+    "Noto Sans Old Permic"_ns,
+    "Noto Sans Old Persian"_ns,
+    "Noto Sans Old South Arabian"_ns,
+    "Noto Sans Old Turkic"_ns,
+    "Noto Sans Osage"_ns,
+    "Noto Sans Osmanya"_ns,
+    "Noto Sans Pahawh Hmong"_ns,
+    "Noto Sans Palmyrene"_ns,
+    "Noto Sans Pau Cin Hau"_ns,
+    "Noto Sans PhagsPa"_ns,
+    "Noto Sans Phoenician"_ns,
+    "Noto Sans Psalter Pahlavi"_ns,
+    "Noto Sans Rejang"_ns,
+    "Noto Sans Samaritan"_ns,
+    "Noto Sans Saurashtra"_ns,
+    "Noto Sans Sharada"_ns,
+    "Noto Sans Siddham"_ns,
+    "Noto Sans Sora Sompeng"_ns,
+    "Noto Sans Sundanese"_ns,
+    "Noto Sans Syloti Nagri"_ns,
+    "Noto Sans Syriac"_ns,
+    "Noto Sans Tagalog"_ns,
+    "Noto Sans Tagbanwa"_ns,
+    "Noto Sans Tai Le"_ns,
+    "Noto Sans Tai Tham"_ns,
+    "Noto Sans Tai Viet"_ns,
+    "Noto Sans Takri"_ns,
+    "Noto Sans Thaana"_ns,
+    "Noto Sans Tifinagh"_ns,
+    "Noto Sans Tirhuta"_ns,
+    "Noto Sans Ugaritic"_ns,
+    "Noto Sans Vai"_ns,
+    "Noto Sans Wancho"_ns,
+    "Noto Sans Warang Citi"_ns,
+    "Noto Sans Yi"_ns,
+    "Noto Sans Zawgyi"_ns,
+    "Noto Serif Ahom"_ns,
+    "Noto Serif Balinese"_ns,
+    "Noto Serif Yezidi"_ns,
+    "Athelas"_ns,
+    "Courier"_ns,
+    "Marion"_ns,
+    "Seravek"_ns,
+    "Superclarendon"_ns,
+    "Times"_ns,
+};
+#endif  // USE_DEPRECATED_FONT_FAMILY_NAMES
+
+// indexes into the NSArray objects that the Cocoa font manager returns
+// as the available members of a family
+#define INDEX_FONT_POSTSCRIPT_NAME 0
+#define INDEX_FONT_FACE_NAME 1
+#define INDEX_FONT_WEIGHT 2
+#define INDEX_FONT_TRAITS 3
+
+static const int kAppleMaxWeight = 14;
+static const int kAppleExtraLightWeight = 3;
+static const int kAppleUltraLightWeight = 2;
+
+static const int gAppleWeightToCSSWeight[] = {
+    0,
+    1,  // 1.
+    1,  // 2.  W1, ultralight
+    2,  // 3.  W2, extralight
+    3,  // 4.  W3, light
+    4,  // 5.  W4, semilight
+    5,  // 6.  W5, medium
+    6,  // 7.
+    6,  // 8.  W6, semibold
+    7,  // 9.  W7, bold
+    8,  // 10. W8, extrabold
+    8,  // 11.
+    9,  // 12. W9, ultrabold
+    9,  // 13
+    9   // 14
+};
+
+// cache Cocoa's "shared font manager" for performance
+static NSFontManager* sFontManager;
+
+static void GetStringForNSString(const NSString* aSrc, nsAString& aDest) {
+  aDest.SetLength([aSrc length]);
+  [aSrc getCharacters:reinterpret_cast<unichar*>(aDest.BeginWriting())
+                range:NSMakeRange(0, [aSrc length])];
+}
+
+static NSString* GetNSStringForString(const nsAString& aSrc) {
+  return [NSString stringWithCharacters:reinterpret_cast<const unichar*>(aSrc.BeginReading())
+                                 length:aSrc.Length()];
+}
+
+#define LOG_FONTLIST(args) \
+  MOZ_LOG(gfxPlatform::GetLog(eGfxLog_fontlist), mozilla::LogLevel::Debug, args)
+#define LOG_FONTLIST_ENABLED() \
+  MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_fontlist), mozilla::LogLevel::Debug)
+#define LOG_CMAPDATA_ENABLED() \
+  MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_cmapdata), mozilla::LogLevel::Debug)
+
+#pragma mark -
+
+// Complex scripts will not render correctly unless appropriate AAT or OT
+// layout tables are present.
+// For OpenType, we also check that the GSUB table supports the relevant
+// script tag, to avoid using things like Arial Unicode MS for Lao (it has
+// the characters, but lacks OpenType support).
+
+// TODO: consider whether we should move this to gfxFontEntry and do similar
+// cmap-masking on other platforms to avoid using fonts that won't shape
+// properly.
+
+nsresult MacOSFontEntry::ReadCMAP(FontInfoData* aFontInfoData) {
+  // attempt this once, if errors occur leave a blank cmap
+  if (mCharacterMap || mShmemCharacterMap) {
+    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);
+
+  if (NS_SUCCEEDED(rv) && !mIsDataUserFont && !HasGraphiteTables()) {
+    // For downloadable fonts, trust the author and don't
+    // try to munge the cmap based on script shaping support.
+
+    // We also assume a Graphite font knows what it's doing,
+    // and provides whatever shaping is needed for the
+    // characters it supports, so only check/clear the
+    // complex-script ranges for non-Graphite fonts
+
+    // for layout support, check for the presence of mort/morx/kerx and/or
+    // opentype layout tables
+    bool hasAATLayout = HasFontTable(TRUETYPE_TAG('m', 'o', 'r', 'x')) ||
+                        HasFontTable(TRUETYPE_TAG('m', 'o', 'r', 't'));
+    bool hasAppleKerning = HasFontTable(TRUETYPE_TAG('k', 'e', 'r', 'x'));
+    bool hasGSUB = HasFontTable(TRUETYPE_TAG('G', 'S', 'U', 'B'));
+    bool hasGPOS = HasFontTable(TRUETYPE_TAG('G', 'P', 'O', 'S'));
+    if ((hasAATLayout && !(hasGSUB || hasGPOS)) || hasAppleKerning) {
+      mRequiresAAT = true;  // prefer CoreText if font has no OTL tables,
+                            // or if it uses the Apple-specific 'kerx'
+                            // variant of kerning table
+    }
+
+    for (const ScriptRange* sr = gfxPlatformFontList::sComplexScriptRanges; sr->rangeStart; sr++) {
+      // check to see if the cmap includes complex script codepoints
+      if (charmap->TestRange(sr->rangeStart, sr->rangeEnd)) {
+        if (hasAATLayout) {
+          // prefer CoreText for Apple's complex-script fonts,
+          // even if they also have some OpenType tables
+          // (e.g. Geeza Pro Bold on 10.6; see bug 614903)
+          mRequiresAAT = true;
+          // and don't mask off complex-script ranges, we assume
+          // the AAT tables will provide the necessary shaping
+          continue;
+        }
+
+        // We check for GSUB here, as GPOS alone would not be ok.
+        if (hasGSUB && SupportsScriptInGSUB(sr->tags, sr->numTags)) {
+          continue;
+        }
+
+        charmap->ClearRange(sr->rangeStart, sr->rangeEnd);
+      }
+    }
+
+    // Bug 1360309, 1393624: several of Apple's Chinese fonts have spurious
+    // blank glyphs for obscure Tibetan and Arabic-script codepoints.
+    // Blocklist these so that font fallback will not use them.
+    if (mRequiresAAT &&
+        (FamilyName().EqualsLiteral("Songti SC") || FamilyName().EqualsLiteral("Songti TC") ||
+         FamilyName().EqualsLiteral("STSong") ||
+         // Bug 1390980: on 10.11, the Kaiti fonts are also affected.
+         FamilyName().EqualsLiteral("Kaiti SC") || FamilyName().EqualsLiteral("Kaiti TC") ||
+         FamilyName().EqualsLiteral("STKaiti"))) {
+      charmap->ClearRange(0x0f6b, 0x0f70);
+      charmap->ClearRange(0x0f8c, 0x0f8f);
+      charmap->clear(0x0f98);
+      charmap->clear(0x0fbd);
+      charmap->ClearRange(0x0fcd, 0x0fff);
+      charmap->clear(0x0620);
+      charmap->clear(0x065f);
+      charmap->ClearRange(0x06ee, 0x06ef);
+      charmap->clear(0x06ff);
+    }
+  }
+
+  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) {
+    // Temporarily retain charmap, until the shared version is
+    // ready for use.
+    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;
+}
+
+gfxFont* MacOSFontEntry::CreateFontInstance(const gfxFontStyle* aFontStyle) {
+  RefPtr<UnscaledFontMac> unscaledFont(mUnscaledFont);
+  if (!unscaledFont) {
+    CGFontRef baseFont = GetFontRef();
+    if (!baseFont) {
+      return nullptr;
+    }
+    unscaledFont = new UnscaledFontMac(baseFont, mIsDataUserFont);
+    mUnscaledFont = unscaledFont;
+  }
+
+  return new gfxMacFont(unscaledFont, this, aFontStyle);
+}
+
+bool MacOSFontEntry::HasVariations() {
+  if (!mHasVariationsInitialized) {
+    mHasVariationsInitialized = true;
+    mHasVariations =
+        gfxPlatform::HasVariationFontSupport() && HasFontTable(TRUETYPE_TAG('f', 'v', 'a', 'r'));
+  }
+
+  return mHasVariations;
+}
+
+void MacOSFontEntry::GetVariationAxes(nsTArray<gfxFontVariationAxis>& aVariationAxes) {
+  // We could do this by creating a CTFont and calling CTFontCopyVariationAxes,
+  // but it is expensive to instantiate a CTFont for every face just to set up
+  // the axis information.
+  // Instead we use gfxFontUtils to read the font tables directly.
+  gfxFontUtils::GetVariationData(this, &aVariationAxes, nullptr);
+}
+
+void MacOSFontEntry::GetVariationInstances(nsTArray<gfxFontVariationInstance>& aInstances) {
+  // Core Text doesn't offer API for this, so we use gfxFontUtils to read the
+  // font tables directly.
+  gfxFontUtils::GetVariationData(this, nullptr, &aInstances);
+}
+
+bool MacOSFontEntry::IsCFF() {
+  if (!mIsCFFInitialized) {
+    mIsCFFInitialized = true;
+    mIsCFF = HasFontTable(TRUETYPE_TAG('C', 'F', 'F', ' '));
+  }
+
+  return mIsCFF;
+}
+
+MacOSFontEntry::MacOSFontEntry(const nsACString& aPostscriptName, WeightRange aWeight,
+                               bool aIsStandardFace, double aSizeHint)
+    : gfxFontEntry(aPostscriptName, aIsStandardFace),
+      mFontRef(NULL),
+      mSizeHint(aSizeHint),
+      mFontRefInitialized(false),
+      mRequiresAAT(false),
+      mIsCFF(false),
+      mIsCFFInitialized(false),
+      mHasVariations(false),
+      mHasVariationsInitialized(false),
+      mHasAATSmallCaps(false),
+      mHasAATSmallCapsInitialized(false) {
+  mWeightRange = aWeight;
+  mOpszAxis.mTag = 0;
+}
+
+MacOSFontEntry::MacOSFontEntry(const nsACString& aPostscriptName, CGFontRef aFontRef,
+                               WeightRange aWeight, StretchRange aStretch, SlantStyleRange aStyle,
+                               bool aIsDataUserFont, bool aIsLocalUserFont)
+    : gfxFontEntry(aPostscriptName, false),
+      mFontRef(NULL),
+      mSizeHint(0.0),
+      mFontRefInitialized(false),
+      mRequiresAAT(false),
+      mIsCFF(false),
+      mIsCFFInitialized(false),
+      mHasVariations(false),
+      mHasVariationsInitialized(false),
+      mHasAATSmallCaps(false),
+      mHasAATSmallCapsInitialized(false) {
+  mFontRef = aFontRef;
+  mFontRefInitialized = true;
+  ::CFRetain(mFontRef);
+
+  mWeightRange = aWeight;
+  mStretchRange = aStretch;
+  mFixedPitch = false;  // xxx - do we need this for downloaded fonts?
+  mStyleRange = aStyle;
+  mOpszAxis.mTag = 0;
+
+  NS_ASSERTION(!(aIsDataUserFont && aIsLocalUserFont),
+               "userfont is either a data font or a local font");
+  mIsDataUserFont = aIsDataUserFont;
+  mIsLocalUserFont = aIsLocalUserFont;
+}
+
+gfxFontEntry* MacOSFontEntry::Clone() const {
+  MOZ_ASSERT(!IsUserFont(), "we can only clone installed fonts!");
+  MacOSFontEntry* fe = new MacOSFontEntry(Name(), Weight(), mStandardFace, mSizeHint);
+  fe->mStyleRange = mStyleRange;
+  fe->mStretchRange = mStretchRange;
+  fe->mFixedPitch = mFixedPitch;
+  return fe;
+}
+
+CGFontRef MacOSFontEntry::GetFontRef() {
+  if (!mFontRefInitialized) {
+    // Cache the CGFontRef, to be released by our destructor.
+    mFontRef = CreateOrCopyFontRef();
+    mFontRefInitialized = true;
+  }
+  // Return a non-retained reference; caller does not need to release.
+  return mFontRef;
+}
+
+CGFontRef MacOSFontEntry::CreateOrCopyFontRef() {
+  if (mFontRef) {
+    // We have a cached CGFont, just add a reference. Caller must
+    // release, but we'll still own our reference.
+    ::CGFontRetain(mFontRef);
+    return mFontRef;
+  }
+
+  CrashReporter::AutoAnnotateCrashReport autoFontName(CrashReporter::Annotation::FontName, mName);
+
+  // Create a new CGFont; caller will own the only reference to it.
+  NSString* psname = GetNSStringForString(NS_ConvertUTF8toUTF16(mName));
+  CGFontRef ref = CGFontCreateWithFontName(CFStringRef(psname));
+  if (!ref) {
+    // This happens on macOS 10.12 for font entry names that start with
+    // .AppleSystemUIFont. For those fonts, we need to go through NSFont
+    // to get the correct CGFontRef.
+    // Both the Text and the Display variant of the display font use
+    // .AppleSystemUIFontSomethingSomething as their member names.
+    // That's why we're carrying along mSizeHint to this place so that
+    // we get the variant that we want for this family.
+    NSFont* font = [NSFont fontWithName:psname size:mSizeHint];
+    if (font) {
+      ref = CTFontCopyGraphicsFont((CTFontRef)font, nullptr);
+    }
+  }
+  return ref;  // Not saved in mFontRef; caller will own the reference
+}
+
+// For a logging build, we wrap the CFDataRef in a FontTableRec so that we can
+// use the MOZ_COUNT_[CD]TOR macros in it. A release build without logging
+// does not get this overhead.
+class FontTableRec {
+ public:
+  explicit FontTableRec(CFDataRef aDataRef) : mDataRef(aDataRef) { MOZ_COUNT_CTOR(FontTableRec); }
+
+  ~FontTableRec() {
+    MOZ_COUNT_DTOR(FontTableRec);
+    ::CFRelease(mDataRef);
+  }
+
+ private:
+  CFDataRef mDataRef;
+};
+
+/*static*/ void MacOSFontEntry::DestroyBlobFunc(void* aUserData) {
+#ifdef NS_BUILD_REFCNT_LOGGING
+  FontTableRec* ftr = static_cast<FontTableRec*>(aUserData);
+  delete ftr;
+#else
+  ::CFRelease((CFDataRef)aUserData);
+#endif
+}
+
+hb_blob_t* MacOSFontEntry::GetFontTable(uint32_t aTag) {
+  AutoCFRelease<CGFontRef> fontRef = CreateOrCopyFontRef();
+  if (!fontRef) {
+    return nullptr;
+  }
+
+  CFDataRef dataRef = ::CGFontCopyTableForTag(fontRef, aTag);
+  if (dataRef) {
+    return hb_blob_create((const char*)::CFDataGetBytePtr(dataRef), ::CFDataGetLength(dataRef),
+                          HB_MEMORY_MODE_READONLY,
+#ifdef NS_BUILD_REFCNT_LOGGING
+                          new FontTableRec(dataRef),
+#else
+                          (void*)dataRef,
+#endif
+                          DestroyBlobFunc);
+  }
+
+  return nullptr;
+}
+
+bool MacOSFontEntry::HasFontTable(uint32_t aTableTag) {
+  if (mAvailableTables.Count() == 0) {
+    nsAutoreleasePool localPool;
+
+    AutoCFRelease<CGFontRef> fontRef = CreateOrCopyFontRef();
+    if (!fontRef) {
+      return false;
+    }
+    AutoCFRelease<CFArrayRef> tags = ::CGFontCopyTableTags(fontRef);
+    if (!tags) {
+      return false;
+    }
+    int numTags = (int)::CFArrayGetCount(tags);
+    for (int t = 0; t < numTags; t++) {
+      uint32_t tag = (uint32_t)(uintptr_t)::CFArrayGetValueAtIndex(tags, t);
+      mAvailableTables.PutEntry(tag);
+    }
+  }
+
+  return mAvailableTables.GetEntry(aTableTag);
+}
+
+static bool CheckForAATSmallCaps(CFArrayRef aFeatures) {
+  // Walk the array of feature descriptors from the font, and see whether
+  // a small-caps feature setting is available.
+  // Just bail out (returning false) if at any point we fail to find the
+  // expected dictionary keys, etc; if the font has bad data, we don't even
+  // try to search the rest of it.
+  auto numFeatures = CFArrayGetCount(aFeatures);
+  for (auto f = 0; f < numFeatures; ++f) {
+    auto featureDict = (CFDictionaryRef)CFArrayGetValueAtIndex(aFeatures, f);
+    if (!featureDict) {
+      return false;
+    }
+    auto featureNum =
+        (CFNumberRef)CFDictionaryGetValue(featureDict, CFSTR("CTFeatureTypeIdentifier"));
+    if (!featureNum) {
+      return false;
+    }
+    int16_t featureType;
+    if (!CFNumberGetValue(featureNum, kCFNumberSInt16Type, &featureType)) {
+      return false;
+    }
+    if (featureType == kLetterCaseType || featureType == kLowerCaseType) {
+      // Which selector to look for, depending whether we've found the
+      // legacy LetterCase feature or the new LowerCase one.
+      const uint16_t smallCaps =
+          (featureType == kLetterCaseType) ? kSmallCapsSelector : kLowerCaseSmallCapsSelector;
+      auto selectors =
+          (CFArrayRef)CFDictionaryGetValue(featureDict, CFSTR("CTFeatureTypeSelectors"));
+      if (!selectors) {
+        return false;
+      }
+      auto numSelectors = CFArrayGetCount(selectors);
+      for (auto s = 0; s < numSelectors; s++) {
+        auto selectorDict = (CFDictionaryRef)CFArrayGetValueAtIndex(selectors, s);
+        if (!selectorDict) {
+          return false;
+        }
+        auto selectorNum =
+            (CFNumberRef)CFDictionaryGetValue(selectorDict, CFSTR("CTFeatureSelectorIdentifier"));
+        if (!selectorNum) {
+          return false;
+        }
+        int16_t selectorValue;
+        if (!CFNumberGetValue(selectorNum, kCFNumberSInt16Type, &selectorValue)) {
+          return false;
+        }
+        if (selectorValue == smallCaps) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+bool MacOSFontEntry::SupportsOpenTypeFeature(Script aScript, uint32_t aFeatureTag) {
+  // If we're going to shape with Core Text, we don't support added
+  // OpenType features (aside from any CT applies by default), except
+  // for 'smcp' which we map to an AAT feature selector.
+  if (RequiresAATLayout()) {
+    if (aFeatureTag != HB_TAG('s', 'm', 'c', 'p')) {
+      return false;
+    }
+    if (mHasAATSmallCapsInitialized) {
+      return mHasAATSmallCaps;
+    }
+    mHasAATSmallCapsInitialized = true;
+    CGFontRef cgFont = GetFontRef();
+    if (!cgFont) {
+      return mHasAATSmallCaps;
+    }
+
+    CrashReporter::AutoAnnotateCrashReport autoFontName(CrashReporter::Annotation::FontName,
+                                                        FamilyName());
+
+    AutoCFRelease<CTFontRef> ctFont = CTFontCreateWithGraphicsFont(cgFont, 0.0, nullptr, nullptr);
+    if (ctFont) {
+      AutoCFRelease<CFArrayRef> features = CTFontCopyFeatures(ctFont);
+      if (features) {
+        mHasAATSmallCaps = CheckForAATSmallCaps(features);
+      }
+    }
+    return mHasAATSmallCaps;
+  }
+  return gfxFontEntry::SupportsOpenTypeFeature(aScript, aFeatureTag);
+}
+
+void MacOSFontEntry::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
+                                            FontListSizes* aSizes) const {
+  aSizes->mFontListSize += aMallocSizeOf(this);
+  AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
+}
+
+/* gfxMacFontFamily */
+#pragma mark -
+
+class gfxMacFontFamily final : public gfxFontFamily {
+ public:
+  gfxMacFontFamily(const nsACString& aName, FontVisibility aVisibility, double aSizeHint = 0.0)
+      : gfxFontFamily(aName, aVisibility), mSizeHint(aSizeHint) {}
+
+  gfxMacFontFamily(const nsACString& aName, NSFont* aSystemFont)
+      : gfxFontFamily(aName, FontVisibility::Unknown), mForSystemFont(aSystemFont) {
+    // I don't think the system font instance is at much risk of being deleted,
+    // but to be on the safe side let's retain a reference until we're finished
+    // using it for lazy initialization.
+    [mForSystemFont retain];
+  }
+
+  virtual ~gfxMacFontFamily() = default;
+
+  void LocalizedName(nsACString& aLocalizedName) override;
+
+  void FindStyleVariationsLocked(FontInfoData* aFontInfoData = nullptr)
+      MOZ_REQUIRES(mLock) override;
+
+ protected:
+  double mSizeHint = 0.0;
+
+  // If non-null, this is a family representing the system UI font, and should use
+  // the given NSFont as the basis for initialization as the normal font-manager APIs
+  // based on family name won't handle it.
+  NSFont* mForSystemFont = nullptr;
+};
+
+void gfxMacFontFamily::LocalizedName(nsACString& aLocalizedName) {
+  nsAutoreleasePool localPool;
+
+  // It's unsafe to call HasOtherFamilyNames off the main thread because
+  // it entrains FindStyleVariations, which calls GetWeightOverride, which
+  // retrieves prefs.  And the pref names can change (via user overrides),
+  // so we can't use StaticPrefs to access them.
+  if (NS_IsMainThread() && !HasOtherFamilyNames()) {
+    aLocalizedName = mName;
+    return;
+  }
+
+  NSString* family = GetNSStringForString(NS_ConvertUTF8toUTF16(mName));
+  NSString* localized = [sFontManager localizedNameForFamily:family face:nil];
+
+  if (localized) {
+    nsAutoString locName;
+    GetStringForNSString(localized, locName);
+    CopyUTF16toUTF8(locName, aLocalizedName);
+    return;
+  }
+
+  // failed to get localized name, just use the canonical one
+  aLocalizedName = mName;
+}
+
+// Return the CSS weight value to use for the given face, overriding what
+// AppKit gives us (used to adjust families with bad weight values, see
+// bug 931426).
+// A return value of 0 indicates no override - use the existing weight.
+static inline int GetWeightOverride(const nsAString& aPSName) {
+  nsAutoCString prefName("font.weight-override.");
+  // The PostScript name is required to be ASCII; if it's not, the font is
+  // broken anyway, so we really don't care that this is lossy.
+  LossyAppendUTF16toASCII(aPSName, prefName);
+  return Preferences::GetInt(prefName.get(), 0);
+}
+
+void gfxMacFontFamily::FindStyleVariationsLocked(FontInfoData* aFontInfoData) {
+  if (mHasStyles) {
+    return;
+  }
+
+  AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING("gfxMacFontFamily::FindStyleVariations", LAYOUT, mName);
+
+  nsAutoreleasePool localPool;
+
+  if (mForSystemFont) {
+    MOZ_ASSERT(gfxPlatform::HasVariationFontSupport());
+
+    auto addToFamily = [&](NSFont* aNSFont) MOZ_REQUIRES(mLock) {
+      NSString* psNameNS = [[aNSFont fontDescriptor] postscriptName];
+      nsAutoString nameUTF16;
+      nsAutoCString psName;
+      nsCocoaUtils::GetStringForNSString(psNameNS, nameUTF16);
+      CopyUTF16toUTF8(nameUTF16, psName);
+
+      auto* fe = new MacOSFontEntry(psName, WeightRange(FontWeight::NORMAL), true, 0.0);
+
+      // Set the appropriate style, assuming it may not have a variation range.
+      fe->mStyleRange = SlantStyleRange(
+          ([[aNSFont fontDescriptor] symbolicTraits] & NSFontItalicTrait) ? FontSlantStyle::ITALIC
+                                                                          : FontSlantStyle::NORMAL);
+
+      // Set up weight (and width, if present) ranges.
+      fe->SetupVariationRanges();
+      AddFontEntryLocked(fe);
+    };
+
+    addToFamily(mForSystemFont);
+
+    // See if there is a corresponding italic face, and add it to the family.
+    NSFont* italicFont = [sFontManager convertFont:mForSystemFont toHaveTrait:NSItalicFontMask];
+    if (italicFont != mForSystemFont) {
+      addToFamily(italicFont);
+    }
+
+    [mForSystemFont release];
+    mForSystemFont = nullptr;
+    SetHasStyles(true);
+
+    return;
+  }
+
+  NSString* family = GetNSStringForString(NS_ConvertUTF8toUTF16(mName));
+
+  // create a font entry for each face
+  NSArray* fontfaces = [sFontManager
+      availableMembersOfFontFamily:family];  // returns an array of [psname, style name, weight,
+                                             // traits] elements, goofy api
+  int faceCount = [fontfaces count];
+  int faceIndex;
+
+  for (faceIndex = 0; faceIndex < faceCount; faceIndex++) {
+    NSArray* face = [fontfaces objectAtIndex:faceIndex];
+    NSString* psname = [face objectAtIndex:INDEX_FONT_POSTSCRIPT_NAME];
+    int32_t appKitWeight = [[face objectAtIndex:INDEX_FONT_WEIGHT] unsignedIntValue];
+    uint32_t macTraits = [[face objectAtIndex:INDEX_FONT_TRAITS] unsignedIntValue];
+    NSString* facename = [face objectAtIndex:INDEX_FONT_FACE_NAME];
+    bool isStandardFace = false;
+
+    if (appKitWeight == kAppleExtraLightWeight) {
+      // if the facename contains UltraLight, set the weight to the ultralight weight value
+      NSRange range = [facename rangeOfString:@"ultralight" options:NSCaseInsensitiveSearch];
+      if (range.location != NSNotFound) {
+        appKitWeight = kAppleUltraLightWeight;
+      }
+    }
+
+    // make a nsString
+    nsAutoString postscriptFontName;
+    GetStringForNSString(psname, postscriptFontName);
+
+    int32_t cssWeight = gfxMacPlatformFontList::AppleWeightToCSSWeight(appKitWeight);
+    // If we are on the startup-time InitFontList thread, we skip this as it
+    // wants to retrieve faces for the default font family, but cannot safely
+    // call the Preferences APIs. Fortunately, the default font doesn't actually
+    // depend on a weight override pref.
+    if (!gfxPlatformFontList::IsInitFontListThread()) {
+      int32_t weightOverride = GetWeightOverride(postscriptFontName);
+      if (weightOverride) {
+        // scale down and clamp, to get a value from 1..9
+        cssWeight = ((weightOverride + 50) / 100);
+        cssWeight = std::max(1, std::min(cssWeight, 9));
+      }
+    }
+    cssWeight *= 100;  // scale up to CSS values
+
+    if ([facename isEqualToString:@"Regular"] || [facename isEqualToString:@"Bold"] ||
+        [facename isEqualToString:@"Italic"] || [facename isEqualToString:@"Oblique"] ||
+        [facename isEqualToString:@"Bold Italic"] || [facename isEqualToString:@"Bold Oblique"]) {
+      isStandardFace = true;
+    }
+
+    // create a font entry
+    MacOSFontEntry* fontEntry =
+        new MacOSFontEntry(NS_ConvertUTF16toUTF8(postscriptFontName),
+                           WeightRange(FontWeight::FromInt(cssWeight)), isStandardFace, mSizeHint);
+    if (!fontEntry) {
+      break;
+    }
+
+    // set additional properties based on the traits reported by Cocoa
+    if (macTraits & (NSCondensedFontMask | NSNarrowFontMask | NSCompressedFontMask)) {
+      fontEntry->mStretchRange = StretchRange(FontStretch::CONDENSED);
+    } else if (macTraits & NSExpandedFontMask) {
+      fontEntry->mStretchRange = StretchRange(FontStretch::EXPANDED);
+    }
+    // Cocoa fails to set the Italic traits bit for HelveticaLightItalic,
+    // at least (see bug 611855), so check for style name endings as well
+    if ((macTraits & NSItalicFontMask) || [facename hasSuffix:@"Italic"] ||
+        [facename hasSuffix:@"Oblique"]) {
+      fontEntry->mStyleRange = SlantStyleRange(FontSlantStyle::ITALIC);
+    }
+    if (macTraits & NSFixedPitchFontMask) {
+      fontEntry->mFixedPitch = true;
+    }
+
+    if (gfxPlatform::HasVariationFontSupport()) {
+      fontEntry->SetupVariationRanges();
+    }
+
+    if (LOG_FONTLIST_ENABLED()) {
+      nsAutoCString weightString;
+      fontEntry->Weight().ToString(weightString);
+      nsAutoCString stretchString;
+      fontEntry->Stretch().ToString(stretchString);
+      LOG_FONTLIST(("(fontlist) added (%s) to family (%s)"
+                    " with style: %s weight: %s stretch: %s"
+                    " (apple-weight: %d macTraits: %8.8x)",
+                    fontEntry->Name().get(), Name().get(),
+                    fontEntry->IsItalic() ? "italic" : "normal", weightString.get(),
+                    stretchString.get(), appKitWeight, macTraits));
+    }
+
+    // insert into font entry array of family
+    AddFontEntryLocked(fontEntry);
+  }
+
+  SortAvailableFonts();
+  SetHasStyles(true);
+
+  if (mIsBadUnderlineFamily) {
+    SetBadUnderlineFonts();
+  }
+
+  CheckForSimpleFamily();
+}
+
+/* gfxSingleFaceMacFontFamily */
+#pragma mark -
+
+class gfxSingleFaceMacFontFamily final : public gfxFontFamily {
+ public:
+  gfxSingleFaceMacFontFamily(const nsACString& aName, FontVisibility aVisibility)
+      : gfxFontFamily(aName, aVisibility) {
+    mFaceNamesInitialized = true;  // omit from face name lists
+  }
+
+  virtual ~gfxSingleFaceMacFontFamily() = default;
+
+  void FindStyleVariationsLocked(FontInfoData* aFontInfoData = nullptr)
+      MOZ_REQUIRES(mLock) override{};
+
+  void LocalizedName(nsACString& aLocalizedName) override;
+
+  void ReadOtherFamilyNames(gfxPlatformFontList* aPlatformFontList) override;
+
+  bool IsSingleFaceFamily() const override { return true; }
+};
+
+void gfxSingleFaceMacFontFamily::LocalizedName(nsACString& aLocalizedName) {
+  nsAutoreleasePool localPool;
+
+  AutoReadLock lock(mLock);
+
+  if (!HasOtherFamilyNames()) {
+    aLocalizedName = mName;
+    return;
+  }
+
+  gfxFontEntry* fe = mAvailableFonts[0];
+  NSFont* font = [NSFont fontWithName:GetNSStringForString(NS_ConvertUTF8toUTF16(fe->Name()))
+                                 size:0.0];
+  if (font) {
+    NSString* localized = [font displayName];
+    if (localized) {
+      nsAutoString locName;
+      GetStringForNSString(localized, locName);
+      CopyUTF16toUTF8(locName, aLocalizedName);
+      return;
+    }
+  }
+
+  // failed to get localized name, just use the canonical one
+  aLocalizedName = mName;
+}
+
+void gfxSingleFaceMacFontFamily::ReadOtherFamilyNames(gfxPlatformFontList* aPlatformFontList) {
+  AutoWriteLock lock(mLock);
+  if (mOtherFamilyNamesInitialized) {
+    return;
+  }
+
+  gfxFontEntry* fe = mAvailableFonts[0];
+  if (!fe) {
+    return;
+  }
+
+  const uint32_t kNAME = TRUETYPE_TAG('n', 'a', 'm', 'e');
+
+  gfxFontEntry::AutoTable nameTable(fe, kNAME);
+  if (!nameTable) {
+    return;
+  }
+
+  mHasOtherFamilyNames = ReadOtherFamilyNamesForFace(aPlatformFontList, nameTable, true);
+
+  mOtherFamilyNamesInitialized = true;
+}
+
+/* gfxMacPlatformFontList */
+#pragma mark -
+
+gfxMacPlatformFontList::gfxMacPlatformFontList()
+    : gfxPlatformFontList(false), mDefaultFont(nullptr), mUseSizeSensitiveSystemFont(false) {
+  CheckFamilyList(kBaseFonts);
+
+#ifdef MOZ_BUNDLED_FONTS
+  // We activate bundled fonts if the pref is > 0 (on) or < 0 (auto), only an
+  // explicit value of 0 (off) will disable them.
+  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
+
+  // cache this in a static variable so that MacOSFontFamily objects
+  // don't have to repeatedly look it up
+  sFontManager = [NSFontManager sharedFontManager];
+
+  // Load the font-list preferences now, so that we don't have to do it from
+  // Init[Shared]FontListForPlatform, which may be called off-main-thread.
+  gfxFontUtils::GetPrefsFontList("font.single-face-list", mSingleFaceFonts);
+  gfxFontUtils::GetPrefsFontList("font.preload-names-list", mPreloadFonts);
+}
+
+gfxMacPlatformFontList::~gfxMacPlatformFontList() {
+  AutoLock lock(mLock);
+
+  if (XRE_IsParentProcess()) {
+    ::CFNotificationCenterRemoveObserver(::CFNotificationCenterGetLocalCenter(), this,
+                                         kCTFontManagerRegisteredFontsChangedNotification, 0);
+  }
+
+  if (mDefaultFont) {
+    ::CFRelease(mDefaultFont);
+  }
+}
+
+void gfxMacPlatformFontList::AddFamily(const nsACString& aFamilyName, FontVisibility aVisibility) {
+  double sizeHint = 0.0;
+  if (aVisibility == FontVisibility::Hidden && mUseSizeSensitiveSystemFont &&
+      mSystemDisplayFontFamilyName.Equals(aFamilyName)) {
+    sizeHint = 128.0;
+  }
+
+  nsAutoCString key;
+  ToLowerCase(aFamilyName, key);
+
+  RefPtr<gfxFontFamily> familyEntry = new gfxMacFontFamily(aFamilyName, aVisibility, sizeHint);
+  mFontFamilies.InsertOrUpdate(key, RefPtr{familyEntry});
+
+  // check the bad underline blocklist
+  if (mBadUnderlineFamilyNames.ContainsSorted(key)) {
+    familyEntry->SetBadUnderlineFamily();
+  }
+}
+
+FontVisibility gfxMacPlatformFontList::GetVisibilityForFamily(const nsACString& aName) const {
+  if (aName[0] == '.' || aName.LowerCaseEqualsLiteral("lastresort")) {
+    return FontVisibility::Hidden;
+  }
+  if (FamilyInList(aName, kBaseFonts)) {
+    return FontVisibility::Base;
+  }
+#ifdef MOZ_BUNDLED_FONTS
+  if (mBundledFamilies.Contains(aName)) {
+    return FontVisibility::Base;
+  }
+#endif
+  return FontVisibility::User;
+}
+
+void gfxMacPlatformFontList::AddFamily(CFStringRef aFamily) {
+  NSString* family = (NSString*)aFamily;
+
+  // CTFontManager includes weird internal family names and
+  // LastResort, skip over those
+  if (!family || [family caseInsensitiveCompare:@"LastResort"] == NSOrderedSame ||
+      [family caseInsensitiveCompare:@".LastResort"] == NSOrderedSame) {
+    return;
+  }
+
+  nsAutoString familyName;
+  nsCocoaUtils::GetStringForNSString(family, familyName);
+
+  NS_ConvertUTF16toUTF8 nameUtf8(familyName);
+  AddFamily(nameUtf8, GetVisibilityForFamily(nameUtf8));
+}
+
+/* static */
+void gfxMacPlatformFontList::ActivateFontsFromDir(const nsACString& aDir,
+                                                  nsTHashSet<nsCStringHashKey>* aLoadedFamilies) {
+  AutoCFRelease<CFURLRef> directory = CFURLCreateFromFileSystemRepresentation(
+      kCFAllocatorDefault, (const UInt8*)nsPromiseFlatCString(aDir).get(), aDir.Length(), true);
+  if (!directory) {
+    return;
+  }
+  AutoCFRelease<CFURLEnumeratorRef> enumerator = CFURLEnumeratorCreateForDirectoryURL(
+      kCFAllocatorDefault, directory, kCFURLEnumeratorDefaultBehavior, nullptr);
+  if (!enumerator) {
+    return;
+  }
+  AutoCFRelease<CFMutableArrayRef> urls =
+      ::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
+  if (!urls) {
+    return;
+  }
+
+  CFURLRef url;
+  CFURLEnumeratorResult result;
+  do {
+    result = CFURLEnumeratorGetNextURL(enumerator, &url, nullptr);
+    if (result != kCFURLEnumeratorSuccess) {
+      continue;
+    }
+    CFArrayAppendValue(urls, url);
+
+    if (!aLoadedFamilies) {
+      continue;
+    }
+    AutoCFRelease<CFArrayRef> descriptors = CTFontManagerCreateFontDescriptorsFromURL(url);
+    if (!descriptors || !CFArrayGetCount(descriptors)) {
+      continue;
+    }
+    CTFontDescriptorRef desc = (CTFontDescriptorRef)CFArrayGetValueAtIndex(descriptors, 0);
+    AutoCFRelease<CFStringRef> name =
+        (CFStringRef)CTFontDescriptorCopyAttribute(desc, kCTFontFamilyNameAttribute);
+    nsAutoCString key;
+    key.SetLength((CFStringGetLength(name) + 1) * 3);
+    if (CFStringGetCString(name, key.BeginWriting(), key.Length(), kCFStringEncodingUTF8)) {
+      key.SetLength(strlen(key.get()));
+      aLoadedFamilies->Insert(key);
+    }
+  } while (result != kCFURLEnumeratorEnd);
+
+  CTFontManagerRegisterFontsForURLs(urls, kCTFontManagerScopeProcess, nullptr);
+}
+
+void gfxMacPlatformFontList::ReadSystemFontList(dom::SystemFontList* aList)
+    MOZ_NO_THREAD_SAFETY_ANALYSIS {
+  // Note: We rely on the records for mSystemTextFontFamilyName and
+  // mSystemDisplayFontFamilyName (if present) being *before* the main
+  // font list, so that those names are known in the content process
+  // by the time we add the actual family records to the font list.
+  aList->entries().AppendElement(FontFamilyListEntry(
+      mSystemTextFontFamilyName, FontVisibility::Unknown, kTextSizeSystemFontFamily));
+  if (mUseSizeSensitiveSystemFont) {
+    aList->entries().AppendElement(FontFamilyListEntry(
+        mSystemDisplayFontFamilyName, FontVisibility::Unknown, kDisplaySizeSystemFontFamily));
+  }
+  // Now collect the list of available families, with visibility attributes.
+  for (auto f = mFontFamilies.Iter(); !f.Done(); f.Next()) {
+    auto macFamily = f.Data().get();
+    if (macFamily->IsSingleFaceFamily()) {
+      continue;  // skip, this will be recreated separately in the child
+    }
+    aList->entries().AppendElement(
+        FontFamilyListEntry(macFamily->Name(), macFamily->Visibility(), kStandardFontFamily));
+  }
+}
+
+void gfxMacPlatformFontList::PreloadNamesList() {
+  uint32_t numFonts = mPreloadFonts.Length();
+  for (uint32_t i = 0; i < numFonts; i++) {
+    nsAutoCString key;
+    GenerateFontListKey(mPreloadFonts[i], key);
+
+    // only search canonical names!
+    gfxFontFamily* familyEntry = mFontFamilies.GetWeak(key);
+    if (familyEntry) {
+      familyEntry->ReadOtherFamilyNames(this);
+    }
+  }
+}
+
+#if USE_DEPRECATED_FONT_FAMILY_NAMES
+static bool DeprecatedFamilyIsAvailable(const nsACString& aName) {
+  NSString* family = GetNSStringForString(NS_ConvertUTF8toUTF16(aName));
+  return [[sFontManager availableMembersOfFontFamily:family] count] > 0;
+}
+#endif
+
+nsresult gfxMacPlatformFontList::InitFontListForPlatform() {
+  nsAutoreleasePool localPool;
+
+  // The font registration thread was created early in startup, to give the
+  // system a head start on activating all the supplemental-language fonts.
+  // Here, we need to wait until it has finished its work.
+  gfxPlatformMac::WaitForFontRegistration();
+
+  Telemetry::AutoTimer<Telemetry::MAC_INITFONTLIST_TOTAL> timer;
+
+  InitSystemFontNames();
+
+  if (XRE_IsParentProcess()) {
+    static bool firstTime = true;
+    if (firstTime) {
+      ::CFNotificationCenterAddObserver(::CFNotificationCenterGetLocalCenter(), this,
+                                        RegisteredFontsChangedNotificationCallback,
+                                        kCTFontManagerRegisteredFontsChangedNotification, 0,
+                                        CFNotificationSuspensionBehaviorDeliverImmediately);
+      firstTime = false;
+    }
+
+    // We're not a content process, so get the available fonts directly
+    // from Core Text.
+    AutoCFRelease<CFArrayRef> familyNames = CTFontManagerCopyAvailableFontFamilyNames();
+    for (NSString* familyName in (NSArray*)(CFArrayRef)familyNames) {
+      AddFamily((CFStringRef)familyName);
+    }
+#if USE_DEPRECATED_FONT_FAMILY_NAMES
+    for (const auto& name : kDeprecatedFontFamilies) {
+      if (DeprecatedFamilyIsAvailable(name)) {
+        AddFamily(name, GetVisibilityForFamily(name));
+      }
+    }
+#endif
+  } else {
+    // Content process: use font list passed from the chrome process via
+    // the GetXPCOMProcessAttributes message, because it's much faster than
+    // querying Core Text again in the child.
+    auto& fontList = dom::ContentChild::GetSingleton()->SystemFontList();
+    for (FontFamilyListEntry& ffe : fontList.entries()) {
+      switch (ffe.entryType()) {
+        case kStandardFontFamily:
+          // On Catalina or later, we pre-initialize system font-family entries
+          // in InitSystemFontNames(), so we can just skip them here.
+          if (nsCocoaFeatures::OnCatalinaOrLater() &&
+              (ffe.familyName() == mSystemTextFontFamilyName ||
+               ffe.familyName() == mSystemDisplayFontFamilyName)) {
+            continue;
+          }
+          AddFamily(ffe.familyName(), ffe.visibility());
+          break;
+        case kTextSizeSystemFontFamily:
+          mSystemTextFontFamilyName = ffe.familyName();
+          break;
+        case kDisplaySizeSystemFontFamily:
+          mSystemDisplayFontFamilyName = ffe.familyName();
+          mUseSizeSensitiveSystemFont = true;
+          break;
+      }
+    }
+    fontList.entries().Clear();
+  }
+
+  InitSingleFaceList();
+
+  // to avoid full search of font name tables, seed the other names table with localized names from
+  // some of the prefs fonts which are accessed via their localized names.  changes in the pref
+  // fonts will only cause a font lookup miss earlier. this is a simple optimization, it's not
+  // required for correctness
+  PreloadNamesList();
+
+  // start the delayed cmap loader
+  GetPrefsAndStartLoader();
+
+  return NS_OK;
+}
+
+void gfxMacPlatformFontList::InitSharedFontListForPlatform() {
+  nsAutoreleasePool localPool;
+
+  gfxPlatformMac::WaitForFontRegistration();
+
+  InitSystemFontNames();
+
+  if (XRE_IsParentProcess()) {
+    // Only the parent process listens for OS font-changed notifications;
+    // after rebuilding its list, it will update the content processes.
+    static bool firstTime = true;
+    if (firstTime) {
+      ::CFNotificationCenterAddObserver(::CFNotificationCenterGetLocalCenter(), this,
+                                        RegisteredFontsChangedNotificationCallback,
+                                        kCTFontManagerRegisteredFontsChangedNotification, 0,
+                                        CFNotificationSuspensionBehaviorDeliverImmediately);
+      firstTime = false;
+    }
+
+    AutoCFRelease<CFArrayRef> familyNames = CTFontManagerCopyAvailableFontFamilyNames();
+    nsTArray<fontlist::Family::InitData> families;
+    families.SetCapacity(CFArrayGetCount(familyNames)
+#if USE_DEPRECATED_FONT_FAMILY_NAMES
+                         + ArrayLength(kDeprecatedFontFamilies)
+#endif
+    );
+    for (NSString* familyName in (NSArray*)(CFArrayRef)familyNames) {
+      nsAutoString name16;
+      GetStringForNSString(familyName, name16);
+      NS_ConvertUTF16toUTF8 name(name16);
+      nsAutoCString key;
+      GenerateFontListKey(name, key);
+      families.AppendElement(fontlist::Family::InitData(key, name, fontlist::Family::kNoIndex,
+                                                        GetVisibilityForFamily(name)));
+    }
+#if USE_DEPRECATED_FONT_FAMILY_NAMES
+    for (const nsACString& name : kDeprecatedFontFamilies) {
+      if (DeprecatedFamilyIsAvailable(name)) {
+        nsAutoCString key;
+        GenerateFontListKey(name, key);
+        families.AppendElement(fontlist::Family::InitData(key, name, fontlist::Family::kNoIndex,
+                                                          GetVisibilityForFamily(name)));
+      }
+    }
+#endif
+    SharedFontList()->SetFamilyNames(families);
+    InitAliasesForSingleFaceList();
+    GetPrefsAndStartLoader();
+  }
+}
+
+void gfxMacPlatformFontList::InitAliasesForSingleFaceList() {
+  for (const auto& familyName : mSingleFaceFonts) {
+    LOG_FONTLIST(("(fontlist-singleface) face name: %s\n", familyName.get()));
+    // Each entry in the "single face families" list is expected to be a
+    // colon-separated pair of FaceName:Family,
+    // where FaceName is the individual face name (psname) of a font
+    // that should be exposed as a separate family name,
+    // and Family is the standard family to which that face belongs.
+    // The only such face listed by default is
+    //    Osaka-Mono:Osaka
+    auto colon = familyName.FindChar(':');
+    if (colon == kNotFound) {
+      continue;
+    }
+
+    // Look for the parent family in the main font family list,
+    // and ensure we have loaded its list of available faces.
+    nsAutoCString key;
+    GenerateFontListKey(Substring(familyName, colon + 1), key);
+    fontlist::Family* family = SharedFontList()->FindFamily(key);
+    if (!family) {
+      // The parent family is not present, so just ignore this entry.
+      continue;
+    }
+    if (!family->IsInitialized()) {
+      if (!gfxPlatformFontList::InitializeFamily(family)) {
+        // This shouldn't ever fail, but if it does, we can safely ignore it.
+        MOZ_ASSERT(false, "failed to initialize font family");
+        continue;
+      }
+    }
+
+    // Truncate the entry from prefs at the colon, so now it is just the
+    // desired single-face-family name.
+    nsAutoCString aliasName(Substring(familyName, 0, colon));
+
+    // Look through the family's faces to see if this one is present.
+    fontlist::FontList* list = SharedFontList();
+    const fontlist::Pointer* facePtrs = family->Faces(list);
+    for (size_t i = 0; i < family->NumFaces(); i++) {
+      if (facePtrs[i].IsNull()) {
+        continue;
+      }
+      auto* face = facePtrs[i].ToPtr<const fontlist::Face>(list);
+      if (face->mDescriptor.AsString(list).Equals(aliasName)) {
+        // Found it! Create an entry in the Alias table.
+        GenerateFontListKey(aliasName, key);
+        if (SharedFontList()->FindFamily(key) || mAliasTable.Get(key)) {
+          // If the family name is already known, something's misconfigured;
+          // just ignore it.
+          MOZ_ASSERT(false, "single-face family already known");
+          break;
+        }
+        auto aliasData = mAliasTable.GetOrInsertNew(key);
+        // The "alias" here isn't based on an existing family, so we don't call
+        // aliasData->InitFromFamily(); the various flags are left as defaults.
+        aliasData->mFaces.AppendElement(facePtrs[i]);
+        aliasData->mBaseFamily = aliasName;
+        aliasData->mVisibility = family->Visibility();
+        break;
+      }
+    }
+  }
+  if (!mAliasTable.IsEmpty()) {
+    // This will be updated when the font loader completes, but we require
+    // at least the Osaka-Mono alias to be available immediately.
+    SharedFontList()->SetAliases(mAliasTable);
+  }
+}
+
+void gfxMacPlatformFontList::InitSingleFaceList() {
+  for (const auto& familyName : mSingleFaceFonts) {
+    LOG_FONTLIST(("(fontlist-singleface) face name: %s\n", familyName.get()));
+    // Each entry in the "single face families" list is expected to be a
+    // colon-separated pair of FaceName:Family,
+    // where FaceName is the individual face name (psname) of a font
+    // that should be exposed as a separate family name,
+    // and Family is the standard family to which that face belongs.
+    // The only such face listed by default is
+    //    Osaka-Mono:Osaka
+    auto colon = familyName.FindChar(':');
+    if (colon == kNotFound) {
+      continue;
+    }
+
+    // Look for the parent family in the main font family list,
+    // and ensure we have loaded its list of available faces.
+    nsAutoCString key(Substring(familyName, colon + 1));
+    ToLowerCase(key);
+    gfxFontFamily* family = mFontFamilies.GetWeak(key);
+    if (!family || family->IsHidden()) {
+      continue;
+    }
+    family->FindStyleVariations();
+
+    // Truncate the entry from prefs at the colon, so now it is just the
+    // desired single-face-family name.
+    nsAutoCString aliasName(Substring(familyName, 0, colon));
+
+    // Look through the family's faces to see if this one is present.
+    const gfxFontEntry* fe = nullptr;
+    family->ReadLock();
+    for (const auto& face : family->GetFontList()) {
+      if (face->Name().Equals(aliasName)) {
+        fe = face;
+        break;
+      }
+    }
+    family->ReadUnlock();
+    if (!fe) {
+      continue;
+    }
+
+    // We found the correct face, so create the single-face family record.
+    GenerateFontListKey(aliasName, key);
+    LOG_FONTLIST(("(fontlist-singleface) family name: %s, key: %s\n", aliasName.get(), key.get()));
+
+    // add only if doesn't exist already
+    if (!mFontFamilies.GetWeak(key)) {
+      RefPtr<gfxFontFamily> familyEntry =
+          new gfxSingleFaceMacFontFamily(aliasName, family->Visibility());
+      // We need a separate font entry, because its family name will
+      // differ from the one we found in the main list.
+      MacOSFontEntry* fontEntry = new MacOSFontEntry(
+          fe->Name(), fe->Weight(), true, static_cast<const MacOSFontEntry*>(fe)->mSizeHint);
+      familyEntry->AddFontEntry(fontEntry);
+      familyEntry->SetHasStyles(true);
+      mFontFamilies.InsertOrUpdate(key, std::move(familyEntry));
+      LOG_FONTLIST(
+          ("(fontlist-singleface) added new family: %s, key: %s\n", aliasName.get(), key.get()));
+    }
+  }
+}
+
+// System fonts under OSX may contain weird "meta" names but if we create
+// a new font using just the Postscript name, the NSFont api returns an object
+// with the actual real family name. For example, under OSX 10.11:
+//
+// [[NSFont menuFontOfSize:8.0] familyName] ==> .AppleSystemUIFont
+// [[NSFont fontWithName:[[[NSFont menuFontOfSize:8.0] fontDescriptor] postscriptName]
+//          size:8.0] familyName] ==> .SF NS Text
+
+static NSString* GetRealFamilyName(NSFont* aFont) {
+  NSString* psName = [[aFont fontDescriptor] postscriptName];
+  // With newer macOS versions and SDKs (e.g. when compiled against SDK 10.15),
+  // [NSFont fontWithName:] fails for hidden system fonts, because the underlying
+  // Core Text functions it uses reject such names and tell us to use the special
+  // CTFontCreateUIFontForLanguage API instead.
+  // To work around this, as we don't yet work directly with the CTFontUIFontType
+  // identifiers, we create a Core Graphics font (as it doesn't reject system font
+  // names), and use this to create a Core Text font that we can query for the
+  // family name.
+  // Eventually we should move to using CTFontUIFontType constants to identify
+  // system fonts, and eliminate the need to instantiate them (indirectly) from
+  // their postscript names.
+  AutoCFRelease<CGFontRef> cgFont = CGFontCreateWithFontName(CFStringRef(psName));
+  if (!cgFont) {
+    return [aFont familyName];
+  }
+
+  AutoCFRelease<CTFontRef> ctFont = CTFontCreateWithGraphicsFont(cgFont, 0.0, nullptr, nullptr);
+  if (!ctFont) {
+    return [aFont familyName];
+  }
+  NSString* familyName = (NSString*)CTFontCopyFamilyName(ctFont);
+
+  return [familyName autorelease];
+}
+
+// System fonts under OSX 10.11 use a combination of two families, one
+// for text sizes and another for larger, display sizes. Each has a
+// different number of weights. There aren't efficient API's for looking
+// this information up, so hard code the logic here but confirm via
+// debug assertions that the logic is correct.
+
+const CGFloat kTextDisplayCrossover = 20.0;  // use text family below this size
+
+void gfxMacPlatformFontList::InitSystemFontNames() {
+  // On Catalina+, the system font uses optical sizing rather than individual
+  // faces, so we don't need to look for a separate display-sized face.
+  mUseSizeSensitiveSystemFont = !nsCocoaFeatures::OnCatalinaOrLater();
+
+  // text font family
+  NSFont* sys = [NSFont systemFontOfSize:0.0];
+  NSString* textFamilyName = GetRealFamilyName(sys);
+  nsAutoString familyName;
+  nsCocoaUtils::GetStringForNSString(textFamilyName, familyName);
+  CopyUTF16toUTF8(familyName, mSystemTextFontFamilyName);
+
+  // On Catalina or later, we store an in-process gfxFontFamily for the system font
+  // even if using the shared fontlist to manage "normal" fonts, because the hidden
+  // system fonts may be excluded from the font list altogether.
+  if (nsCocoaFeatures::OnCatalinaOrLater()) {
+    // This family will be populated based on the given NSFont.
+    RefPtr<gfxFontFamily> fam = new gfxMacFontFamily(mSystemTextFontFamilyName, sys);
+    if (fam) {
+      nsAutoCString key;
+      GenerateFontListKey(mSystemTextFontFamilyName, key);
+      mFontFamilies.InsertOrUpdate(key, std::move(fam));
+    }
+  }
+
+  // display font family, if on OSX 10.11 - 10.14
+  if (mUseSizeSensitiveSystemFont) {
+    NSFont* displaySys = [NSFont systemFontOfSize:128.0];
+    NSString* displayFamilyName = GetRealFamilyName(displaySys);
+    if ([displayFamilyName isEqualToString:textFamilyName]) {
+      mUseSizeSensitiveSystemFont = false;
+    } else {
+      nsCocoaUtils::GetStringForNSString(displayFamilyName, familyName);
+      CopyUTF16toUTF8(familyName, mSystemDisplayFontFamilyName);
+    }
+  }
+
+#ifdef DEBUG
+  // different system font API's always map to the same family under OSX, so
+  // just assume that and emit a warning if that ever changes
+  NSString* sysFamily = GetRealFamilyName([NSFont systemFontOfSize:0.0]);
+  if ([sysFamily compare:GetRealFamilyName([NSFont boldSystemFontOfSize:0.0])] != NSOrderedSame ||
+      [sysFamily compare:GetRealFamilyName([NSFont controlContentFontOfSize:0.0])] !=
+          NSOrderedSame ||
+      [sysFamily compare:GetRealFamilyName([NSFont menuBarFontOfSize:0.0])] != NSOrderedSame ||
+      [sysFamily compare:GetRealFamilyName([NSFont toolTipsFontOfSize:0.0])] != NSOrderedSame) {
+    NS_WARNING("system font types map to different font families"
+               " -- please log a bug!!");
+  }
+#endif
+}
+
+gfxFontFamily* gfxMacPlatformFontList::FindSystemFontFamily(const nsACString& aFamily) {
+  nsAutoCString key;
+  GenerateFontListKey(aFamily, key);
+
+  gfxFontFamily* familyEntry;
+  if ((familyEntry = mFontFamilies.GetWeak(key))) {
+    return CheckFamily(familyEntry);
+  }
+
+  return nullptr;
+}
+
+void gfxMacPlatformFontList::RegisteredFontsChangedNotificationCallback(
+    CFNotificationCenterRef center, void* observer, CFStringRef name, const void* object,
+    CFDictionaryRef userInfo) {
+  if (!::CFEqual(name, kCTFontManagerRegisteredFontsChangedNotification)) {
+    return;
+  }
+
+  gfxMacPlatformFontList* fl = static_cast<gfxMacPlatformFontList*>(observer);
+  if (!fl->IsInitialized()) {
+    return;
+  }
+
+  // xxx - should be carefully pruning the list of fonts, not rebuilding it from scratch
+  fl->UpdateFontList();
+
+  gfxPlatform::ForceGlobalReflow(gfxPlatform::NeedsReframe::Yes);
+  dom::ContentParent::NotifyUpdatedFonts(true);
+}
+
+gfxFontEntry* gfxMacPlatformFontList::PlatformGlobalFontFallback(nsPresContext* aPresContext,
+                                                                 const uint32_t aCh,
+                                                                 Script aRunScript,
+                                                                 const gfxFontStyle* aMatchStyle,
+                                                                 FontFamily& aMatchedFamily) {
+  CFStringRef str;
+  UniChar ch[2];
+  CFIndex length = 1;
+
+  if (IS_IN_BMP(aCh)) {
+    ch[0] = aCh;
+    str = ::CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, ch, 1, kCFAllocatorNull);
+  } else {
+    ch[0] = H_SURROGATE(aCh);
+    ch[1] = L_SURROGATE(aCh);
+    str = ::CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, ch, 2, kCFAllocatorNull);
+    if (!str) {
+      return nullptr;
+    }
+    length = 2;
+  }
+
+  // use CoreText to find the fallback family
+
+  gfxFontEntry* fontEntry = nullptr;
+  bool cantUseFallbackFont = false;
+
+  if (!mDefaultFont) {
+    mDefaultFont = ::CTFontCreateWithName(CFSTR("LucidaGrande"), 12.f, NULL);
+  }
+
+  AutoCFRelease<CTFontRef> fallback =
+      ::CTFontCreateForString(mDefaultFont, str, ::CFRangeMake(0, length));
+
+  if (fallback) {
+    AutoCFRelease<CFStringRef> familyNameRef = ::CTFontCopyFamilyName(fallback);
+
+    if (familyNameRef &&
+        ::CFStringCompare(familyNameRef, CFSTR("LastResort"), kCFCompareCaseInsensitive) !=
+            kCFCompareEqualTo &&
+        ::CFStringCompare(familyNameRef, CFSTR(".LastResort"), kCFCompareCaseInsensitive) !=
+            kCFCompareEqualTo) {
+      AutoTArray<UniChar, 1024> buffer;
+      CFIndex familyNameLen = ::CFStringGetLength(familyNameRef);
+      buffer.SetLength(familyNameLen + 1);
+      ::CFStringGetCharacters(familyNameRef, ::CFRangeMake(0, familyNameLen), buffer.Elements());
+      buffer[familyNameLen] = 0;
+      NS_ConvertUTF16toUTF8 familyNameString(reinterpret_cast<char16_t*>(buffer.Elements()),
+                                             familyNameLen);
+
+      if (SharedFontList()) {
+        fontlist::Family* family = FindSharedFamily(aPresContext, familyNameString);
+        if (family) {
+          fontlist::Face* face = family->FindFaceForStyle(SharedFontList(), *aMatchStyle);
+          if (face) {
+            fontEntry = GetOrCreateFontEntryLocked(face, family);
+          }
+          if (fontEntry) {
+            if (fontEntry->HasCharacter(aCh)) {
+              aMatchedFamily = FontFamily(family);
+            } else {
+              fontEntry = nullptr;
+              cantUseFallbackFont = true;
+            }
+          }
+        }
+      }
+
+      // The macOS system font does not appear in the shared font list, so if
+      // we didn't find the fallback font above, we should also check for an
+      // unshared fontFamily in the system list.
+      if (!fontEntry) {
+        gfxFontFamily* family = FindSystemFontFamily(familyNameString);
+        if (family) {
+          fontEntry = family->FindFontForStyle(*aMatchStyle);
+          if (fontEntry) {
+            if (fontEntry->HasCharacter(aCh)) {
+              aMatchedFamily = FontFamily(family);
+            } else {
+              fontEntry = nullptr;
+              cantUseFallbackFont = true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (cantUseFallbackFont) {
+    Telemetry::Accumulate(Telemetry::BAD_FALLBACK_FONT, cantUseFallbackFont);
+  }
+
+  ::CFRelease(str);
+
+  return fontEntry;
+}
+
+FontFamily gfxMacPlatformFontList::GetDefaultFontForPlatform(nsPresContext* aPresContext,
+                                                             const gfxFontStyle* aStyle,
+                                                             nsAtom* aLanguage) {
+  nsAutoreleasePool localPool;
+
+  NSString* defaultFamily = [[NSFont userFontOfSize:aStyle->size] familyName];
+  nsAutoString familyName;
+
+  GetStringForNSString(defaultFamily, familyName);
+  return FindFamily(aPresContext, NS_ConvertUTF16toUTF8(familyName));
+}
+
+int32_t gfxMacPlatformFontList::AppleWeightToCSSWeight(int32_t aAppleWeight) {
+  if (aAppleWeight < 1)
+    aAppleWeight = 1;
+  else if (aAppleWeight > kAppleMaxWeight)
+    aAppleWeight = kAppleMaxWeight;
+  return gAppleWeightToCSSWeight[aAppleWeight];
+}
+
+gfxFontEntry* gfxMacPlatformFontList::LookupLocalFont(nsPresContext* aPresContext,
+                                                      const nsACString& aFontName,
+                                                      WeightRange aWeightForEntry,
+                                                      StretchRange aStretchForEntry,
+                                                      SlantStyleRange aStyleForEntry) {
+  if (aFontName.IsEmpty() || aFontName[0] == '.') {
+    return nullptr;
+  }
+
+  AutoLock lock(mLock);
+
+  nsAutoreleasePool localPool;
+
+  // Bug 567552 - disable auto-activation of fonts on first call to
+  // LookupLocalFont.
+  static bool firstTime = true;
+  if (firstTime) {
+    firstTime = false;
+    // get the main bundle identifier
+    CFBundleRef mainBundle = ::CFBundleGetMainBundle();
+    CFStringRef mainBundleID = nullptr;
+    if (mainBundle) {
+      mainBundleID = ::CFBundleGetIdentifier(mainBundle);
+    }
+    // Bug 969388 and bug 922590 - mainBundlID as null is sometimes problematic.
+    if (!mainBundleID) {
+      NS_WARNING("missing bundle ID, packaging set up incorrectly");
+    } else {
+      CTFontManagerSetAutoActivationSetting(mainBundleID, kCTFontManagerAutoActivationDisabled);
+    }
+  }
+
+  CrashReporter::AutoAnnotateCrashReport autoFontName(CrashReporter::Annotation::FontName,
+                                                      aFontName);
+
+  NSString* faceName = GetNSStringForString(NS_ConvertUTF8toUTF16(aFontName));
+
+  // lookup face based on postscript or full name
+  AutoCFRelease<CGFontRef> fontRef = CGFontCreateWithFontName(CFStringRef(faceName));
+  if (!fontRef) {
+    return nullptr;
+  }
+
+  // It's possible for CGFontCreateWithFontName to return a font that has been
+  // deactivated/uninstalled, or a font that is excluded from the font list due
+  // to CSS font-visibility restriction. So we need to check whether this font is
+  // allowed to be used.
+
+  // CGFontRef doesn't offer a family-name API, so we go via a CTFontRef.
+  AutoCFRelease<CTFontRef> ctFont = CTFontCreateWithGraphicsFont(fontRef, 0.0, nullptr, nullptr);
+  if (!ctFont) {
+    return nullptr;
+  }
+  AutoCFRelease<CFStringRef> name = CTFontCopyFamilyName(ctFont);
+
+  // Convert the family name to a key suitable for font-list lookup (8-bit, lowercased).
+  nsAutoCString key;
+  // CFStringGetLength is in UTF-16 code units. The maximum this count can expand
+  // when converted to UTF-8 is 3x. We add 1 to ensure there will also be space for
+  // null-termination of the resulting C string.
+  key.SetLength((CFStringGetLength(name) + 1) * 3);
+  if (!CFStringGetCString(name, key.BeginWriting(), key.Length(), kCFStringEncodingUTF8)) {
+    // This shouldn't ever happen, but if it does we just bail.
+    NS_WARNING("Failed to get family name?");
+    key.Truncate(0);
+  }
+  if (key.IsEmpty()) {
+    return nullptr;
+  }
+  // Reset our string length to match the actual C string we got, which will usually
+  // be much shorter than the maximal buffer we allocated.
+  key.Truncate(strlen(key.get()));
+  ToLowerCase(key);
+  // If the family can't be looked up, this font is not available for use.
+  FontFamily family = FindFamily(aPresContext, key);
+  if (family.IsNull()) {
+    return nullptr;
+  }
+
+  return new MacOSFontEntry(aFontName, fontRef, aWeightForEntry, aStretchForEntry, aStyleForEntry,
+                            false, true);
+}
+
+static void ReleaseData(void* info, const void* data, size_t size) { free((void*)data); }
+
+gfxFontEntry* gfxMacPlatformFontList::MakePlatformFont(const nsACString& aFontName,
+                                                       WeightRange aWeightForEntry,
+                                                       StretchRange aStretchForEntry,
+                                                       SlantStyleRange aStyleForEntry,
+                                                       const uint8_t* aFontData, uint32_t aLength) {
+  NS_ASSERTION(aFontData, "MakePlatformFont called with null data");
+
+  // create the font entry
+  nsAutoString uniqueName;
+
+  nsresult rv = gfxFontUtils::MakeUniqueUserFontName(uniqueName);
+  if (NS_FAILED(rv)) {
+    return nullptr;
+  }
+
+  CrashReporter::AutoAnnotateCrashReport autoFontName(CrashReporter::Annotation::FontName,
+                                                      aFontName);
+
+  AutoCFRelease<CGDataProviderRef> provider =
+      ::CGDataProviderCreateWithData(nullptr, aFontData, aLength, &ReleaseData);
+  AutoCFRelease<CGFontRef> fontRef = ::CGFontCreateWithDataProvider(provider);
+  if (!fontRef) {
+    return nullptr;
+  }
+
+  auto newFontEntry =
+      MakeUnique<MacOSFontEntry>(NS_ConvertUTF16toUTF8(uniqueName), fontRef, aWeightForEntry,
+                                 aStretchForEntry, aStyleForEntry, true, false);
+  return newFontEntry.release();
+}
+
+// Webkit code uses a system font meta name, so mimic that here
+// WebCore/platform/graphics/mac/FontCacheMac.mm
+static const char kSystemFont_system[] = "-apple-system";
+
+bool gfxMacPlatformFontList::FindAndAddFamiliesLocked(
+    nsPresContext* aPresContext, StyleGenericFontFamily aGeneric, const nsACString& aFamily,
+    nsTArray<FamilyAndGeneric>* aOutput, FindFamiliesFlags aFlags, gfxFontStyle* aStyle,
+    nsAtom* aLanguage, gfxFloat aDevToCssSize) {
+  if (aFamily.EqualsLiteral(kSystemFont_system)) {
+    // Search for special system font name, -apple-system. This is not done via
+    // the shared fontlist on Catalina or later, because the hidden system font
+    // may not be included there; we create a separate gfxFontFamily to manage
+    // this family.
+    const nsCString& systemFontFamilyName =
+        mUseSizeSensitiveSystemFont && aStyle &&
+                (aStyle->size * aDevToCssSize) >= kTextDisplayCrossover
+            ? mSystemDisplayFontFamilyName
+            : mSystemTextFontFamilyName;
+    if (SharedFontList() && !nsCocoaFeatures::OnCatalinaOrLater()) {
+      FindFamiliesFlags flags = aFlags | FindFamiliesFlags::eSearchHiddenFamilies;
+      return gfxPlatformFontList::FindAndAddFamiliesLocked(aPresContext, aGeneric,
+                                                           systemFontFamilyName, aOutput, flags,
+                                                           aStyle, aLanguage, aDevToCssSize);
+    } else {
+      if (auto* fam = FindSystemFontFamily(systemFontFamilyName)) {
+        aOutput->AppendElement(fam);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  return gfxPlatformFontList::FindAndAddFamiliesLocked(aPresContext, aGeneric, aFamily, aOutput,
+                                                       aFlags, aStyle, aLanguage, aDevToCssSize);
+}
+
+void gfxMacPlatformFontList::LookupSystemFont(LookAndFeel::FontID aSystemFontID,
+                                              nsACString& aSystemFontName,
+                                              gfxFontStyle& aFontStyle) {
+  // Provide a local pool because we may be called from stylo threads.
+  nsAutoreleasePool localPool;
+
+  // code moved here from widget/cocoa/nsLookAndFeel.mm
+  NSFont* font = nullptr;
+  char* systemFontName = nullptr;
+  switch (aSystemFontID) {
+    case LookAndFeel::FontID::MessageBox:
+    case LookAndFeel::FontID::StatusBar:
+    case LookAndFeel::FontID::MozList:
+    case LookAndFeel::FontID::MozField:
+    case LookAndFeel::FontID::MozButton:
+      font = [NSFont systemFontOfSize:[NSFont smallSystemFontSize]];
+      systemFontName = (char*)kSystemFont_system;
+      break;
+
+    case LookAndFeel::FontID::SmallCaption:
+      font = [NSFont boldSystemFontOfSize:[NSFont smallSystemFontSize]];
+      systemFontName = (char*)kSystemFont_system;
+      break;
+
+    case LookAndFeel::FontID::Icon:  // used in urlbar; tried labelFont, but too small
+      font = [NSFont controlContentFontOfSize:0.0];
+      systemFontName = (char*)kSystemFont_system;
+      break;
+
+    case LookAndFeel::FontID::MozPullDownMenu:
+      font = [NSFont menuBarFontOfSize:0.0];
+      systemFontName = (char*)kSystemFont_system;
+      break;
+
+    case LookAndFeel::FontID::Caption:
+    case LookAndFeel::FontID::Menu:
+    default:
+      font = [NSFont systemFontOfSize:0.0];
+      systemFontName = (char*)kSystemFont_system;
+      break;
+  }
+  NS_ASSERTION(font, "system font not set");
+  NS_ASSERTION(systemFontName, "system font name not set");
+
+  if (systemFontName) {
+    aSystemFontName.AssignASCII(systemFontName);
+  }
+
+  NSFontSymbolicTraits traits = [[font fontDescriptor] symbolicTraits];
+  aFontStyle.style = (traits & NSFontItalicTrait) ? FontSlantStyle::ITALIC : FontSlantStyle::NORMAL;
+  aFontStyle.weight = (traits & NSFontBoldTrait) ? FontWeight::BOLD : FontWeight::NORMAL;
+  aFontStyle.stretch = (traits & NSFontExpandedTrait)    ? FontStretch::EXPANDED
+                       : (traits & NSFontCondensedTrait) ? FontStretch::CONDENSED
+                                                         : FontStretch::NORMAL;
+  aFontStyle.size = [font pointSize];
+  aFontStyle.systemFont = true;
+}
+
+// used to load system-wide font info on off-main thread
+class MacFontInfo final : public FontInfoData {
+ public:
+  MacFontInfo(bool aLoadOtherNames, bool aLoadFaceNames, bool aLoadCmaps, RecursiveMutex& aLock)
+      : FontInfoData(aLoadOtherNames, aLoadFaceNames, aLoadCmaps), mLock(aLock) {}
+
+  virtual ~MacFontInfo() = default;
+
+  virtual void Load() {
+    nsAutoreleasePool localPool;
+    FontInfoData::Load();
+  }
+
+  // loads font data for all members of a given family
+  virtual void LoadFontFamilyData(const nsACString& aFamilyName);
+
+  RecursiveMutex& mLock;
+};
+
+void MacFontInfo::LoadFontFamilyData(const nsACString& aFamilyName) {
+  CrashReporter::AutoAnnotateCrashReport autoFontName(CrashReporter::Annotation::FontName,
+                                                      aFamilyName);
+  // Prevent this from running concurrently with CGFont operations on the main thread,
+  // because the macOS font cache is fragile with concurrent access. This appears to be
+  // a vulnerability within CoreText in versions of macOS before macOS 13. In time, we
+  // can remove this lock.
+  RecursiveMutexAutoLock lock(mLock);
+
+  // family name ==> CTFontDescriptor
+  NSString* famName = GetNSStringForString(NS_ConvertUTF8toUTF16(aFamilyName));
+  CFStringRef family = CFStringRef(famName);
+
+  AutoCFRelease<CFMutableDictionaryRef> attr = CFDictionaryCreateMutable(
+      NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+  CFDictionaryAddValue(attr, kCTFontFamilyNameAttribute, family);
+  AutoCFRelease<CTFontDescriptorRef> fd = CTFontDescriptorCreateWithAttributes(attr);
+  AutoCFRelease<CFArrayRef> matchingFonts = CTFontDescriptorCreateMatchingFontDescriptors(fd, NULL);
+  if (!matchingFonts) {
+    return;
+  }
+
+  nsTArray<nsCString> otherFamilyNames;
+  bool hasOtherFamilyNames = true;
+
+  // iterate over faces in the family
+  int f, numFaces = (int)CFArrayGetCount(matchingFonts);
+  for (f = 0; f < numFaces; f++) {
+    mLoadStats.fonts++;
+
+    CTFontDescriptorRef faceDesc = (CTFontDescriptorRef)CFArrayGetValueAtIndex(matchingFonts, f);
+    if (!faceDesc) {
+      continue;
+    }
+    AutoCFRelease<CTFontRef> fontRef = CTFontCreateWithFontDescriptor(faceDesc, 0.0, nullptr);
+    if (!fontRef) {
+      NS_WARNING("failed to create a CTFontRef");
+      continue;
+    }
+
+    if (mLoadCmaps) {
+      // face name
+      AutoCFRelease<CFStringRef> faceName =
+          (CFStringRef)CTFontDescriptorCopyAttribute(faceDesc, kCTFontNameAttribute);
+
+      AutoTArray<UniChar, 1024> buffer;
+      CFIndex len = CFStringGetLength(faceName);
+      buffer.SetLength(len + 1);
+      CFStringGetCharacters(faceName, ::CFRangeMake(0, len), buffer.Elements());
+      buffer[len] = 0;
+      NS_ConvertUTF16toUTF8 fontName(reinterpret_cast<char16_t*>(buffer.Elements()), len);
+
+      // load the cmap data
+      FontFaceData fontData;
+      AutoCFRelease<CFDataRef> cmapTable =
+          CTFontCopyTable(fontRef, kCTFontTableCmap, kCTFontTableOptionNoOptions);
+
+      if (cmapTable) {
+        const uint8_t* cmapData = (const uint8_t*)CFDataGetBytePtr(cmapTable);
+        uint32_t cmapLen = CFDataGetLength(cmapTable);
+        RefPtr<gfxCharacterMap> charmap = new gfxCharacterMap();
+        uint32_t offset;
+        nsresult rv;
+
+        rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen, *charmap, offset);
+        if (NS_SUCCEEDED(rv)) {
+          fontData.mCharacterMap = charmap;
+          fontData.mUVSOffset = offset;
+          mLoadStats.cmaps++;
+        }
+      }
+
+      mFontFaceData.InsertOrUpdate(fontName, fontData);
+    }
+
+    if (mLoadOtherNames && hasOtherFamilyNames) {
+      AutoCFRelease<CFDataRef> nameTable =
+          CTFontCopyTable(fontRef, kCTFontTableName, kCTFontTableOptionNoOptions);
+
+      if (nameTable) {
+        const char* nameData = (const char*)CFDataGetBytePtr(nameTable);
+        uint32_t nameLen = CFDataGetLength(nameTable);
+        gfxFontUtils::ReadOtherFamilyNamesForFace(aFamilyName, nameData, nameLen, otherFamilyNames,
+                                                  false);
+        hasOtherFamilyNames = otherFamilyNames.Length() != 0;
+      }
+    }
+  }
+
+  // if found other names, insert them in the hash table
+  if (otherFamilyNames.Length() != 0) {
+    mOtherFamilyNames.InsertOrUpdate(aFamilyName, otherFamilyNames);
+    mLoadStats.othernames += otherFamilyNames.Length();
+  }
+}
+
+already_AddRefed<FontInfoData> gfxMacPlatformFontList::CreateFontInfoData() {
+  bool loadCmaps =
+      !UsesSystemFallback() || gfxPlatform::GetPlatform()->UseCmapsDuringSystemFallback();
+
+  mLock.AssertCurrentThreadIn();
+  RefPtr<MacFontInfo> fi = new MacFontInfo(true, NeedFullnamePostscriptNames(), loadCmaps, mLock);
+  return fi.forget();
+}
+
+gfxFontFamily* gfxMacPlatformFontList::CreateFontFamily(const nsACString& aName,
+                                                        FontVisibility aVisibility) const {
+  return new gfxMacFontFamily(aName, aVisibility);
+}
+
+gfxFontEntry* gfxMacPlatformFontList::CreateFontEntry(fontlist::Face* aFace,
+                                                      const fontlist::Family* aFamily) {
+  MacOSFontEntry* fe =
+      new MacOSFontEntry(aFace->mDescriptor.AsString(SharedFontList()), aFace->mWeight, false,
+                         0.0);  // XXX standardFace, sizeHint
+  fe->InitializeFrom(aFace, aFamily);
+  return fe;
+}
+
+void gfxMacPlatformFontList::GetFacesInitDataForFamily(const fontlist::Family* aFamily,
+                                                       nsTArray<fontlist::Face::InitData>& aFaces,
+                                                       bool aLoadCmaps) const {
+  nsAutoreleasePool localPool;
+
+  auto name = aFamily->Key().AsString(SharedFontList());
+  NSString* family = GetNSStringForString(NS_ConvertUTF8toUTF16(name));
+
+  CrashReporter::AutoAnnotateCrashReport autoFontName(CrashReporter::Annotation::FontName, name);
+
+  // returns an array of [psname, style name, weight, traits] elements, goofy api
+  NSArray* fontfaces = [sFontManager availableMembersOfFontFamily:family];
+  int faceCount = [fontfaces count];
+  for (int faceIndex = 0; faceIndex < faceCount; faceIndex++) {
+    NSArray* face = [fontfaces objectAtIndex:faceIndex];
+    NSString* psname = [face objectAtIndex:INDEX_FONT_POSTSCRIPT_NAME];
+    int32_t appKitWeight = [[face objectAtIndex:INDEX_FONT_WEIGHT] unsignedIntValue];
+    uint32_t macTraits = [[face objectAtIndex:INDEX_FONT_TRAITS] unsignedIntValue];
+    NSString* facename = [face objectAtIndex:INDEX_FONT_FACE_NAME];
+
+    if (appKitWeight == kAppleExtraLightWeight) {
+      // if the facename contains UltraLight, set the weight to the ultralight weight value
+      NSRange range = [facename rangeOfString:@"ultralight" options:NSCaseInsensitiveSearch];
+      if (range.location != NSNotFound) {
+        appKitWeight = kAppleUltraLightWeight;
+      }
+    }
+
+    // make a nsString
+    nsAutoString postscriptFontName;
+    GetStringForNSString(psname, postscriptFontName);
+
+    int32_t cssWeight = gfxMacPlatformFontList::AppleWeightToCSSWeight(appKitWeight);
+    if (PR_GetCurrentThread() != sInitFontListThread) {
+      int32_t weightOverride = GetWeightOverride(postscriptFontName);
+      if (weightOverride) {
+        // scale down and clamp, to get a value from 1..9
+        cssWeight = ((weightOverride + 50) / 100);
+        cssWeight = std::max(1, std::min(cssWeight, 9));
+      }
+    }
+    cssWeight *= 100;  // scale up to CSS values
+
+    StretchRange stretch(FontStretch::NORMAL);
+    if (macTraits & (NSCondensedFontMask | NSNarrowFontMask | NSCompressedFontMask)) {
+      stretch = StretchRange(FontStretch::CONDENSED);
+    } else if (macTraits & NSExpandedFontMask) {
+      stretch = StretchRange(FontStretch::EXPANDED);
+    }
+    // Cocoa fails to set the Italic traits bit for HelveticaLightItalic,
+    // at least (see bug 611855), so check for style name endings as well
+    SlantStyleRange slantStyle(FontSlantStyle::NORMAL);
+    if ((macTraits & NSItalicFontMask) || [facename hasSuffix:@"Italic"] ||
+        [facename hasSuffix:@"Oblique"]) {
+      slantStyle = SlantStyleRange(FontSlantStyle::ITALIC);
+    }
+
+    bool fixedPitch = (macTraits & NSFixedPitchFontMask) ? true : false;
+
+    RefPtr<gfxCharacterMap> charmap;
+    if (aLoadCmaps) {
+      AutoCFRelease<CGFontRef> font = CGFontCreateWithFontName(CFStringRef(psname));
+      if (font) {
+        uint32_t kCMAP = TRUETYPE_TAG('c', 'm', 'a', 'p');
+        AutoCFRelease<CFDataRef> data = CGFontCopyTableForTag(font, kCMAP);
+        if (data) {
+          uint32_t offset;
+          charmap = new gfxCharacterMap();
+          gfxFontUtils::ReadCMAP(CFDataGetBytePtr(data), CFDataGetLength(data), *charmap, offset);
+        }
+      }
+    }
+
+    // Ensure that a face named "Regular" goes to the front of the list, so it
+    // will take precedence over other faces with the same style attributes but
+    // a different name (such as "Outline").
+    auto data = fontlist::Face::InitData{
+        NS_ConvertUTF16toUTF8(postscriptFontName),
+        0,
+        fixedPitch,
+        WeightRange(FontWeight::FromInt(cssWeight)),
+        stretch,
+        slantStyle,
+        charmap,
+    };
+    if ([facename caseInsensitiveCompare:@"Regular"] == NSOrderedSame) {
+      aFaces.InsertElementAt(0, std::move(data));
+    } else {
+      aFaces.AppendElement(std::move(data));
+    }
+  }
+}
+
+void gfxMacPlatformFontList::ReadFaceNamesForFamily(fontlist::Family* aFamily,
+                                                    bool aNeedFullnamePostscriptNames) {
+  if (!aFamily->IsInitialized()) {
+    if (!InitializeFamily(aFamily)) {
+      return;
+    }
+  }
+  const uint32_t kNAME = TRUETYPE_TAG('n', 'a', 'm', 'e');
+  fontlist::FontList* list = SharedFontList();
+  nsAutoCString canonicalName(aFamily->DisplayName().AsString(list));
+  const auto* facePtrs = aFamily->Faces(list);
+  for (uint32_t i = 0, n = aFamily->NumFaces(); i < n; i++) {
+    auto* face = facePtrs[i].ToPtr<const fontlist::Face>(list);
+    if (!face) {
+      continue;
+    }
+    nsAutoCString name(face->mDescriptor.AsString(list));
+    // We create a temporary MacOSFontEntry just to read family names from the
+    // 'name' table in the font resource. The style attributes here are ignored
+    // as this entry is not used for font style matching.
+    // The size hint might be used to select which face is accessed in the case
+    // of the macOS UI font; see MacOSFontEntry::GetFontRef(). We pass 16.0 in
+    // order to get a standard text-size face in this case, although it's
+    // unlikely to matter for the purpose of just reading family names.
+    auto fe = MakeUnique<MacOSFontEntry>(name, WeightRange(FontWeight::NORMAL), false, 16.0);
+    if (!fe) {
+      continue;
+    }
+    gfxFontEntry::AutoTable nameTable(fe.get(), kNAME);
+    if (!nameTable) {
+      continue;
+    }
+    uint32_t dataLength;
+    const char* nameData = hb_blob_get_data(nameTable, &dataLength);
+    AutoTArray<nsCString, 4> otherFamilyNames;
+    gfxFontUtils::ReadOtherFamilyNamesForFace(canonicalName, nameData, dataLength, otherFamilyNames,
+                                              false);
+    for (const auto& alias : otherFamilyNames) {
+      nsAutoCString key;
+      GenerateFontListKey(alias, key);
+      auto aliasData = mAliasTable.GetOrInsertNew(key);
+      aliasData->InitFromFamily(aFamily, canonicalName);
+      aliasData->mFaces.AppendElement(facePtrs[i]);
+    }
+  }
+}
+
+#ifdef MOZ_BUNDLED_FONTS
+void gfxMacPlatformFontList::ActivateBundledFonts() {
+  nsCOMPtr<nsIFile> localDir;
+  if (NS_FAILED(NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(localDir)))) {
+    return;
+  }
+  if (NS_FAILED(localDir->Append(u"fonts"_ns))) {
+    return;
+  }
+  nsAutoCString path;
+  if (NS_FAILED(localDir->GetNativePath(path))) {
+    return;
+  }
+  ActivateFontsFromDir(path, &mBundledFamilies);
+}
+#endif