Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

1 files changed, 1361 insertions, 0 deletions

diff --git a/gfx/thebes/SharedFontList.cpp b/gfx/thebes/SharedFontList.cpp
new file mode 100644
index 0000000000..e9f64089be
--- /dev/null
+++ b/gfx/thebes/SharedFontList.cpp
@@ -0,0 +1,1361 @@
+/* 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 "SharedFontList-impl.h"
+#include "gfxPlatformFontList.h"
+#include "gfxFontUtils.h"
+#include "gfxFont.h"
+#include "nsReadableUtils.h"
+#include "prerror.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Unused.h"
+
+#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)
+
+namespace mozilla {
+namespace fontlist {
+
+static double WSSDistance(const Face* aFace, const gfxFontStyle& aStyle) {
+  double stretchDist = StretchDistance(aFace->mStretch, aStyle.stretch);
+  double styleDist = StyleDistance(aFace->mStyle, aStyle.style);
+  double weightDist = WeightDistance(aFace->mWeight, aStyle.weight);
+
+  // Sanity-check that the distances are within the expected range
+  // (update if implementation of the distance functions is changed).
+  MOZ_ASSERT(stretchDist >= 0.0 && stretchDist <= 2000.0);
+  MOZ_ASSERT(styleDist >= 0.0 && styleDist <= 500.0);
+  MOZ_ASSERT(weightDist >= 0.0 && weightDist <= 1600.0);
+
+  // weight/style/stretch priority: stretch >> style >> weight
+  // so we multiply the stretch and style values to make them dominate
+  // the result
+  return stretchDist * kStretchFactor + styleDist * kStyleFactor +
+         weightDist * kWeightFactor;
+}
+
+void* Pointer::ToPtr(FontList* aFontList,
+                     size_t aSize) const MOZ_NO_THREAD_SAFETY_ANALYSIS {
+  // On failure, we'll return null; callers need to handle this appropriately
+  // (e.g. via fallback).
+  void* result = nullptr;
+
+  if (IsNull()) {
+    return result;
+  }
+
+  // Ensure the list doesn't get replaced out from under us. Font-list rebuild
+  // happens on the main thread, so only non-main-thread callers need to lock
+  // it here.
+  bool isMainThread = NS_IsMainThread();
+  if (!isMainThread) {
+    gfxPlatformFontList::PlatformFontList()->Lock();
+  }
+
+  uint32_t blockIndex = Block();
+
+  // If the Pointer refers to a block we have not yet mapped in this process,
+  // we first need to retrieve new block handle(s) from the parent and update
+  // our mBlocks list.
+  auto& blocks = aFontList->mBlocks;
+  if (blockIndex >= blocks.Length()) {
+    if (MOZ_UNLIKELY(XRE_IsParentProcess())) {
+      // Shouldn't happen! A content process tried to pass a bad Pointer?
+      goto cleanup;
+    }
+    // If we're not on the main thread, we can't do the IPC involved in
+    // UpdateShmBlocks; just let the lookup fail for now.
+    if (!isMainThread) {
+      goto cleanup;
+    }
+    // UpdateShmBlocks can fail, if the parent has replaced the font list with
+    // a new generation. In that case we just return null, and whatever font
+    // the content process was trying to use will appear unusable for now. It's
+    // about to receive a notification of the new font list anyhow, at which
+    // point it will flush its caches and reflow everything, so the temporary
+    // failure of this font will be forgotten.
+    // UpdateShmBlocks will take the platform font-list lock during the update.
+    if (MOZ_UNLIKELY(!aFontList->UpdateShmBlocks(true))) {
+      goto cleanup;
+    }
+    MOZ_ASSERT(blockIndex < blocks.Length(), "failure in UpdateShmBlocks?");
+    // This is wallpapering bug 1667977; it's unclear if we will always survive
+    // this, as the content process may be unable to shape/render text if all
+    // font lookups are failing.
+    // In at least some cases, however, this can occur transiently while the
+    // font list is being rebuilt by the parent; content will then be notified
+    // that the list has changed, and should refresh everything successfully.
+    if (MOZ_UNLIKELY(blockIndex >= blocks.Length())) {
+      goto cleanup;
+    }
+  }
+
+  {
+    // Don't create a pointer that's outside what the block has allocated!
+    const auto& block = blocks[blockIndex];
+    if (MOZ_LIKELY(Offset() + aSize <= block->Allocated())) {
+      result = static_cast<char*>(block->Memory()) + Offset();
+    }
+  }
+
+cleanup:
+  if (!isMainThread) {
+    gfxPlatformFontList::PlatformFontList()->Unlock();
+  }
+
+  return result;
+}
+
+void String::Assign(const nsACString& aString, FontList* aList) {
+  // We only assign to previously-empty strings; they are never modified
+  // after initial assignment.
+  MOZ_ASSERT(mPointer.IsNull());
+  mLength = aString.Length();
+  mPointer = aList->Alloc(mLength + 1);
+  auto* p = mPointer.ToArray<char>(aList, mLength);
+  std::memcpy(p, aString.BeginReading(), mLength);
+  p[mLength] = '\0';
+}
+
+Family::Family(FontList* aList, const InitData& aData)
+    : mFaceCount(0),
+      mKey(aList, aData.mKey),
+      mName(aList, aData.mName),
+      mCharacterMap(Pointer::Null()),
+      mFaces(Pointer::Null()),
+      mIndex(aData.mIndex),
+      mVisibility(aData.mVisibility),
+      mIsSimple(false),
+      mIsBundled(aData.mBundled),
+      mIsBadUnderlineFamily(aData.mBadUnderline),
+      mIsForceClassic(aData.mForceClassic),
+      mIsAltLocale(aData.mAltLocale) {}
+
+class SetCharMapRunnable : public mozilla::Runnable {
+ public:
+  SetCharMapRunnable(uint32_t aListGeneration, Pointer aFacePtr,
+                     gfxCharacterMap* aCharMap)
+      : Runnable("SetCharMapRunnable"),
+        mListGeneration(aListGeneration),
+        mFacePtr(aFacePtr),
+        mCharMap(aCharMap) {}
+
+  NS_IMETHOD Run() override {
+    auto* list = gfxPlatformFontList::PlatformFontList()->SharedFontList();
+    if (!list || list->GetGeneration() != mListGeneration) {
+      return NS_OK;
+    }
+    dom::ContentChild::GetSingleton()->SendSetCharacterMap(mListGeneration,
+                                                           mFacePtr, *mCharMap);
+    return NS_OK;
+  }
+
+ private:
+  uint32_t mListGeneration;
+  Pointer mFacePtr;
+  RefPtr<gfxCharacterMap> mCharMap;
+};
+
+void Face::SetCharacterMap(FontList* aList, gfxCharacterMap* aCharMap) {
+  if (!XRE_IsParentProcess()) {
+    Pointer ptr = aList->ToSharedPointer(this);
+    if (NS_IsMainThread()) {
+      dom::ContentChild::GetSingleton()->SendSetCharacterMap(
+          aList->GetGeneration(), ptr, *aCharMap);
+    } else {
+      NS_DispatchToMainThread(
+          new SetCharMapRunnable(aList->GetGeneration(), ptr, aCharMap));
+    }
+    return;
+  }
+  auto pfl = gfxPlatformFontList::PlatformFontList();
+  mCharacterMap = pfl->GetShmemCharMap(aCharMap);
+}
+
+void Family::AddFaces(FontList* aList, const nsTArray<Face::InitData>& aFaces) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  if (mFaceCount > 0) {
+    // Already initialized!
+    return;
+  }
+
+  uint32_t count = aFaces.Length();
+  bool isSimple = false;
+  // A family is "simple" (i.e. simplified style selection may be used instead
+  // of the full CSS font-matching algorithm) if there is at maximum one normal,
+  // bold, italic, and bold-italic face; in this case, they are stored at known
+  // positions in the mFaces array.
+  const Face::InitData* slots[4] = {nullptr, nullptr, nullptr, nullptr};
+  if (count >= 2 && count <= 4) {
+    // Check if this can be treated as a "simple" family
+    isSimple = true;
+    for (const auto& f : aFaces) {
+      if (!f.mWeight.IsSingle() || !f.mStretch.IsSingle() ||
+          !f.mStyle.IsSingle()) {
+        isSimple = false;
+        break;
+      }
+      if (!f.mStretch.Min().IsNormal()) {
+        isSimple = false;
+        break;
+      }
+      // Figure out which slot (0-3) this face belongs in
+      size_t slot = 0;
+      static_assert((kBoldMask | kItalicMask) == 0b11, "bad bold/italic bits");
+      if (f.mWeight.Min().IsBold()) {
+        slot |= kBoldMask;
+      }
+      if (f.mStyle.Min().IsItalic() || f.mStyle.Min().IsOblique()) {
+        slot |= kItalicMask;
+      }
+      if (slots[slot]) {
+        // More than one face mapped to the same slot - not a simple family!
+        isSimple = false;
+        break;
+      }
+      slots[slot] = &f;
+    }
+    if (isSimple) {
+      // Ensure all 4 slots will exist, even if some are empty.
+      count = 4;
+    }
+  }
+
+  // Allocate space for the face records, and initialize them.
+  // coverity[suspicious_sizeof]
+  Pointer p = aList->Alloc(count * sizeof(Pointer));
+  auto* facePtrs = p.ToArray<Pointer>(aList, count);
+  for (size_t i = 0; i < count; i++) {
+    if (isSimple && !slots[i]) {
+      facePtrs[i] = Pointer::Null();
+    } else {
+      const auto* initData = isSimple ? slots[i] : &aFaces[i];
+      Pointer fp = aList->Alloc(sizeof(Face));
+      auto* face = fp.ToPtr<Face>(aList);
+      (void)new (face) Face(aList, *initData);
+      facePtrs[i] = fp;
+      if (initData->mCharMap) {
+        face->SetCharacterMap(aList, initData->mCharMap);
+      }
+    }
+  }
+
+  mIsSimple = isSimple;
+  mFaces = p;
+  mFaceCount.store(count);
+
+  if (LOG_FONTLIST_ENABLED()) {
+    const nsCString& fam = DisplayName().AsString(aList);
+    for (unsigned j = 0; j < aFaces.Length(); j++) {
+      nsAutoCString weight, style, stretch;
+      aFaces[j].mWeight.ToString(weight);
+      aFaces[j].mStyle.ToString(style);
+      aFaces[j].mStretch.ToString(stretch);
+      LOG_FONTLIST(
+          ("(shared-fontlist) family (%s) added face (%s) index %u, weight "
+           "%s, style %s, stretch %s",
+           fam.get(), aFaces[j].mDescriptor.get(), aFaces[j].mIndex,
+           weight.get(), style.get(), stretch.get()));
+    }
+  }
+}
+
+bool Family::FindAllFacesForStyleInternal(FontList* aList,
+                                          const gfxFontStyle& aStyle,
+                                          nsTArray<Face*>& aFaceList) const {
+  MOZ_ASSERT(aFaceList.IsEmpty());
+  if (!IsInitialized()) {
+    return false;
+  }
+
+  Pointer* facePtrs = Faces(aList);
+  if (!facePtrs) {
+    return false;
+  }
+
+  // Depending on the kind of family, we have to do varying amounts of work
+  // to figure out what face(s) to use for the requested style properties.
+
+  // If the family has only one face, we simply use it; no further style
+  // checking needed. (However, for bitmap fonts we may still need to check
+  // whether the size is acceptable.)
+  if (NumFaces() == 1) {
+    MOZ_ASSERT(!facePtrs[0].IsNull());
+    auto* face = facePtrs[0].ToPtr<Face>(aList);
+    if (face && face->HasValidDescriptor()) {
+      aFaceList.AppendElement(face);
+#ifdef MOZ_WIDGET_GTK
+      if (face->mSize) {
+        return true;
+      }
+#endif
+    }
+    return false;
+  }
+
+  // Most families are "simple", having just Regular/Bold/Italic/BoldItalic,
+  // or some subset of these. In this case, we have exactly 4 entries in
+  // mAvailableFonts, stored in the above order; note that some of the entries
+  // may be nullptr. We can then pick the required entry based on whether the
+  // request is for bold or non-bold, italic or non-italic, without running
+  // the more complex matching algorithm used for larger families with many
+  // weights and/or widths.
+
+  if (mIsSimple) {
+    // Family has no more than the "standard" 4 faces, at fixed indexes;
+    // calculate which one we want.
+    // Note that we cannot simply return it as not all 4 faces are necessarily
+    // present.
+    bool wantBold = aStyle.weight.IsBold();
+    bool wantItalic = !aStyle.style.IsNormal();
+    uint8_t faceIndex =
+        (wantItalic ? kItalicMask : 0) | (wantBold ? kBoldMask : 0);
+
+    // If the desired style is available, use it directly.
+    auto* face = facePtrs[faceIndex].ToPtr<Face>(aList);
+    if (face && face->HasValidDescriptor()) {
+      aFaceList.AppendElement(face);
+#ifdef MOZ_WIDGET_GTK
+      if (face->mSize) {
+        return true;
+      }
+#endif
+      return false;
+    }
+
+    // Order to check fallback faces in a simple family, depending on the
+    // requested style.
+    static const uint8_t simpleFallbacks[4][3] = {
+        {kBoldFaceIndex, kItalicFaceIndex,
+         kBoldItalicFaceIndex},  // fallback sequence for Regular
+        {kRegularFaceIndex, kBoldItalicFaceIndex, kItalicFaceIndex},  // Bold
+        {kBoldItalicFaceIndex, kRegularFaceIndex, kBoldFaceIndex},    // Italic
+        {kItalicFaceIndex, kBoldFaceIndex, kRegularFaceIndex}  // BoldItalic
+    };
+    const uint8_t* order = simpleFallbacks[faceIndex];
+
+    for (uint8_t trial = 0; trial < 3; ++trial) {
+      // check remaining faces in order of preference to find the first that
+      // actually exists
+      face = facePtrs[order[trial]].ToPtr<Face>(aList);
+      if (face && face->HasValidDescriptor()) {
+        aFaceList.AppendElement(face);
+#ifdef MOZ_WIDGET_GTK
+        if (face->mSize) {
+          return true;
+        }
+#endif
+        return false;
+      }
+    }
+
+    // We can only reach here if we failed to resolve the face pointer, which
+    // can happen if we're on a stylo thread and caught the font list being
+    // updated; in that case we just fail quietly and let font fallback do
+    // something for the time being.
+    return false;
+  }
+
+  // Pick the font(s) that are closest to the desired weight, style, and
+  // stretch. Iterate over all fonts, measuring the weight/style distance.
+  // Because of unicode-range values, there may be more than one font for a
+  // given but the 99% use case is only a single font entry per
+  // weight/style/stretch distance value. To optimize this, only add entries
+  // to the matched font array when another entry already has the same
+  // weight/style/stretch distance and add the last matched font entry. For
+  // normal platform fonts with a single font entry for each
+  // weight/style/stretch combination, only the last matched font entry will
+  // be added.
+  double minDistance = INFINITY;
+  Face* matched = nullptr;
+  // Keep track of whether we've included any non-scalable font resources in
+  // the selected set.
+  bool anyNonScalable = false;
+  for (uint32_t i = 0; i < NumFaces(); i++) {
+    auto* face = facePtrs[i].ToPtr<Face>(aList);
+    if (face) {
+      // weight/style/stretch priority: stretch >> style >> weight
+      double distance = WSSDistance(face, aStyle);
+      if (distance < minDistance) {
+        matched = face;
+        if (!aFaceList.IsEmpty()) {
+          aFaceList.Clear();
+        }
+        minDistance = distance;
+      } else if (distance == minDistance) {
+        if (matched) {
+          aFaceList.AppendElement(matched);
+#ifdef MOZ_WIDGET_GTK
+          if (matched->mSize) {
+            anyNonScalable = true;
+          }
+#endif
+        }
+        matched = face;
+      }
+    }
+  }
+
+  MOZ_ASSERT(matched, "didn't match a font within a family");
+  if (matched) {
+    aFaceList.AppendElement(matched);
+#ifdef MOZ_WIDGET_GTK
+    if (matched->mSize) {
+      anyNonScalable = true;
+    }
+#endif
+  }
+
+  return anyNonScalable;
+}
+
+void Family::FindAllFacesForStyle(FontList* aList, const gfxFontStyle& aStyle,
+                                  nsTArray<Face*>& aFaceList,
+                                  bool aIgnoreSizeTolerance) const {
+#ifdef MOZ_WIDGET_GTK
+  bool anyNonScalable =
+#else
+  Unused <<
+#endif
+      FindAllFacesForStyleInternal(aList, aStyle, aFaceList);
+
+#ifdef MOZ_WIDGET_GTK
+  // aFaceList now contains whatever faces are the best style match for
+  // the requested style. If specifically-sized bitmap faces are supported,
+  // we need to additionally filter the list to choose the appropriate size.
+  //
+  // It would be slightly more efficient to integrate this directly into the
+  // face-selection algorithm above, but it's a rare case that doesn't apply
+  // at all to most font families.
+  //
+  // Currently we only support pixel-sized bitmap font faces on Linux/Gtk (i.e.
+  // when using the gfxFcPlatformFontList implementation), so this filtering is
+  // not needed on other platforms.
+  //
+  // (Note that color-bitmap emoji fonts like Apple Color Emoji or Noto Color
+  // Emoji don't count here; they package multiple bitmap sizes into a single
+  // OpenType wrapper, so they appear as a single "scalable" face in our list.)
+  if (anyNonScalable) {
+    uint16_t best = 0;
+    gfxFloat dist = 0.0;
+    for (const auto& f : aFaceList) {
+      if (f->mSize == 0) {
+        // Scalable face; no size distance to compute.
+        continue;
+      }
+      gfxFloat d = fabs(gfxFloat(f->mSize) - aStyle.size);
+      if (!aIgnoreSizeTolerance && (d * 5.0 > f->mSize)) {
+        continue;  // Too far from the requested size, ignore.
+      }
+      // If we haven't found a "best" bitmap size yet, or if this is a better
+      // match, remember it.
+      if (!best || d < dist) {
+        best = f->mSize;
+        dist = d;
+      }
+    }
+    // Discard all faces except the chosen "best" size; or if no pixel size was
+    // chosen, all except scalable faces.
+    // This may eliminate *all* faces in the family, if all were bitmaps and
+    // none was a good enough size match, in which case we'll fall back to the
+    // next font-family name.
+    aFaceList.RemoveElementsBy([=](const auto& e) { return e->mSize != best; });
+  }
+#endif
+}
+
+Face* Family::FindFaceForStyle(FontList* aList, const gfxFontStyle& aStyle,
+                               bool aIgnoreSizeTolerance) const {
+  AutoTArray<Face*, 4> faces;
+  FindAllFacesForStyle(aList, aStyle, faces, aIgnoreSizeTolerance);
+  return faces.IsEmpty() ? nullptr : faces[0];
+}
+
+void Family::SearchAllFontsForChar(FontList* aList,
+                                   GlobalFontMatch* aMatchData) {
+  auto* charmap = mCharacterMap.ToPtr<const SharedBitSet>(aList);
+  if (!charmap) {
+    // If the face list is not yet initialized, or if character maps have
+    // not been loaded, go ahead and do this now (by sending a message to the
+    // parent process, if we're running in a child).
+    // After this, all faces should have their mCharacterMap set up, and the
+    // family's mCharacterMap should also be set; but in the code below we
+    // don't assume this all succeeded, so it still checks.
+    if (!gfxPlatformFontList::PlatformFontList()->InitializeFamily(this,
+                                                                   true)) {
+      return;
+    }
+    charmap = mCharacterMap.ToPtr<const SharedBitSet>(aList);
+  }
+  if (charmap && !charmap->test(aMatchData->mCh)) {
+    return;
+  }
+
+  uint32_t numFaces = NumFaces();
+  uint32_t charMapsLoaded = 0;  // number of faces whose charmap is loaded
+  Pointer* facePtrs = Faces(aList);
+  if (!facePtrs) {
+    return;
+  }
+  for (uint32_t i = 0; i < numFaces; i++) {
+    auto* face = facePtrs[i].ToPtr<Face>(aList);
+    if (!face) {
+      continue;
+    }
+    MOZ_ASSERT(face->HasValidDescriptor());
+    // Get the face's character map, if available (may be null!)
+    charmap = face->mCharacterMap.ToPtr<const SharedBitSet>(aList);
+    if (charmap) {
+      ++charMapsLoaded;
+    }
+    // Check style distance if the char is supported, or if charmap not known
+    // (so that we don't trigger cmap-loading for faces that would be a worse
+    // match than what we've already found).
+    if (!charmap || charmap->test(aMatchData->mCh)) {
+      double distance = WSSDistance(face, aMatchData->mStyle);
+      if (distance < aMatchData->mMatchDistance) {
+        // It's a better style match: get a fontEntry, and if we haven't
+        // already checked character coverage, do it now (note that
+        // HasCharacter() will trigger loading the fontEntry's cmap, if
+        // needed).
+        RefPtr<gfxFontEntry> fe =
+            gfxPlatformFontList::PlatformFontList()->GetOrCreateFontEntry(face,
+                                                                          this);
+        if (!fe) {
+          continue;
+        }
+        if (!charmap && !fe->HasCharacter(aMatchData->mCh)) {
+          continue;
+        }
+        if (aMatchData->mPresentation != eFontPresentation::Any) {
+          RefPtr<gfxFont> font = fe->FindOrMakeFont(&aMatchData->mStyle);
+          if (!font) {
+            continue;
+          }
+          bool hasColorGlyph =
+              font->HasColorGlyphFor(aMatchData->mCh, aMatchData->mNextCh);
+          if (hasColorGlyph != PrefersColor(aMatchData->mPresentation)) {
+            distance += kPresentationMismatch;
+            if (distance >= aMatchData->mMatchDistance) {
+              continue;
+            }
+          }
+        }
+        aMatchData->mBestMatch = fe;
+        aMatchData->mMatchDistance = distance;
+        aMatchData->mMatchedSharedFamily = this;
+      }
+    }
+  }
+  if (mCharacterMap.IsNull() && charMapsLoaded == numFaces) {
+    SetupFamilyCharMap(aList);
+  }
+}
+
+void Family::SetFacePtrs(FontList* aList, nsTArray<Pointer>& aFaces) {
+  if (aFaces.Length() >= 2 && aFaces.Length() <= 4) {
+    // Check whether the faces meet the criteria for a "simple" family: no more
+    // than one each of Regular, Bold, Italic, BoldItalic styles. If so, store
+    // them at the appropriate slots in mFaces and set the mIsSimple flag to
+    // accelerate font-matching.
+    bool isSimple = true;
+    Pointer slots[4] = {Pointer::Null(), Pointer::Null(), Pointer::Null(),
+                        Pointer::Null()};
+    for (const Pointer& fp : aFaces) {
+      auto* f = fp.ToPtr<const Face>(aList);
+      if (!f->mWeight.IsSingle() || !f->mStyle.IsSingle() ||
+          !f->mStretch.IsSingle()) {
+        isSimple = false;
+        break;
+      }
+      if (!f->mStretch.Min().IsNormal()) {
+        isSimple = false;
+        break;
+      }
+      size_t slot = 0;
+      if (f->mWeight.Min().IsBold()) {
+        slot |= kBoldMask;
+      }
+      if (f->mStyle.Min().IsItalic() || f->mStyle.Min().IsOblique()) {
+        slot |= kItalicMask;
+      }
+      if (!slots[slot].IsNull()) {
+        isSimple = false;
+        break;
+      }
+      slots[slot] = fp;
+    }
+    if (isSimple) {
+      size_t size = 4 * sizeof(Pointer);
+      mFaces = aList->Alloc(size);
+      memcpy(mFaces.ToPtr(aList, size), slots, size);
+      mFaceCount.store(4);
+      mIsSimple = true;
+      return;
+    }
+  }
+  size_t size = aFaces.Length() * sizeof(Pointer);
+  mFaces = aList->Alloc(size);
+  memcpy(mFaces.ToPtr(aList, size), aFaces.Elements(), size);
+  mFaceCount.store(aFaces.Length());
+}
+
+void Family::SetupFamilyCharMap(FontList* aList) {
+  // Set the character map of the family to the union of all the face cmaps,
+  // to allow font fallback searches to more rapidly reject the family.
+  if (!mCharacterMap.IsNull()) {
+    return;
+  }
+  if (!XRE_IsParentProcess()) {
+    // |this| could be a Family record in either the Families() or Aliases()
+    // arrays
+    if (NS_IsMainThread()) {
+      dom::ContentChild::GetSingleton()->SendSetupFamilyCharMap(
+          aList->GetGeneration(), aList->ToSharedPointer(this));
+      return;
+    }
+    NS_DispatchToMainThread(NS_NewRunnableFunction(
+        "SetupFamilyCharMap callback",
+        [gen = aList->GetGeneration(), ptr = aList->ToSharedPointer(this)] {
+          dom::ContentChild::GetSingleton()->SendSetupFamilyCharMap(gen, ptr);
+        }));
+    return;
+  }
+  gfxSparseBitSet familyMap;
+  Pointer firstMapShmPointer;
+  const SharedBitSet* firstMap = nullptr;
+  bool merged = false;
+  Pointer* faces = Faces(aList);
+  if (!faces) {
+    return;
+  }
+  for (size_t i = 0; i < NumFaces(); i++) {
+    auto* f = faces[i].ToPtr<const Face>(aList);
+    if (!f) {
+      continue;  // Skip missing face (in an incomplete "simple" family)
+    }
+    auto* faceMap = f->mCharacterMap.ToPtr<const SharedBitSet>(aList);
+    if (!faceMap) {
+      continue;  // If there's a face where setting up the cmap failed, we skip
+                 // it as unusable.
+    }
+    if (!firstMap) {
+      firstMap = faceMap;
+      firstMapShmPointer = f->mCharacterMap;
+    } else if (faceMap != firstMap) {
+      if (!merged) {
+        familyMap.Union(*firstMap);
+        merged = true;
+      }
+      familyMap.Union(*faceMap);
+    }
+  }
+  // If we created a merged cmap, we need to save that on the family; or if we
+  // found no usable cmaps at all, we need to store the empty familyMap so that
+  // we won't repeatedly attempt this for an unusable family.
+  if (merged || firstMapShmPointer.IsNull()) {
+    mCharacterMap =
+        gfxPlatformFontList::PlatformFontList()->GetShmemCharMap(&familyMap);
+  } else {
+    // If all [usable] faces had the same cmap, we can just share it.
+    mCharacterMap = firstMapShmPointer;
+  }
+}
+
+FontList::FontList(uint32_t aGeneration) {
+  if (XRE_IsParentProcess()) {
+    // Create the initial shared block, and initialize Header
+    if (AppendShmBlock(SHM_BLOCK_SIZE)) {
+      Header& header = GetHeader();
+      header.mBlockHeader.mAllocated.store(sizeof(Header));
+      header.mGeneration = aGeneration;
+      header.mFamilyCount = 0;
+      header.mBlockCount.store(1);
+      header.mAliasCount.store(0);
+      header.mLocalFaceCount.store(0);
+      header.mFamilies = Pointer::Null();
+      header.mAliases = Pointer::Null();
+      header.mLocalFaces = Pointer::Null();
+    } else {
+      MOZ_CRASH("parent: failed to initialize FontList");
+    }
+  } else {
+    // Initialize using the list of shmem blocks passed by the parent via
+    // SetXPCOMProcessAttributes.
+    auto& blocks = dom::ContentChild::GetSingleton()->SharedFontListBlocks();
+    for (auto& handle : blocks) {
+      auto newShm = MakeUnique<base::SharedMemory>();
+      if (!newShm->IsHandleValid(handle)) {
+        // Bail out and let UpdateShmBlocks try to do its thing below.
+        break;
+      }
+      if (!newShm->SetHandle(std::move(handle), true)) {
+        MOZ_CRASH("failed to set shm handle");
+      }
+      if (!newShm->Map(SHM_BLOCK_SIZE) || !newShm->memory()) {
+        MOZ_CRASH("failed to map shared memory");
+      }
+      uint32_t size = static_cast<BlockHeader*>(newShm->memory())->mBlockSize;
+      MOZ_ASSERT(size >= SHM_BLOCK_SIZE);
+      if (size != SHM_BLOCK_SIZE) {
+        newShm->Unmap();
+        if (!newShm->Map(size) || !newShm->memory()) {
+          MOZ_CRASH("failed to map shared memory");
+        }
+      }
+      mBlocks.AppendElement(new ShmBlock(std::move(newShm)));
+    }
+    blocks.Clear();
+    // Update in case of any changes since the initial message was sent.
+    for (unsigned retryCount = 0; retryCount < 3; ++retryCount) {
+      if (UpdateShmBlocks(false)) {
+        return;
+      }
+      // The only reason for UpdateShmBlocks to fail is if the parent recreated
+      // the list after we read its first block, but before we finished getting
+      // them all, and so the generation check failed on a subsequent request.
+      // Discarding whatever we've got and retrying should get us a new,
+      // consistent set of memory blocks in this case. If this doesn't work
+      // after a couple of retries, bail out.
+      DetachShmBlocks();
+    }
+    NS_WARNING("child: failed to initialize shared FontList");
+  }
+}
+
+FontList::~FontList() { DetachShmBlocks(); }
+
+FontList::Header& FontList::GetHeader() const MOZ_NO_THREAD_SAFETY_ANALYSIS {
+  // We only need to lock if we're not on the main thread.
+  bool isMainThread = NS_IsMainThread();
+  if (!isMainThread) {
+    gfxPlatformFontList::PlatformFontList()->Lock();
+  }
+
+  // It's invalid to try and access this before the first block exists.
+  MOZ_ASSERT(mBlocks.Length() > 0);
+  auto& result = *static_cast<Header*>(mBlocks[0]->Memory());
+
+  if (!isMainThread) {
+    gfxPlatformFontList::PlatformFontList()->Unlock();
+  }
+
+  return result;
+}
+
+bool FontList::AppendShmBlock(uint32_t aSizeNeeded) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  uint32_t size = std::max(aSizeNeeded, SHM_BLOCK_SIZE);
+  auto newShm = MakeUnique<base::SharedMemory>();
+  if (!newShm->CreateFreezeable(size)) {
+    MOZ_CRASH("failed to create shared memory");
+    return false;
+  }
+  if (!newShm->Map(size) || !newShm->memory()) {
+    MOZ_CRASH("failed to map shared memory");
+    return false;
+  }
+  auto readOnly = MakeUnique<base::SharedMemory>();
+  if (!newShm->ReadOnlyCopy(readOnly.get())) {
+    MOZ_CRASH("failed to create read-only copy");
+    return false;
+  }
+
+  ShmBlock* block = new ShmBlock(std::move(newShm));
+  block->StoreAllocated(sizeof(BlockHeader));
+  block->BlockSize() = size;
+
+  mBlocks.AppendElement(block);
+  GetHeader().mBlockCount.store(mBlocks.Length());
+
+  mReadOnlyShmems.AppendElement(std::move(readOnly));
+
+  // We don't need to broadcast the addition of the initial block,
+  // because child processes can't have initialized their list at all
+  // prior to the first block being set up.
+  if (mBlocks.Length() > 1) {
+    if (NS_IsMainThread()) {
+      dom::ContentParent::BroadcastShmBlockAdded(GetGeneration(),
+                                                 mBlocks.Length() - 1);
+    } else {
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "ShmBlockAdded callback",
+          [generation = GetGeneration(), index = mBlocks.Length() - 1] {
+            dom::ContentParent::BroadcastShmBlockAdded(generation, index);
+          }));
+    }
+  }
+
+  return true;
+}
+
+void FontList::ShmBlockAdded(uint32_t aGeneration, uint32_t aIndex,
+                             base::SharedMemoryHandle aHandle) {
+  MOZ_ASSERT(!XRE_IsParentProcess());
+  MOZ_ASSERT(mBlocks.Length() > 0);
+
+  auto newShm = MakeUnique<base::SharedMemory>();
+  if (!newShm->IsHandleValid(aHandle)) {
+    return;
+  }
+  if (!newShm->SetHandle(std::move(aHandle), true)) {
+    MOZ_CRASH("failed to set shm handle");
+  }
+
+  if (aIndex != mBlocks.Length()) {
+    return;
+  }
+  if (aGeneration != GetGeneration()) {
+    return;
+  }
+
+  if (!newShm->Map(SHM_BLOCK_SIZE) || !newShm->memory()) {
+    MOZ_CRASH("failed to map shared memory");
+  }
+
+  uint32_t size = static_cast<BlockHeader*>(newShm->memory())->mBlockSize;
+  MOZ_ASSERT(size >= SHM_BLOCK_SIZE);
+  if (size != SHM_BLOCK_SIZE) {
+    newShm->Unmap();
+    if (!newShm->Map(size) || !newShm->memory()) {
+      MOZ_CRASH("failed to map shared memory");
+    }
+  }
+
+  mBlocks.AppendElement(new ShmBlock(std::move(newShm)));
+}
+
+void FontList::DetachShmBlocks() {
+  for (auto& i : mBlocks) {
+    i->mShmem = nullptr;
+  }
+  mBlocks.Clear();
+  mReadOnlyShmems.Clear();
+}
+
+FontList::ShmBlock* FontList::GetBlockFromParent(uint32_t aIndex) {
+  MOZ_ASSERT(!XRE_IsParentProcess());
+  // If we have no existing blocks, we don't want a generation check yet;
+  // the header in the first block will define the generation of this list
+  uint32_t generation = aIndex == 0 ? 0 : GetGeneration();
+  base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle();
+  if (!dom::ContentChild::GetSingleton()->SendGetFontListShmBlock(
+          generation, aIndex, &handle)) {
+    return nullptr;
+  }
+  auto newShm = MakeUnique<base::SharedMemory>();
+  if (!newShm->IsHandleValid(handle)) {
+    return nullptr;
+  }
+  if (!newShm->SetHandle(std::move(handle), true)) {
+    MOZ_CRASH("failed to set shm handle");
+  }
+  if (!newShm->Map(SHM_BLOCK_SIZE) || !newShm->memory()) {
+    MOZ_CRASH("failed to map shared memory");
+  }
+  uint32_t size = static_cast<BlockHeader*>(newShm->memory())->mBlockSize;
+  MOZ_ASSERT(size >= SHM_BLOCK_SIZE);
+  if (size != SHM_BLOCK_SIZE) {
+    newShm->Unmap();
+    if (!newShm->Map(size) || !newShm->memory()) {
+      MOZ_CRASH("failed to map shared memory");
+    }
+  }
+  return new ShmBlock(std::move(newShm));
+}
+
+// We don't take the lock when called from the constructor, so disable thread-
+// safety analysis here.
+bool FontList::UpdateShmBlocks(bool aMustLock) MOZ_NO_THREAD_SAFETY_ANALYSIS {
+  MOZ_ASSERT(!XRE_IsParentProcess());
+  if (aMustLock) {
+    gfxPlatformFontList::PlatformFontList()->Lock();
+  }
+  bool result = true;
+  while (!mBlocks.Length() || mBlocks.Length() < GetHeader().mBlockCount) {
+    ShmBlock* newBlock = GetBlockFromParent(mBlocks.Length());
+    if (!newBlock) {
+      result = false;
+      break;
+    }
+    mBlocks.AppendElement(newBlock);
+  }
+  if (aMustLock) {
+    gfxPlatformFontList::PlatformFontList()->Unlock();
+  }
+  return result;
+}
+
+void FontList::ShareBlocksToProcess(nsTArray<base::SharedMemoryHandle>* aBlocks,
+                                    base::ProcessId aPid) {
+  MOZ_RELEASE_ASSERT(mReadOnlyShmems.Length() == mBlocks.Length());
+  for (auto& shmem : mReadOnlyShmems) {
+    auto handle = shmem->CloneHandle();
+    if (!handle) {
+      // If something went wrong here, we just bail out; the child will need to
+      // request the blocks as needed, at some performance cost. (Although in
+      // practice this may mean resources are so constrained the child process
+      // isn't really going to work at all. But that's not our problem here.)
+      aBlocks->Clear();
+      return;
+    }
+    aBlocks->AppendElement(std::move(handle));
+  }
+}
+
+base::SharedMemoryHandle FontList::ShareBlockToProcess(uint32_t aIndex,
+                                                       base::ProcessId aPid) {
+  MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
+  MOZ_RELEASE_ASSERT(mReadOnlyShmems.Length() == mBlocks.Length());
+  MOZ_RELEASE_ASSERT(aIndex < mReadOnlyShmems.Length());
+
+  return mReadOnlyShmems[aIndex]->CloneHandle();
+}
+
+Pointer FontList::Alloc(uint32_t aSize) {
+  // Only the parent process does allocation.
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  // 4-byte alignment is good enough for anything we allocate in the font list,
+  // as our "Pointer" (block index/offset) is a 32-bit value even on x64.
+  auto align = [](uint32_t aSize) -> size_t { return (aSize + 3u) & ~3u; };
+
+  aSize = align(aSize);
+
+  int32_t blockIndex = -1;
+  uint32_t curAlloc, size;
+
+  if (aSize < SHM_BLOCK_SIZE - sizeof(BlockHeader)) {
+    // Try to allocate in the most recently added block first, as this is
+    // highly likely to succeed; if not, try earlier blocks (to fill gaps).
+    const int32_t blockCount = mBlocks.Length();
+    for (blockIndex = blockCount - 1; blockIndex >= 0; --blockIndex) {
+      size = mBlocks[blockIndex]->BlockSize();
+      curAlloc = mBlocks[blockIndex]->Allocated();
+      if (size - curAlloc >= aSize) {
+        break;
+      }
+    }
+  }
+
+  if (blockIndex < 0) {
+    // Couldn't find enough space (or the requested size is too large to use
+    // a part of a block): create a new block.
+    if (!AppendShmBlock(aSize + sizeof(BlockHeader))) {
+      return Pointer::Null();
+    }
+    blockIndex = mBlocks.Length() - 1;
+    curAlloc = mBlocks[blockIndex]->Allocated();
+  }
+
+  // We've found a block; allocate space from it, and return
+  mBlocks[blockIndex]->StoreAllocated(curAlloc + aSize);
+
+  return Pointer(blockIndex, curAlloc);
+}
+
+void FontList::SetFamilyNames(nsTArray<Family::InitData>& aFamilies) {
+  // Only the parent process should ever assign the list of families.
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  Header& header = GetHeader();
+  MOZ_ASSERT(!header.mFamilyCount);
+
+  gfxPlatformFontList::PlatformFontList()->ApplyWhitelist(aFamilies);
+  aFamilies.Sort();
+
+  size_t count = aFamilies.Length();
+
+  // Check for duplicate family entries (can occur if there is a bundled font
+  // that has the same name as a system-installed one); in this case we keep
+  // the bundled one as it will always be exposed.
+  if (count > 1) {
+    for (size_t i = 1; i < count; ++i) {
+      if (aFamilies[i].mKey.Equals(aFamilies[i - 1].mKey)) {
+        // Decide whether to discard the current entry or the preceding one
+        size_t discard =
+            aFamilies[i].mBundled && !aFamilies[i - 1].mBundled ? i - 1 : i;
+        aFamilies.RemoveElementAt(discard);
+        --count;
+        --i;
+      }
+    }
+  }
+
+  header.mFamilies = Alloc(count * sizeof(Family));
+  if (header.mFamilies.IsNull()) {
+    return;
+  }
+
+  // We can't call Families() here because the mFamilyCount field has not yet
+  // been set!
+  auto* families = header.mFamilies.ToArray<Family>(this, count);
+  for (size_t i = 0; i < count; i++) {
+    (void)new (&families[i]) Family(this, aFamilies[i]);
+    LOG_FONTLIST(("(shared-fontlist) family %u (%s)", (unsigned)i,
+                  aFamilies[i].mName.get()));
+  }
+
+  header.mFamilyCount = count;
+}
+
+void FontList::SetAliases(
+    nsClassHashtable<nsCStringHashKey, AliasData>& aAliasTable) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  Header& header = GetHeader();
+
+  // Build an array of Family::InitData records based on the entries in
+  // aAliasTable, then sort them and store into the fontlist.
+  nsTArray<Family::InitData> aliasArray;
+  aliasArray.SetCapacity(aAliasTable.Count());
+  for (const auto& entry : aAliasTable) {
+    aliasArray.AppendElement(Family::InitData(
+        entry.GetKey(), entry.GetData()->mBaseFamily, entry.GetData()->mIndex,
+        entry.GetData()->mVisibility, entry.GetData()->mBundled,
+        entry.GetData()->mBadUnderline, entry.GetData()->mForceClassic, true));
+  }
+  aliasArray.Sort();
+
+  size_t count = aliasArray.Length();
+  if (count < header.mAliasCount) {
+    // This shouldn't happen, but handle it safely by just bailing out.
+    NS_WARNING("cannot reduce number of aliases");
+    return;
+  }
+  fontlist::Pointer ptr = Alloc(count * sizeof(Family));
+  auto* aliases = ptr.ToArray<Family>(this, count);
+  for (size_t i = 0; i < count; i++) {
+    (void)new (&aliases[i]) Family(this, aliasArray[i]);
+    LOG_FONTLIST(("(shared-fontlist) alias family %u (%s: %s)", (unsigned)i,
+                  aliasArray[i].mKey.get(), aliasArray[i].mName.get()));
+    aliases[i].SetFacePtrs(this, aAliasTable.Get(aliasArray[i].mKey)->mFaces);
+    if (LOG_FONTLIST_ENABLED()) {
+      const auto& faces = aAliasTable.Get(aliasArray[i].mKey)->mFaces;
+      for (unsigned j = 0; j < faces.Length(); j++) {
+        auto* face = faces[j].ToPtr<const Face>(this);
+        const nsCString& desc = face->mDescriptor.AsString(this);
+        nsAutoCString weight, style, stretch;
+        face->mWeight.ToString(weight);
+        face->mStyle.ToString(style);
+        face->mStretch.ToString(stretch);
+        LOG_FONTLIST(
+            ("(shared-fontlist) face (%s) index %u, weight %s, style %s, "
+             "stretch %s",
+             desc.get(), face->mIndex, weight.get(), style.get(),
+             stretch.get()));
+      }
+    }
+  }
+
+  // Set the pointer before the count, so that any other process trying to read
+  // will not risk out-of-bounds access to the array.
+  header.mAliases = ptr;
+  header.mAliasCount.store(count);
+}
+
+void FontList::SetLocalNames(
+    nsTHashMap<nsCStringHashKey, LocalFaceRec::InitData>& aLocalNameTable) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  Header& header = GetHeader();
+  if (header.mLocalFaceCount > 0) {
+    return;  // already been done!
+  }
+  auto faceArray = ToTArray<nsTArray<nsCString>>(aLocalNameTable.Keys());
+  faceArray.Sort();
+  size_t count = faceArray.Length();
+  Family* families = Families();
+  fontlist::Pointer ptr = Alloc(count * sizeof(LocalFaceRec));
+  auto* faces = ptr.ToArray<LocalFaceRec>(this, count);
+  for (size_t i = 0; i < count; i++) {
+    (void)new (&faces[i]) LocalFaceRec();
+    const auto& rec = aLocalNameTable.Get(faceArray[i]);
+    faces[i].mKey.Assign(faceArray[i], this);
+    // Local face name records will refer to the canonical family name; we don't
+    // need to search aliases here.
+    const auto* family = FindFamily(rec.mFamilyName, /*aPrimaryNameOnly*/ true);
+    if (!family) {
+      // Skip this record if the family was excluded by the font whitelist pref.
+      continue;
+    }
+    faces[i].mFamilyIndex = family - families;
+    if (rec.mFaceIndex == uint32_t(-1)) {
+      // The InitData record contains an mFaceDescriptor rather than an index,
+      // so now we need to look for the appropriate index in the family.
+      faces[i].mFaceIndex = 0;
+      const Pointer* faceList =
+          static_cast<const Pointer*>(family->Faces(this));
+      for (uint32_t j = 0; j < family->NumFaces(); j++) {
+        if (!faceList[j].IsNull()) {
+          auto* f = faceList[j].ToPtr<const Face>(this);
+          if (f && rec.mFaceDescriptor == f->mDescriptor.AsString(this)) {
+            faces[i].mFaceIndex = j;
+            break;
+          }
+        }
+      }
+    } else {
+      faces[i].mFaceIndex = rec.mFaceIndex;
+    }
+  }
+  header.mLocalFaces = ptr;
+  header.mLocalFaceCount.store(count);
+}
+
+nsCString FontList::LocalizedFamilyName(const Family* aFamily) {
+  // If the given family was created for an alternate locale or legacy name,
+  // search for a standard family that corresponds to it. This is a linear
+  // search of the font list, but (a) this is only used to show names in
+  // Preferences, so is not performance-critical for layout etc.; and (b) few
+  // such family names are normally present anyway, the vast majority of fonts
+  // just have a single family name and we return it directly.
+  if (aFamily->IsAltLocaleFamily()) {
+    // Currently only the Windows backend actually does this; on other systems,
+    // the family index is unused and will be kNoIndex for all fonts.
+    if (aFamily->Index() != Family::kNoIndex) {
+      const Family* families = Families();
+      for (uint32_t i = 0; i < NumFamilies(); ++i) {
+        if (families[i].Index() == aFamily->Index() &&
+            families[i].IsBundled() == aFamily->IsBundled() &&
+            !families[i].IsAltLocaleFamily()) {
+          return families[i].DisplayName().AsString(this);
+        }
+      }
+    }
+  }
+
+  // For standard families (or if we failed to find the expected standard
+  // family for some reason), just return the DisplayName.
+  return aFamily->DisplayName().AsString(this);
+}
+
+Family* FontList::FindFamily(const nsCString& aName, bool aPrimaryNameOnly) {
+  struct FamilyNameComparator {
+    FamilyNameComparator(FontList* aList, const nsCString& aTarget)
+        : mList(aList), mTarget(aTarget) {}
+
+    int operator()(const Family& aVal) const {
+      return Compare(mTarget,
+                     nsDependentCString(aVal.Key().BeginReading(mList)));
+    }
+
+   private:
+    FontList* mList;
+    const nsCString& mTarget;
+  };
+
+  const Header& header = GetHeader();
+
+  Family* families = Families();
+  if (!families) {
+    return nullptr;
+  }
+
+  size_t match;
+  if (BinarySearchIf(families, 0, header.mFamilyCount,
+                     FamilyNameComparator(this, aName), &match)) {
+    return &families[match];
+  }
+
+  if (aPrimaryNameOnly) {
+    return nullptr;
+  }
+
+  if (header.mAliasCount) {
+    Family* aliases = AliasFamilies();
+    size_t match;
+    if (aliases && BinarySearchIf(aliases, 0, header.mAliasCount,
+                                  FamilyNameComparator(this, aName), &match)) {
+      return &aliases[match];
+    }
+  }
+
+#ifdef XP_WIN
+  // For Windows only, because of how DWrite munges font family names in some
+  // cases (see
+  // https://msdnshared.blob.core.windows.net/media/MSDNBlogsFS/prod.evol.blogs.msdn.com/CommunityServer.Components.PostAttachments/00/02/24/90/36/WPF%20Font%20Selection%20Model.pdf
+  // and discussion on the OpenType list), try stripping a possible style-name
+  // suffix from the end of the requested family name.
+  // After the deferred font loader has finished, this is no longer needed as
+  // the "real" family names will have been found in AliasFamilies() above.
+  if (aName.Contains(' ')) {
+    auto pfl = gfxPlatformFontList::PlatformFontList();
+    pfl->mLock.AssertCurrentThreadIn();
+    if (header.mAliasCount) {
+      // Aliases have been fully loaded by the parent process, so just discard
+      // any stray mAliasTable and mLocalNameTable entries from earlier calls
+      // to this code, and return.
+      pfl->mAliasTable.Clear();
+      pfl->mLocalNameTable.Clear();
+      return nullptr;
+    }
+
+    // Do we already have an aliasData record for this name? If so, we just
+    // return its base family.
+    if (auto lookup = pfl->mAliasTable.Lookup(aName)) {
+      return FindFamily(lookup.Data()->mBaseFamily, true);
+    }
+
+    // Strip the style suffix (after last space in the name) to get a "base"
+    // family name.
+    const char* data = aName.BeginReading();
+    int32_t index = aName.Length();
+    while (--index > 0) {
+      if (data[index] == ' ') {
+        break;
+      }
+    }
+    if (index <= 0) {
+      return nullptr;
+    }
+    nsAutoCString base(Substring(aName, 0, index));
+    if (BinarySearchIf(families, 0, header.mFamilyCount,
+                       FamilyNameComparator(this, base), &match)) {
+      // This may be a possible base family to satisfy the search; call
+      // ReadFaceNamesForFamily and see if the desired name ends up in
+      // mAliasTable.
+      // Note that ReadFaceNamesForFamily may store entries in mAliasTable
+      // (and mLocalNameTable), but if this is happening in a content
+      // process (which is the common case) those entries will not be saved
+      // into the shared font list; they're just used here until the "real"
+      // alias list is ready, then discarded.
+      Family* baseFamily = &families[match];
+      pfl->ReadFaceNamesForFamily(baseFamily, false);
+      if (auto lookup = pfl->mAliasTable.Lookup(aName)) {
+        if (lookup.Data()->mFaces.Length() != baseFamily->NumFaces()) {
+          // If the alias family doesn't have all the faces of the base family,
+          // then style matching may end up resolving to a face that isn't
+          // supposed to be available in the legacy styled family. To ensure
+          // such mis-styling will get fixed, we start the async font info
+          // loader (if it hasn't yet been triggered), which will pull in the
+          // full metadata we need and then force a reflow.
+          pfl->InitOtherFamilyNames(/* aDeferOtherFamilyNamesLoading */ true);
+        }
+        return baseFamily;
+      }
+    }
+  }
+#endif
+
+  return nullptr;
+}
+
+LocalFaceRec* FontList::FindLocalFace(const nsCString& aName) {
+  struct FaceNameComparator {
+    FaceNameComparator(FontList* aList, const nsCString& aTarget)
+        : mList(aList), mTarget(aTarget) {}
+
+    int operator()(const LocalFaceRec& aVal) const {
+      return Compare(mTarget,
+                     nsDependentCString(aVal.mKey.BeginReading(mList)));
+    }
+
+   private:
+    FontList* mList;
+    const nsCString& mTarget;
+  };
+
+  Header& header = GetHeader();
+
+  LocalFaceRec* faces = LocalFaces();
+  size_t match;
+  if (faces && BinarySearchIf(faces, 0, header.mLocalFaceCount,
+                              FaceNameComparator(this, aName), &match)) {
+    return &faces[match];
+  }
+
+  return nullptr;
+}
+
+void FontList::SearchForLocalFace(const nsACString& aName, Family** aFamily,
+                                  Face** aFace) {
+  Header& header = GetHeader();
+  MOZ_ASSERT(header.mLocalFaceCount == 0,
+             "do not use when local face names are already set up!");
+  LOG_FONTLIST(
+      ("(shared-fontlist) local face search for (%s)", aName.BeginReading()));
+  char initial = aName[0];
+  Family* families = Families();
+  if (!families) {
+    return;
+  }
+  for (uint32_t i = 0; i < header.mFamilyCount; i++) {
+    Family* family = &families[i];
+    if (family->Key().BeginReading(this)[0] != initial) {
+      continue;
+    }
+    LOG_FONTLIST(("(shared-fontlist) checking family (%s)",
+                  family->Key().AsString(this).BeginReading()));
+    if (!family->IsInitialized()) {
+      if (!gfxPlatformFontList::PlatformFontList()->InitializeFamily(family)) {
+        continue;
+      }
+    }
+    Pointer* faces = family->Faces(this);
+    if (!faces) {
+      continue;
+    }
+    for (uint32_t j = 0; j < family->NumFaces(); j++) {
+      auto* face = faces[j].ToPtr<Face>(this);
+      if (!face) {
+        continue;
+      }
+      nsAutoCString psname, fullname;
+      if (gfxPlatformFontList::PlatformFontList()->ReadFaceNames(
+              family, face, psname, fullname)) {
+        LOG_FONTLIST(("(shared-fontlist) read psname (%s) fullname (%s)",
+                      psname.get(), fullname.get()));
+        ToLowerCase(psname);
+        ToLowerCase(fullname);
+        if (aName == psname || aName == fullname) {
+          *aFamily = family;
+          *aFace = face;
+          return;
+        }
+      }
+    }
+  }
+}
+
+Pointer FontList::ToSharedPointer(const void* aPtr) {
+  const char* p = (const char*)aPtr;
+  const uint32_t blockCount = mBlocks.Length();
+  for (uint32_t i = 0; i < blockCount; ++i) {
+    const char* blockAddr = (const char*)mBlocks[i]->Memory();
+    if (p >= blockAddr && p < blockAddr + SHM_BLOCK_SIZE) {
+      return Pointer(i, p - blockAddr);
+    }
+  }
+  MOZ_DIAGNOSTIC_ASSERT(false, "invalid shared-memory pointer");
+  return Pointer::Null();
+}
+
+size_t FontList::SizeOfIncludingThis(
+    mozilla::MallocSizeOf aMallocSizeOf) const {
+  return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+
+size_t FontList::SizeOfExcludingThis(
+    mozilla::MallocSizeOf aMallocSizeOf) const {
+  size_t result = mBlocks.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  for (const auto& b : mBlocks) {
+    result += aMallocSizeOf(b.get()) + aMallocSizeOf(b->mShmem.get());
+  }
+  return result;
+}
+
+size_t FontList::AllocatedShmemSize() const {
+  size_t result = 0;
+  for (const auto& b : mBlocks) {
+    result += b->BlockSize();
+  }
+  return result;
+}
+
+}  // namespace fontlist
+}  // namespace mozilla