Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 3852 insertions, 0 deletions

diff --git a/gfx/thebes/gfxTextRun.cpp b/gfx/thebes/gfxTextRun.cpp
new file mode 100644
index 0000000000..447594ba66
--- /dev/null
+++ b/gfx/thebes/gfxTextRun.cpp
@@ -0,0 +1,3852 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=4 et sw=2 tw=80: */
+/* 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 "gfxTextRun.h"
+#include "gfxGlyphExtents.h"
+#include "gfxHarfBuzzShaper.h"
+#include "gfxPlatformFontList.h"
+#include "gfxUserFontSet.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/PathHelpers.h"
+#include "mozilla/ServoStyleSet.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StaticPresData.h"
+
+#include "gfxContext.h"
+#include "gfxFontConstants.h"
+#include "gfxFontMissingGlyphs.h"
+#include "gfxScriptItemizer.h"
+#include "nsUnicodeProperties.h"
+#include "nsStyleConsts.h"
+#include "nsStyleUtil.h"
+#include "mozilla/Likely.h"
+#include "gfx2DGlue.h"
+#include "mozilla/gfx/Logging.h"  // for gfxCriticalError
+#include "mozilla/intl/String.h"
+#include "mozilla/intl/UnicodeProperties.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Unused.h"
+#include "SharedFontList-impl.h"
+#include "TextDrawTarget.h"
+
+#ifdef XP_WIN
+#  include "gfxWindowsPlatform.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::intl;
+using namespace mozilla::unicode;
+using mozilla::services::GetObserverService;
+
+static const char16_t kEllipsisChar[] = {0x2026, 0x0};
+static const char16_t kASCIIPeriodsChar[] = {'.', '.', '.', 0x0};
+
+#ifdef DEBUG_roc
+#  define DEBUG_TEXT_RUN_STORAGE_METRICS
+#endif
+
+#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS
+extern uint32_t gTextRunStorageHighWaterMark;
+extern uint32_t gTextRunStorage;
+extern uint32_t gFontCount;
+extern uint32_t gGlyphExtentsCount;
+extern uint32_t gGlyphExtentsWidthsTotalSize;
+extern uint32_t gGlyphExtentsSetupEagerSimple;
+extern uint32_t gGlyphExtentsSetupEagerTight;
+extern uint32_t gGlyphExtentsSetupLazyTight;
+extern uint32_t gGlyphExtentsSetupFallBackToTight;
+#endif
+
+void gfxTextRun::GlyphRunIterator::NextRun() {
+  if (mReverse) {
+    if (mGlyphRun == mTextRun->mGlyphRuns.begin()) {
+      mGlyphRun = nullptr;
+      return;
+    }
+    --mGlyphRun;
+  } else {
+    MOZ_DIAGNOSTIC_ASSERT(mGlyphRun != mTextRun->mGlyphRuns.end());
+    ++mGlyphRun;
+    if (mGlyphRun == mTextRun->mGlyphRuns.end()) {
+      mGlyphRun = nullptr;
+      return;
+    }
+  }
+  if (mGlyphRun->mCharacterOffset >= mEndOffset) {
+    mGlyphRun = nullptr;
+    return;
+  }
+  uint32_t glyphRunEndOffset = mGlyphRun == mTextRun->mGlyphRuns.end() - 1
+                                   ? mTextRun->GetLength()
+                                   : (mGlyphRun + 1)->mCharacterOffset;
+  if (glyphRunEndOffset < mStartOffset) {
+    mGlyphRun = nullptr;
+    return;
+  }
+  mStringEnd = std::min(mEndOffset, glyphRunEndOffset);
+  mStringStart = std::max(mStartOffset, mGlyphRun->mCharacterOffset);
+}
+
+#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS
+static void AccountStorageForTextRun(gfxTextRun* aTextRun, int32_t aSign) {
+  // Ignores detailed glyphs... we don't know when those have been constructed
+  // Also ignores gfxSkipChars dynamic storage (which won't be anything
+  // for preformatted text)
+  // Also ignores GlyphRun array, again because it hasn't been constructed
+  // by the time this gets called. If there's only one glyphrun that's stored
+  // directly in the textrun anyway so no additional overhead.
+  uint32_t length = aTextRun->GetLength();
+  int32_t bytes = length * sizeof(gfxTextRun::CompressedGlyph);
+  bytes += sizeof(gfxTextRun);
+  gTextRunStorage += bytes * aSign;
+  gTextRunStorageHighWaterMark =
+      std::max(gTextRunStorageHighWaterMark, gTextRunStorage);
+}
+#endif
+
+bool gfxTextRun::NeedsGlyphExtents() const {
+  if (GetFlags() & gfx::ShapedTextFlags::TEXT_NEED_BOUNDING_BOX) {
+    return true;
+  }
+  for (const auto& run : mGlyphRuns) {
+    if (run.mFont->GetFontEntry()->IsUserFont()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Helper for textRun creation to preallocate storage for glyph records;
+// this function returns a pointer to the newly-allocated glyph storage.
+// Returns nullptr if allocation fails.
+void* gfxTextRun::AllocateStorageForTextRun(size_t aSize, uint32_t aLength) {
+  // Allocate the storage we need, returning nullptr on failure rather than
+  // throwing an exception (because web content can create huge runs).
+  void* storage = malloc(aSize + aLength * sizeof(CompressedGlyph));
+  if (!storage) {
+    NS_WARNING("failed to allocate storage for text run!");
+    return nullptr;
+  }
+
+  // Initialize the glyph storage (beyond aSize) to zero
+  memset(reinterpret_cast<char*>(storage) + aSize, 0,
+         aLength * sizeof(CompressedGlyph));
+
+  return storage;
+}
+
+already_AddRefed<gfxTextRun> gfxTextRun::Create(
+    const gfxTextRunFactory::Parameters* aParams, uint32_t aLength,
+    gfxFontGroup* aFontGroup, gfx::ShapedTextFlags aFlags,
+    nsTextFrameUtils::Flags aFlags2) {
+  void* storage = AllocateStorageForTextRun(sizeof(gfxTextRun), aLength);
+  if (!storage) {
+    return nullptr;
+  }
+
+  RefPtr<gfxTextRun> result =
+      new (storage) gfxTextRun(aParams, aLength, aFontGroup, aFlags, aFlags2);
+  return result.forget();
+}
+
+gfxTextRun::gfxTextRun(const gfxTextRunFactory::Parameters* aParams,
+                       uint32_t aLength, gfxFontGroup* aFontGroup,
+                       gfx::ShapedTextFlags aFlags,
+                       nsTextFrameUtils::Flags aFlags2)
+    : gfxShapedText(aLength, aFlags, aParams->mAppUnitsPerDevUnit),
+      mUserData(aParams->mUserData),
+      mFontGroup(aFontGroup),
+      mFlags2(aFlags2),
+      mReleasedFontGroup(false),
+      mReleasedFontGroupSkippedDrawing(false),
+      mShapingState(eShapingState_Normal) {
+  NS_ASSERTION(mAppUnitsPerDevUnit > 0, "Invalid app unit scale");
+  NS_ADDREF(mFontGroup);
+
+#ifndef RELEASE_OR_BETA
+  gfxTextPerfMetrics* tp = aFontGroup->GetTextPerfMetrics();
+  if (tp) {
+    tp->current.textrunConst++;
+  }
+#endif
+
+  mCharacterGlyphs = reinterpret_cast<CompressedGlyph*>(this + 1);
+
+  if (aParams->mSkipChars) {
+    mSkipChars.TakeFrom(aParams->mSkipChars);
+  }
+
+#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS
+  AccountStorageForTextRun(this, 1);
+#endif
+
+  mDontSkipDrawing =
+      !!(aFlags2 & nsTextFrameUtils::Flags::DontSkipDrawingForPendingUserFonts);
+}
+
+gfxTextRun::~gfxTextRun() {
+#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS
+  AccountStorageForTextRun(this, -1);
+#endif
+#ifdef DEBUG
+  // Make it easy to detect a dead text run
+  mFlags = ~gfx::ShapedTextFlags();
+  mFlags2 = ~nsTextFrameUtils::Flags();
+#endif
+
+  // The cached ellipsis textrun (if any) in a fontgroup will have already
+  // been told to release its reference to the group, so we mustn't do that
+  // again here.
+  if (!mReleasedFontGroup) {
+#ifndef RELEASE_OR_BETA
+    gfxTextPerfMetrics* tp = mFontGroup->GetTextPerfMetrics();
+    if (tp) {
+      tp->current.textrunDestr++;
+    }
+#endif
+    NS_RELEASE(mFontGroup);
+  }
+}
+
+void gfxTextRun::ReleaseFontGroup() {
+  NS_ASSERTION(!mReleasedFontGroup, "doubly released!");
+
+  // After dropping our reference to the font group, we'll no longer be able
+  // to get up-to-date results for ShouldSkipDrawing().  Store the current
+  // value in mReleasedFontGroupSkippedDrawing.
+  //
+  // (It doesn't actually matter that we can't get up-to-date results for
+  // ShouldSkipDrawing(), since the only text runs that we call
+  // ReleaseFontGroup() for are ellipsis text runs, and we ask the font
+  // group for a new ellipsis text run each time we want to draw one,
+  // and ensure that the cached one is cleared in ClearCachedData() when
+  // font loading status changes.)
+  mReleasedFontGroupSkippedDrawing = mFontGroup->ShouldSkipDrawing();
+
+  NS_RELEASE(mFontGroup);
+  mReleasedFontGroup = true;
+}
+
+bool gfxTextRun::SetPotentialLineBreaks(Range aRange,
+                                        const uint8_t* aBreakBefore) {
+  NS_ASSERTION(aRange.end <= GetLength(), "Overflow");
+
+  uint32_t changed = 0;
+  CompressedGlyph* cg = mCharacterGlyphs + aRange.start;
+  const CompressedGlyph* const end = cg + aRange.Length();
+  while (cg < end) {
+    uint8_t canBreak = *aBreakBefore++;
+    if (canBreak && !cg->IsClusterStart()) {
+      // XXX If we replace the line-breaker with one based more closely
+      // on UAX#14 (e.g. using ICU), this may not be needed any more.
+      // Avoid possible breaks inside a cluster, EXCEPT when the previous
+      // character was a space (compare UAX#14 rules LB9, LB10).
+      if (cg == mCharacterGlyphs || !(cg - 1)->CharIsSpace()) {
+        canBreak = CompressedGlyph::FLAG_BREAK_TYPE_NONE;
+      }
+    }
+    changed |= cg->SetCanBreakBefore(canBreak);
+    ++cg;
+  }
+  return changed != 0;
+}
+
+gfxTextRun::LigatureData gfxTextRun::ComputeLigatureData(
+    Range aPartRange, const PropertyProvider* aProvider) const {
+  NS_ASSERTION(aPartRange.start < aPartRange.end,
+               "Computing ligature data for empty range");
+  NS_ASSERTION(aPartRange.end <= GetLength(), "Character length overflow");
+
+  LigatureData result;
+  const CompressedGlyph* charGlyphs = mCharacterGlyphs;
+
+  uint32_t i;
+  for (i = aPartRange.start; !charGlyphs[i].IsLigatureGroupStart(); --i) {
+    NS_ASSERTION(i > 0, "Ligature at the start of the run??");
+  }
+  result.mRange.start = i;
+  for (i = aPartRange.start + 1;
+       i < GetLength() && !charGlyphs[i].IsLigatureGroupStart(); ++i) {
+  }
+  result.mRange.end = i;
+
+  int32_t ligatureWidth = GetAdvanceForGlyphs(result.mRange);
+  // Count the number of started clusters we have seen
+  uint32_t totalClusterCount = 0;
+  uint32_t partClusterIndex = 0;
+  uint32_t partClusterCount = 0;
+  for (i = result.mRange.start; i < result.mRange.end; ++i) {
+    // Treat the first character of the ligature as the start of a
+    // cluster for our purposes of allocating ligature width to its
+    // characters.
+    if (i == result.mRange.start || charGlyphs[i].IsClusterStart()) {
+      ++totalClusterCount;
+      if (i < aPartRange.start) {
+        ++partClusterIndex;
+      } else if (i < aPartRange.end) {
+        ++partClusterCount;
+      }
+    }
+  }
+  NS_ASSERTION(totalClusterCount > 0, "Ligature involving no clusters??");
+  result.mPartAdvance = partClusterIndex * (ligatureWidth / totalClusterCount);
+  result.mPartWidth = partClusterCount * (ligatureWidth / totalClusterCount);
+
+  // Any rounding errors are apportioned to the final part of the ligature,
+  // so that measuring all parts of a ligature and summing them is equal to
+  // the ligature width.
+  if (aPartRange.end == result.mRange.end) {
+    gfxFloat allParts = totalClusterCount * (ligatureWidth / totalClusterCount);
+    result.mPartWidth += ligatureWidth - allParts;
+  }
+
+  if (partClusterCount == 0) {
+    // nothing to draw
+    result.mClipBeforePart = result.mClipAfterPart = true;
+  } else {
+    // Determine whether we should clip before or after this part when
+    // drawing its slice of the ligature.
+    // We need to clip before the part if any cluster is drawn before
+    // this part.
+    result.mClipBeforePart = partClusterIndex > 0;
+    // We need to clip after the part if any cluster is drawn after
+    // this part.
+    result.mClipAfterPart =
+        partClusterIndex + partClusterCount < totalClusterCount;
+  }
+
+  if (aProvider && (mFlags & gfx::ShapedTextFlags::TEXT_ENABLE_SPACING)) {
+    gfxFont::Spacing spacing;
+    if (aPartRange.start == result.mRange.start) {
+      aProvider->GetSpacing(Range(aPartRange.start, aPartRange.start + 1),
+                            &spacing);
+      result.mPartWidth += spacing.mBefore;
+    }
+    if (aPartRange.end == result.mRange.end) {
+      aProvider->GetSpacing(Range(aPartRange.end - 1, aPartRange.end),
+                            &spacing);
+      result.mPartWidth += spacing.mAfter;
+    }
+  }
+
+  return result;
+}
+
+gfxFloat gfxTextRun::ComputePartialLigatureWidth(
+    Range aPartRange, const PropertyProvider* aProvider) const {
+  if (aPartRange.start >= aPartRange.end) return 0;
+  LigatureData data = ComputeLigatureData(aPartRange, aProvider);
+  return data.mPartWidth;
+}
+
+int32_t gfxTextRun::GetAdvanceForGlyphs(Range aRange) const {
+  int32_t advance = 0;
+  for (auto i = aRange.start; i < aRange.end; ++i) {
+    advance += GetAdvanceForGlyph(i);
+  }
+  return advance;
+}
+
+static void GetAdjustedSpacing(
+    const gfxTextRun* aTextRun, gfxTextRun::Range aRange,
+    const gfxTextRun::PropertyProvider& aProvider,
+    gfxTextRun::PropertyProvider::Spacing* aSpacing) {
+  if (aRange.start >= aRange.end) {
+    return;
+  }
+
+  aProvider.GetSpacing(aRange, aSpacing);
+
+#ifdef DEBUG
+  // Check to see if we have spacing inside ligatures
+
+  const gfxTextRun::CompressedGlyph* charGlyphs =
+      aTextRun->GetCharacterGlyphs();
+  uint32_t i;
+
+  for (i = aRange.start; i < aRange.end; ++i) {
+    if (!charGlyphs[i].IsLigatureGroupStart()) {
+      NS_ASSERTION(i == aRange.start || aSpacing[i - aRange.start].mBefore == 0,
+                   "Before-spacing inside a ligature!");
+      NS_ASSERTION(
+          i - 1 <= aRange.start || aSpacing[i - 1 - aRange.start].mAfter == 0,
+          "After-spacing inside a ligature!");
+    }
+  }
+#endif
+}
+
+bool gfxTextRun::GetAdjustedSpacingArray(
+    Range aRange, const PropertyProvider* aProvider, Range aSpacingRange,
+    nsTArray<PropertyProvider::Spacing>* aSpacing) const {
+  if (!aProvider || !(mFlags & gfx::ShapedTextFlags::TEXT_ENABLE_SPACING)) {
+    return false;
+  }
+  if (!aSpacing->AppendElements(aRange.Length(), fallible)) {
+    return false;
+  }
+  auto spacingOffset = aSpacingRange.start - aRange.start;
+  memset(aSpacing->Elements(), 0, sizeof(gfxFont::Spacing) * spacingOffset);
+  GetAdjustedSpacing(this, aSpacingRange, *aProvider,
+                     aSpacing->Elements() + spacingOffset);
+  memset(aSpacing->Elements() + spacingOffset + aSpacingRange.Length(), 0,
+         sizeof(gfxFont::Spacing) * (aRange.end - aSpacingRange.end));
+  return true;
+}
+
+bool gfxTextRun::ShrinkToLigatureBoundaries(Range* aRange) const {
+  if (aRange->start >= aRange->end) {
+    return false;
+  }
+
+  const CompressedGlyph* charGlyphs = mCharacterGlyphs;
+  bool adjusted = false;
+  while (aRange->start < aRange->end &&
+         !charGlyphs[aRange->start].IsLigatureGroupStart()) {
+    ++aRange->start;
+    adjusted = true;
+  }
+  if (aRange->end < GetLength()) {
+    while (aRange->end > aRange->start &&
+           !charGlyphs[aRange->end].IsLigatureGroupStart()) {
+      --aRange->end;
+      adjusted = true;
+    }
+  }
+  return adjusted;
+}
+
+void gfxTextRun::DrawGlyphs(gfxFont* aFont, Range aRange, gfx::Point* aPt,
+                            const PropertyProvider* aProvider,
+                            Range aSpacingRange, TextRunDrawParams& aParams,
+                            gfx::ShapedTextFlags aOrientation) const {
+  AutoTArray<PropertyProvider::Spacing, 200> spacingBuffer;
+  bool haveSpacing =
+      GetAdjustedSpacingArray(aRange, aProvider, aSpacingRange, &spacingBuffer);
+  aParams.spacing = haveSpacing ? spacingBuffer.Elements() : nullptr;
+  aFont->Draw(this, aRange.start, aRange.end, aPt, aParams, aOrientation);
+}
+
+static void ClipPartialLigature(const gfxTextRun* aTextRun, gfxFloat* aStart,
+                                gfxFloat* aEnd, gfxFloat aOrigin,
+                                gfxTextRun::LigatureData* aLigature) {
+  if (aLigature->mClipBeforePart) {
+    if (aTextRun->IsRightToLeft()) {
+      *aEnd = std::min(*aEnd, aOrigin);
+    } else {
+      *aStart = std::max(*aStart, aOrigin);
+    }
+  }
+  if (aLigature->mClipAfterPart) {
+    gfxFloat endEdge =
+        aOrigin + aTextRun->GetDirection() * aLigature->mPartWidth;
+    if (aTextRun->IsRightToLeft()) {
+      *aStart = std::max(*aStart, endEdge);
+    } else {
+      *aEnd = std::min(*aEnd, endEdge);
+    }
+  }
+}
+
+void gfxTextRun::DrawPartialLigature(gfxFont* aFont, Range aRange,
+                                     gfx::Point* aPt,
+                                     const PropertyProvider* aProvider,
+                                     TextRunDrawParams& aParams,
+                                     gfx::ShapedTextFlags aOrientation) const {
+  if (aRange.start >= aRange.end) {
+    return;
+  }
+
+  // Draw partial ligature. We hack this by clipping the ligature.
+  LigatureData data = ComputeLigatureData(aRange, aProvider);
+  gfxRect clipExtents = aParams.context->GetClipExtents();
+  gfxFloat start, end;
+  if (aParams.isVerticalRun) {
+    start = clipExtents.Y() * mAppUnitsPerDevUnit;
+    end = clipExtents.YMost() * mAppUnitsPerDevUnit;
+    ClipPartialLigature(this, &start, &end, aPt->y, &data);
+  } else {
+    start = clipExtents.X() * mAppUnitsPerDevUnit;
+    end = clipExtents.XMost() * mAppUnitsPerDevUnit;
+    ClipPartialLigature(this, &start, &end, aPt->x, &data);
+  }
+
+  gfxClipAutoSaveRestore autoSaveClip(aParams.context);
+  {
+    // use division here to ensure that when the rect is aligned on multiples
+    // of mAppUnitsPerDevUnit, we clip to true device unit boundaries.
+    // Also, make sure we snap the rectangle to device pixels.
+    Rect clipRect =
+        aParams.isVerticalRun
+            ? Rect(clipExtents.X(), start / mAppUnitsPerDevUnit,
+                   clipExtents.Width(), (end - start) / mAppUnitsPerDevUnit)
+            : Rect(start / mAppUnitsPerDevUnit, clipExtents.Y(),
+                   (end - start) / mAppUnitsPerDevUnit, clipExtents.Height());
+    MaybeSnapToDevicePixels(clipRect, *aParams.dt, true);
+
+    autoSaveClip.Clip(clipRect);
+  }
+
+  gfx::Point pt;
+  if (aParams.isVerticalRun) {
+    pt = Point(aPt->x, aPt->y - aParams.direction * data.mPartAdvance);
+  } else {
+    pt = Point(aPt->x - aParams.direction * data.mPartAdvance, aPt->y);
+  }
+
+  DrawGlyphs(aFont, data.mRange, &pt, aProvider, aRange, aParams, aOrientation);
+
+  if (aParams.isVerticalRun) {
+    aPt->y += aParams.direction * data.mPartWidth;
+  } else {
+    aPt->x += aParams.direction * data.mPartWidth;
+  }
+}
+
+// Returns true if the font has synthetic bolding enabled,
+// or is a color font (COLR/SVG/sbix/CBDT), false otherwise. This is used to
+// check whether the text run needs to be explicitly composited in order to
+// support opacity.
+static bool HasSyntheticBoldOrColor(gfxFont* aFont) {
+  if (aFont->ApplySyntheticBold()) {
+    return true;
+  }
+  gfxFontEntry* fe = aFont->GetFontEntry();
+  if (fe->TryGetSVGData(aFont) || fe->TryGetColorGlyphs()) {
+    return true;
+  }
+#if defined(XP_MACOSX)  // sbix fonts only supported via Core Text
+  if (fe->HasFontTable(TRUETYPE_TAG('s', 'b', 'i', 'x'))) {
+    return true;
+  }
+#endif
+  return false;
+}
+
+// helper class for double-buffering drawing with non-opaque color
+struct MOZ_STACK_CLASS BufferAlphaColor {
+  explicit BufferAlphaColor(gfxContext* aContext) : mContext(aContext) {}
+
+  ~BufferAlphaColor() = default;
+
+  void PushSolidColor(const gfxRect& aBounds, const DeviceColor& aAlphaColor,
+                      uint32_t appsPerDevUnit) {
+    mContext->Save();
+    mContext->SnappedClip(gfxRect(
+        aBounds.X() / appsPerDevUnit, aBounds.Y() / appsPerDevUnit,
+        aBounds.Width() / appsPerDevUnit, aBounds.Height() / appsPerDevUnit));
+    mContext->SetDeviceColor(
+        DeviceColor(aAlphaColor.r, aAlphaColor.g, aAlphaColor.b));
+    mContext->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, aAlphaColor.a);
+  }
+
+  void PopAlpha() {
+    // pop the text, using the color alpha as the opacity
+    mContext->PopGroupAndBlend();
+    mContext->Restore();
+  }
+
+  gfxContext* mContext;
+};
+
+void gfxTextRun::Draw(const Range aRange, const gfx::Point aPt,
+                      const DrawParams& aParams) const {
+  NS_ASSERTION(aRange.end <= GetLength(), "Substring out of range");
+  NS_ASSERTION(aParams.drawMode == DrawMode::GLYPH_PATH ||
+                   !(aParams.drawMode & DrawMode::GLYPH_PATH),
+               "GLYPH_PATH cannot be used with GLYPH_FILL, GLYPH_STROKE or "
+               "GLYPH_STROKE_UNDERNEATH");
+  NS_ASSERTION(aParams.drawMode == DrawMode::GLYPH_PATH || !aParams.callbacks,
+               "callback must not be specified unless using GLYPH_PATH");
+
+  bool skipDrawing =
+      !mDontSkipDrawing && (mFontGroup ? mFontGroup->ShouldSkipDrawing()
+                                       : mReleasedFontGroupSkippedDrawing);
+  auto* textDrawer = aParams.context->GetTextDrawer();
+  if (aParams.drawMode & DrawMode::GLYPH_FILL) {
+    DeviceColor currentColor;
+    if (aParams.context->GetDeviceColor(currentColor) && currentColor.a == 0 &&
+        !textDrawer) {
+      skipDrawing = true;
+    }
+  }
+
+  gfxFloat direction = GetDirection();
+
+  if (skipDrawing) {
+    // We don't need to draw anything;
+    // but if the caller wants advance width, we need to compute it here
+    if (aParams.advanceWidth) {
+      gfxTextRun::Metrics metrics =
+          MeasureText(aRange, gfxFont::LOOSE_INK_EXTENTS,
+                      aParams.context->GetDrawTarget(), aParams.provider);
+      *aParams.advanceWidth = metrics.mAdvanceWidth * direction;
+    }
+
+    // return without drawing
+    return;
+  }
+
+  // synthetic bolding draws glyphs twice ==> colors with opacity won't draw
+  // correctly unless first drawn without alpha
+  BufferAlphaColor syntheticBoldBuffer(aParams.context);
+  DeviceColor currentColor;
+  bool mayNeedBuffering =
+      aParams.drawMode & DrawMode::GLYPH_FILL &&
+      aParams.context->HasNonOpaqueNonTransparentColor(currentColor) &&
+      !textDrawer;
+
+  // If we need to double-buffer, we'll need to measure the text first to
+  // get the bounds of the area of interest. Ideally we'd do that just for
+  // the specific glyph run(s) that need buffering, but because of bug
+  // 1612610 we currently use the extent of the entire range even when
+  // just buffering a subrange. So we'll measure the full range once and
+  // keep the metrics on hand for any subsequent subranges.
+  gfxTextRun::Metrics metrics;
+  bool gotMetrics = false;
+
+  // Set up parameters that will be constant across all glyph runs we need
+  // to draw, regardless of the font used.
+  TextRunDrawParams params;
+  params.context = aParams.context;
+  params.devPerApp = 1.0 / double(GetAppUnitsPerDevUnit());
+  params.isVerticalRun = IsVertical();
+  params.isRTL = IsRightToLeft();
+  params.direction = direction;
+  params.strokeOpts = aParams.strokeOpts;
+  params.textStrokeColor = aParams.textStrokeColor;
+  params.fontPalette = aParams.fontPalette;
+  params.paletteValueSet = aParams.paletteValueSet;
+  params.textStrokePattern = aParams.textStrokePattern;
+  params.drawOpts = aParams.drawOpts;
+  params.drawMode = aParams.drawMode;
+  params.callbacks = aParams.callbacks;
+  params.runContextPaint = aParams.contextPaint;
+  params.paintSVGGlyphs =
+      !aParams.callbacks || aParams.callbacks->mShouldPaintSVGGlyphs;
+  params.dt = aParams.context->GetDrawTarget();
+  params.textDrawer = textDrawer;
+  if (textDrawer) {
+    params.clipRect = textDrawer->GeckoClipRect();
+  }
+  params.allowGDI = aParams.allowGDI;
+
+  gfxFloat advance = 0.0;
+  gfx::Point pt = aPt;
+
+  for (GlyphRunIterator iter(this, aRange); !iter.AtEnd(); iter.NextRun()) {
+    gfxFont* font = iter.GlyphRun()->mFont;
+    Range runRange(iter.StringStart(), iter.StringEnd());
+
+    bool needToRestore = false;
+    if (mayNeedBuffering && HasSyntheticBoldOrColor(font)) {
+      needToRestore = true;
+      if (!gotMetrics) {
+        // Measure text; use the bounding box to determine the area we need
+        // to buffer. We measure the entire range, rather than just the glyph
+        // run that we're actually handling, because of bug 1612610: if the
+        // bounding box passed to PushSolidColor does not intersect the
+        // drawTarget's current clip, the skia backend fails to clip properly.
+        // This means we may use a larger buffer than actually needed, but is
+        // otherwise harmless.
+        metrics = MeasureText(aRange, gfxFont::LOOSE_INK_EXTENTS, params.dt,
+                              aParams.provider);
+        if (IsRightToLeft()) {
+          metrics.mBoundingBox.MoveBy(
+              gfxPoint(aPt.x - metrics.mAdvanceWidth, aPt.y));
+        } else {
+          metrics.mBoundingBox.MoveBy(gfxPoint(aPt.x, aPt.y));
+        }
+        gotMetrics = true;
+      }
+      syntheticBoldBuffer.PushSolidColor(metrics.mBoundingBox, currentColor,
+                                         GetAppUnitsPerDevUnit());
+    }
+
+    Range ligatureRange(runRange);
+    bool adjusted = ShrinkToLigatureBoundaries(&ligatureRange);
+
+    bool drawPartial =
+        adjusted &&
+        ((aParams.drawMode & (DrawMode::GLYPH_FILL | DrawMode::GLYPH_STROKE)) ||
+         (aParams.drawMode == DrawMode::GLYPH_PATH && aParams.callbacks));
+    gfx::Point origPt = pt;
+
+    if (drawPartial) {
+      DrawPartialLigature(font, Range(runRange.start, ligatureRange.start), &pt,
+                          aParams.provider, params,
+                          iter.GlyphRun()->mOrientation);
+    }
+
+    DrawGlyphs(font, ligatureRange, &pt, aParams.provider, ligatureRange,
+               params, iter.GlyphRun()->mOrientation);
+
+    if (drawPartial) {
+      DrawPartialLigature(font, Range(ligatureRange.end, runRange.end), &pt,
+                          aParams.provider, params,
+                          iter.GlyphRun()->mOrientation);
+    }
+
+    if (params.isVerticalRun) {
+      advance += (pt.y - origPt.y) * params.direction;
+    } else {
+      advance += (pt.x - origPt.x) * params.direction;
+    }
+
+    // composite result when synthetic bolding used
+    if (needToRestore) {
+      syntheticBoldBuffer.PopAlpha();
+    }
+  }
+
+  if (aParams.advanceWidth) {
+    *aParams.advanceWidth = advance;
+  }
+}
+
+// This method is mostly parallel to Draw().
+void gfxTextRun::DrawEmphasisMarks(gfxContext* aContext, gfxTextRun* aMark,
+                                   gfxFloat aMarkAdvance, gfx::Point aPt,
+                                   Range aRange,
+                                   const PropertyProvider* aProvider) const {
+  MOZ_ASSERT(aRange.end <= GetLength());
+
+  EmphasisMarkDrawParams params;
+  params.context = aContext;
+  params.mark = aMark;
+  params.advance = aMarkAdvance;
+  params.direction = GetDirection();
+  params.isVertical = IsVertical();
+
+  float& inlineCoord = params.isVertical ? aPt.y.value : aPt.x.value;
+  float direction = params.direction;
+
+  for (GlyphRunIterator iter(this, aRange); !iter.AtEnd(); iter.NextRun()) {
+    gfxFont* font = iter.GlyphRun()->mFont;
+    uint32_t start = iter.StringStart();
+    uint32_t end = iter.StringEnd();
+    Range ligatureRange(start, end);
+    bool adjusted = ShrinkToLigatureBoundaries(&ligatureRange);
+
+    if (adjusted) {
+      inlineCoord +=
+          direction * ComputePartialLigatureWidth(
+                          Range(start, ligatureRange.start), aProvider);
+    }
+
+    AutoTArray<PropertyProvider::Spacing, 200> spacingBuffer;
+    bool haveSpacing = GetAdjustedSpacingArray(ligatureRange, aProvider,
+                                               ligatureRange, &spacingBuffer);
+    params.spacing = haveSpacing ? spacingBuffer.Elements() : nullptr;
+    font->DrawEmphasisMarks(this, &aPt, ligatureRange.start,
+                            ligatureRange.Length(), params);
+
+    if (adjusted) {
+      inlineCoord += direction * ComputePartialLigatureWidth(
+                                     Range(ligatureRange.end, end), aProvider);
+    }
+  }
+}
+
+void gfxTextRun::AccumulateMetricsForRun(
+    gfxFont* aFont, Range aRange, gfxFont::BoundingBoxType aBoundingBoxType,
+    DrawTarget* aRefDrawTarget, const PropertyProvider* aProvider,
+    Range aSpacingRange, gfx::ShapedTextFlags aOrientation,
+    Metrics* aMetrics) const {
+  AutoTArray<PropertyProvider::Spacing, 200> spacingBuffer;
+  bool haveSpacing =
+      GetAdjustedSpacingArray(aRange, aProvider, aSpacingRange, &spacingBuffer);
+  Metrics metrics = aFont->Measure(
+      this, aRange.start, aRange.end, aBoundingBoxType, aRefDrawTarget,
+      haveSpacing ? spacingBuffer.Elements() : nullptr, aOrientation);
+  aMetrics->CombineWith(metrics, IsRightToLeft());
+}
+
+void gfxTextRun::AccumulatePartialLigatureMetrics(
+    gfxFont* aFont, Range aRange, gfxFont::BoundingBoxType aBoundingBoxType,
+    DrawTarget* aRefDrawTarget, const PropertyProvider* aProvider,
+    gfx::ShapedTextFlags aOrientation, Metrics* aMetrics) const {
+  if (aRange.start >= aRange.end) return;
+
+  // Measure partial ligature. We hack this by clipping the metrics in the
+  // same way we clip the drawing.
+  LigatureData data = ComputeLigatureData(aRange, aProvider);
+
+  // First measure the complete ligature
+  Metrics metrics;
+  AccumulateMetricsForRun(aFont, data.mRange, aBoundingBoxType, aRefDrawTarget,
+                          aProvider, aRange, aOrientation, &metrics);
+
+  // Clip the bounding box to the ligature part
+  gfxFloat bboxLeft = metrics.mBoundingBox.X();
+  gfxFloat bboxRight = metrics.mBoundingBox.XMost();
+  // Where we are going to start "drawing" relative to our left baseline origin
+  gfxFloat origin =
+      IsRightToLeft() ? metrics.mAdvanceWidth - data.mPartAdvance : 0;
+  ClipPartialLigature(this, &bboxLeft, &bboxRight, origin, &data);
+  metrics.mBoundingBox.SetBoxX(bboxLeft, bboxRight);
+
+  // mBoundingBox is now relative to the left baseline origin for the entire
+  // ligature. Shift it left.
+  metrics.mBoundingBox.MoveByX(
+      -(IsRightToLeft()
+            ? metrics.mAdvanceWidth - (data.mPartAdvance + data.mPartWidth)
+            : data.mPartAdvance));
+  metrics.mAdvanceWidth = data.mPartWidth;
+
+  aMetrics->CombineWith(metrics, IsRightToLeft());
+}
+
+gfxTextRun::Metrics gfxTextRun::MeasureText(
+    Range aRange, gfxFont::BoundingBoxType aBoundingBoxType,
+    DrawTarget* aRefDrawTarget, const PropertyProvider* aProvider) const {
+  NS_ASSERTION(aRange.end <= GetLength(), "Substring out of range");
+
+  Metrics accumulatedMetrics;
+  for (GlyphRunIterator iter(this, aRange); !iter.AtEnd(); iter.NextRun()) {
+    gfxFont* font = iter.GlyphRun()->mFont;
+    uint32_t start = iter.StringStart();
+    uint32_t end = iter.StringEnd();
+    Range ligatureRange(start, end);
+    bool adjusted = ShrinkToLigatureBoundaries(&ligatureRange);
+
+    if (adjusted) {
+      AccumulatePartialLigatureMetrics(font, Range(start, ligatureRange.start),
+                                       aBoundingBoxType, aRefDrawTarget,
+                                       aProvider, iter.GlyphRun()->mOrientation,
+                                       &accumulatedMetrics);
+    }
+
+    // XXX This sucks. We have to get glyph extents just so we can detect
+    // glyphs outside the font box, even when aBoundingBoxType is LOOSE,
+    // even though in almost all cases we could get correct results just
+    // by getting some ascent/descent from the font and using our stored
+    // advance widths.
+    AccumulateMetricsForRun(font, ligatureRange, aBoundingBoxType,
+                            aRefDrawTarget, aProvider, ligatureRange,
+                            iter.GlyphRun()->mOrientation, &accumulatedMetrics);
+
+    if (adjusted) {
+      AccumulatePartialLigatureMetrics(
+          font, Range(ligatureRange.end, end), aBoundingBoxType, aRefDrawTarget,
+          aProvider, iter.GlyphRun()->mOrientation, &accumulatedMetrics);
+    }
+  }
+
+  return accumulatedMetrics;
+}
+
+void gfxTextRun::GetLineHeightMetrics(Range aRange, gfxFloat& aAscent,
+                                      gfxFloat& aDescent) const {
+  Metrics accumulatedMetrics;
+  for (GlyphRunIterator iter(this, aRange); !iter.AtEnd(); iter.NextRun()) {
+    gfxFont* font = iter.GlyphRun()->mFont;
+    auto metrics =
+        font->Measure(this, 0, 0, gfxFont::LOOSE_INK_EXTENTS, nullptr, nullptr,
+                      iter.GlyphRun()->mOrientation);
+    accumulatedMetrics.CombineWith(metrics, false);
+  }
+  aAscent = accumulatedMetrics.mAscent;
+  aDescent = accumulatedMetrics.mDescent;
+}
+
+#define MEASUREMENT_BUFFER_SIZE 100
+
+void gfxTextRun::ClassifyAutoHyphenations(uint32_t aStart, Range aRange,
+                                          nsTArray<HyphenType>& aHyphenBuffer,
+                                          HyphenationState* aWordState) {
+  MOZ_ASSERT(
+      aRange.end - aStart <= aHyphenBuffer.Length() && aRange.start >= aStart,
+      "Range out of bounds");
+  MOZ_ASSERT(aWordState->mostRecentBoundary >= aStart,
+             "Unexpected aMostRecentWordBoundary!!");
+
+  uint32_t start =
+      std::min<uint32_t>(aRange.start, aWordState->mostRecentBoundary);
+
+  for (uint32_t i = start; i < aRange.end; ++i) {
+    if (aHyphenBuffer[i - aStart] == HyphenType::Explicit &&
+        !aWordState->hasExplicitHyphen) {
+      aWordState->hasExplicitHyphen = true;
+    }
+    if (!aWordState->hasManualHyphen &&
+        (aHyphenBuffer[i - aStart] == HyphenType::Soft ||
+         aHyphenBuffer[i - aStart] == HyphenType::Explicit)) {
+      aWordState->hasManualHyphen = true;
+      // This is the first manual hyphen in the current word. We can only
+      // know if the current word has a manual hyphen until now. So, we need
+      // to run a sub loop to update the auto hyphens between the start of
+      // the current word and this manual hyphen.
+      if (aWordState->hasAutoHyphen) {
+        for (uint32_t j = aWordState->mostRecentBoundary; j < i; j++) {
+          if (aHyphenBuffer[j - aStart] ==
+              HyphenType::AutoWithoutManualInSameWord) {
+            aHyphenBuffer[j - aStart] = HyphenType::AutoWithManualInSameWord;
+          }
+        }
+      }
+    }
+    if (aHyphenBuffer[i - aStart] == HyphenType::AutoWithoutManualInSameWord) {
+      if (!aWordState->hasAutoHyphen) {
+        aWordState->hasAutoHyphen = true;
+      }
+      if (aWordState->hasManualHyphen) {
+        aHyphenBuffer[i - aStart] = HyphenType::AutoWithManualInSameWord;
+      }
+    }
+
+    // If we're at the word boundary, clear/reset couple states.
+    if (mCharacterGlyphs[i].CharIsSpace() || mCharacterGlyphs[i].CharIsTab() ||
+        mCharacterGlyphs[i].CharIsNewline() ||
+        // Since we will not have a boundary in the end of the string, let's
+        // call the end of the string a special case for word boundary.
+        i == GetLength() - 1) {
+      // We can only get to know whether we should raise/clear an explicit
+      // manual hyphen until we get to the end of a word, because this depends
+      // on whether there exists at least one auto hyphen in the same word.
+      if (!aWordState->hasAutoHyphen && aWordState->hasExplicitHyphen) {
+        for (uint32_t j = aWordState->mostRecentBoundary; j <= i; j++) {
+          if (aHyphenBuffer[j - aStart] == HyphenType::Explicit) {
+            aHyphenBuffer[j - aStart] = HyphenType::None;
+          }
+        }
+      }
+      aWordState->mostRecentBoundary = i;
+      aWordState->hasManualHyphen = false;
+      aWordState->hasAutoHyphen = false;
+      aWordState->hasExplicitHyphen = false;
+    }
+  }
+}
+
+uint32_t gfxTextRun::BreakAndMeasureText(
+    uint32_t aStart, uint32_t aMaxLength, bool aLineBreakBefore,
+    gfxFloat aWidth, const PropertyProvider& aProvider,
+    SuppressBreak aSuppressBreak, gfxFont::BoundingBoxType aBoundingBoxType,
+    DrawTarget* aRefDrawTarget, bool aCanWordWrap, bool aCanWhitespaceWrap,
+    TrimmableWS* aOutTrimmableWhitespace, Metrics& aOutMetrics,
+    bool& aOutUsedHyphenation, uint32_t& aOutLastBreak,
+    gfxBreakPriority& aBreakPriority) {
+  aMaxLength = std::min(aMaxLength, GetLength() - aStart);
+
+  NS_ASSERTION(aStart + aMaxLength <= GetLength(), "Substring out of range");
+
+  Range bufferRange(
+      aStart, aStart + std::min<uint32_t>(aMaxLength, MEASUREMENT_BUFFER_SIZE));
+  PropertyProvider::Spacing spacingBuffer[MEASUREMENT_BUFFER_SIZE];
+  bool haveSpacing = !!(mFlags & gfx::ShapedTextFlags::TEXT_ENABLE_SPACING);
+  if (haveSpacing) {
+    GetAdjustedSpacing(this, bufferRange, aProvider, spacingBuffer);
+  }
+  AutoTArray<HyphenType, 4096> hyphenBuffer;
+  HyphenationState wordState;
+  wordState.mostRecentBoundary = aStart;
+  bool haveHyphenation =
+      (aProvider.GetHyphensOption() == StyleHyphens::Auto ||
+       (aProvider.GetHyphensOption() == StyleHyphens::Manual &&
+        !!(mFlags & gfx::ShapedTextFlags::TEXT_ENABLE_HYPHEN_BREAKS)));
+  if (haveHyphenation) {
+    if (hyphenBuffer.AppendElements(bufferRange.Length(), fallible)) {
+      aProvider.GetHyphenationBreaks(bufferRange, hyphenBuffer.Elements());
+      if (aProvider.GetHyphensOption() == StyleHyphens::Auto) {
+        ClassifyAutoHyphenations(aStart, bufferRange, hyphenBuffer, &wordState);
+      }
+    } else {
+      haveHyphenation = false;
+    }
+  }
+
+  gfxFloat width = 0;
+  gfxFloat advance = 0;
+  // The number of space characters that can be trimmed or hang at a soft-wrap
+  uint32_t trimmableChars = 0;
+  // The amount of space removed by ignoring trimmableChars
+  gfxFloat trimmableAdvance = 0;
+  int32_t lastBreak = -1;
+  int32_t lastBreakTrimmableChars = -1;
+  gfxFloat lastBreakTrimmableAdvance = -1;
+  // Cache the last candidate break
+  int32_t lastCandidateBreak = -1;
+  int32_t lastCandidateBreakTrimmableChars = -1;
+  gfxFloat lastCandidateBreakTrimmableAdvance = -1;
+  bool lastCandidateBreakUsedHyphenation = false;
+  gfxBreakPriority lastCandidateBreakPriority = gfxBreakPriority::eNoBreak;
+  bool aborted = false;
+  uint32_t end = aStart + aMaxLength;
+  bool lastBreakUsedHyphenation = false;
+  Range ligatureRange(aStart, end);
+  ShrinkToLigatureBoundaries(&ligatureRange);
+
+  // We may need to move `i` backwards in the following loop, and re-scan
+  // part of the textrun; we'll use `rescanLimit` so we can tell when that
+  // is happening: if `i < rescanLimit` then we're rescanning.
+  uint32_t rescanLimit = aStart;
+  for (uint32_t i = aStart; i < end; ++i) {
+    if (i >= bufferRange.end) {
+      // Fetch more spacing and hyphenation data
+      uint32_t oldHyphenBufferLength = hyphenBuffer.Length();
+      bufferRange.start = i;
+      bufferRange.end =
+          std::min(aStart + aMaxLength, i + MEASUREMENT_BUFFER_SIZE);
+      // For spacing, we always overwrite the old data with the newly
+      // fetched one. However, for hyphenation, hyphenation data sometimes
+      // depends on the context in every word (if "hyphens: auto" is set).
+      // To ensure we get enough information between neighboring buffers,
+      // we grow the hyphenBuffer instead of overwrite it.
+      // NOTE that this means bufferRange does not correspond to the
+      // entire hyphenBuffer, but only to the most recently added portion.
+      // Therefore, we need to add the old length to hyphenBuffer.Elements()
+      // when getting more data.
+      if (haveSpacing) {
+        GetAdjustedSpacing(this, bufferRange, aProvider, spacingBuffer);
+      }
+      if (haveHyphenation) {
+        if (hyphenBuffer.AppendElements(bufferRange.Length(), fallible)) {
+          aProvider.GetHyphenationBreaks(
+              bufferRange, hyphenBuffer.Elements() + oldHyphenBufferLength);
+          if (aProvider.GetHyphensOption() == StyleHyphens::Auto) {
+            uint32_t prevMostRecentWordBoundary = wordState.mostRecentBoundary;
+            ClassifyAutoHyphenations(aStart, bufferRange, hyphenBuffer,
+                                     &wordState);
+            // If the buffer boundary is in the middle of a word,
+            // we need to go back to the start of the current word.
+            // So, we can correct the wrong candidates that we set
+            // in the previous runs of the loop.
+            if (prevMostRecentWordBoundary < oldHyphenBufferLength) {
+              rescanLimit = i;
+              i = prevMostRecentWordBoundary - 1;
+              continue;
+            }
+          }
+        } else {
+          haveHyphenation = false;
+        }
+      }
+    }
+
+    // There can't be a word-wrap break opportunity at the beginning of the
+    // line: if the width is too small for even one character to fit, it
+    // could be the first and last break opportunity on the line, and that
+    // would trigger an infinite loop.
+    if (aSuppressBreak != eSuppressAllBreaks &&
+        (aSuppressBreak != eSuppressInitialBreak || i > aStart)) {
+      bool atNaturalBreak = mCharacterGlyphs[i].CanBreakBefore() == 1;
+      // atHyphenationBreak indicates we're at a "soft" hyphen, where an extra
+      // hyphen glyph will need to be painted. It is NOT set for breaks at an
+      // explicit hyphen present in the text.
+      //
+      // NOTE(emilio): If you change this condition you also need to change
+      // nsTextFrame::AddInlineMinISizeForFlow to match.
+      bool atHyphenationBreak = !atNaturalBreak && haveHyphenation &&
+                                IsOptionalHyphenBreak(hyphenBuffer[i - aStart]);
+      bool atAutoHyphenWithManualHyphenInSameWord =
+          atHyphenationBreak &&
+          hyphenBuffer[i - aStart] == HyphenType::AutoWithManualInSameWord;
+      bool atBreak = atNaturalBreak || atHyphenationBreak;
+      bool wordWrapping = aCanWordWrap &&
+                          mCharacterGlyphs[i].IsClusterStart() &&
+                          aBreakPriority <= gfxBreakPriority::eWordWrapBreak;
+
+      bool whitespaceWrapping = false;
+      if (i > aStart) {
+        // The spec says the breaking opportunity is *after* whitespace.
+        auto const& g = mCharacterGlyphs[i - 1];
+        whitespaceWrapping =
+            aCanWhitespaceWrap &&
+            (g.CharIsSpace() || g.CharIsTab() || g.CharIsNewline());
+      }
+
+      if (atBreak || wordWrapping || whitespaceWrapping) {
+        gfxFloat hyphenatedAdvance = advance;
+        if (atHyphenationBreak) {
+          hyphenatedAdvance += aProvider.GetHyphenWidth();
+        }
+
+        if (lastBreak < 0 ||
+            width + hyphenatedAdvance - trimmableAdvance <= aWidth) {
+          // We can break here.
+          lastBreak = i;
+          lastBreakTrimmableChars = trimmableChars;
+          lastBreakTrimmableAdvance = trimmableAdvance;
+          lastBreakUsedHyphenation = atHyphenationBreak;
+          aBreakPriority = (atBreak || whitespaceWrapping)
+                               ? gfxBreakPriority::eNormalBreak
+                               : gfxBreakPriority::eWordWrapBreak;
+        }
+
+        width += advance;
+        advance = 0;
+        if (width - trimmableAdvance > aWidth) {
+          // No more text fits. Abort
+          aborted = true;
+          break;
+        }
+        // There are various kinds of break opportunities:
+        // 1. word wrap break,
+        // 2. natural break,
+        // 3. manual hyphenation break,
+        // 4. auto hyphenation break without any manual hyphenation
+        //    in the same word,
+        // 5. auto hyphenation break with another manual hyphenation
+        //    in the same word.
+        // Allow all of them except the last one to be a candidate.
+        // So, we can ensure that we don't use an automatic
+        // hyphenation opportunity within a word that contains another
+        // manual hyphenation, unless it is the only choice.
+        if (wordWrapping || !atAutoHyphenWithManualHyphenInSameWord) {
+          lastCandidateBreak = lastBreak;
+          lastCandidateBreakTrimmableChars = lastBreakTrimmableChars;
+          lastCandidateBreakTrimmableAdvance = lastBreakTrimmableAdvance;
+          lastCandidateBreakUsedHyphenation = lastBreakUsedHyphenation;
+          lastCandidateBreakPriority = aBreakPriority;
+        }
+      }
+    }
+
+    // If we're re-scanning part of a word (to re-process potential
+    // hyphenation types) then we don't want to accumulate widths again
+    // for the characters that were already added to `advance`.
+    if (i < rescanLimit) {
+      continue;
+    }
+
+    gfxFloat charAdvance;
+    if (i >= ligatureRange.start && i < ligatureRange.end) {
+      charAdvance = GetAdvanceForGlyphs(Range(i, i + 1));
+      if (haveSpacing) {
+        PropertyProvider::Spacing* space =
+            &spacingBuffer[i - bufferRange.start];
+        charAdvance += space->mBefore + space->mAfter;
+      }
+    } else {
+      charAdvance = ComputePartialLigatureWidth(Range(i, i + 1), &aProvider);
+    }
+
+    advance += charAdvance;
+    if (aOutTrimmableWhitespace) {
+      if (mCharacterGlyphs[i].CharIsSpace()) {
+        ++trimmableChars;
+        trimmableAdvance += charAdvance;
+      } else {
+        trimmableAdvance = 0;
+        trimmableChars = 0;
+      }
+    }
+  }
+
+  if (!aborted) {
+    width += advance;
+  }
+
+  // There are three possibilities:
+  // 1) all the text fit (width <= aWidth)
+  // 2) some of the text fit up to a break opportunity (width > aWidth &&
+  //    lastBreak >= 0)
+  // 3) none of the text fits before a break opportunity (width > aWidth &&
+  //    lastBreak < 0)
+  uint32_t charsFit;
+  aOutUsedHyphenation = false;
+  if (width - trimmableAdvance <= aWidth) {
+    charsFit = aMaxLength;
+  } else if (lastBreak >= 0) {
+    if (lastCandidateBreak >= 0 && lastCandidateBreak != lastBreak) {
+      lastBreak = lastCandidateBreak;
+      lastBreakTrimmableChars = lastCandidateBreakTrimmableChars;
+      lastBreakTrimmableAdvance = lastCandidateBreakTrimmableAdvance;
+      lastBreakUsedHyphenation = lastCandidateBreakUsedHyphenation;
+      aBreakPriority = lastCandidateBreakPriority;
+    }
+    charsFit = lastBreak - aStart;
+    trimmableChars = lastBreakTrimmableChars;
+    trimmableAdvance = lastBreakTrimmableAdvance;
+    aOutUsedHyphenation = lastBreakUsedHyphenation;
+  } else {
+    charsFit = aMaxLength;
+  }
+
+  // Get the overall metrics of the range that fit (including any potentially
+  // trimmable or hanging whitespace).
+  aOutMetrics = MeasureText(Range(aStart, aStart + charsFit), aBoundingBoxType,
+                            aRefDrawTarget, &aProvider);
+
+  if (aOutTrimmableWhitespace) {
+    aOutTrimmableWhitespace->mAdvance = trimmableAdvance;
+    aOutTrimmableWhitespace->mCount = trimmableChars;
+  }
+
+  if (charsFit == aMaxLength) {
+    if (lastBreak < 0) {
+      aOutLastBreak = UINT32_MAX;
+    } else {
+      aOutLastBreak = lastBreak - aStart;
+    }
+  }
+
+  return charsFit;
+}
+
+gfxFloat gfxTextRun::GetAdvanceWidth(
+    Range aRange, const PropertyProvider* aProvider,
+    PropertyProvider::Spacing* aSpacing) const {
+  NS_ASSERTION(aRange.end <= GetLength(), "Substring out of range");
+
+  Range ligatureRange = aRange;
+  bool adjusted = ShrinkToLigatureBoundaries(&ligatureRange);
+
+  gfxFloat result =
+      adjusted ? ComputePartialLigatureWidth(
+                     Range(aRange.start, ligatureRange.start), aProvider) +
+                     ComputePartialLigatureWidth(
+                         Range(ligatureRange.end, aRange.end), aProvider)
+               : 0.0;
+
+  if (aSpacing) {
+    aSpacing->mBefore = aSpacing->mAfter = 0;
+  }
+
+  // Account for all remaining spacing here. This is more efficient than
+  // processing it along with the glyphs.
+  if (aProvider && (mFlags & gfx::ShapedTextFlags::TEXT_ENABLE_SPACING)) {
+    uint32_t i;
+    AutoTArray<PropertyProvider::Spacing, 200> spacingBuffer;
+    if (spacingBuffer.AppendElements(aRange.Length(), fallible)) {
+      GetAdjustedSpacing(this, ligatureRange, *aProvider,
+                         spacingBuffer.Elements());
+      for (i = 0; i < ligatureRange.Length(); ++i) {
+        PropertyProvider::Spacing* space = &spacingBuffer[i];
+        result += space->mBefore + space->mAfter;
+      }
+      if (aSpacing) {
+        aSpacing->mBefore = spacingBuffer[0].mBefore;
+        aSpacing->mAfter = spacingBuffer.LastElement().mAfter;
+      }
+    }
+  }
+
+  return result + GetAdvanceForGlyphs(ligatureRange);
+}
+
+gfxFloat gfxTextRun::GetMinAdvanceWidth(Range aRange) {
+  MOZ_ASSERT(aRange.end <= GetLength(), "Substring out of range");
+
+  Range ligatureRange = aRange;
+  bool adjusted = ShrinkToLigatureBoundaries(&ligatureRange);
+
+  gfxFloat result =
+      adjusted
+          ? std::max(ComputePartialLigatureWidth(
+                         Range(aRange.start, ligatureRange.start), nullptr),
+                     ComputePartialLigatureWidth(
+                         Range(ligatureRange.end, aRange.end), nullptr))
+          : 0.0;
+
+  // Compute min advance width by assuming each grapheme cluster takes its own
+  // line.
+  gfxFloat clusterAdvance = 0;
+  for (uint32_t i = ligatureRange.start; i < ligatureRange.end; ++i) {
+    if (mCharacterGlyphs[i].CharIsSpace()) {
+      // Skip space char to prevent its advance width contributing to the
+      // result. That is, don't consider a space can be in its own line.
+      continue;
+    }
+    clusterAdvance += GetAdvanceForGlyph(i);
+    if (i + 1 == ligatureRange.end || IsClusterStart(i + 1)) {
+      result = std::max(result, clusterAdvance);
+      clusterAdvance = 0;
+    }
+  }
+
+  return result;
+}
+
+bool gfxTextRun::SetLineBreaks(Range aRange, bool aLineBreakBefore,
+                               bool aLineBreakAfter,
+                               gfxFloat* aAdvanceWidthDelta) {
+  // Do nothing because our shaping does not currently take linebreaks into
+  // account. There is no change in advance width.
+  if (aAdvanceWidthDelta) {
+    *aAdvanceWidthDelta = 0;
+  }
+  return false;
+}
+
+const gfxTextRun::GlyphRun* gfxTextRun::FindFirstGlyphRunContaining(
+    uint32_t aOffset) const {
+  MOZ_ASSERT(aOffset <= GetLength(), "Bad offset looking for glyphrun");
+  MOZ_ASSERT(GetLength() == 0 || !mGlyphRuns.IsEmpty(),
+             "non-empty text but no glyph runs present!");
+  if (mGlyphRuns.Length() <= 1) {
+    return mGlyphRuns.begin();
+  }
+  if (aOffset == GetLength()) {
+    return mGlyphRuns.end() - 1;
+  }
+  const auto* start = mGlyphRuns.begin();
+  const auto* limit = mGlyphRuns.end();
+  while (limit - start > 1) {
+    const auto* mid = start + (limit - start) / 2;
+    if (mid->mCharacterOffset <= aOffset) {
+      start = mid;
+    } else {
+      limit = mid;
+    }
+  }
+  MOZ_ASSERT(start->mCharacterOffset <= aOffset,
+             "Hmm, something went wrong, aOffset should have been found");
+  return start;
+}
+
+void gfxTextRun::AddGlyphRun(gfxFont* aFont, FontMatchType aMatchType,
+                             uint32_t aUTF16Offset, bool aForceNewRun,
+                             gfx::ShapedTextFlags aOrientation, bool aIsCJK) {
+  MOZ_ASSERT(aFont, "adding glyph run for null font!");
+  MOZ_ASSERT(aOrientation != gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED,
+             "mixed orientation should have been resolved");
+  if (!aFont) {
+    return;
+  }
+
+  if (mGlyphRuns.IsEmpty()) {
+    mGlyphRuns.AppendElement(
+        GlyphRun{aFont, aUTF16Offset, aOrientation, aMatchType, aIsCJK});
+    return;
+  }
+
+  uint32_t numGlyphRuns = mGlyphRuns.Length();
+  if (!aForceNewRun) {
+    GlyphRun* lastGlyphRun = &mGlyphRuns.LastElement();
+
+    MOZ_ASSERT(lastGlyphRun->mCharacterOffset <= aUTF16Offset,
+               "Glyph runs out of order (and run not forced)");
+
+    // Don't append a run if the font is already the one we want
+    if (lastGlyphRun->Matches(aFont, aOrientation, aIsCJK, aMatchType)) {
+      return;
+    }
+
+    // If the offset has not changed, avoid leaving a zero-length run
+    // by overwriting the last entry instead of appending...
+    if (lastGlyphRun->mCharacterOffset == aUTF16Offset) {
+      // ...except that if the run before the last entry had the same
+      // font as the new one wants, merge with it instead of creating
+      // adjacent runs with the same font
+      if (numGlyphRuns > 1 && mGlyphRuns[numGlyphRuns - 2].Matches(
+                                  aFont, aOrientation, aIsCJK, aMatchType)) {
+        mGlyphRuns.TruncateLength(numGlyphRuns - 1);
+        return;
+      }
+
+      lastGlyphRun->SetProperties(aFont, aOrientation, aIsCJK, aMatchType);
+      return;
+    }
+  }
+
+  MOZ_ASSERT(
+      aForceNewRun || numGlyphRuns > 0 || aUTF16Offset == 0,
+      "First run doesn't cover the first character (and run not forced)?");
+
+  mGlyphRuns.AppendElement(
+      GlyphRun{aFont, aUTF16Offset, aOrientation, aMatchType, aIsCJK});
+}
+
+void gfxTextRun::SanitizeGlyphRuns() {
+  if (mGlyphRuns.Length() < 2) {
+    return;
+  }
+
+  auto& runs = mGlyphRuns.Array();
+
+  // The runs are almost certain to be already sorted, so it's worth avoiding
+  // the Sort() call if possible.
+  bool isSorted = true;
+  uint32_t prevOffset = 0;
+  for (const auto& r : runs) {
+    if (r.mCharacterOffset < prevOffset) {
+      isSorted = false;
+      break;
+    }
+    prevOffset = r.mCharacterOffset;
+  }
+  if (!isSorted) {
+    runs.Sort(GlyphRunOffsetComparator());
+  }
+
+  // Coalesce adjacent glyph runs that have the same properties, and eliminate
+  // any empty runs.
+  GlyphRun* prevRun = nullptr;
+  const CompressedGlyph* charGlyphs = mCharacterGlyphs;
+
+  runs.RemoveElementsBy([&](GlyphRun& aRun) -> bool {
+    // First run is always retained.
+    if (!prevRun) {
+      prevRun = &aRun;
+      return false;
+    }
+
+    // Merge any run whose properties match its predecessor.
+    if (prevRun->Matches(aRun.mFont, aRun.mOrientation, aRun.mIsCJK,
+                         aRun.mMatchType)) {
+      return true;
+    }
+
+    if (prevRun->mCharacterOffset >= aRun.mCharacterOffset) {
+      // Preceding run is empty (or has become so due to the adjusting for
+      // ligature boundaries), so we will overwrite it with this one, which
+      // will then be discarded.
+      *prevRun = aRun;
+      return true;
+    }
+
+    // If any glyph run starts with ligature-continuation characters, we need to
+    // advance it to the first "real" character to avoid drawing partial
+    // ligature glyphs from wrong font (seen with U+FEFF in reftest 474417-1, as
+    // Core Text eliminates the glyph, which makes it appear as if a ligature
+    // has been formed)
+    while (charGlyphs[aRun.mCharacterOffset].IsLigatureContinuation() &&
+           aRun.mCharacterOffset < GetLength()) {
+      aRun.mCharacterOffset++;
+    }
+
+    // We're keeping another run, so update prevRun pointer to refer to it (in
+    // its new position).
+    ++prevRun;
+    return false;
+  });
+
+  MOZ_ASSERT(prevRun == &runs.LastElement(), "lost track of prevRun!");
+
+  // Drop any trailing empty run.
+  if (runs.Length() > 1 && prevRun->mCharacterOffset == GetLength()) {
+    runs.RemoveLastElement();
+  }
+
+  MOZ_ASSERT(!runs.IsEmpty());
+  if (runs.Length() == 1) {
+    mGlyphRuns.ConvertToElement();
+  }
+}
+
+void gfxTextRun::CopyGlyphDataFrom(gfxShapedWord* aShapedWord,
+                                   uint32_t aOffset) {
+  uint32_t wordLen = aShapedWord->GetLength();
+  MOZ_ASSERT(aOffset + wordLen <= GetLength(), "word overruns end of textrun");
+
+  CompressedGlyph* charGlyphs = GetCharacterGlyphs();
+  const CompressedGlyph* wordGlyphs = aShapedWord->GetCharacterGlyphs();
+  if (aShapedWord->HasDetailedGlyphs()) {
+    for (uint32_t i = 0; i < wordLen; ++i, ++aOffset) {
+      const CompressedGlyph& g = wordGlyphs[i];
+      if (!g.IsSimpleGlyph()) {
+        const DetailedGlyph* details =
+            g.GetGlyphCount() > 0 ? aShapedWord->GetDetailedGlyphs(i) : nullptr;
+        SetDetailedGlyphs(aOffset, g.GetGlyphCount(), details);
+      }
+      charGlyphs[aOffset] = g;
+    }
+  } else {
+    memcpy(charGlyphs + aOffset, wordGlyphs, wordLen * sizeof(CompressedGlyph));
+  }
+}
+
+void gfxTextRun::CopyGlyphDataFrom(gfxTextRun* aSource, Range aRange,
+                                   uint32_t aDest) {
+  MOZ_ASSERT(aRange.end <= aSource->GetLength(),
+             "Source substring out of range");
+  MOZ_ASSERT(aDest + aRange.Length() <= GetLength(),
+             "Destination substring out of range");
+
+  if (aSource->mDontSkipDrawing) {
+    mDontSkipDrawing = true;
+  }
+
+  // Copy base glyph data, and DetailedGlyph data where present
+  const CompressedGlyph* srcGlyphs = aSource->mCharacterGlyphs + aRange.start;
+  CompressedGlyph* dstGlyphs = mCharacterGlyphs + aDest;
+  for (uint32_t i = 0; i < aRange.Length(); ++i) {
+    CompressedGlyph g = srcGlyphs[i];
+    g.SetCanBreakBefore(!g.IsClusterStart()
+                            ? CompressedGlyph::FLAG_BREAK_TYPE_NONE
+                            : dstGlyphs[i].CanBreakBefore());
+    if (!g.IsSimpleGlyph()) {
+      uint32_t count = g.GetGlyphCount();
+      if (count > 0) {
+        // DetailedGlyphs allocation is infallible, so this should never be
+        // null unless the source textrun is somehow broken.
+        DetailedGlyph* src = aSource->GetDetailedGlyphs(i + aRange.start);
+        MOZ_ASSERT(src, "missing DetailedGlyphs?");
+        if (src) {
+          DetailedGlyph* dst = AllocateDetailedGlyphs(i + aDest, count);
+          ::memcpy(dst, src, count * sizeof(DetailedGlyph));
+        } else {
+          g.SetMissing();
+        }
+      }
+    }
+    dstGlyphs[i] = g;
+  }
+
+  // Copy glyph runs
+#ifdef DEBUG
+  GlyphRun* prevRun = nullptr;
+#endif
+  for (GlyphRunIterator iter(aSource, aRange); !iter.AtEnd(); iter.NextRun()) {
+    gfxFont* font = iter.GlyphRun()->mFont;
+    MOZ_ASSERT(!prevRun || !prevRun->Matches(iter.GlyphRun()->mFont,
+                                             iter.GlyphRun()->mOrientation,
+                                             iter.GlyphRun()->mIsCJK,
+                                             FontMatchType::Kind::kUnspecified),
+               "Glyphruns not coalesced?");
+#ifdef DEBUG
+    prevRun = const_cast<GlyphRun*>(iter.GlyphRun());
+    uint32_t end = iter.StringEnd();
+#endif
+    uint32_t start = iter.StringStart();
+
+    // These used to be NS_ASSERTION()s, but WARNING is more appropriate.
+    // Although it's unusual (and not desirable), it's possible for us to assign
+    // different fonts to a base character and a following diacritic.
+    // Example on OSX 10.5/10.6 with default fonts installed:
+    //     data:text/html,<p style="font-family:helvetica, arial, sans-serif;">
+    //                    &%23x043E;&%23x0486;&%23x20;&%23x043E;&%23x0486;
+    // This means the rendering of the cluster will probably not be very good,
+    // but it's the best we can do for now if the specified font only covered
+    // the initial base character and not its applied marks.
+    NS_WARNING_ASSERTION(aSource->IsClusterStart(start),
+                         "Started font run in the middle of a cluster");
+    NS_WARNING_ASSERTION(
+        end == aSource->GetLength() || aSource->IsClusterStart(end),
+        "Ended font run in the middle of a cluster");
+
+    AddGlyphRun(font, iter.GlyphRun()->mMatchType, start - aRange.start + aDest,
+                false, iter.GlyphRun()->mOrientation, iter.GlyphRun()->mIsCJK);
+  }
+}
+
+void gfxTextRun::ClearGlyphsAndCharacters() {
+  ResetGlyphRuns();
+  memset(reinterpret_cast<char*>(mCharacterGlyphs), 0,
+         mLength * sizeof(CompressedGlyph));
+  mDetailedGlyphs = nullptr;
+}
+
+void gfxTextRun::SetSpaceGlyph(gfxFont* aFont, DrawTarget* aDrawTarget,
+                               uint32_t aCharIndex,
+                               gfx::ShapedTextFlags aOrientation) {
+  if (SetSpaceGlyphIfSimple(aFont, aCharIndex, ' ', aOrientation)) {
+    return;
+  }
+
+  gfx::ShapedTextFlags flags =
+      gfx::ShapedTextFlags::TEXT_IS_8BIT | aOrientation;
+  bool vertical =
+      !!(GetFlags() & gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT);
+  gfxFontShaper::RoundingFlags roundingFlags =
+      aFont->GetRoundOffsetsToPixels(aDrawTarget);
+  aFont->ProcessSingleSpaceShapedWord(
+      aDrawTarget, vertical, mAppUnitsPerDevUnit, flags, roundingFlags,
+      [&](gfxShapedWord* aShapedWord) {
+        const GlyphRun* prevRun = TrailingGlyphRun();
+        bool isCJK = prevRun && prevRun->mFont == aFont &&
+                             prevRun->mOrientation == aOrientation
+                         ? prevRun->mIsCJK
+                         : false;
+        AddGlyphRun(aFont, FontMatchType::Kind::kUnspecified, aCharIndex, false,
+                    aOrientation, isCJK);
+        CopyGlyphDataFrom(aShapedWord, aCharIndex);
+        GetCharacterGlyphs()[aCharIndex].SetIsSpace();
+      });
+}
+
+bool gfxTextRun::SetSpaceGlyphIfSimple(gfxFont* aFont, uint32_t aCharIndex,
+                                       char16_t aSpaceChar,
+                                       gfx::ShapedTextFlags aOrientation) {
+  uint32_t spaceGlyph = aFont->GetSpaceGlyph();
+  if (!spaceGlyph || !CompressedGlyph::IsSimpleGlyphID(spaceGlyph)) {
+    return false;
+  }
+
+  gfxFont::Orientation fontOrientation =
+      (aOrientation & gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT)
+          ? nsFontMetrics::eVertical
+          : nsFontMetrics::eHorizontal;
+  uint32_t spaceWidthAppUnits = NS_lroundf(
+      aFont->GetMetrics(fontOrientation).spaceWidth * mAppUnitsPerDevUnit);
+  if (!CompressedGlyph::IsSimpleAdvance(spaceWidthAppUnits)) {
+    return false;
+  }
+
+  const GlyphRun* prevRun = TrailingGlyphRun();
+  bool isCJK = prevRun && prevRun->mFont == aFont &&
+                       prevRun->mOrientation == aOrientation
+                   ? prevRun->mIsCJK
+                   : false;
+  AddGlyphRun(aFont, FontMatchType::Kind::kUnspecified, aCharIndex, false,
+              aOrientation, isCJK);
+  CompressedGlyph g =
+      CompressedGlyph::MakeSimpleGlyph(spaceWidthAppUnits, spaceGlyph);
+  if (aSpaceChar == ' ') {
+    g.SetIsSpace();
+  }
+  GetCharacterGlyphs()[aCharIndex] = g;
+  return true;
+}
+
+void gfxTextRun::FetchGlyphExtents(DrawTarget* aRefDrawTarget) const {
+  bool needsGlyphExtents = NeedsGlyphExtents();
+  if (!needsGlyphExtents && !mDetailedGlyphs) {
+    return;
+  }
+
+  uint32_t runCount;
+  const GlyphRun* glyphRuns = GetGlyphRuns(&runCount);
+  CompressedGlyph* charGlyphs = mCharacterGlyphs;
+  for (uint32_t i = 0; i < runCount; ++i) {
+    const GlyphRun& run = glyphRuns[i];
+    gfxFont* font = run.mFont;
+    if (MOZ_UNLIKELY(font->GetStyle()->AdjustedSizeMustBeZero())) {
+      continue;
+    }
+
+    uint32_t start = run.mCharacterOffset;
+    uint32_t end =
+        i + 1 < runCount ? glyphRuns[i + 1].mCharacterOffset : GetLength();
+    gfxGlyphExtents* extents =
+        font->GetOrCreateGlyphExtents(mAppUnitsPerDevUnit);
+
+    AutoReadLock lock(extents->mLock);
+    for (uint32_t j = start; j < end; ++j) {
+      const gfxTextRun::CompressedGlyph* glyphData = &charGlyphs[j];
+      if (glyphData->IsSimpleGlyph()) {
+        // If we're in speed mode, don't set up glyph extents here; we'll
+        // just return "optimistic" glyph bounds later
+        if (needsGlyphExtents) {
+          uint32_t glyphIndex = glyphData->GetSimpleGlyph();
+          if (!extents->IsGlyphKnownLocked(glyphIndex)) {
+#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS
+            ++gGlyphExtentsSetupEagerSimple;
+#endif
+            extents->mLock.ReadUnlock();
+            font->SetupGlyphExtents(aRefDrawTarget, glyphIndex, false, extents);
+            extents->mLock.ReadLock();
+          }
+        }
+      } else if (!glyphData->IsMissing()) {
+        uint32_t glyphCount = glyphData->GetGlyphCount();
+        if (glyphCount == 0) {
+          continue;
+        }
+        const gfxTextRun::DetailedGlyph* details = GetDetailedGlyphs(j);
+        if (!details) {
+          continue;
+        }
+        for (uint32_t k = 0; k < glyphCount; ++k, ++details) {
+          uint32_t glyphIndex = details->mGlyphID;
+          if (!extents->IsGlyphKnownWithTightExtentsLocked(glyphIndex)) {
+#ifdef DEBUG_TEXT_RUN_STORAGE_METRICS
+            ++gGlyphExtentsSetupEagerTight;
+#endif
+            extents->mLock.ReadUnlock();
+            font->SetupGlyphExtents(aRefDrawTarget, glyphIndex, true, extents);
+            extents->mLock.ReadLock();
+          }
+        }
+      }
+    }
+  }
+}
+
+size_t gfxTextRun::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) {
+  size_t total = mGlyphRuns.ShallowSizeOfExcludingThis(aMallocSizeOf);
+
+  if (mDetailedGlyphs) {
+    total += mDetailedGlyphs->SizeOfIncludingThis(aMallocSizeOf);
+  }
+
+  return total;
+}
+
+size_t gfxTextRun::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+  return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+
+#ifdef DEBUG_FRAME_DUMP
+void gfxTextRun::Dump(FILE* out) {
+#  define APPEND_FLAG(string_, enum_, field_, flag_)                    \
+    if (field_ & enum_::flag_) {                                        \
+      string_.AppendPrintf(remaining != field_ ? " %s" : "%s", #flag_); \
+      remaining &= ~enum_::flag_;                                       \
+    }
+#  define APPEND_FLAGS(string_, enum_, field_, flags_)              \
+    {                                                               \
+      auto remaining = field_;                                      \
+      MOZ_FOR_EACH(APPEND_FLAG, (string_, enum_, field_, ), flags_) \
+      if (int(remaining)) {                                         \
+        string_.AppendPrintf(" %s(0x%0x)", #enum_, int(remaining)); \
+      }                                                             \
+    }
+
+  nsCString flagsString;
+  ShapedTextFlags orient = mFlags & ShapedTextFlags::TEXT_ORIENT_MASK;
+  ShapedTextFlags otherFlags = mFlags & ~ShapedTextFlags::TEXT_ORIENT_MASK;
+  APPEND_FLAGS(flagsString, ShapedTextFlags, otherFlags,
+               (TEXT_IS_RTL, TEXT_ENABLE_SPACING, TEXT_IS_8BIT,
+                TEXT_ENABLE_HYPHEN_BREAKS, TEXT_NEED_BOUNDING_BOX,
+                TEXT_DISABLE_OPTIONAL_LIGATURES, TEXT_OPTIMIZE_SPEED,
+                TEXT_HIDE_CONTROL_CHARACTERS, TEXT_TRAILING_ARABICCHAR,
+                TEXT_INCOMING_ARABICCHAR, TEXT_USE_MATH_SCRIPT))
+
+  if (orient != ShapedTextFlags::TEXT_ORIENT_HORIZONTAL &&
+      !flagsString.IsEmpty()) {
+    flagsString += ' ';
+  }
+
+  switch (orient) {
+    case ShapedTextFlags::TEXT_ORIENT_HORIZONTAL:
+      break;
+    case ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT:
+      flagsString += "TEXT_ORIENT_VERTICAL_UPRIGHT";
+      break;
+    case ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT:
+      flagsString += "TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT";
+      break;
+    case ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED:
+      flagsString += "TEXT_ORIENT_VERTICAL_MIXED";
+      break;
+    case ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT:
+      flagsString += "TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT";
+      break;
+    default:
+      flagsString.AppendPrintf("UNKNOWN_TEXT_ORIENT_MASK(0x%0x)", int(orient));
+      break;
+  }
+
+  nsCString flags2String;
+  APPEND_FLAGS(
+      flags2String, nsTextFrameUtils::Flags, mFlags2,
+      (HasTab, HasShy, DontSkipDrawingForPendingUserFonts, IsSimpleFlow,
+       IncomingWhitespace, TrailingWhitespace, CompressedLeadingWhitespace,
+       NoBreaks, IsTransformed, HasTrailingBreak, IsSingleCharMi,
+       MightHaveGlyphChanges, RunSizeAccounted))
+
+#  undef APPEND_FLAGS
+#  undef APPEND_FLAG
+
+  nsAutoCString lang;
+  mFontGroup->Language()->ToUTF8String(lang);
+  fprintf(out, "gfxTextRun@%p (length %u) [%s] [%s] [%s]\n", this, mLength,
+          flagsString.get(), flags2String.get(), lang.get());
+
+  fprintf(out, "  Glyph runs:\n");
+  for (const auto& run : mGlyphRuns) {
+    gfxFont* font = run.mFont;
+    const gfxFontStyle* style = font->GetStyle();
+    nsAutoCString styleString;
+    style->style.ToString(styleString);
+    fprintf(out, "    offset=%d %s %f/%g/%s\n", run.mCharacterOffset,
+            font->GetName().get(), style->size, style->weight.ToFloat(),
+            styleString.get());
+  }
+
+  fprintf(out, "  Glyphs:\n");
+  for (uint32_t i = 0; i < mLength; ++i) {
+    auto glyphData = GetCharacterGlyphs()[i];
+
+    nsCString line;
+    line.AppendPrintf("    [%d] 0x%p %s", i, GetCharacterGlyphs() + i,
+                      glyphData.IsSimpleGlyph() ? "simple" : "detailed");
+
+    if (glyphData.IsSimpleGlyph()) {
+      line.AppendPrintf(" id=%d adv=%d", glyphData.GetSimpleGlyph(),
+                        glyphData.GetSimpleAdvance());
+    } else {
+      uint32_t count = glyphData.GetGlyphCount();
+      if (count) {
+        line += " ids=";
+        for (uint32_t j = 0; j < count; j++) {
+          line.AppendPrintf(j ? ",%d" : "%d", GetDetailedGlyphs(i)[j].mGlyphID);
+        }
+        line += " advs=";
+        for (uint32_t j = 0; j < count; j++) {
+          line.AppendPrintf(j ? ",%d" : "%d", GetDetailedGlyphs(i)[j].mAdvance);
+        }
+        line += " offsets=";
+        for (uint32_t j = 0; j < count; j++) {
+          auto offset = GetDetailedGlyphs(i)[j].mOffset;
+          line.AppendPrintf(j ? ",(%g,%g)" : "(%g,%g)", offset.x.value,
+                            offset.y.value);
+        }
+      } else {
+        line += " (no glyphs)";
+      }
+    }
+
+    if (glyphData.CharIsSpace()) {
+      line += " CHAR_IS_SPACE";
+    }
+    if (glyphData.CharIsTab()) {
+      line += " CHAR_IS_TAB";
+    }
+    if (glyphData.CharIsNewline()) {
+      line += " CHAR_IS_NEWLINE";
+    }
+    if (glyphData.CharIsFormattingControl()) {
+      line += " CHAR_IS_FORMATTING_CONTROL";
+    }
+    if (glyphData.CharTypeFlags() &
+        CompressedGlyph::FLAG_CHAR_NO_EMPHASIS_MARK) {
+      line += " CHAR_NO_EMPHASIS_MARK";
+    }
+
+    if (!glyphData.IsSimpleGlyph()) {
+      if (!glyphData.IsMissing()) {
+        line += " NOT_MISSING";
+      }
+      if (!glyphData.IsClusterStart()) {
+        line += " NOT_IS_CLUSTER_START";
+      }
+      if (!glyphData.IsLigatureGroupStart()) {
+        line += " NOT_LIGATURE_GROUP_START";
+      }
+    }
+
+    switch (glyphData.CanBreakBefore()) {
+      case CompressedGlyph::FLAG_BREAK_TYPE_NORMAL:
+        line += " BREAK_TYPE_NORMAL";
+        break;
+      case CompressedGlyph::FLAG_BREAK_TYPE_HYPHEN:
+        line += " BREAK_TYPE_HYPHEN";
+        break;
+    }
+
+    fprintf(out, "%s\n", line.get());
+  }
+}
+#endif
+
+gfxFontGroup::gfxFontGroup(nsPresContext* aPresContext,
+                           const StyleFontFamilyList& aFontFamilyList,
+                           const gfxFontStyle* aStyle, nsAtom* aLanguage,
+                           bool aExplicitLanguage,
+                           gfxTextPerfMetrics* aTextPerf,
+                           gfxUserFontSet* aUserFontSet, gfxFloat aDevToCssSize,
+                           StyleFontVariantEmoji aVariantEmoji)
+    : mPresContext(aPresContext),  // Note that aPresContext may be null!
+      mFamilyList(aFontFamilyList),
+      mStyle(*aStyle),
+      mLanguage(aLanguage),
+      mUnderlineOffset(UNDERLINE_OFFSET_NOT_SET),
+      mHyphenWidth(-1),
+      mDevToCssSize(aDevToCssSize),
+      mUserFontSet(aUserFontSet),
+      mTextPerf(aTextPerf),
+      mLastPrefLang(eFontPrefLang_Western),
+      mPageLang(gfxPlatformFontList::GetFontPrefLangFor(aLanguage)),
+      mLastPrefFirstFont(false),
+      mSkipDrawing(false),
+      mExplicitLanguage(aExplicitLanguage) {
+  switch (aVariantEmoji) {
+    case StyleFontVariantEmoji::Normal:
+    case StyleFontVariantEmoji::Unicode:
+      break;
+    case StyleFontVariantEmoji::Text:
+      mEmojiPresentation = eFontPresentation::Text;
+      break;
+    case StyleFontVariantEmoji::Emoji:
+      mEmojiPresentation = eFontPresentation::EmojiExplicit;
+      break;
+  }
+  // We don't use SetUserFontSet() here, as we want to unconditionally call
+  // BuildFontList() rather than only do UpdateUserFonts() if it changed.
+  mCurrGeneration = GetGeneration();
+  BuildFontList();
+}
+
+gfxFontGroup::~gfxFontGroup() {
+  // Should not be dropped by stylo
+  MOZ_ASSERT(!Servo_IsWorkerThread());
+}
+
+static StyleGenericFontFamily GetDefaultGeneric(nsAtom* aLanguage) {
+  return StaticPresData::Get()
+      ->GetFontPrefsForLang(aLanguage)
+      ->GetDefaultGeneric();
+}
+
+void gfxFontGroup::BuildFontList() {
+  // initialize fonts in the font family list
+  AutoTArray<FamilyAndGeneric, 10> fonts;
+  gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+  mFontListGeneration = pfl->GetGeneration();
+
+  // lookup fonts in the fontlist
+  for (const StyleSingleFontFamily& name : mFamilyList.list.AsSpan()) {
+    if (name.IsFamilyName()) {
+      const auto& familyName = name.AsFamilyName();
+      AddPlatformFont(nsAtomCString(familyName.name.AsAtom()),
+                      familyName.syntax == StyleFontFamilyNameSyntax::Quoted,
+                      fonts);
+    } else {
+      MOZ_ASSERT(name.IsGeneric());
+      const StyleGenericFontFamily generic = name.AsGeneric();
+      // system-ui is usually a single family, so it doesn't work great as
+      // fallback. Prefer the following generic or the language default instead.
+      if (mFallbackGeneric == StyleGenericFontFamily::None &&
+          generic != StyleGenericFontFamily::SystemUi) {
+        mFallbackGeneric = generic;
+      }
+      pfl->AddGenericFonts(mPresContext, generic, mLanguage, fonts);
+      if (mTextPerf) {
+        mTextPerf->current.genericLookups++;
+      }
+    }
+  }
+
+  // If necessary, append default language generic onto the end.
+  if (mFallbackGeneric == StyleGenericFontFamily::None && !mStyle.systemFont) {
+    auto defaultLanguageGeneric = GetDefaultGeneric(mLanguage);
+
+    pfl->AddGenericFonts(mPresContext, defaultLanguageGeneric, mLanguage,
+                         fonts);
+    if (mTextPerf) {
+      mTextPerf->current.genericLookups++;
+    }
+  }
+
+  // build the fontlist from the specified families
+  for (const auto& f : fonts) {
+    if (f.mFamily.mShared) {
+      AddFamilyToFontList(f.mFamily.mShared, f.mGeneric);
+    } else {
+      AddFamilyToFontList(f.mFamily.mUnshared, f.mGeneric);
+    }
+  }
+}
+
+void gfxFontGroup::AddPlatformFont(const nsACString& aName, bool aQuotedName,
+                                   nsTArray<FamilyAndGeneric>& aFamilyList) {
+  // First, look up in the user font set...
+  // If the fontSet matches the family, we must not look for a platform
+  // font of the same name, even if we fail to actually get a fontEntry
+  // here; we'll fall back to the next name in the CSS font-family list.
+  if (mUserFontSet) {
+    // Add userfonts to the fontlist whether already loaded
+    // or not. Loading is initiated during font matching.
+    RefPtr<gfxFontFamily> family = mUserFontSet->LookupFamily(aName);
+    if (family) {
+      aFamilyList.AppendElement(std::move(family));
+      return;
+    }
+  }
+
+  // Not known in the user font set ==> check system fonts
+  gfxPlatformFontList::PlatformFontList()->FindAndAddFamilies(
+      mPresContext, StyleGenericFontFamily::None, aName, &aFamilyList,
+      aQuotedName ? gfxPlatformFontList::FindFamiliesFlags::eQuotedFamilyName
+                  : gfxPlatformFontList::FindFamiliesFlags(0),
+      &mStyle, mLanguage.get(), mDevToCssSize);
+}
+
+void gfxFontGroup::AddFamilyToFontList(gfxFontFamily* aFamily,
+                                       StyleGenericFontFamily aGeneric) {
+  if (!aFamily) {
+    MOZ_ASSERT_UNREACHABLE("don't try to add a null font family!");
+    return;
+  }
+  AutoTArray<gfxFontEntry*, 4> fontEntryList;
+  aFamily->FindAllFontsForStyle(mStyle, fontEntryList);
+  // add these to the fontlist
+  for (gfxFontEntry* fe : fontEntryList) {
+    if (!HasFont(fe)) {
+      FamilyFace ff(aFamily, fe, aGeneric);
+      if (fe->mIsUserFontContainer) {
+        ff.CheckState(mSkipDrawing);
+      }
+      mFonts.AppendElement(ff);
+    }
+  }
+  // for a family marked as "check fallback faces", only mark the last
+  // entry so that fallbacks for a family are only checked once
+  if (aFamily->CheckForFallbackFaces() && !fontEntryList.IsEmpty() &&
+      !mFonts.IsEmpty()) {
+    mFonts.LastElement().SetCheckForFallbackFaces();
+  }
+}
+
+void gfxFontGroup::AddFamilyToFontList(fontlist::Family* aFamily,
+                                       StyleGenericFontFamily aGeneric) {
+  gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+  if (!aFamily->IsInitialized()) {
+    if (ServoStyleSet* set = gfxFontUtils::CurrentServoStyleSet()) {
+      // If we need to initialize a Family record, but we're on a style
+      // worker thread, we have to defer it.
+      set->AppendTask(PostTraversalTask::InitializeFamily(aFamily));
+      set->AppendTask(PostTraversalTask::FontInfoUpdate(set));
+      return;
+    }
+    if (!pfl->InitializeFamily(aFamily)) {
+      return;
+    }
+  }
+  AutoTArray<fontlist::Face*, 4> faceList;
+  aFamily->FindAllFacesForStyle(pfl->SharedFontList(), mStyle, faceList);
+  for (auto* face : faceList) {
+    gfxFontEntry* fe = pfl->GetOrCreateFontEntry(face, aFamily);
+    if (fe && !HasFont(fe)) {
+      FamilyFace ff(aFamily, fe, aGeneric);
+      mFonts.AppendElement(ff);
+    }
+  }
+}
+
+bool gfxFontGroup::HasFont(const gfxFontEntry* aFontEntry) {
+  for (auto& f : mFonts) {
+    if (f.FontEntry() == aFontEntry) {
+      return true;
+    }
+  }
+  return false;
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::GetFontAt(int32_t i, uint32_t aCh,
+                                                  bool* aLoading) {
+  if (uint32_t(i) >= mFonts.Length()) {
+    return nullptr;
+  }
+
+  FamilyFace& ff = mFonts[i];
+  if (ff.IsInvalid() || ff.IsLoading()) {
+    return nullptr;
+  }
+
+  RefPtr<gfxFont> font = ff.Font();
+  if (!font) {
+    gfxFontEntry* fe = ff.FontEntry();
+    if (!fe) {
+      return nullptr;
+    }
+    gfxCharacterMap* unicodeRangeMap = nullptr;
+    if (fe->mIsUserFontContainer) {
+      gfxUserFontEntry* ufe = static_cast<gfxUserFontEntry*>(fe);
+      if (ufe->LoadState() == gfxUserFontEntry::STATUS_NOT_LOADED &&
+          ufe->CharacterInUnicodeRange(aCh) && !*aLoading) {
+        ufe->Load();
+        ff.CheckState(mSkipDrawing);
+        *aLoading = ff.IsLoading();
+      }
+      fe = ufe->GetPlatformFontEntry();
+      if (!fe) {
+        return nullptr;
+      }
+      unicodeRangeMap = ufe->GetUnicodeRangeMap();
+    }
+    font = fe->FindOrMakeFont(&mStyle, unicodeRangeMap);
+    if (!font || !font->Valid()) {
+      ff.SetInvalid();
+      return nullptr;
+    }
+    ff.SetFont(font);
+  }
+  return font.forget();
+}
+
+void gfxFontGroup::FamilyFace::CheckState(bool& aSkipDrawing) {
+  gfxFontEntry* fe = FontEntry();
+  if (!fe) {
+    return;
+  }
+  if (fe->mIsUserFontContainer) {
+    gfxUserFontEntry* ufe = static_cast<gfxUserFontEntry*>(fe);
+    gfxUserFontEntry::UserFontLoadState state = ufe->LoadState();
+    switch (state) {
+      case gfxUserFontEntry::STATUS_LOAD_PENDING:
+      case gfxUserFontEntry::STATUS_LOADING:
+        SetLoading(true);
+        break;
+      case gfxUserFontEntry::STATUS_FAILED:
+        SetInvalid();
+        // fall-thru to the default case
+        [[fallthrough]];
+      default:
+        SetLoading(false);
+    }
+    if (ufe->WaitForUserFont()) {
+      aSkipDrawing = true;
+    }
+  }
+}
+
+bool gfxFontGroup::FamilyFace::EqualsUserFont(
+    const gfxUserFontEntry* aUserFont) const {
+  gfxFontEntry* fe = FontEntry();
+  // if there's a font, the entry is the underlying platform font
+  if (mFontCreated) {
+    gfxFontEntry* pfe = aUserFont->GetPlatformFontEntry();
+    if (pfe == fe) {
+      return true;
+    }
+  } else if (fe == aUserFont) {
+    return true;
+  }
+  return false;
+}
+
+static nsAutoCString FamilyListToString(
+    const StyleFontFamilyList& aFamilyList) {
+  return StringJoin(","_ns, aFamilyList.list.AsSpan(),
+                    [](nsACString& dst, const StyleSingleFontFamily& name) {
+                      name.AppendToString(dst);
+                    });
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::GetDefaultFont() {
+  if (mDefaultFont) {
+    return do_AddRef(mDefaultFont);
+  }
+
+  gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+  FontFamily family = pfl->GetDefaultFont(mPresContext, &mStyle);
+  MOZ_ASSERT(!family.IsNull(),
+             "invalid default font returned by GetDefaultFont");
+
+  gfxFontEntry* fe = nullptr;
+  if (family.mShared) {
+    fontlist::Family* fam = family.mShared;
+    if (!fam->IsInitialized()) {
+      // If this fails, FindFaceForStyle will just safely return nullptr
+      Unused << pfl->InitializeFamily(fam);
+    }
+    fontlist::Face* face = fam->FindFaceForStyle(pfl->SharedFontList(), mStyle);
+    if (face) {
+      fe = pfl->GetOrCreateFontEntry(face, fam);
+    }
+  } else {
+    fe = family.mUnshared->FindFontForStyle(mStyle);
+  }
+  if (fe) {
+    mDefaultFont = fe->FindOrMakeFont(&mStyle);
+  }
+
+  uint32_t numInits, loaderState;
+  pfl->GetFontlistInitInfo(numInits, loaderState);
+
+  MOZ_ASSERT(numInits != 0,
+             "must initialize system fontlist before getting default font!");
+
+  uint32_t numFonts = 0;
+  if (!mDefaultFont) {
+    // Try for a "font of last resort...."
+    // Because an empty font list would be Really Bad for later code
+    // that assumes it will be able to get valid metrics for layout,
+    // just look for the first usable font and put in the list.
+    // (see bug 554544)
+    if (pfl->SharedFontList()) {
+      fontlist::FontList* list = pfl->SharedFontList();
+      numFonts = list->NumFamilies();
+      fontlist::Family* families = list->Families();
+      for (uint32_t i = 0; i < numFonts; ++i) {
+        fontlist::Family* fam = &families[i];
+        if (!fam->IsInitialized()) {
+          Unused << pfl->InitializeFamily(fam);
+        }
+        fontlist::Face* face =
+            fam->FindFaceForStyle(pfl->SharedFontList(), mStyle);
+        if (face) {
+          fe = pfl->GetOrCreateFontEntry(face, fam);
+          if (fe) {
+            mDefaultFont = fe->FindOrMakeFont(&mStyle);
+            if (mDefaultFont) {
+              break;
+            }
+            NS_WARNING("FindOrMakeFont failed");
+          }
+        }
+      }
+    } else {
+      AutoTArray<RefPtr<gfxFontFamily>, 200> familyList;
+      pfl->GetFontFamilyList(familyList);
+      numFonts = familyList.Length();
+      for (uint32_t i = 0; i < numFonts; ++i) {
+        gfxFontEntry* fe = familyList[i]->FindFontForStyle(mStyle, true);
+        if (fe) {
+          mDefaultFont = fe->FindOrMakeFont(&mStyle);
+          if (mDefaultFont) {
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  if (!mDefaultFont && pfl->SharedFontList() && !XRE_IsParentProcess()) {
+    // If we're a content process, it's possible this is failing because the
+    // chrome process has just updated the shared font list and we haven't yet
+    // refreshed our reference to it. If that's the case, update and retry.
+    // But if we're not on the main thread, we can't do this, so just use
+    // the platform default font directly.
+    if (NS_IsMainThread()) {
+      uint32_t oldGeneration = pfl->SharedFontList()->GetGeneration();
+      pfl->UpdateFontList();
+      if (pfl->SharedFontList()->GetGeneration() != oldGeneration) {
+        return GetDefaultFont();
+      }
+    }
+  }
+
+  if (!mDefaultFont) {
+    // We must have failed to find anything usable in our font-family list,
+    // or it's badly broken. One more last-ditch effort to make a font:
+    gfxFontEntry* fe = pfl->GetDefaultFontEntry();
+    if (fe) {
+      RefPtr<gfxFont> f = fe->FindOrMakeFont(&mStyle);
+      if (f) {
+        return f.forget();
+      }
+    }
+  }
+
+  if (!mDefaultFont) {
+    // an empty font list at this point is fatal; we're not going to
+    // be able to do even the most basic layout operations
+
+    // annotate crash report with fontlist info
+    nsAutoCString fontInitInfo;
+    fontInitInfo.AppendPrintf("no fonts - init: %d fonts: %d loader: %d",
+                              numInits, numFonts, loaderState);
+#ifdef XP_WIN
+    bool dwriteEnabled = gfxWindowsPlatform::GetPlatform()->DWriteEnabled();
+    double upTime = (double)GetTickCount();
+    fontInitInfo.AppendPrintf(" backend: %s system-uptime: %9.3f sec",
+                              dwriteEnabled ? "directwrite" : "gdi",
+                              upTime / 1000);
+#endif
+    gfxCriticalError() << fontInitInfo.get();
+
+    char msg[256];  // CHECK buffer length if revising message below
+    SprintfLiteral(msg, "unable to find a usable font (%.220s)",
+                   FamilyListToString(mFamilyList).get());
+    MOZ_CRASH_UNSAFE(msg);
+  }
+
+  return do_AddRef(mDefaultFont);
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::GetFirstValidFont(
+    uint32_t aCh, StyleGenericFontFamily* aGeneric, bool* aIsFirst) {
+  // Ensure cached font instances are valid.
+  CheckForUpdatedPlatformList();
+
+  uint32_t count = mFonts.Length();
+  bool loading = false;
+
+  // Check whether the font supports the given character, unless the char is
+  // SPACE, in which case it is not required to be present in the font, but
+  // we must still check if it was excluded by a unicode-range descriptor.
+  auto isValidForChar = [](gfxFont* aFont, uint32_t aCh) -> bool {
+    if (!aFont) {
+      return false;
+    }
+    if (aCh == 0x20) {
+      if (const auto* unicodeRange = aFont->GetUnicodeRangeMap()) {
+        return unicodeRange->test(aCh);
+      }
+      return true;
+    }
+    return aFont->HasCharacter(aCh);
+  };
+
+  for (uint32_t i = 0; i < count; ++i) {
+    FamilyFace& ff = mFonts[i];
+    if (ff.IsInvalid()) {
+      continue;
+    }
+
+    // already have a font?
+    RefPtr<gfxFont> font = ff.Font();
+    if (isValidForChar(font, aCh)) {
+      if (aGeneric) {
+        *aGeneric = ff.Generic();
+      }
+      if (aIsFirst) {
+        *aIsFirst = (i == 0);
+      }
+      return font.forget();
+    }
+
+    // Need to build a font, loading userfont if not loaded. In
+    // cases where unicode range might apply, use the character
+    // provided.
+    gfxFontEntry* fe = ff.FontEntry();
+    if (fe && fe->mIsUserFontContainer) {
+      gfxUserFontEntry* ufe = static_cast<gfxUserFontEntry*>(fe);
+      bool inRange = ufe->CharacterInUnicodeRange(aCh);
+      if (inRange) {
+        if (!loading &&
+            ufe->LoadState() == gfxUserFontEntry::STATUS_NOT_LOADED) {
+          ufe->Load();
+          ff.CheckState(mSkipDrawing);
+        }
+        if (ff.IsLoading()) {
+          loading = true;
+        }
+      }
+      if (ufe->LoadState() != gfxUserFontEntry::STATUS_LOADED || !inRange) {
+        continue;
+      }
+    }
+
+    font = GetFontAt(i, aCh, &loading);
+    if (isValidForChar(font, aCh)) {
+      if (aGeneric) {
+        *aGeneric = ff.Generic();
+      }
+      if (aIsFirst) {
+        *aIsFirst = (i == 0);
+      }
+      return font.forget();
+    }
+  }
+  if (aGeneric) {
+    *aGeneric = StyleGenericFontFamily::None;
+  }
+  if (aIsFirst) {
+    *aIsFirst = false;
+  }
+  return GetDefaultFont();
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::GetFirstMathFont() {
+  uint32_t count = mFonts.Length();
+  for (uint32_t i = 0; i < count; ++i) {
+    RefPtr<gfxFont> font = GetFontAt(i);
+    if (font && font->TryGetMathTable()) {
+      return font.forget();
+    }
+  }
+  return nullptr;
+}
+
+bool gfxFontGroup::IsInvalidChar(uint8_t ch) {
+  return ((ch & 0x7f) < 0x20 || ch == 0x7f);
+}
+
+bool gfxFontGroup::IsInvalidChar(char16_t ch) {
+  // All printable 7-bit ASCII values are OK
+  if (ch >= ' ' && ch < 0x7f) {
+    return false;
+  }
+  // No point in sending non-printing control chars through font shaping
+  if (ch <= 0x9f) {
+    return true;
+  }
+  // Word-separating format/bidi control characters are not shaped as part
+  // of words.
+  return (((ch & 0xFF00) == 0x2000 /* Unicode control character */ &&
+           (ch == 0x200B /*ZWSP*/ || ch == 0x2028 /*LSEP*/ ||
+            ch == 0x2029 /*PSEP*/ || ch == 0x2060 /*WJ*/)) ||
+          ch == 0xfeff /*ZWNBSP*/ || IsBidiControl(ch));
+}
+
+already_AddRefed<gfxTextRun> gfxFontGroup::MakeEmptyTextRun(
+    const Parameters* aParams, gfx::ShapedTextFlags aFlags,
+    nsTextFrameUtils::Flags aFlags2) {
+  aFlags |= ShapedTextFlags::TEXT_IS_8BIT;
+  return gfxTextRun::Create(aParams, 0, this, aFlags, aFlags2);
+}
+
+already_AddRefed<gfxTextRun> gfxFontGroup::MakeSpaceTextRun(
+    const Parameters* aParams, gfx::ShapedTextFlags aFlags,
+    nsTextFrameUtils::Flags aFlags2) {
+  aFlags |= ShapedTextFlags::TEXT_IS_8BIT;
+
+  RefPtr<gfxTextRun> textRun =
+      gfxTextRun::Create(aParams, 1, this, aFlags, aFlags2);
+  if (!textRun) {
+    return nullptr;
+  }
+
+  gfx::ShapedTextFlags orientation = aFlags & ShapedTextFlags::TEXT_ORIENT_MASK;
+  if (orientation == ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED) {
+    orientation = ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+  }
+
+  RefPtr<gfxFont> font = GetFirstValidFont();
+  if (MOZ_UNLIKELY(GetStyle()->AdjustedSizeMustBeZero())) {
+    // Short-circuit for size-0 fonts, as Windows and ATSUI can't handle
+    // them, and always create at least size 1 fonts, i.e. they still
+    // render something for size 0 fonts.
+    textRun->AddGlyphRun(font, FontMatchType::Kind::kUnspecified, 0, false,
+                         orientation, false);
+  } else {
+    if (font->GetSpaceGlyph()) {
+      // Normally, the font has a cached space glyph, so we can avoid
+      // the cost of calling FindFontForChar.
+      textRun->SetSpaceGlyph(font, aParams->mDrawTarget, 0, orientation);
+    } else {
+      // In case the primary font doesn't have <space> (bug 970891),
+      // find one that does.
+      FontMatchType matchType;
+      RefPtr<gfxFont> spaceFont =
+          FindFontForChar(' ', 0, 0, Script::LATIN, nullptr, &matchType);
+      if (spaceFont) {
+        textRun->SetSpaceGlyph(spaceFont, aParams->mDrawTarget, 0, orientation);
+      }
+    }
+  }
+
+  // Note that the gfxGlyphExtents glyph bounds storage for the font will
+  // always contain an entry for the font's space glyph, so we don't have
+  // to call FetchGlyphExtents here.
+  return textRun.forget();
+}
+
+template <typename T>
+already_AddRefed<gfxTextRun> gfxFontGroup::MakeBlankTextRun(
+    const T* aString, uint32_t aLength, const Parameters* aParams,
+    gfx::ShapedTextFlags aFlags, nsTextFrameUtils::Flags aFlags2) {
+  RefPtr<gfxTextRun> textRun =
+      gfxTextRun::Create(aParams, aLength, this, aFlags, aFlags2);
+  if (!textRun) {
+    return nullptr;
+  }
+
+  gfx::ShapedTextFlags orientation = aFlags & ShapedTextFlags::TEXT_ORIENT_MASK;
+  if (orientation == ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED) {
+    orientation = ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT;
+  }
+  RefPtr<gfxFont> font = GetFirstValidFont();
+  textRun->AddGlyphRun(font, FontMatchType::Kind::kUnspecified, 0, false,
+                       orientation, false);
+
+  textRun->SetupClusterBoundaries(0, aString, aLength);
+
+  for (uint32_t i = 0; i < aLength; i++) {
+    if (aString[i] == '\n') {
+      textRun->SetIsNewline(i);
+    } else if (aString[i] == '\t') {
+      textRun->SetIsTab(i);
+    }
+  }
+
+  return textRun.forget();
+}
+
+already_AddRefed<gfxTextRun> gfxFontGroup::MakeHyphenTextRun(
+    DrawTarget* aDrawTarget, gfx::ShapedTextFlags aFlags,
+    uint32_t aAppUnitsPerDevUnit) {
+  // only use U+2010 if it is supported by the first font in the group;
+  // it's better to use ASCII '-' from the primary font than to fall back to
+  // U+2010 from some other, possibly poorly-matching face
+  static const char16_t hyphen = 0x2010;
+  RefPtr<gfxFont> font = GetFirstValidFont(uint32_t(hyphen));
+  if (font->HasCharacter(hyphen)) {
+    return MakeTextRun(&hyphen, 1, aDrawTarget, aAppUnitsPerDevUnit, aFlags,
+                       nsTextFrameUtils::Flags(), nullptr);
+  }
+
+  static const uint8_t dash = '-';
+  return MakeTextRun(&dash, 1, aDrawTarget, aAppUnitsPerDevUnit, aFlags,
+                     nsTextFrameUtils::Flags(), nullptr);
+}
+
+gfxFloat gfxFontGroup::GetHyphenWidth(
+    const gfxTextRun::PropertyProvider* aProvider) {
+  if (mHyphenWidth < 0) {
+    RefPtr<DrawTarget> dt(aProvider->GetDrawTarget());
+    if (dt) {
+      RefPtr<gfxTextRun> hyphRun(
+          MakeHyphenTextRun(dt, aProvider->GetShapedTextFlags(),
+                            aProvider->GetAppUnitsPerDevUnit()));
+      mHyphenWidth = hyphRun.get() ? hyphRun->GetAdvanceWidth() : 0;
+    }
+  }
+  return mHyphenWidth;
+}
+
+template <typename T>
+already_AddRefed<gfxTextRun> gfxFontGroup::MakeTextRun(
+    const T* aString, uint32_t aLength, const Parameters* aParams,
+    gfx::ShapedTextFlags aFlags, nsTextFrameUtils::Flags aFlags2,
+    gfxMissingFontRecorder* aMFR) {
+  if (aLength == 0) {
+    return MakeEmptyTextRun(aParams, aFlags, aFlags2);
+  }
+  if (aLength == 1 && aString[0] == ' ') {
+    return MakeSpaceTextRun(aParams, aFlags, aFlags2);
+  }
+
+  if (sizeof(T) == 1) {
+    aFlags |= ShapedTextFlags::TEXT_IS_8BIT;
+  }
+
+  if (MOZ_UNLIKELY(GetStyle()->AdjustedSizeMustBeZero())) {
+    // Short-circuit for size-0 fonts, as Windows and ATSUI can't handle
+    // them, and always create at least size 1 fonts, i.e. they still
+    // render something for size 0 fonts.
+    return MakeBlankTextRun(aString, aLength, aParams, aFlags, aFlags2);
+  }
+
+  RefPtr<gfxTextRun> textRun =
+      gfxTextRun::Create(aParams, aLength, this, aFlags, aFlags2);
+  if (!textRun) {
+    return nullptr;
+  }
+
+  InitTextRun(aParams->mDrawTarget, textRun.get(), aString, aLength, aMFR);
+
+  textRun->FetchGlyphExtents(aParams->mDrawTarget);
+
+  return textRun.forget();
+}
+
+// MakeTextRun instantiations (needed by Linux64 base-toolchain build).
+template already_AddRefed<gfxTextRun> gfxFontGroup::MakeTextRun(
+    const uint8_t* aString, uint32_t aLength, const Parameters* aParams,
+    gfx::ShapedTextFlags aFlags, nsTextFrameUtils::Flags aFlags2,
+    gfxMissingFontRecorder* aMFR);
+template already_AddRefed<gfxTextRun> gfxFontGroup::MakeTextRun(
+    const char16_t* aString, uint32_t aLength, const Parameters* aParams,
+    gfx::ShapedTextFlags aFlags, nsTextFrameUtils::Flags aFlags2,
+    gfxMissingFontRecorder* aMFR);
+
+template <typename T>
+void gfxFontGroup::InitTextRun(DrawTarget* aDrawTarget, gfxTextRun* aTextRun,
+                               const T* aString, uint32_t aLength,
+                               gfxMissingFontRecorder* aMFR) {
+  NS_ASSERTION(aLength > 0, "don't call InitTextRun for a zero-length run");
+
+  // we need to do numeral processing even on 8-bit text,
+  // in case we're converting Western to Hindi/Arabic digits
+  uint32_t numOption = gfxPlatform::GetPlatform()->GetBidiNumeralOption();
+  UniquePtr<char16_t[]> transformedString;
+  if (numOption != IBMBIDI_NUMERAL_NOMINAL) {
+    // scan the string for numerals that may need to be transformed;
+    // if we find any, we'll make a local copy here and use that for
+    // font matching and glyph generation/shaping
+    bool prevIsArabic =
+        !!(aTextRun->GetFlags() & ShapedTextFlags::TEXT_INCOMING_ARABICCHAR);
+    for (uint32_t i = 0; i < aLength; ++i) {
+      char16_t origCh = aString[i];
+      char16_t newCh = HandleNumberInChar(origCh, prevIsArabic, numOption);
+      if (newCh != origCh) {
+        if (!transformedString) {
+          transformedString = MakeUnique<char16_t[]>(aLength);
+          if constexpr (sizeof(T) == sizeof(char16_t)) {
+            memcpy(transformedString.get(), aString, i * sizeof(char16_t));
+          } else {
+            for (uint32_t j = 0; j < i; ++j) {
+              transformedString[j] = aString[j];
+            }
+          }
+        }
+      }
+      if (transformedString) {
+        transformedString[i] = newCh;
+      }
+      prevIsArabic = IS_ARABIC_CHAR(newCh);
+    }
+  }
+
+  LogModule* log = mStyle.systemFont ? gfxPlatform::GetLog(eGfxLog_textrunui)
+                                     : gfxPlatform::GetLog(eGfxLog_textrun);
+
+  // variant fallback handling may end up passing through this twice
+  bool redo;
+  do {
+    redo = false;
+
+    if (sizeof(T) == sizeof(uint8_t) && !transformedString) {
+      if (MOZ_UNLIKELY(MOZ_LOG_TEST(log, LogLevel::Warning))) {
+        nsAutoCString lang;
+        mLanguage->ToUTF8String(lang);
+        nsAutoCString str((const char*)aString, aLength);
+        nsAutoCString styleString;
+        mStyle.style.ToString(styleString);
+        auto defaultLanguageGeneric = GetDefaultGeneric(mLanguage);
+        MOZ_LOG(
+            log, LogLevel::Warning,
+            ("(%s) fontgroup: [%s] default: %s lang: %s script: %d "
+             "len %d weight: %g stretch: %g%% style: %s size: %6.2f %zu-byte "
+             "TEXTRUN [%s] ENDTEXTRUN\n",
+             (mStyle.systemFont ? "textrunui" : "textrun"),
+             FamilyListToString(mFamilyList).get(),
+             (defaultLanguageGeneric == StyleGenericFontFamily::Serif
+                  ? "serif"
+                  : (defaultLanguageGeneric == StyleGenericFontFamily::SansSerif
+                         ? "sans-serif"
+                         : "none")),
+             lang.get(), static_cast<int>(Script::LATIN), aLength,
+             mStyle.weight.ToFloat(), mStyle.stretch.ToFloat(),
+             styleString.get(), mStyle.size, sizeof(T), str.get()));
+      }
+
+      // the text is still purely 8-bit; bypass the script-run itemizer
+      // and treat it as a single Latin run
+      InitScriptRun(aDrawTarget, aTextRun, aString, 0, aLength, Script::LATIN,
+                    aMFR);
+    } else {
+      const char16_t* textPtr;
+      if (transformedString) {
+        textPtr = transformedString.get();
+      } else {
+        // typecast to avoid compilation error for the 8-bit version,
+        // even though this is dead code in that case
+        textPtr = reinterpret_cast<const char16_t*>(aString);
+      }
+
+      // split into script runs so that script can potentially influence
+      // the font matching process below
+      gfxScriptItemizer scriptRuns(textPtr, aLength);
+
+      uint32_t runStart = 0, runLimit = aLength;
+      Script runScript = Script::LATIN;
+      while (scriptRuns.Next(runStart, runLimit, runScript)) {
+        if (MOZ_UNLIKELY(MOZ_LOG_TEST(log, LogLevel::Warning))) {
+          nsAutoCString lang;
+          mLanguage->ToUTF8String(lang);
+          nsAutoCString styleString;
+          mStyle.style.ToString(styleString);
+          auto defaultLanguageGeneric = GetDefaultGeneric(mLanguage);
+          uint32_t runLen = runLimit - runStart;
+          MOZ_LOG(log, LogLevel::Warning,
+                  ("(%s) fontgroup: [%s] default: %s lang: %s script: %d "
+                   "len %d weight: %g stretch: %g%% style: %s size: %6.2f "
+                   "%zu-byte TEXTRUN [%s] ENDTEXTRUN\n",
+                   (mStyle.systemFont ? "textrunui" : "textrun"),
+                   FamilyListToString(mFamilyList).get(),
+                   (defaultLanguageGeneric == StyleGenericFontFamily::Serif
+                        ? "serif"
+                        : (defaultLanguageGeneric ==
+                                   StyleGenericFontFamily::SansSerif
+                               ? "sans-serif"
+                               : "none")),
+                   lang.get(), static_cast<int>(runScript), runLen,
+                   mStyle.weight.ToFloat(), mStyle.stretch.ToFloat(),
+                   styleString.get(), mStyle.size, sizeof(T),
+                   NS_ConvertUTF16toUTF8(textPtr + runStart, runLen).get()));
+        }
+
+        InitScriptRun(aDrawTarget, aTextRun, textPtr + runStart, runStart,
+                      runLimit - runStart, runScript, aMFR);
+      }
+    }
+
+    // if shaping was aborted due to lack of feature support, clear out
+    // glyph runs and redo shaping with fallback forced on
+    if (aTextRun->GetShapingState() == gfxTextRun::eShapingState_Aborted) {
+      redo = true;
+      aTextRun->SetShapingState(gfxTextRun::eShapingState_ForceFallbackFeature);
+      aTextRun->ClearGlyphsAndCharacters();
+    }
+
+  } while (redo);
+
+  if (sizeof(T) == sizeof(char16_t) && aLength > 0) {
+    gfxTextRun::CompressedGlyph* glyph = aTextRun->GetCharacterGlyphs();
+    if (!glyph->IsSimpleGlyph()) {
+      glyph->SetClusterStart(true);
+    }
+  }
+
+  // It's possible for CoreText to omit glyph runs if it decides they contain
+  // only invisibles (e.g., U+FEFF, see reftest 474417-1). In this case, we
+  // need to eliminate them from the glyph run array to avoid drawing "partial
+  // ligatures" with the wrong font.
+  // We don't do this during InitScriptRun (or gfxFont::InitTextRun) because
+  // it will iterate back over all glyphruns in the textrun, which leads to
+  // pathologically-bad perf in the case where a textrun contains many script
+  // changes (see bug 680402) - we'd end up re-sanitizing all the earlier runs
+  // every time a new script subrun is processed.
+  aTextRun->SanitizeGlyphRuns();
+}
+
+static inline bool IsPUA(uint32_t aUSV) {
+  // We could look up the General Category of the codepoint here,
+  // but it's simpler to check PUA codepoint ranges.
+  return (aUSV >= 0xE000 && aUSV <= 0xF8FF) || (aUSV >= 0xF0000);
+}
+
+template <typename T>
+void gfxFontGroup::InitScriptRun(DrawTarget* aDrawTarget, gfxTextRun* aTextRun,
+                                 const T* aString,  // text for this script run,
+                                                    // not the entire textrun
+                                 uint32_t aOffset,  // position of the script
+                                                    // run within the textrun
+                                 uint32_t aLength,  // length of the script run
+                                 Script aRunScript,
+                                 gfxMissingFontRecorder* aMFR) {
+  NS_ASSERTION(aLength > 0, "don't call InitScriptRun for a 0-length run");
+  NS_ASSERTION(aTextRun->GetShapingState() != gfxTextRun::eShapingState_Aborted,
+               "don't call InitScriptRun with aborted shaping state");
+
+  // confirm the load state of userfonts in the list
+  if (mUserFontSet && mCurrGeneration != mUserFontSet->GetGeneration()) {
+    UpdateUserFonts();
+  }
+
+  RefPtr<gfxFont> mainFont = GetFirstValidFont();
+
+  ShapedTextFlags orientation =
+      aTextRun->GetFlags() & ShapedTextFlags::TEXT_ORIENT_MASK;
+
+  if (orientation != ShapedTextFlags::TEXT_ORIENT_HORIZONTAL &&
+      (aRunScript == Script::MONGOLIAN || aRunScript == Script::PHAGS_PA)) {
+    // Mongolian and Phags-pa text should ignore text-orientation and
+    // always render in its "native" vertical mode, implemented by fonts
+    // as sideways-right (i.e as if shaped horizontally, and then the
+    // entire line is rotated to render vertically). Therefore, we ignore
+    // the aOrientation value from the textrun's flags, and make all
+    // vertical Mongolian/Phags-pa use sideways-right.
+    orientation = ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+  }
+
+  uint32_t runStart = 0;
+  AutoTArray<TextRange, 3> fontRanges;
+  ComputeRanges(fontRanges, aString, aLength, aRunScript, orientation);
+  uint32_t numRanges = fontRanges.Length();
+  bool missingChars = false;
+  bool isCJK = gfxTextRun::IsCJKScript(aRunScript);
+
+  for (uint32_t r = 0; r < numRanges; r++) {
+    const TextRange& range = fontRanges[r];
+    uint32_t matchedLength = range.Length();
+    RefPtr<gfxFont> matchedFont = range.font;
+    // create the glyph run for this range
+    if (matchedFont && mStyle.noFallbackVariantFeatures) {
+      // common case - just do glyph layout and record the
+      // resulting positioned glyphs
+      aTextRun->AddGlyphRun(matchedFont, range.matchType, aOffset + runStart,
+                            (matchedLength > 0), range.orientation, isCJK);
+      if (!matchedFont->SplitAndInitTextRun(
+              aDrawTarget, aTextRun, aString + runStart, aOffset + runStart,
+              matchedLength, aRunScript, mLanguage, range.orientation)) {
+        // glyph layout failed! treat as missing glyphs
+        matchedFont = nullptr;
+      }
+    } else if (matchedFont) {
+      // shape with some variant feature that requires fallback handling
+      bool petiteToSmallCaps = false;
+      bool syntheticLower = false;
+      bool syntheticUpper = false;
+
+      if (mStyle.variantSubSuper != NS_FONT_VARIANT_POSITION_NORMAL &&
+          (aTextRun->GetShapingState() ==
+               gfxTextRun::eShapingState_ForceFallbackFeature ||
+           !matchedFont->SupportsSubSuperscript(mStyle.variantSubSuper, aString,
+                                                aLength, aRunScript))) {
+        // fallback for subscript/superscript variant glyphs
+
+        // if the feature was already used, abort and force
+        // fallback across the entire textrun
+        gfxTextRun::ShapingState ss = aTextRun->GetShapingState();
+
+        if (ss == gfxTextRun::eShapingState_Normal) {
+          aTextRun->SetShapingState(
+              gfxTextRun::eShapingState_ShapingWithFallback);
+        } else if (ss == gfxTextRun::eShapingState_ShapingWithFeature) {
+          aTextRun->SetShapingState(gfxTextRun::eShapingState_Aborted);
+          return;
+        }
+
+        RefPtr<gfxFont> subSuperFont = matchedFont->GetSubSuperscriptFont(
+            aTextRun->GetAppUnitsPerDevUnit());
+        aTextRun->AddGlyphRun(subSuperFont, range.matchType, aOffset + runStart,
+                              (matchedLength > 0), range.orientation, isCJK);
+        if (!subSuperFont->SplitAndInitTextRun(
+                aDrawTarget, aTextRun, aString + runStart, aOffset + runStart,
+                matchedLength, aRunScript, mLanguage, range.orientation)) {
+          // glyph layout failed! treat as missing glyphs
+          matchedFont = nullptr;
+        }
+      } else if (mStyle.variantCaps != NS_FONT_VARIANT_CAPS_NORMAL &&
+                 mStyle.allowSyntheticSmallCaps &&
+                 !matchedFont->SupportsVariantCaps(
+                     aRunScript, mStyle.variantCaps, petiteToSmallCaps,
+                     syntheticLower, syntheticUpper)) {
+        // fallback for small-caps variant glyphs
+        if (!matchedFont->InitFakeSmallCapsRun(
+                mPresContext, aDrawTarget, aTextRun, aString + runStart,
+                aOffset + runStart, matchedLength, range.matchType,
+                range.orientation, aRunScript,
+                mExplicitLanguage ? mLanguage.get() : nullptr, syntheticLower,
+                syntheticUpper)) {
+          matchedFont = nullptr;
+        }
+      } else {
+        // shape normally with variant feature enabled
+        gfxTextRun::ShapingState ss = aTextRun->GetShapingState();
+
+        // adjust the shaping state if necessary
+        if (ss == gfxTextRun::eShapingState_Normal) {
+          aTextRun->SetShapingState(
+              gfxTextRun::eShapingState_ShapingWithFeature);
+        } else if (ss == gfxTextRun::eShapingState_ShapingWithFallback) {
+          // already have shaping results using fallback, need to redo
+          aTextRun->SetShapingState(gfxTextRun::eShapingState_Aborted);
+          return;
+        }
+
+        // do glyph layout and record the resulting positioned glyphs
+        aTextRun->AddGlyphRun(matchedFont, range.matchType, aOffset + runStart,
+                              (matchedLength > 0), range.orientation, isCJK);
+        if (!matchedFont->SplitAndInitTextRun(
+                aDrawTarget, aTextRun, aString + runStart, aOffset + runStart,
+                matchedLength, aRunScript, mLanguage, range.orientation)) {
+          // glyph layout failed! treat as missing glyphs
+          matchedFont = nullptr;
+        }
+      }
+    } else {
+      aTextRun->AddGlyphRun(mainFont, FontMatchType::Kind::kFontGroup,
+                            aOffset + runStart, (matchedLength > 0),
+                            range.orientation, isCJK);
+    }
+
+    if (!matchedFont) {
+      // We need to set cluster boundaries (and mark spaces) so that
+      // surrogate pairs, combining characters, etc behave properly,
+      // even if we don't have glyphs for them
+      aTextRun->SetupClusterBoundaries(aOffset + runStart, aString + runStart,
+                                       matchedLength);
+
+      // various "missing" characters may need special handling,
+      // so we check for them here
+      uint32_t runLimit = runStart + matchedLength;
+      for (uint32_t index = runStart; index < runLimit; index++) {
+        T ch = aString[index];
+
+        // tab and newline are not to be displayed as hexboxes,
+        // but do need to be recorded in the textrun
+        if (ch == '\n') {
+          aTextRun->SetIsNewline(aOffset + index);
+          continue;
+        }
+        if (ch == '\t') {
+          aTextRun->SetIsTab(aOffset + index);
+          continue;
+        }
+
+        // for 16-bit textruns only, check for surrogate pairs and
+        // special Unicode spaces; omit these checks in 8-bit runs
+        if constexpr (sizeof(T) == sizeof(char16_t)) {
+          if (index + 1 < aLength &&
+              NS_IS_SURROGATE_PAIR(ch, aString[index + 1])) {
+            uint32_t usv = SURROGATE_TO_UCS4(ch, aString[index + 1]);
+            aTextRun->SetMissingGlyph(aOffset + index, usv, mainFont);
+            index++;
+            if (!mSkipDrawing && !IsPUA(usv)) {
+              missingChars = true;
+            }
+            continue;
+          }
+
+          // check if this is a known Unicode whitespace character that
+          // we can render using the space glyph with a custom width
+          gfxFloat wid = mainFont->SynthesizeSpaceWidth(ch);
+          if (wid >= 0.0) {
+            nscoord advance =
+                aTextRun->GetAppUnitsPerDevUnit() * floor(wid + 0.5);
+            if (gfxShapedText::CompressedGlyph::IsSimpleAdvance(advance)) {
+              aTextRun->GetCharacterGlyphs()[aOffset + index].SetSimpleGlyph(
+                  advance, mainFont->GetSpaceGlyph());
+            } else {
+              gfxTextRun::DetailedGlyph detailedGlyph;
+              detailedGlyph.mGlyphID = mainFont->GetSpaceGlyph();
+              detailedGlyph.mAdvance = advance;
+              aTextRun->SetDetailedGlyphs(aOffset + index, 1, &detailedGlyph);
+            }
+            continue;
+          }
+        }
+
+        if (IsInvalidChar(ch)) {
+          // invalid chars are left as zero-width/invisible
+          continue;
+        }
+
+        // record char code so we can draw a box with the Unicode value
+        aTextRun->SetMissingGlyph(aOffset + index, ch, mainFont);
+        if (!mSkipDrawing && !IsPUA(ch)) {
+          missingChars = true;
+        }
+      }
+    }
+
+    runStart += matchedLength;
+  }
+
+  if (aMFR && missingChars) {
+    aMFR->RecordScript(aRunScript);
+  }
+}
+
+gfxTextRun* gfxFontGroup::GetEllipsisTextRun(
+    int32_t aAppUnitsPerDevPixel, gfx::ShapedTextFlags aFlags,
+    LazyReferenceDrawTargetGetter& aRefDrawTargetGetter) {
+  MOZ_ASSERT(!(aFlags & ~ShapedTextFlags::TEXT_ORIENT_MASK),
+             "flags here should only be used to specify orientation");
+  if (mCachedEllipsisTextRun &&
+      (mCachedEllipsisTextRun->GetFlags() &
+       ShapedTextFlags::TEXT_ORIENT_MASK) == aFlags &&
+      mCachedEllipsisTextRun->GetAppUnitsPerDevUnit() == aAppUnitsPerDevPixel) {
+    return mCachedEllipsisTextRun.get();
+  }
+
+  // Use a Unicode ellipsis if the font supports it,
+  // otherwise use three ASCII periods as fallback.
+  RefPtr<gfxFont> firstFont = GetFirstValidFont();
+  nsString ellipsis =
+      firstFont->HasCharacter(kEllipsisChar[0])
+          ? nsDependentString(kEllipsisChar, ArrayLength(kEllipsisChar) - 1)
+          : nsDependentString(kASCIIPeriodsChar,
+                              ArrayLength(kASCIIPeriodsChar) - 1);
+
+  RefPtr<DrawTarget> refDT = aRefDrawTargetGetter.GetRefDrawTarget();
+  Parameters params = {refDT,   nullptr, nullptr,
+                       nullptr, 0,       aAppUnitsPerDevPixel};
+  mCachedEllipsisTextRun =
+      MakeTextRun(ellipsis.BeginReading(), ellipsis.Length(), &params, aFlags,
+                  nsTextFrameUtils::Flags(), nullptr);
+  if (!mCachedEllipsisTextRun) {
+    return nullptr;
+  }
+  // don't let the presence of a cached ellipsis textrun prolong the
+  // fontgroup's life
+  mCachedEllipsisTextRun->ReleaseFontGroup();
+  return mCachedEllipsisTextRun.get();
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::FindFallbackFaceForChar(
+    gfxFontFamily* aFamily, uint32_t aCh, uint32_t aNextCh,
+    eFontPresentation aPresentation) {
+  GlobalFontMatch data(aCh, aNextCh, mStyle, aPresentation);
+  aFamily->SearchAllFontsForChar(&data);
+  gfxFontEntry* fe = data.mBestMatch;
+  if (!fe) {
+    return nullptr;
+  }
+  return fe->FindOrMakeFont(&mStyle);
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::FindFallbackFaceForChar(
+    fontlist::Family* aFamily, uint32_t aCh, uint32_t aNextCh,
+    eFontPresentation aPresentation) {
+  auto* pfl = gfxPlatformFontList::PlatformFontList();
+  auto* list = pfl->SharedFontList();
+
+  // If async fallback is enabled, and the family isn't fully initialized yet,
+  // just start the async cmap loading and return.
+  if (!aFamily->IsFullyInitialized() &&
+      StaticPrefs::gfx_font_rendering_fallback_async() &&
+      !XRE_IsParentProcess()) {
+    pfl->StartCmapLoadingFromFamily(aFamily - list->Families());
+    return nullptr;
+  }
+
+  GlobalFontMatch data(aCh, aNextCh, mStyle, aPresentation);
+  aFamily->SearchAllFontsForChar(list, &data);
+  gfxFontEntry* fe = data.mBestMatch;
+  if (!fe) {
+    return nullptr;
+  }
+  return fe->FindOrMakeFont(&mStyle);
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::FindFallbackFaceForChar(
+    const FamilyFace& aFamily, uint32_t aCh, uint32_t aNextCh,
+    eFontPresentation aPresentation) {
+  if (aFamily.IsSharedFamily()) {
+    return FindFallbackFaceForChar(aFamily.SharedFamily(), aCh, aNextCh,
+                                   aPresentation);
+  }
+  return FindFallbackFaceForChar(aFamily.OwnedFamily(), aCh, aNextCh,
+                                 aPresentation);
+}
+
+gfxFloat gfxFontGroup::GetUnderlineOffset() {
+  if (mUnderlineOffset == UNDERLINE_OFFSET_NOT_SET) {
+    // if the fontlist contains a bad underline font, make the underline
+    // offset the min of the first valid font and bad font underline offsets
+    uint32_t len = mFonts.Length();
+    for (uint32_t i = 0; i < len; i++) {
+      FamilyFace& ff = mFonts[i];
+      gfxFontEntry* fe = ff.FontEntry();
+      if (!fe) {
+        continue;
+      }
+      if (!fe->mIsUserFontContainer && !fe->IsUserFont() &&
+          ((ff.IsSharedFamily() && ff.SharedFamily() &&
+            ff.SharedFamily()->IsBadUnderlineFamily()) ||
+           (!ff.IsSharedFamily() && ff.OwnedFamily() &&
+            ff.OwnedFamily()->IsBadUnderlineFamily()))) {
+        RefPtr<gfxFont> font = GetFontAt(i);
+        if (!font) {
+          continue;
+        }
+        gfxFloat bad =
+            font->GetMetrics(nsFontMetrics::eHorizontal).underlineOffset;
+        RefPtr<gfxFont> firstValidFont = GetFirstValidFont();
+        gfxFloat first = firstValidFont->GetMetrics(nsFontMetrics::eHorizontal)
+                             .underlineOffset;
+        mUnderlineOffset = std::min(first, bad);
+        return mUnderlineOffset;
+      }
+    }
+
+    // no bad underline fonts, use the first valid font's metric
+    RefPtr<gfxFont> firstValidFont = GetFirstValidFont();
+    mUnderlineOffset =
+        firstValidFont->GetMetrics(nsFontMetrics::eHorizontal).underlineOffset;
+  }
+
+  return mUnderlineOffset;
+}
+
+#define NARROW_NO_BREAK_SPACE 0x202fu
+
+already_AddRefed<gfxFont> gfxFontGroup::FindFontForChar(
+    uint32_t aCh, uint32_t aPrevCh, uint32_t aNextCh, Script aRunScript,
+    gfxFont* aPrevMatchedFont, FontMatchType* aMatchType) {
+  // If the char is a cluster extender, we want to use the same font as the
+  // preceding character if possible. This is preferable to using the font
+  // group because it avoids breaks in shaping within a cluster.
+  if (aPrevMatchedFont && IsClusterExtender(aCh)) {
+    if (aPrevMatchedFont->HasCharacter(aCh) || IsDefaultIgnorable(aCh)) {
+      return do_AddRef(aPrevMatchedFont);
+    }
+    // Check if this char and preceding char can compose; if so, is the
+    // combination supported by the current font.
+    uint32_t composed = intl::String::ComposePairNFC(aPrevCh, aCh);
+    if (composed > 0 && aPrevMatchedFont->HasCharacter(composed)) {
+      return do_AddRef(aPrevMatchedFont);
+    }
+  }
+
+  // Special cases for NNBSP (as used in Mongolian):
+  if (aCh == NARROW_NO_BREAK_SPACE) {
+    // If there is no preceding character, try the font that we'd use
+    // for the next char (unless it's just another NNBSP; we don't try
+    // to look ahead through a whole run of them).
+    if (!aPrevCh && aNextCh && aNextCh != NARROW_NO_BREAK_SPACE) {
+      RefPtr<gfxFont> nextFont = FindFontForChar(aNextCh, 0, 0, aRunScript,
+                                                 aPrevMatchedFont, aMatchType);
+      if (nextFont && nextFont->HasCharacter(aCh)) {
+        return nextFont.forget();
+      }
+    }
+    // Otherwise, treat NNBSP like a cluster extender (as above) and try
+    // to continue the preceding font run.
+    if (aPrevMatchedFont && aPrevMatchedFont->HasCharacter(aCh)) {
+      return do_AddRef(aPrevMatchedFont);
+    }
+  }
+
+  // To optimize common cases, try the first font in the font-group
+  // before going into the more detailed checks below
+  uint32_t fontListLength = mFonts.Length();
+  uint32_t nextIndex = 0;
+  bool isJoinControl = gfxFontUtils::IsJoinControl(aCh);
+  bool wasJoinCauser = gfxFontUtils::IsJoinCauser(aPrevCh);
+  bool isVarSelector = gfxFontUtils::IsVarSelector(aCh);
+  bool nextIsVarSelector = gfxFontUtils::IsVarSelector(aNextCh);
+
+  // For Unicode hyphens, if not supported in the font then we'll try for
+  // the ASCII hyphen-minus as a fallback.
+  // Similarly, for NBSP we try normal <space> as a fallback.
+  uint32_t fallbackChar = (aCh == 0x2010 || aCh == 0x2011) ? '-'
+                          : (aCh == 0x00A0)                ? ' '
+                                                           : 0;
+
+  // Whether we've seen a font that is currently loading a resource that may
+  // provide this character (so we should not start a new load).
+  bool loading = false;
+
+  // Do we need to explicitly look for a font that does or does not provide a
+  // color glyph for the given character?
+  // For characters with no `EMOJI` property, we'll use whatever the family
+  // list calls for; but if it's a potential emoji codepoint, we need to check
+  // if there's a variation selector specifically asking for Text-style or
+  // Emoji-style rendering and look for a suitable font.
+  eFontPresentation presentation = eFontPresentation::Any;
+  EmojiPresentation emojiPresentation = GetEmojiPresentation(aCh);
+  if (emojiPresentation != TextOnly) {
+    // Default presentation from the font-variant-emoji property.
+    presentation = mEmojiPresentation;
+    // If the prefer-emoji selector is present, or if it's a default-emoji
+    // char and the prefer-text selector is NOT present, or if there's a
+    // skin-tone modifier, we specifically look for a font with a color
+    // glyph.
+    // If the prefer-text selector is present, we specifically look for a
+    // font that will provide a monochrome glyph.
+    // Otherwise, we'll accept either color or monochrome font-family
+    // entries, so that a color font can be explicitly applied via font-
+    // family even to characters that are not inherently emoji-style.
+    if (aNextCh == kVariationSelector16 ||
+        (aNextCh >= kEmojiSkinToneFirst && aNextCh <= kEmojiSkinToneLast) ||
+        gfxFontUtils::IsEmojiFlagAndTag(aCh, aNextCh)) {
+      // Emoji presentation is explicitly requested by a variation selector
+      // or the presence of a skin-tone codepoint.
+      presentation = eFontPresentation::EmojiExplicit;
+    } else if (emojiPresentation == EmojiPresentation::EmojiDefault &&
+               aNextCh != kVariationSelector15) {
+      // Emoji presentation is the default for this Unicode character. but we
+      // will allow an explicitly-specified webfont to apply to it,
+      // regardless of its glyph type.
+      presentation = eFontPresentation::EmojiDefault;
+    } else if (aNextCh == kVariationSelector15) {
+      // Text presentation is explicitly requested.
+      presentation = eFontPresentation::Text;
+    }
+  }
+
+  if (!isJoinControl && !wasJoinCauser && !isVarSelector &&
+      !nextIsVarSelector && presentation == eFontPresentation::Any) {
+    RefPtr<gfxFont> firstFont = GetFontAt(0, aCh, &loading);
+    if (firstFont) {
+      if (firstFont->HasCharacter(aCh) ||
+          (fallbackChar && firstFont->HasCharacter(fallbackChar))) {
+        *aMatchType = {FontMatchType::Kind::kFontGroup, mFonts[0].Generic()};
+        return firstFont.forget();
+      }
+
+      RefPtr<gfxFont> font;
+      if (mFonts[0].CheckForFallbackFaces()) {
+        font = FindFallbackFaceForChar(mFonts[0], aCh, aNextCh, presentation);
+      } else if (!firstFont->GetFontEntry()->IsUserFont()) {
+        // For platform fonts (but not userfonts), we may need to do
+        // fallback within the family to handle cases where some faces
+        // such as Italic or Black have reduced character sets compared
+        // to the family's Regular face.
+        font = FindFallbackFaceForChar(mFonts[0], aCh, aNextCh, presentation);
+      }
+      if (font) {
+        *aMatchType = {FontMatchType::Kind::kFontGroup, mFonts[0].Generic()};
+        return font.forget();
+      }
+    } else {
+      if (fontListLength > 0) {
+        loading = loading || mFonts[0].IsLoadingFor(aCh);
+      }
+    }
+
+    // we don't need to check the first font again below
+    ++nextIndex;
+  }
+
+  if (aPrevMatchedFont) {
+    // Don't switch fonts for control characters, regardless of
+    // whether they are present in the current font, as they won't
+    // actually be rendered (see bug 716229)
+    if (isJoinControl ||
+        GetGeneralCategory(aCh) == HB_UNICODE_GENERAL_CATEGORY_CONTROL) {
+      return do_AddRef(aPrevMatchedFont);
+    }
+
+    // if previous character was a join-causer (ZWJ),
+    // use the same font as the previous range if we can
+    if (wasJoinCauser) {
+      if (aPrevMatchedFont->HasCharacter(aCh)) {
+        return do_AddRef(aPrevMatchedFont);
+      }
+    }
+  }
+
+  // If this character is a variation selector or default-ignorable, use the
+  // previous font regardless of whether it supports the codepoint or not.
+  // (We don't want to unnecessarily split glyph runs, and the character will
+  // not be visibly rendered.)
+  if (isVarSelector || IsDefaultIgnorable(aCh)) {
+    return do_AddRef(aPrevMatchedFont);
+  }
+
+  // Used to remember the first "candidate" font that would provide a fallback
+  // text-style rendering if no color glyph can be found.
+  // If we decide NOT to return this font, we must AddRef/Release it to ensure
+  // that it goes into the global font cache as a candidate for deletion.
+  // This is done for us by CheckCandidate, but any code path that returns
+  // WITHOUT calling CheckCandidate needs to handle it explicitly.
+  RefPtr<gfxFont> candidateFont;
+  FontMatchType candidateMatchType;
+
+  // Handle a candidate font that could support the character, returning true
+  // if we should go ahead and return |f|, false to continue searching.
+  // If there is already a saved candidate font, and the new candidate is
+  // accepted, we AddRef/Release the existing candidate so it won't leak.
+  auto CheckCandidate = [&](gfxFont* f, FontMatchType t) -> bool {
+    // If no preference, then just accept the font.
+    if (presentation == eFontPresentation::Any ||
+        (presentation == eFontPresentation::EmojiDefault &&
+         f->GetFontEntry()->IsUserFont())) {
+      *aMatchType = t;
+      return true;
+    }
+    // Does the candidate font provide a color glyph for the current character?
+    bool hasColorGlyph = f->HasColorGlyphFor(aCh, aNextCh);
+    // If the provided glyph matches the preference, accept the font.
+    if (hasColorGlyph == PrefersColor(presentation)) {
+      *aMatchType = t;
+      return true;
+    }
+    // If the character was a TextDefault char, but the next char is VS16,
+    // and the font is a COLR font that supports both these codepoints, then
+    // we'll assume it knows what it is doing (eg Twemoji Mozilla keycap
+    // sequences).
+    // TODO: reconsider all this as part of any fix for bug 543200.
+    if (aNextCh == kVariationSelector16 && emojiPresentation == TextDefault &&
+        f->HasCharacter(aNextCh) && f->GetFontEntry()->TryGetColorGlyphs()) {
+      return true;
+    }
+    // Otherwise, remember the first potential fallback, but keep searching.
+    if (!candidateFont) {
+      candidateFont = f;
+      candidateMatchType = t;
+    }
+    return false;
+  };
+
+  // 1. check remaining fonts in the font group
+  for (uint32_t i = nextIndex; i < fontListLength; i++) {
+    FamilyFace& ff = mFonts[i];
+    if (ff.IsInvalid() || ff.IsLoading()) {
+      if (ff.IsLoadingFor(aCh)) {
+        loading = true;
+      }
+      continue;
+    }
+
+    RefPtr<gfxFont> font = ff.Font();
+    if (font) {
+      // if available, use already-made gfxFont and check for character
+      if (font->HasCharacter(aCh) ||
+          (fallbackChar && font->HasCharacter(fallbackChar))) {
+        if (CheckCandidate(font,
+                           {FontMatchType::Kind::kFontGroup, ff.Generic()})) {
+          return font.forget();
+        }
+      }
+    } else {
+      // don't have a gfxFont yet, test charmap before instantiating
+      gfxFontEntry* fe = ff.FontEntry();
+      if (fe && fe->mIsUserFontContainer) {
+        // for userfonts, need to test both the unicode range map and
+        // the cmap of the platform font entry
+        gfxUserFontEntry* ufe = static_cast<gfxUserFontEntry*>(fe);
+
+        // never match a character outside the defined unicode range
+        if (!ufe->CharacterInUnicodeRange(aCh)) {
+          continue;
+        }
+
+        // Load if not already loaded, unless we've already seen an in-
+        // progress load that is expected to satisfy this request.
+        if (!loading &&
+            ufe->LoadState() == gfxUserFontEntry::STATUS_NOT_LOADED) {
+          ufe->Load();
+          ff.CheckState(mSkipDrawing);
+        }
+
+        if (ff.IsLoading()) {
+          loading = true;
+        }
+
+        gfxFontEntry* pfe = ufe->GetPlatformFontEntry();
+        if (pfe && (pfe->HasCharacter(aCh) ||
+                    (fallbackChar && pfe->HasCharacter(fallbackChar)))) {
+          font = GetFontAt(i, aCh, &loading);
+          if (font) {
+            if (CheckCandidate(font, {FontMatchType::Kind::kFontGroup,
+                                      mFonts[i].Generic()})) {
+              return font.forget();
+            }
+          }
+        }
+      } else if (fe && (fe->HasCharacter(aCh) ||
+                        (fallbackChar && fe->HasCharacter(fallbackChar)))) {
+        // for normal platform fonts, after checking the cmap
+        // build the font via GetFontAt
+        font = GetFontAt(i, aCh, &loading);
+        if (font) {
+          if (CheckCandidate(font, {FontMatchType::Kind::kFontGroup,
+                                    mFonts[i].Generic()})) {
+            return font.forget();
+          }
+        }
+      }
+    }
+
+    // check other family faces if needed
+    if (ff.CheckForFallbackFaces()) {
+#ifdef DEBUG
+      if (i > 0) {
+        fontlist::FontList* list =
+            gfxPlatformFontList::PlatformFontList()->SharedFontList();
+        nsCString s1 = mFonts[i - 1].IsSharedFamily()
+                           ? mFonts[i - 1].SharedFamily()->Key().AsString(list)
+                           : mFonts[i - 1].OwnedFamily()->Name();
+        nsCString s2 = ff.IsSharedFamily()
+                           ? ff.SharedFamily()->Key().AsString(list)
+                           : ff.OwnedFamily()->Name();
+        MOZ_ASSERT(!mFonts[i - 1].CheckForFallbackFaces() || !s1.Equals(s2),
+                   "should only do fallback once per font family");
+      }
+#endif
+      font = FindFallbackFaceForChar(ff, aCh, aNextCh, presentation);
+      if (font) {
+        if (CheckCandidate(font,
+                           {FontMatchType::Kind::kFontGroup, ff.Generic()})) {
+          return font.forget();
+        }
+      }
+    } else {
+      // For platform fonts, but not user fonts, consider intra-family
+      // fallback to handle styles with reduced character sets (see
+      // also above).
+      gfxFontEntry* fe = ff.FontEntry();
+      if (fe && !fe->mIsUserFontContainer && !fe->IsUserFont()) {
+        font = FindFallbackFaceForChar(ff, aCh, aNextCh, presentation);
+        if (font) {
+          if (CheckCandidate(font,
+                             {FontMatchType::Kind::kFontGroup, ff.Generic()})) {
+            return font.forget();
+          }
+        }
+      }
+    }
+  }
+
+  if (fontListLength == 0) {
+    RefPtr<gfxFont> defaultFont = GetDefaultFont();
+    if (defaultFont->HasCharacter(aCh) ||
+        (fallbackChar && defaultFont->HasCharacter(fallbackChar))) {
+      if (CheckCandidate(defaultFont, FontMatchType::Kind::kFontGroup)) {
+        return defaultFont.forget();
+      }
+    }
+  }
+
+  // If character is in Private Use Area, or is unassigned in Unicode, don't do
+  // matching against pref or system fonts. We only support such codepoints
+  // when used with an explicitly-specified font, as they have no standard/
+  // interoperable meaning.
+  // Also don't attempt any fallback for control characters or noncharacters,
+  // where we won't be rendering a glyph anyhow, or for codepoints where global
+  // fallback has already noted a failure.
+  FontVisibility level =
+      mPresContext ? mPresContext->GetFontVisibility() : FontVisibility::User;
+  auto* pfl = gfxPlatformFontList::PlatformFontList();
+  if (pfl->SkipFontFallbackForChar(level, aCh) ||
+      (!StaticPrefs::gfx_font_rendering_fallback_unassigned_chars() &&
+       GetGeneralCategory(aCh) == HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED)) {
+    if (candidateFont) {
+      *aMatchType = candidateMatchType;
+    }
+    return candidateFont.forget();
+  }
+
+  // 2. search pref fonts
+  RefPtr<gfxFont> font = WhichPrefFontSupportsChar(aCh, aNextCh, presentation);
+  if (font) {
+    if (PrefersColor(presentation) && pfl->EmojiPrefHasUserValue()) {
+      // For emoji, always accept the font from preferences if it's explicitly
+      // user-set, even if it isn't actually a color-emoji font, as some users
+      // may want to set their emoji font preference to a monochrome font like
+      // Symbola.
+      // So a user-provided font.name-list.emoji preference takes precedence
+      // over the Unicode presentation style here.
+      RefPtr<gfxFont> autoRefDeref(candidateFont);
+      *aMatchType = FontMatchType::Kind::kPrefsFallback;
+      return font.forget();
+    }
+    if (CheckCandidate(font, FontMatchType::Kind::kPrefsFallback)) {
+      return font.forget();
+    }
+  }
+
+  // For fallback searches, we don't want to use a color-emoji font unless
+  // emoji-style presentation is specifically required, so we map Any to
+  // Text here.
+  if (presentation == eFontPresentation::Any) {
+    presentation = eFontPresentation::Text;
+  }
+
+  // 3. use fallback fonts
+  // -- before searching for something else check the font used for the
+  //    previous character
+  if (aPrevMatchedFont &&
+      (aPrevMatchedFont->HasCharacter(aCh) ||
+       (fallbackChar && aPrevMatchedFont->HasCharacter(fallbackChar)))) {
+    if (CheckCandidate(aPrevMatchedFont,
+                       FontMatchType::Kind::kSystemFallback)) {
+      return do_AddRef(aPrevMatchedFont);
+    }
+  }
+
+  // for known "space" characters, don't do a full system-fallback search;
+  // we'll synthesize appropriate-width spaces instead of missing-glyph boxes
+  font = GetFirstValidFont();
+  if (GetGeneralCategory(aCh) == HB_UNICODE_GENERAL_CATEGORY_SPACE_SEPARATOR &&
+      font->SynthesizeSpaceWidth(aCh) >= 0.0) {
+    return nullptr;
+  }
+
+  // -- otherwise look for other stuff
+  font = WhichSystemFontSupportsChar(aCh, aNextCh, aRunScript, presentation);
+  if (font) {
+    if (CheckCandidate(font, FontMatchType::Kind::kSystemFallback)) {
+      return font.forget();
+    }
+  }
+  if (candidateFont) {
+    *aMatchType = candidateMatchType;
+  }
+  return candidateFont.forget();
+}
+
+template <typename T>
+void gfxFontGroup::ComputeRanges(nsTArray<TextRange>& aRanges, const T* aString,
+                                 uint32_t aLength, Script aRunScript,
+                                 gfx::ShapedTextFlags aOrientation) {
+  NS_ASSERTION(aRanges.Length() == 0, "aRanges must be initially empty");
+  NS_ASSERTION(aLength > 0, "don't call ComputeRanges for zero-length text");
+
+  uint32_t prevCh = 0;
+  uint32_t nextCh = aString[0];
+  if constexpr (sizeof(T) == sizeof(char16_t)) {
+    if (aLength > 1 && NS_IS_SURROGATE_PAIR(nextCh, aString[1])) {
+      nextCh = SURROGATE_TO_UCS4(nextCh, aString[1]);
+    }
+  }
+  int32_t lastRangeIndex = -1;
+
+  // initialize prevFont to the group's primary font, so that this will be
+  // used for string-initial control chars, etc rather than risk hitting font
+  // fallback for these (bug 716229)
+  StyleGenericFontFamily generic = StyleGenericFontFamily::None;
+  RefPtr<gfxFont> prevFont = GetFirstValidFont(' ', &generic);
+
+  // if we use the initial value of prevFont, we treat this as a match from
+  // the font group; fixes bug 978313
+  FontMatchType matchType = {FontMatchType::Kind::kFontGroup, generic};
+
+  for (uint32_t i = 0; i < aLength; i++) {
+    const uint32_t origI = i;  // save off in case we increase for surrogate
+
+    // set up current ch
+    uint32_t ch = nextCh;
+
+    // Get next char (if any) so that FindFontForChar can look ahead
+    // for a possible variation selector.
+
+    if constexpr (sizeof(T) == sizeof(char16_t)) {
+      // In 16-bit case only, check for surrogate pairs.
+      if (ch > 0xffffu) {
+        i++;
+      }
+      if (i < aLength - 1) {
+        nextCh = aString[i + 1];
+        if (i + 2 < aLength && NS_IS_SURROGATE_PAIR(nextCh, aString[i + 2])) {
+          nextCh = SURROGATE_TO_UCS4(nextCh, aString[i + 2]);
+        }
+      } else {
+        nextCh = 0;
+      }
+    } else {
+      // 8-bit case is trivial.
+      nextCh = i < aLength - 1 ? aString[i + 1] : 0;
+    }
+
+    RefPtr<gfxFont> font;
+
+    // Find the font for this char; but try to avoid calling the expensive
+    // FindFontForChar method for the most common case, where the first
+    // font in the list supports the current char, and it is not one of
+    // the special cases where FindFontForChar will attempt to propagate
+    // the font selected for an adjacent character.
+    if ((font = GetFontAt(0, ch)) != nullptr && font->HasCharacter(ch) &&
+        (sizeof(T) == sizeof(uint8_t) ||
+         (!IsClusterExtender(ch) && ch != NARROW_NO_BREAK_SPACE &&
+          !gfxFontUtils::IsJoinControl(ch) &&
+          !gfxFontUtils::IsJoinCauser(prevCh) &&
+          !gfxFontUtils::IsVarSelector(ch) &&
+          GetEmojiPresentation(ch) == TextOnly))) {
+      matchType = {FontMatchType::Kind::kFontGroup, mFonts[0].Generic()};
+    } else {
+      font =
+          FindFontForChar(ch, prevCh, nextCh, aRunScript, prevFont, &matchType);
+    }
+
+#ifndef RELEASE_OR_BETA
+    if (MOZ_UNLIKELY(mTextPerf)) {
+      if (matchType.kind == FontMatchType::Kind::kPrefsFallback) {
+        mTextPerf->current.fallbackPrefs++;
+      } else if (matchType.kind == FontMatchType::Kind::kSystemFallback) {
+        mTextPerf->current.fallbackSystem++;
+      }
+    }
+#endif
+
+    prevCh = ch;
+
+    ShapedTextFlags orient = aOrientation;
+    if (aOrientation == ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED) {
+      // For CSS text-orientation:mixed, we need to resolve orientation
+      // on a per-character basis using the UTR50 orientation property.
+      switch (GetVerticalOrientation(ch)) {
+        case VERTICAL_ORIENTATION_U:
+        case VERTICAL_ORIENTATION_Tu:
+          orient = ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT;
+          break;
+        case VERTICAL_ORIENTATION_Tr: {
+          // We check for a vertical presentation form first as that's
+          // likely to be cheaper than inspecting lookups to see if the
+          // 'vert' feature is going to handle this character, and if the
+          // presentation form is available then it will be used as
+          // fallback if needed, so it's OK if the feature is missing.
+          //
+          // Because "common" CJK punctuation characters in isolation will be
+          // resolved to Bopomofo script (as the first script listed in their
+          // ScriptExtensions property), but this is not always well supported
+          // by fonts' OpenType tables, we also try Han script; harfbuzz will
+          // apply a 'vert' feature from any available script (see
+          // https://github.com/harfbuzz/harfbuzz/issues/63) when shaping,
+          // so this is OK. It's not quite as general as what harfbuzz does
+          // (it will find the feature in *any* script), but should be enough
+          // for likely real-world examples.
+          uint32_t v = gfxHarfBuzzShaper::GetVerticalPresentationForm(ch);
+          const uint32_t kVert = HB_TAG('v', 'e', 'r', 't');
+          orient = (!font || (v && font->HasCharacter(v)) ||
+                    font->FeatureWillHandleChar(aRunScript, kVert, ch) ||
+                    (aRunScript == Script::BOPOMOFO &&
+                     font->FeatureWillHandleChar(Script::HAN, kVert, ch)))
+                       ? ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT
+                       : ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+          break;
+        }
+        case VERTICAL_ORIENTATION_R:
+          orient = ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+          break;
+      }
+    }
+
+    if (lastRangeIndex == -1) {
+      // first char ==> make a new range
+      aRanges.AppendElement(TextRange(0, 1, font, matchType, orient));
+      lastRangeIndex++;
+      prevFont = std::move(font);
+    } else {
+      // if font or orientation has changed, make a new range...
+      // unless ch is a variation selector (bug 1248248)
+      TextRange& prevRange = aRanges[lastRangeIndex];
+      if (prevRange.font != font ||
+          (prevRange.orientation != orient && !IsClusterExtender(ch))) {
+        // close out the previous range
+        prevRange.end = origI;
+        aRanges.AppendElement(TextRange(origI, i + 1, font, matchType, orient));
+        lastRangeIndex++;
+
+        // update prevFont for the next match, *unless* we switched
+        // fonts on a ZWJ, in which case propagating the changed font
+        // is probably not a good idea (see bug 619511)
+        if (sizeof(T) == sizeof(uint8_t) || !gfxFontUtils::IsJoinCauser(ch)) {
+          prevFont = std::move(font);
+        }
+      } else {
+        prevRange.matchType |= matchType;
+      }
+    }
+  }
+
+  aRanges[lastRangeIndex].end = aLength;
+
+#ifndef RELEASE_OR_BETA
+  LogModule* log = mStyle.systemFont ? gfxPlatform::GetLog(eGfxLog_textrunui)
+                                     : gfxPlatform::GetLog(eGfxLog_textrun);
+
+  if (MOZ_UNLIKELY(MOZ_LOG_TEST(log, LogLevel::Debug))) {
+    nsAutoCString lang;
+    mLanguage->ToUTF8String(lang);
+    auto defaultLanguageGeneric = GetDefaultGeneric(mLanguage);
+
+    // collect the font matched for each range
+    nsAutoCString fontMatches;
+    for (size_t i = 0, i_end = aRanges.Length(); i < i_end; i++) {
+      const TextRange& r = aRanges[i];
+      nsAutoCString matchTypes;
+      if (r.matchType.kind & FontMatchType::Kind::kFontGroup) {
+        matchTypes.AppendLiteral("list");
+      }
+      if (r.matchType.kind & FontMatchType::Kind::kPrefsFallback) {
+        if (!matchTypes.IsEmpty()) {
+          matchTypes.AppendLiteral(",");
+        }
+        matchTypes.AppendLiteral("prefs");
+      }
+      if (r.matchType.kind & FontMatchType::Kind::kSystemFallback) {
+        if (!matchTypes.IsEmpty()) {
+          matchTypes.AppendLiteral(",");
+        }
+        matchTypes.AppendLiteral("sys");
+      }
+      fontMatches.AppendPrintf(
+          " [%u:%u] %.200s (%s)", r.start, r.end,
+          (r.font.get() ? r.font->GetName().get() : "<null>"),
+          matchTypes.get());
+    }
+    MOZ_LOG(log, LogLevel::Debug,
+            ("(%s-fontmatching) fontgroup: [%s] default: %s lang: %s script: %d"
+             "%s\n",
+             (mStyle.systemFont ? "textrunui" : "textrun"),
+             FamilyListToString(mFamilyList).get(),
+             (defaultLanguageGeneric == StyleGenericFontFamily::Serif
+                  ? "serif"
+                  : (defaultLanguageGeneric == StyleGenericFontFamily::SansSerif
+                         ? "sans-serif"
+                         : "none")),
+             lang.get(), static_cast<int>(aRunScript), fontMatches.get()));
+  }
+#endif
+}
+
+gfxUserFontSet* gfxFontGroup::GetUserFontSet() { return mUserFontSet; }
+
+void gfxFontGroup::SetUserFontSet(gfxUserFontSet* aUserFontSet) {
+  if (aUserFontSet == mUserFontSet) {
+    return;
+  }
+  mUserFontSet = aUserFontSet;
+  mCurrGeneration = GetGeneration() - 1;
+  UpdateUserFonts();
+}
+
+uint64_t gfxFontGroup::GetGeneration() {
+  if (!mUserFontSet) return 0;
+  return mUserFontSet->GetGeneration();
+}
+
+uint64_t gfxFontGroup::GetRebuildGeneration() {
+  if (!mUserFontSet) return 0;
+  return mUserFontSet->GetRebuildGeneration();
+}
+
+void gfxFontGroup::UpdateUserFonts() {
+  if (mCurrGeneration < GetRebuildGeneration()) {
+    // fonts in userfont set changed, need to redo the fontlist
+    mFonts.Clear();
+    ClearCachedData();
+    BuildFontList();
+    mCurrGeneration = GetGeneration();
+  } else if (mCurrGeneration != GetGeneration()) {
+    // load state change occurred, verify load state and validity of fonts
+    ClearCachedData();
+
+    uint32_t len = mFonts.Length();
+    for (uint32_t i = 0; i < len; i++) {
+      FamilyFace& ff = mFonts[i];
+      if (ff.Font() || !ff.IsUserFontContainer()) {
+        continue;
+      }
+      ff.CheckState(mSkipDrawing);
+    }
+
+    mCurrGeneration = GetGeneration();
+  }
+}
+
+bool gfxFontGroup::ContainsUserFont(const gfxUserFontEntry* aUserFont) {
+  UpdateUserFonts();
+  // search through the fonts list for a specific user font
+  uint32_t len = mFonts.Length();
+  for (uint32_t i = 0; i < len; i++) {
+    FamilyFace& ff = mFonts[i];
+    if (ff.EqualsUserFont(aUserFont)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::WhichPrefFontSupportsChar(
+    uint32_t aCh, uint32_t aNextCh, eFontPresentation aPresentation) {
+  eFontPrefLang charLang;
+  gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+
+  if (PrefersColor(aPresentation)) {
+    charLang = eFontPrefLang_Emoji;
+  } else {
+    // get the pref font list if it hasn't been set up already
+    charLang = pfl->GetFontPrefLangFor(aCh);
+  }
+
+  // if the last pref font was the first family in the pref list, no need to
+  // recheck through a list of families
+  if (mLastPrefFont && charLang == mLastPrefLang && mLastPrefFirstFont &&
+      mLastPrefFont->HasCharacter(aCh)) {
+    return do_AddRef(mLastPrefFont);
+  }
+
+  // based on char lang and page lang, set up list of pref lang fonts to check
+  eFontPrefLang prefLangs[kMaxLenPrefLangList];
+  uint32_t i, numLangs = 0;
+
+  pfl->GetLangPrefs(prefLangs, numLangs, charLang, mPageLang);
+
+  for (i = 0; i < numLangs; i++) {
+    eFontPrefLang currentLang = prefLangs[i];
+    StyleGenericFontFamily generic =
+        mFallbackGeneric != StyleGenericFontFamily::None
+            ? mFallbackGeneric
+            : pfl->GetDefaultGeneric(currentLang);
+    gfxPlatformFontList::PrefFontList* families =
+        pfl->GetPrefFontsLangGroup(mPresContext, generic, currentLang);
+    NS_ASSERTION(families, "no pref font families found");
+
+    // find the first pref font that includes the character
+    uint32_t j, numPrefs;
+    numPrefs = families->Length();
+    for (j = 0; j < numPrefs; j++) {
+      // look up the appropriate face
+      FontFamily family = (*families)[j];
+      if (family.IsNull()) {
+        continue;
+      }
+
+      // if a pref font is used, it's likely to be used again in the same text
+      // run. the style doesn't change so the face lookup can be cached rather
+      // than calling FindOrMakeFont repeatedly.  speeds up FindFontForChar
+      // lookup times for subsequent pref font lookups
+      if (family == mLastPrefFamily && mLastPrefFont->HasCharacter(aCh)) {
+        return do_AddRef(mLastPrefFont);
+      }
+
+      gfxFontEntry* fe = nullptr;
+      if (family.mShared) {
+        fontlist::Family* fam = family.mShared;
+        if (!fam->IsInitialized()) {
+          Unused << pfl->InitializeFamily(fam);
+        }
+        fontlist::Face* face =
+            fam->FindFaceForStyle(pfl->SharedFontList(), mStyle);
+        if (face) {
+          fe = pfl->GetOrCreateFontEntry(face, fam);
+        }
+      } else {
+        fe = family.mUnshared->FindFontForStyle(mStyle);
+      }
+      if (!fe) {
+        continue;
+      }
+
+      // if ch in cmap, create and return a gfxFont
+      RefPtr<gfxFont> prefFont;
+      if (fe->HasCharacter(aCh)) {
+        prefFont = fe->FindOrMakeFont(&mStyle);
+        if (!prefFont) {
+          continue;
+        }
+        if (aPresentation == eFontPresentation::EmojiExplicit &&
+            !prefFont->HasColorGlyphFor(aCh, aNextCh)) {
+          continue;
+        }
+      }
+
+      // If the char was not available, see if we can fall back to an
+      // alternative face in the same family.
+      if (!prefFont) {
+        prefFont = family.mShared
+                       ? FindFallbackFaceForChar(family.mShared, aCh, aNextCh,
+                                                 aPresentation)
+                       : FindFallbackFaceForChar(family.mUnshared, aCh, aNextCh,
+                                                 aPresentation);
+      }
+      if (prefFont) {
+        mLastPrefFamily = family;
+        mLastPrefFont = prefFont;
+        mLastPrefLang = charLang;
+        mLastPrefFirstFont = (i == 0 && j == 0);
+        return prefFont.forget();
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+already_AddRefed<gfxFont> gfxFontGroup::WhichSystemFontSupportsChar(
+    uint32_t aCh, uint32_t aNextCh, Script aRunScript,
+    eFontPresentation aPresentation) {
+  FontVisibility visibility;
+  return gfxPlatformFontList::PlatformFontList()->SystemFindFontForChar(
+      mPresContext, aCh, aNextCh, aRunScript, aPresentation, &mStyle,
+      &visibility);
+}
+
+gfxFont::Metrics gfxFontGroup::GetMetricsForCSSUnits(
+    gfxFont::Orientation aOrientation) {
+  bool isFirst;
+  RefPtr<gfxFont> font = GetFirstValidFont(0x20, nullptr, &isFirst);
+  auto metrics = font->GetMetrics(aOrientation);
+
+  // If the font we used to get metrics was not the first in the list,
+  // or if it doesn't support the ZERO character, check for the font that
+  // does support ZERO and use its metrics for the 'ch' unit.
+  if (!isFirst || !font->HasCharacter('0')) {
+    RefPtr<gfxFont> zeroFont = GetFirstValidFont('0');
+    if (zeroFont != font) {
+      const auto& zeroMetrics = zeroFont->GetMetrics(aOrientation);
+      metrics.zeroWidth = zeroMetrics.zeroWidth;
+    }
+  }
+
+  // Likewise for the WATER ideograph character used as the basis for 'ic'.
+  if (!isFirst || !font->HasCharacter(0x6C34)) {
+    RefPtr<gfxFont> icFont = GetFirstValidFont(0x6C34);
+    if (icFont != font) {
+      const auto& icMetrics = icFont->GetMetrics(aOrientation);
+      metrics.ideographicWidth = icMetrics.ideographicWidth;
+    }
+  }
+
+  return metrics;
+}
+
+void gfxMissingFontRecorder::Flush() {
+  static bool mNotifiedFontsInitialized = false;
+  static uint32_t mNotifiedFonts[gfxMissingFontRecorder::kNumScriptBitsWords];
+  if (!mNotifiedFontsInitialized) {
+    memset(&mNotifiedFonts, 0, sizeof(mNotifiedFonts));
+    mNotifiedFontsInitialized = true;
+  }
+
+  nsAutoString fontNeeded;
+  for (uint32_t i = 0; i < kNumScriptBitsWords; ++i) {
+    mMissingFonts[i] &= ~mNotifiedFonts[i];
+    if (!mMissingFonts[i]) {
+      continue;
+    }
+    for (uint32_t j = 0; j < 32; ++j) {
+      if (!(mMissingFonts[i] & (1 << j))) {
+        continue;
+      }
+      mNotifiedFonts[i] |= (1 << j);
+      if (!fontNeeded.IsEmpty()) {
+        fontNeeded.Append(char16_t(','));
+      }
+      uint32_t sc = i * 32 + j;
+      MOZ_ASSERT(sc < static_cast<uint32_t>(Script::NUM_SCRIPT_CODES),
+                 "how did we set the bit for an invalid script code?");
+      uint32_t tag = GetScriptTagForCode(static_cast<Script>(sc));
+      fontNeeded.Append(char16_t(tag >> 24));
+      fontNeeded.Append(char16_t((tag >> 16) & 0xff));
+      fontNeeded.Append(char16_t((tag >> 8) & 0xff));
+      fontNeeded.Append(char16_t(tag & 0xff));
+    }
+    mMissingFonts[i] = 0;
+  }
+  if (!fontNeeded.IsEmpty()) {
+    nsCOMPtr<nsIObserverService> service = GetObserverService();
+    service->NotifyObservers(nullptr, "font-needed", fontNeeded.get());
+  }
+}