Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 2378 insertions, 0 deletions

diff --git a/gfx/thebes/gfxFont.h b/gfx/thebes/gfxFont.h
new file mode 100644
index 0000000000..f51c08ea82
--- /dev/null
+++ b/gfx/thebes/gfxFont.h
@@ -0,0 +1,2378 @@
+/* -*- 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/. */
+
+#ifndef GFX_FONT_H
+#define GFX_FONT_H
+
+#include <new>
+#include <utility>
+#include <functional>
+#include "PLDHashTable.h"
+#include "ThebesRLBoxTypes.h"
+#include "gfxFontVariations.h"
+#include "gfxRect.h"
+#include "gfxTypes.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/FontPropertyTypes.h"
+#include "mozilla/HashTable.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/MruCache.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/RWLock.h"
+#include "mozilla/TypedEnumBits.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/gfx/FontPaletteCache.h"
+#include "mozilla/gfx/MatrixFwd.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/intl/UnicodeScriptCodes.h"
+#include "nsCOMPtr.h"
+#include "nsColor.h"
+#include "nsTHashMap.h"
+#include "nsTHashSet.h"
+#include "nsExpirationTracker.h"
+#include "nsFontMetrics.h"
+#include "nsHashKeys.h"
+#include "nsIMemoryReporter.h"
+#include "nsIObserver.h"
+#include "nsISupports.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsTHashtable.h"
+#include "nscore.h"
+#include "DrawMode.h"
+
+// Only required for function bodies
+#include "gfxFontEntry.h"
+#include "gfxFontFeatures.h"
+
+class gfxContext;
+class gfxGraphiteShaper;
+class gfxHarfBuzzShaper;
+class gfxGlyphExtents;
+class gfxMathTable;
+class gfxPattern;
+class gfxShapedText;
+class gfxShapedWord;
+class gfxSkipChars;
+class gfxTextRun;
+class nsIEventTarget;
+class nsITimer;
+struct gfxTextRunDrawCallbacks;
+
+namespace mozilla {
+class SVGContextPaint;
+namespace layout {
+class TextDrawTarget;
+}
+}  // namespace mozilla
+
+typedef struct _cairo cairo_t;
+typedef struct _cairo_scaled_font cairo_scaled_font_t;
+
+#define FONT_MAX_SIZE 2000.0
+
+#define SMALL_CAPS_SCALE_FACTOR 0.8
+
+// The skew factor used for synthetic-italic [oblique] fonts;
+// we use a platform-dependent value to harmonize with the platform's own APIs.
+#ifdef XP_WIN
+#  define OBLIQUE_SKEW_FACTOR 0.3f
+#elif defined(MOZ_WIDGET_GTK)
+#  define OBLIQUE_SKEW_FACTOR 0.2f
+#else
+#  define OBLIQUE_SKEW_FACTOR 0.25f
+#endif
+
+struct gfxFontStyle {
+  using FontStretch = mozilla::FontStretch;
+  using FontSlantStyle = mozilla::FontSlantStyle;
+  using FontWeight = mozilla::FontWeight;
+  using FontSizeAdjust = mozilla::StyleFontSizeAdjust;
+
+  gfxFontStyle();
+  gfxFontStyle(FontSlantStyle aStyle, FontWeight aWeight, FontStretch aStretch,
+               gfxFloat aSize, const FontSizeAdjust& aSizeAdjust,
+               bool aSystemFont, bool aPrinterFont, bool aWeightSynthesis,
+               bool aStyleSynthesis, bool aSmallCapsSynthesis,
+               bool aPositionSynthesis, uint32_t aLanguageOverride);
+  // Features are composed of (1) features from style rules (2) features
+  // from feature settings rules and (3) family-specific features.  (1) and
+  // (3) are guaranteed to be mutually exclusive
+
+  // custom opentype feature settings
+  CopyableTArray<gfxFontFeature> featureSettings;
+
+  // Some font-variant property values require font-specific settings
+  // defined via @font-feature-values rules.  These are resolved after
+  // font matching occurs.
+
+  // -- list of value tags for specific alternate features
+  mozilla::StyleFontVariantAlternates variantAlternates;
+
+  // -- object used to look these up once the font is matched
+  RefPtr<gfxFontFeatureValueSet> featureValueLookup;
+
+  // opentype variation settings
+  CopyableTArray<gfxFontVariation> variationSettings;
+
+  // The logical size of the font, in pixels
+  gfxFloat size;
+
+  // The optical size value to apply (if supported); negative means none.
+  float autoOpticalSize = -1.0f;
+
+  // The aspect-value (ie., the ratio actualsize:actualxheight) that any
+  // actual physical font created from this font structure must have when
+  // rendering or measuring a string. A value of -1.0 means no adjustment
+  // needs to be done; otherwise the value must be nonnegative.
+  float sizeAdjust;
+
+  // baseline offset, used when simulating sub/superscript glyphs
+  float baselineOffset;
+
+  // Language system tag, to override document language;
+  // an OpenType "language system" tag represented as a 32-bit integer
+  // (see http://www.microsoft.com/typography/otspec/languagetags.htm).
+  // Normally 0, so font rendering will use the document or element language
+  // (see above) to control any language-specific rendering, but the author
+  // can override this for cases where the options implemented in the font
+  // do not directly match the actual language. (E.g. lang may be Macedonian,
+  // but the font in use does not explicitly support this; the author can
+  // use font-language-override to request the Serbian option in the font
+  // in order to get correct glyph shapes.)
+  uint32_t languageOverride;
+
+  // The Font{Weight,Stretch,SlantStyle} fields are each a 16-bit type.
+
+  // The weight of the font: 100, 200, ... 900.
+  FontWeight weight;
+
+  // The stretch of the font
+  FontStretch stretch;
+
+  // The style of font
+  FontSlantStyle style;
+
+  // Whether face-selection properties weight/style/stretch are all 'normal'
+  bool IsNormalStyle() const {
+    return weight.IsNormal() && style.IsNormal() && stretch.IsNormal();
+  }
+
+  // We pack these three small-integer fields into a single byte to avoid
+  // overflowing an 8-byte boundary [in a 64-bit build] and ending up with
+  // 7 bytes of padding at the end of the struct.
+
+  // caps variant (small-caps, petite-caps, etc.)
+  uint8_t variantCaps : 3;  // uses range 0..6
+
+  // sub/superscript variant
+  uint8_t variantSubSuper : 2;  // uses range 0..2
+
+  // font metric used as basis of font-size-adjust
+  uint8_t sizeAdjustBasis : 3;  // uses range 0..4
+
+  // Say that this font is a system font and therefore does not
+  // require certain fixup that we do for fonts from untrusted
+  // sources.
+  bool systemFont : 1;
+
+  // Say that this font is used for print or print preview.
+  bool printerFont : 1;
+
+  // Used to imitate -webkit-font-smoothing: antialiased
+  bool useGrayscaleAntialiasing : 1;
+
+  // Whether synthetic styles are allowed (required, in the case of position)
+  bool allowSyntheticWeight : 1;
+  bool allowSyntheticStyle : 1;
+  bool allowSyntheticSmallCaps : 1;
+  bool useSyntheticPosition : 1;
+
+  // some variant features require fallback which complicates the shaping
+  // code, so set up a bool to indicate when shaping with fallback is needed
+  bool noFallbackVariantFeatures : 1;
+
+  // Return the final adjusted font size for the given aspect ratio.
+  // Not meant to be called when sizeAdjustBasis is NONE.
+  gfxFloat GetAdjustedSize(gfxFloat aspect) const {
+    MOZ_ASSERT(
+        FontSizeAdjust::Tag(sizeAdjustBasis) != FontSizeAdjust::Tag::None,
+        "Not meant to be called when sizeAdjustBasis is none");
+    gfxFloat adjustedSize =
+        std::max(NS_round(size * (sizeAdjust / aspect)), 1.0);
+    return std::min(adjustedSize, FONT_MAX_SIZE);
+  }
+
+  // Some callers want to take a short-circuit path if they can be sure the
+  // adjusted size will be zero.
+  bool AdjustedSizeMustBeZero() const {
+    return size == 0.0 ||
+           (FontSizeAdjust::Tag(sizeAdjustBasis) != FontSizeAdjust::Tag::None &&
+            sizeAdjust == 0.0);
+  }
+
+  PLDHashNumber Hash() const;
+
+  // Adjust this style to simulate sub/superscript (as requested in the
+  // variantSubSuper field) using size and baselineOffset instead.
+  void AdjustForSubSuperscript(int32_t aAppUnitsPerDevPixel);
+
+  // Should this style cause the given font entry to use synthetic bold?
+  bool NeedsSyntheticBold(gfxFontEntry* aFontEntry) const {
+    return weight.IsBold() && allowSyntheticWeight &&
+           !aFontEntry->SupportsBold();
+  }
+
+  bool Equals(const gfxFontStyle& other) const {
+    return mozilla::NumbersAreBitwiseIdentical(size, other.size) &&
+           (style == other.style) && (weight == other.weight) &&
+           (stretch == other.stretch) && (variantCaps == other.variantCaps) &&
+           (variantSubSuper == other.variantSubSuper) &&
+           (allowSyntheticWeight == other.allowSyntheticWeight) &&
+           (allowSyntheticStyle == other.allowSyntheticStyle) &&
+           (allowSyntheticSmallCaps == other.allowSyntheticSmallCaps) &&
+           (useSyntheticPosition == other.useSyntheticPosition) &&
+           (systemFont == other.systemFont) &&
+           (printerFont == other.printerFont) &&
+           (useGrayscaleAntialiasing == other.useGrayscaleAntialiasing) &&
+           (baselineOffset == other.baselineOffset) &&
+           mozilla::NumbersAreBitwiseIdentical(sizeAdjust, other.sizeAdjust) &&
+           (sizeAdjustBasis == other.sizeAdjustBasis) &&
+           (featureSettings == other.featureSettings) &&
+           (variantAlternates == other.variantAlternates) &&
+           (featureValueLookup == other.featureValueLookup) &&
+           (variationSettings == other.variationSettings) &&
+           (languageOverride == other.languageOverride) &&
+           mozilla::NumbersAreBitwiseIdentical(autoOpticalSize,
+                                               other.autoOpticalSize);
+  }
+};
+
+/**
+ * Font cache design:
+ *
+ * The mFonts hashtable contains most fonts, indexed by (gfxFontEntry*, style).
+ * It maintains a strong reference to the fonts it contains.
+ * Whenever a font is accessed, it is marked as used to move it to a new
+ * generation in the tracker to avoid expiration.
+ * The expiration tracker will only expire fonts with a single reference, the
+ * cache itself. Fonts with more than one reference are marked as used.
+ *
+ * We're using 3 generations with a ten-second generation interval, so
+ * zero-refcount fonts will be deleted 20-30 seconds after their refcount
+ * goes to zero, if timer events fire in a timely manner.
+ *
+ * The font cache also handles timed expiration of cached ShapedWords
+ * for "persistent" fonts: it has a repeating timer, and notifies
+ * each cached font to "age" its shaped words. The words will be released
+ * by the fonts if they get aged three times without being re-used in the
+ * meantime.
+ *
+ * Note that the ShapedWord timeout is much larger than the font timeout,
+ * so that in the case of a short-lived font, we'll discard the gfxFont
+ * completely, with all its words, and avoid the cost of aging the words
+ * individually. That only happens with longer-lived fonts.
+ */
+struct FontCacheSizes {
+  FontCacheSizes() : mFontInstances(0), mShapedWords(0) {}
+
+  size_t mFontInstances;  // memory used by instances of gfxFont subclasses
+  size_t mShapedWords;    // memory used by the per-font shapedWord caches
+};
+
+class gfxFontCache final
+    : public ExpirationTrackerImpl<gfxFont, 3, mozilla::Mutex,
+                                   mozilla::MutexAutoLock> {
+ protected:
+  // Expiration tracker implementation.
+  enum { FONT_TIMEOUT_SECONDS = 10 };
+
+  typedef mozilla::Mutex Lock;
+  typedef mozilla::MutexAutoLock AutoLock;
+
+  // This protects the ExpirationTracker tables.
+  Lock mMutex = Lock("fontCacheExpirationMutex");
+
+  Lock& GetMutex() override { return mMutex; }
+
+ public:
+  explicit gfxFontCache(nsIEventTarget* aEventTarget);
+  ~gfxFontCache();
+
+  enum { SHAPED_WORD_TIMEOUT_SECONDS = 60 };
+
+  /*
+   * Get the global gfxFontCache.  You must call Init() before
+   * calling this method --- the result will not be null.
+   */
+  static gfxFontCache* GetCache() { return gGlobalCache; }
+
+  static nsresult Init();
+  // It's OK to call this even if Init() has not been called.
+  static void Shutdown();
+
+  // Look up a font in the cache. Returns null if there's nothing matching
+  // in the cache
+  already_AddRefed<gfxFont> Lookup(const gfxFontEntry* aFontEntry,
+                                   const gfxFontStyle* aStyle,
+                                   const gfxCharacterMap* aUnicodeRangeMap);
+
+  // We created a new font (presumably because Lookup returned null);
+  // put it in the cache. The font's refcount should be nonzero. It is
+  // allowable to add a new font even if there is one already in the
+  // cache with the same key, as we may race with other threads to do
+  // the insertion -- in that case we will return the original font,
+  // and destroy the new one.
+  already_AddRefed<gfxFont> MaybeInsert(gfxFont* aFont);
+
+  bool MaybeDestroy(gfxFont* aFont);
+
+  // Cleans out the hashtable and removes expired fonts waiting for cleanup.
+  // Other gfxFont objects may be still in use but they will be pushed
+  // into the expiration queues and removed.
+  void Flush();
+
+  void FlushShapedWordCaches();
+  void NotifyGlyphsChanged();
+
+  void AgeCachedWords();
+
+  void RunWordCacheExpirationTimer() {
+    if (!mTimerRunning) {
+      mozilla::MutexAutoLock lock(mMutex);
+      if (!mTimerRunning && mWordCacheExpirationTimer) {
+        mWordCacheExpirationTimer->InitWithNamedFuncCallback(
+            WordCacheExpirationTimerCallback, this,
+            SHAPED_WORD_TIMEOUT_SECONDS * 1000, nsITimer::TYPE_REPEATING_SLACK,
+            "gfxFontCache::WordCacheExpiration");
+        mTimerRunning = true;
+      }
+    }
+  }
+  void PauseWordCacheExpirationTimer() {
+    if (mTimerRunning) {
+      mozilla::MutexAutoLock lock(mMutex);
+      if (mTimerRunning && mWordCacheExpirationTimer) {
+        mWordCacheExpirationTimer->Cancel();
+        mTimerRunning = false;
+      }
+    }
+  }
+
+  void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                              FontCacheSizes* aSizes) const;
+  void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                              FontCacheSizes* aSizes) const;
+
+ protected:
+  class MemoryReporter final : public nsIMemoryReporter {
+    ~MemoryReporter() = default;
+
+   public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIMEMORYREPORTER
+  };
+
+  // Observer for notifications that the font cache cares about
+  class Observer final : public nsIObserver {
+    ~Observer() = default;
+
+   public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIOBSERVER
+  };
+
+  nsresult AddObject(gfxFont* aFont) {
+    AutoLock lock(mMutex);
+    return AddObjectLocked(aFont, lock);
+  }
+
+  // This gets called when the timeout has expired on a single-refcount
+  // font; we just delete it.
+  void NotifyExpiredLocked(gfxFont* aFont, const AutoLock&)
+      MOZ_REQUIRES(mMutex) override;
+  void NotifyHandlerEnd() override;
+
+  void DestroyDiscard(nsTArray<gfxFont*>& aDiscard);
+
+  static gfxFontCache* gGlobalCache;
+
+  struct MOZ_STACK_CLASS Key {
+    const gfxFontEntry* mFontEntry;
+    const gfxFontStyle* mStyle;
+    const gfxCharacterMap* mUnicodeRangeMap;
+    Key(const gfxFontEntry* aFontEntry, const gfxFontStyle* aStyle,
+        const gfxCharacterMap* aUnicodeRangeMap)
+        : mFontEntry(aFontEntry),
+          mStyle(aStyle),
+          mUnicodeRangeMap(aUnicodeRangeMap) {}
+  };
+
+  class HashEntry : public PLDHashEntryHdr {
+   public:
+    typedef const Key& KeyType;
+    typedef const Key* KeyTypePointer;
+
+    // When constructing a new entry in the hashtable, we'll leave this
+    // blank. The caller of Put() will fill this in.
+    explicit HashEntry(KeyTypePointer aStr) {}
+
+    bool KeyEquals(const KeyTypePointer aKey) const;
+    static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+    static PLDHashNumber HashKey(const KeyTypePointer aKey) {
+      return mozilla::HashGeneric(aKey->mStyle->Hash(), aKey->mFontEntry,
+                                  aKey->mUnicodeRangeMap);
+    }
+    enum { ALLOW_MEMMOVE = true };
+
+    gfxFont* MOZ_UNSAFE_REF("tracking for deferred deletion") mFont = nullptr;
+  };
+
+  nsTHashtable<HashEntry> mFonts MOZ_GUARDED_BY(mMutex);
+
+  nsTArray<gfxFont*> mTrackerDiscard MOZ_GUARDED_BY(mMutex);
+
+  static void WordCacheExpirationTimerCallback(nsITimer* aTimer, void* aCache);
+
+  nsCOMPtr<nsITimer> mWordCacheExpirationTimer MOZ_GUARDED_BY(mMutex);
+  std::atomic<bool> mTimerRunning = false;
+};
+
+class gfxTextPerfMetrics {
+ public:
+  struct TextCounts {
+    uint32_t numContentTextRuns;
+    uint32_t numChromeTextRuns;
+    uint32_t numChars;
+    uint32_t maxTextRunLen;
+    uint32_t wordCacheSpaceRules;
+    uint32_t wordCacheLong;
+    uint32_t wordCacheHit;
+    uint32_t wordCacheMiss;
+    uint32_t fallbackPrefs;
+    uint32_t fallbackSystem;
+    uint32_t textrunConst;
+    uint32_t textrunDestr;
+    uint32_t genericLookups;
+  };
+
+  uint32_t reflowCount;
+
+  // counts per reflow operation
+  TextCounts current;
+
+  // totals for the lifetime of a document
+  TextCounts cumulative;
+
+  gfxTextPerfMetrics() { memset(this, 0, sizeof(gfxTextPerfMetrics)); }
+
+  // add current totals to cumulative ones
+  void Accumulate() {
+    if (current.numChars == 0) {
+      return;
+    }
+    cumulative.numContentTextRuns += current.numContentTextRuns;
+    cumulative.numChromeTextRuns += current.numChromeTextRuns;
+    cumulative.numChars += current.numChars;
+    if (current.maxTextRunLen > cumulative.maxTextRunLen) {
+      cumulative.maxTextRunLen = current.maxTextRunLen;
+    }
+    cumulative.wordCacheSpaceRules += current.wordCacheSpaceRules;
+    cumulative.wordCacheLong += current.wordCacheLong;
+    cumulative.wordCacheHit += current.wordCacheHit;
+    cumulative.wordCacheMiss += current.wordCacheMiss;
+    cumulative.fallbackPrefs += current.fallbackPrefs;
+    cumulative.fallbackSystem += current.fallbackSystem;
+    cumulative.textrunConst += current.textrunConst;
+    cumulative.textrunDestr += current.textrunDestr;
+    cumulative.genericLookups += current.genericLookups;
+    memset(&current, 0, sizeof(current));
+  }
+};
+
+namespace mozilla {
+namespace gfx {
+
+class UnscaledFont;
+
+// Flags that live in the gfxShapedText::mFlags field.
+// (Note that gfxTextRun has an additional mFlags2 field for use
+// by textrun clients like nsTextFrame.)
+//
+// If you add a flag, please add support for it in gfxTextRun::Dump.
+enum class ShapedTextFlags : uint16_t {
+  /**
+   * When set, the text is RTL.
+   */
+  TEXT_IS_RTL = 0x0001,
+  /**
+   * When set, spacing is enabled and the textrun needs to call GetSpacing
+   * on the spacing provider.
+   */
+  TEXT_ENABLE_SPACING = 0x0002,
+  /**
+   * When set, the text has no characters above 255 and it is stored
+   * in the textrun in 8-bit format.
+   */
+  TEXT_IS_8BIT = 0x0004,
+  /**
+   * When set, GetHyphenationBreaks may return true for some character
+   * positions, otherwise it will always return false for all characters.
+   */
+  TEXT_ENABLE_HYPHEN_BREAKS = 0x0008,
+  /**
+   * When set, the RunMetrics::mBoundingBox field will be initialized
+   * properly based on glyph extents, in particular, glyph extents that
+   * overflow the standard font-box (the box defined by the ascent, descent
+   * and advance width of the glyph). When not set, it may just be the
+   * standard font-box even if glyphs overflow.
+   */
+  TEXT_NEED_BOUNDING_BOX = 0x0010,
+  /**
+   * When set, optional ligatures are disabled. Ligatures that are
+   * required for legible text should still be enabled.
+   */
+  TEXT_DISABLE_OPTIONAL_LIGATURES = 0x0020,
+  /**
+   * When set, the textrun should favour speed of construction over
+   * quality. This may involve disabling ligatures and/or kerning or
+   * other effects.
+   */
+  TEXT_OPTIMIZE_SPEED = 0x0040,
+  /**
+   * When set, the textrun should discard control characters instead of
+   * turning them into hexboxes.
+   */
+  TEXT_HIDE_CONTROL_CHARACTERS = 0x0080,
+
+  /**
+   * nsTextFrameThebes sets these, but they're defined here rather than
+   * in nsTextFrameUtils.h because ShapedWord creation/caching also needs
+   * to check the _INCOMING flag
+   */
+  TEXT_TRAILING_ARABICCHAR = 0x0100,
+  /**
+   * When set, the previous character for this textrun was an Arabic
+   * character.  This is used for the context detection necessary for
+   * bidi.numeral implementation.
+   */
+  TEXT_INCOMING_ARABICCHAR = 0x0200,
+
+  /**
+   * Set if the textrun should use the OpenType 'math' script.
+   */
+  TEXT_USE_MATH_SCRIPT = 0x0400,
+
+  /*
+   * Bit 0x0800 is currently unused.
+   */
+
+  /**
+   * Field for orientation of the textrun and glyphs within it.
+   * Possible values of the TEXT_ORIENT_MASK field:
+   *   TEXT_ORIENT_HORIZONTAL
+   *   TEXT_ORIENT_VERTICAL_UPRIGHT
+   *   TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT
+   *   TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT
+   *   TEXT_ORIENT_VERTICAL_MIXED
+   * For all VERTICAL settings, the x and y coordinates of glyph
+   * positions are exchanged, so that simple advances are vertical.
+   *
+   * The MIXED value indicates vertical textRuns for which the CSS
+   * text-orientation property is 'mixed', but is never used for
+   * individual glyphRuns; it will be resolved to either UPRIGHT
+   * or SIDEWAYS_RIGHT according to the UTR50 properties of the
+   * characters, and separate glyphRuns created for the resulting
+   * glyph orientations.
+   */
+  TEXT_ORIENT_MASK = 0x7000,
+  TEXT_ORIENT_HORIZONTAL = 0x0000,
+  TEXT_ORIENT_VERTICAL_UPRIGHT = 0x1000,
+  TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT = 0x2000,
+  TEXT_ORIENT_VERTICAL_MIXED = 0x3000,
+  TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT = 0x4000,
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(ShapedTextFlags)
+}  // namespace gfx
+}  // namespace mozilla
+
+class gfxTextRunFactory {
+  // Used by stylo
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(gfxTextRunFactory)
+
+ public:
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+
+  /**
+   * This record contains all the parameters needed to initialize a textrun.
+   */
+  struct MOZ_STACK_CLASS Parameters {
+    // Shape text params suggesting where the textrun will be rendered
+    DrawTarget* mDrawTarget;
+    // Pointer to arbitrary user data (which should outlive the textrun)
+    void* mUserData;
+    // A description of which characters have been stripped from the original
+    // DOM string to produce the characters in the textrun. May be null
+    // if that information is not relevant.
+    gfxSkipChars* mSkipChars;
+    // A list of where linebreaks are currently placed in the textrun. May
+    // be null if mInitialBreakCount is zero.
+    uint32_t* mInitialBreaks;
+    uint32_t mInitialBreakCount;
+    // The ratio to use to convert device pixels to application layout units
+    int32_t mAppUnitsPerDevUnit;
+  };
+
+ protected:
+  // Protected destructor, to discourage deletion outside of Release():
+  virtual ~gfxTextRunFactory();
+};
+
+/**
+ * gfxFontShaper
+ *
+ * This class implements text shaping (character to glyph mapping and
+ * glyph layout). There is a gfxFontShaper subclass for each text layout
+ * technology (uniscribe, core text, harfbuzz,....) we support.
+ *
+ * The shaper is responsible for setting up glyph data in gfxTextRuns.
+ *
+ * A generic, platform-independent shaper relies only on the standard
+ * gfxFont interface and can work with any concrete subclass of gfxFont.
+ *
+ * Platform-specific implementations designed to interface to platform
+ * shaping APIs such as Uniscribe or CoreText may rely on features of a
+ * specific font subclass to access native font references
+ * (such as CTFont, HFONT, DWriteFont, etc).
+ */
+
+class gfxFontShaper {
+ public:
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+  typedef mozilla::intl::Script Script;
+
+  enum class RoundingFlags : uint8_t { kRoundX = 0x01, kRoundY = 0x02 };
+
+  explicit gfxFontShaper(gfxFont* aFont) : mFont(aFont) {
+    NS_ASSERTION(aFont, "shaper requires a valid font!");
+  }
+
+  virtual ~gfxFontShaper() = default;
+
+  // Shape a piece of text and store the resulting glyph data into
+  // aShapedText. Parameters aOffset/aLength indicate the range of
+  // aShapedText to be updated; aLength is also the length of aText.
+  virtual bool ShapeText(DrawTarget* aDrawTarget, const char16_t* aText,
+                         uint32_t aOffset, uint32_t aLength, Script aScript,
+                         nsAtom* aLanguage,  // may be null, indicating no
+                                             // lang-specific shaping to be
+                                             // applied
+                         bool aVertical, RoundingFlags aRounding,
+                         gfxShapedText* aShapedText) = 0;
+
+  gfxFont* GetFont() const { return mFont; }
+
+  static void MergeFontFeatures(
+      const gfxFontStyle* aStyle, const nsTArray<gfxFontFeature>& aFontFeatures,
+      bool aDisableLigatures, const nsACString& aFamilyName, bool aAddSmallCaps,
+      void (*aHandleFeature)(uint32_t, uint32_t, void*),
+      void* aHandleFeatureData);
+
+ protected:
+  // the font this shaper is working with. The font owns a UniquePtr reference
+  // to this object, and will destroy it before it dies. Thus, mFont will always
+  // be valid.
+  gfxFont* MOZ_NON_OWNING_REF mFont;
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(gfxFontShaper::RoundingFlags)
+
+/*
+ * gfxShapedText is an abstract superclass for gfxShapedWord and gfxTextRun.
+ * These are objects that store a list of zero or more glyphs for each
+ * character. For each glyph we store the glyph ID, the advance, and possibly
+ * x/y-offsets. The idea is that a string is rendered by a loop that draws each
+ * glyph at its designated offset from the current point, then advances the
+ * current point by the glyph's advance in the direction of the textrun (LTR or
+ * RTL). Each glyph advance is always rounded to the nearest appunit; this
+ * ensures consistent results when dividing the text in a textrun into multiple
+ * text frames (frame boundaries are always aligned to appunits). We optimize
+ * for the case where a character has a single glyph and zero xoffset and
+ * yoffset, and the glyph ID and advance are in a reasonable range so we can
+ * pack all necessary data into 32 bits.
+ *
+ * gfxFontShaper can shape text into either a gfxShapedWord (cached by a
+ * gfxFont) or directly into a gfxTextRun (for cases where we want to shape
+ * textruns in their entirety rather than using cached words, because there may
+ * be layout features that depend on the inter-word spaces).
+ */
+class gfxShapedText {
+ public:
+  typedef mozilla::intl::Script Script;
+
+  gfxShapedText(uint32_t aLength, mozilla::gfx::ShapedTextFlags aFlags,
+                uint16_t aAppUnitsPerDevUnit)
+      : mLength(aLength),
+        mFlags(aFlags),
+        mAppUnitsPerDevUnit(aAppUnitsPerDevUnit) {}
+
+  virtual ~gfxShapedText() = default;
+
+  /**
+   * This class records the information associated with a character in the
+   * input string. It's optimized for the case where there is one glyph
+   * representing that character alone.
+   *
+   * A character can have zero or more associated glyphs. Each glyph
+   * has an advance width and an x and y offset.
+   * A character may be the start of a cluster.
+   * A character may be the start of a ligature group.
+   * A character can be "missing", indicating that the system is unable
+   * to render the character.
+   *
+   * All characters in a ligature group conceptually share all the glyphs
+   * associated with the characters in a group.
+   */
+  class CompressedGlyph {
+   public:
+    enum {
+      // Indicates that a cluster and ligature group starts at this
+      // character; this character has a single glyph with a reasonable
+      // advance and zero offsets. A "reasonable" advance
+      // is one that fits in the available bits (currently 12) (specified
+      // in appunits).
+      FLAG_IS_SIMPLE_GLYPH = 0x80000000U,
+
+      // These flags are applicable to both "simple" and "complex" records.
+      COMMON_FLAGS_MASK = 0x70000000U,
+
+      // Indicates whether a linebreak is allowed before this character;
+      // this is a two-bit field that holds a FLAG_BREAK_TYPE_xxx value
+      // indicating the kind of linebreak (if any) allowed here.
+      FLAGS_CAN_BREAK_BEFORE = 0x60000000U,
+
+      FLAGS_CAN_BREAK_SHIFT = 29,
+      FLAG_BREAK_TYPE_NONE = 0,
+      FLAG_BREAK_TYPE_NORMAL = 1,
+      FLAG_BREAK_TYPE_HYPHEN = 2,
+      // Allow break before this position if needed to avoid overflow:
+      FLAG_BREAK_TYPE_EMERGENCY_WRAP = 3,
+
+      FLAG_CHAR_IS_SPACE = 0x10000000U,
+
+      // Fields present only when FLAG_IS_SIMPLE_GLYPH is /true/.
+      // The advance is stored in appunits as a 12-bit field:
+      ADVANCE_MASK = 0x0FFF0000U,
+      ADVANCE_SHIFT = 16,
+      // and the glyph ID is stored in the low 16 bits.
+      GLYPH_MASK = 0x0000FFFFU,
+
+      // Fields present only when FLAG_IS_SIMPLE_GLYPH is /false/.
+      // Non-simple glyphs may or may not have glyph data in the
+      // corresponding mDetailedGlyphs entry. They have a glyph count
+      // stored in the low 16 bits, and the following flag bits:
+      GLYPH_COUNT_MASK = 0x0000FFFFU,
+
+      // When NOT set, indicates that this character corresponds to a
+      // missing glyph and should be skipped (or possibly, render the character
+      // Unicode value in some special way). If there are glyphs,
+      // the mGlyphID is actually the UTF16 character code. The bit is
+      // inverted so we can memset the array to zero to indicate all missing.
+      FLAG_NOT_MISSING = 0x010000,
+      FLAG_NOT_CLUSTER_START = 0x020000,
+      FLAG_NOT_LIGATURE_GROUP_START = 0x040000,
+      // Flag bit 0x080000 is currently unused.
+
+      // Certain types of characters are marked so that they can be given
+      // special treatment in rendering. This may require use of a "complex"
+      // CompressedGlyph record even for a character that would otherwise be
+      // treated as "simple".
+      CHAR_TYPE_FLAGS_MASK = 0xF00000,
+      FLAG_CHAR_IS_TAB = 0x100000,
+      FLAG_CHAR_IS_NEWLINE = 0x200000,
+      // Per CSS Text Decoration Module Level 3, emphasis marks are not
+      // drawn for any character in Unicode categories Z*, Cc, Cf, and Cn
+      // which is not combined with any combining characters. This flag is
+      // set for all those characters except 0x20 whitespace.
+      FLAG_CHAR_NO_EMPHASIS_MARK = 0x400000,
+      // Per CSS Text, letter-spacing is not applied to formatting chars
+      // (category Cf). We mark those in the textrun so as to be able to
+      // skip them when setting up spacing in nsTextFrame.
+      FLAG_CHAR_IS_FORMATTING_CONTROL = 0x800000,
+
+      // The bits 0x0F000000 are currently unused in non-simple glyphs.
+    };
+
+    // "Simple glyphs" have a simple glyph ID, simple advance and their
+    // x and y offsets are zero. Also the glyph extents do not overflow
+    // the font-box defined by the font ascent, descent and glyph advance width.
+    // These case is optimized to avoid storing DetailedGlyphs.
+
+    // Returns true if the glyph ID aGlyph fits into the compressed
+    // representation
+    static bool IsSimpleGlyphID(uint32_t aGlyph) {
+      return (aGlyph & GLYPH_MASK) == aGlyph;
+    }
+    // Returns true if the advance aAdvance fits into the compressed
+    // representation. aAdvance is in appunits.
+    static bool IsSimpleAdvance(uint32_t aAdvance) {
+      return (aAdvance & (ADVANCE_MASK >> ADVANCE_SHIFT)) == aAdvance;
+    }
+
+    bool IsSimpleGlyph() const { return mValue & FLAG_IS_SIMPLE_GLYPH; }
+    uint32_t GetSimpleAdvance() const {
+      MOZ_ASSERT(IsSimpleGlyph());
+      return (mValue & ADVANCE_MASK) >> ADVANCE_SHIFT;
+    }
+    uint32_t GetSimpleGlyph() const {
+      MOZ_ASSERT(IsSimpleGlyph());
+      return mValue & GLYPH_MASK;
+    }
+
+    bool IsMissing() const {
+      return !(mValue & (FLAG_NOT_MISSING | FLAG_IS_SIMPLE_GLYPH));
+    }
+    bool IsClusterStart() const {
+      return IsSimpleGlyph() || !(mValue & FLAG_NOT_CLUSTER_START);
+    }
+    bool IsLigatureGroupStart() const {
+      return IsSimpleGlyph() || !(mValue & FLAG_NOT_LIGATURE_GROUP_START);
+    }
+    bool IsLigatureContinuation() const {
+      return !IsSimpleGlyph() &&
+             (mValue & (FLAG_NOT_LIGATURE_GROUP_START | FLAG_NOT_MISSING)) ==
+                 (FLAG_NOT_LIGATURE_GROUP_START | FLAG_NOT_MISSING);
+    }
+
+    // Return true if the original character was a normal (breakable,
+    // trimmable) space (U+0020). Not true for other characters that
+    // may happen to map to the space glyph (U+00A0).
+    bool CharIsSpace() const { return mValue & FLAG_CHAR_IS_SPACE; }
+
+    bool CharIsTab() const {
+      return !IsSimpleGlyph() && (mValue & FLAG_CHAR_IS_TAB);
+    }
+    bool CharIsNewline() const {
+      return !IsSimpleGlyph() && (mValue & FLAG_CHAR_IS_NEWLINE);
+    }
+    bool CharMayHaveEmphasisMark() const {
+      return !CharIsSpace() &&
+             (IsSimpleGlyph() || !(mValue & FLAG_CHAR_NO_EMPHASIS_MARK));
+    }
+    bool CharIsFormattingControl() const {
+      return !IsSimpleGlyph() && (mValue & FLAG_CHAR_IS_FORMATTING_CONTROL);
+    }
+
+    uint32_t CharTypeFlags() const {
+      return IsSimpleGlyph() ? 0 : (mValue & CHAR_TYPE_FLAGS_MASK);
+    }
+
+    void SetClusterStart(bool aIsClusterStart) {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      if (aIsClusterStart) {
+        mValue &= ~FLAG_NOT_CLUSTER_START;
+      } else {
+        mValue |= FLAG_NOT_CLUSTER_START;
+      }
+    }
+
+    uint8_t CanBreakBefore() const {
+      return (mValue & FLAGS_CAN_BREAK_BEFORE) >> FLAGS_CAN_BREAK_SHIFT;
+    }
+    // Returns FLAGS_CAN_BREAK_BEFORE if the setting changed, 0 otherwise
+    uint32_t SetCanBreakBefore(uint8_t aCanBreakBefore) {
+      MOZ_ASSERT(aCanBreakBefore <= 3, "Bogus break-flags value!");
+      uint32_t breakMask = (uint32_t(aCanBreakBefore) << FLAGS_CAN_BREAK_SHIFT);
+      uint32_t toggle = breakMask ^ (mValue & FLAGS_CAN_BREAK_BEFORE);
+      mValue ^= toggle;
+      return toggle;
+    }
+
+    // Create a CompressedGlyph value representing a simple glyph with
+    // no extra flags (line-break or is_space) set.
+    static CompressedGlyph MakeSimpleGlyph(uint32_t aAdvanceAppUnits,
+                                           uint32_t aGlyph) {
+      MOZ_ASSERT(IsSimpleAdvance(aAdvanceAppUnits));
+      MOZ_ASSERT(IsSimpleGlyphID(aGlyph));
+      CompressedGlyph g;
+      g.mValue =
+          FLAG_IS_SIMPLE_GLYPH | (aAdvanceAppUnits << ADVANCE_SHIFT) | aGlyph;
+      return g;
+    }
+
+    // Assign a simple glyph value to an existing CompressedGlyph record,
+    // preserving line-break/is-space flags if present.
+    CompressedGlyph& SetSimpleGlyph(uint32_t aAdvanceAppUnits,
+                                    uint32_t aGlyph) {
+      MOZ_ASSERT(!CharTypeFlags(), "Char type flags lost");
+      mValue = (mValue & COMMON_FLAGS_MASK) |
+               MakeSimpleGlyph(aAdvanceAppUnits, aGlyph).mValue;
+      return *this;
+    }
+
+    // Create a CompressedGlyph value representing a complex glyph record,
+    // without any line-break or char-type flags.
+    static CompressedGlyph MakeComplex(bool aClusterStart,
+                                       bool aLigatureStart) {
+      CompressedGlyph g;
+      g.mValue = FLAG_NOT_MISSING |
+                 (aClusterStart ? 0 : FLAG_NOT_CLUSTER_START) |
+                 (aLigatureStart ? 0 : FLAG_NOT_LIGATURE_GROUP_START);
+      return g;
+    }
+
+    // Assign a complex glyph value to an existing CompressedGlyph record,
+    // preserving line-break/char-type flags if present.
+    // This sets the glyphCount to zero; it will be updated when we call
+    // gfxShapedText::SetDetailedGlyphs.
+    CompressedGlyph& SetComplex(bool aClusterStart, bool aLigatureStart) {
+      mValue = (mValue & COMMON_FLAGS_MASK) | CharTypeFlags() |
+               MakeComplex(aClusterStart, aLigatureStart).mValue;
+      return *this;
+    }
+
+    /**
+     * Mark a glyph record as being a missing-glyph.
+     * Missing glyphs are treated as ligature group starts; don't mess with
+     * the cluster-start flag (see bugs 618870 and 619286).
+     * We also preserve the glyph count here, as this is used after any
+     * required DetailedGlyphs (to store the char code for a hexbox) has been
+     * set up.
+     * This must be called *after* SetDetailedGlyphs is used for the relevant
+     * offset in the shaped-word, because that will mark it as not-missing.
+     */
+    CompressedGlyph& SetMissing() {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      mValue &= ~(FLAG_NOT_MISSING | FLAG_NOT_LIGATURE_GROUP_START);
+      return *this;
+    }
+
+    uint32_t GetGlyphCount() const {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      return mValue & GLYPH_COUNT_MASK;
+    }
+    void SetGlyphCount(uint32_t aGlyphCount) {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      MOZ_ASSERT(GetGlyphCount() == 0, "Glyph count already set");
+      MOZ_ASSERT(aGlyphCount <= 0xffff, "Glyph count out of range");
+      mValue |= FLAG_NOT_MISSING | aGlyphCount;
+    }
+
+    void SetIsSpace() { mValue |= FLAG_CHAR_IS_SPACE; }
+    void SetIsTab() {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      mValue |= FLAG_CHAR_IS_TAB;
+    }
+    void SetIsNewline() {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      mValue |= FLAG_CHAR_IS_NEWLINE;
+    }
+    void SetNoEmphasisMark() {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      mValue |= FLAG_CHAR_NO_EMPHASIS_MARK;
+    }
+    void SetIsFormattingControl() {
+      MOZ_ASSERT(!IsSimpleGlyph());
+      mValue |= FLAG_CHAR_IS_FORMATTING_CONTROL;
+    }
+
+   private:
+    uint32_t mValue;
+  };
+
+  // Accessor for the array of CompressedGlyph records, which will be in
+  // a different place in gfxShapedWord vs gfxTextRun
+  virtual const CompressedGlyph* GetCharacterGlyphs() const = 0;
+  virtual CompressedGlyph* GetCharacterGlyphs() = 0;
+
+  /**
+   * When the glyphs for a character don't fit into a CompressedGlyph record
+   * in SimpleGlyph format, we use an array of DetailedGlyphs instead.
+   */
+  struct DetailedGlyph {
+    // The glyphID, or the Unicode character if this is a missing glyph
+    uint32_t mGlyphID;
+    // The advance of the glyph, in appunits.
+    // mAdvance is in the text direction (RTL or LTR),
+    // and will normally be non-negative (although this is not guaranteed)
+    int32_t mAdvance;
+    // The offset from the glyph's default position, in line-relative
+    // coordinates (so mOffset.x is an offset in the line-right direction,
+    // and mOffset.y is an offset in line-downwards direction).
+    // These values are in floating-point appUnits.
+    mozilla::gfx::Point mOffset;
+  };
+
+  // Store DetailedGlyph records for the given index. (This does not modify
+  // the associated CompressedGlyph character-type or break flags.)
+  void SetDetailedGlyphs(uint32_t aIndex, uint32_t aGlyphCount,
+                         const DetailedGlyph* aGlyphs);
+
+  void SetMissingGlyph(uint32_t aIndex, uint32_t aChar, gfxFont* aFont);
+
+  void SetIsSpace(uint32_t aIndex) {
+    GetCharacterGlyphs()[aIndex].SetIsSpace();
+  }
+
+  bool HasDetailedGlyphs() const { return mDetailedGlyphs != nullptr; }
+
+  bool IsLigatureGroupStart(uint32_t aPos) {
+    NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+    return GetCharacterGlyphs()[aPos].IsLigatureGroupStart();
+  }
+
+  // NOTE that this must not be called for a character offset that does
+  // not have any DetailedGlyph records; callers must have verified that
+  // GetCharacterGlyphs()[aCharIndex].GetGlyphCount() is greater than zero.
+  DetailedGlyph* GetDetailedGlyphs(uint32_t aCharIndex) const {
+    NS_ASSERTION(GetCharacterGlyphs() && HasDetailedGlyphs() &&
+                     !GetCharacterGlyphs()[aCharIndex].IsSimpleGlyph() &&
+                     GetCharacterGlyphs()[aCharIndex].GetGlyphCount() > 0,
+                 "invalid use of GetDetailedGlyphs; check the caller!");
+    return mDetailedGlyphs->Get(aCharIndex);
+  }
+
+  void ApplyTrackingToClusters(gfxFloat aTrackingAdjustment, uint32_t aOffset,
+                               uint32_t aLength);
+
+  // Mark clusters in the CompressedGlyph records, starting at aOffset,
+  // based on the Unicode properties of the text in aString.
+  // This is also responsible to set the IsSpace flag for space characters.
+  void SetupClusterBoundaries(uint32_t aOffset, const char16_t* aString,
+                              uint32_t aLength);
+  // In 8-bit text, there won't actually be any clusters, but we still need
+  // the space-marking functionality.
+  void SetupClusterBoundaries(uint32_t aOffset, const uint8_t* aString,
+                              uint32_t aLength);
+
+  mozilla::gfx::ShapedTextFlags GetFlags() const { return mFlags; }
+
+  bool IsVertical() const {
+    return (GetFlags() & mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_MASK) !=
+           mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_HORIZONTAL;
+  }
+
+  bool UseCenterBaseline() const {
+    mozilla::gfx::ShapedTextFlags orient =
+        GetFlags() & mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_MASK;
+    return orient ==
+               mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED ||
+           orient ==
+               mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT;
+  }
+
+  bool IsRightToLeft() const {
+    return (GetFlags() & mozilla::gfx::ShapedTextFlags::TEXT_IS_RTL) ==
+           mozilla::gfx::ShapedTextFlags::TEXT_IS_RTL;
+  }
+
+  bool IsSidewaysLeft() const {
+    return (GetFlags() & mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_MASK) ==
+           mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT;
+  }
+
+  // Return true if the logical inline direction is reversed compared to
+  // normal physical coordinates (i.e. if it is leftwards or upwards)
+  bool IsInlineReversed() const { return IsSidewaysLeft() != IsRightToLeft(); }
+
+  gfxFloat GetDirection() const { return IsInlineReversed() ? -1.0f : 1.0f; }
+
+  bool DisableLigatures() const {
+    return (GetFlags() &
+            mozilla::gfx::ShapedTextFlags::TEXT_DISABLE_OPTIONAL_LIGATURES) ==
+           mozilla::gfx::ShapedTextFlags::TEXT_DISABLE_OPTIONAL_LIGATURES;
+  }
+
+  bool TextIs8Bit() const {
+    return (GetFlags() & mozilla::gfx::ShapedTextFlags::TEXT_IS_8BIT) ==
+           mozilla::gfx::ShapedTextFlags::TEXT_IS_8BIT;
+  }
+
+  int32_t GetAppUnitsPerDevUnit() const { return mAppUnitsPerDevUnit; }
+
+  uint32_t GetLength() const { return mLength; }
+
+  bool FilterIfIgnorable(uint32_t aIndex, uint32_t aCh);
+
+ protected:
+  // Allocate aCount DetailedGlyphs for the given index
+  DetailedGlyph* AllocateDetailedGlyphs(uint32_t aCharIndex, uint32_t aCount);
+
+  // Ensure the glyph on the given index is complex glyph so that we can use
+  // it to record specific characters that layout may need to detect.
+  void EnsureComplexGlyph(uint32_t aIndex, CompressedGlyph& aGlyph) {
+    MOZ_ASSERT(GetCharacterGlyphs() + aIndex == &aGlyph);
+    if (aGlyph.IsSimpleGlyph()) {
+      DetailedGlyph details = {aGlyph.GetSimpleGlyph(),
+                               (int32_t)aGlyph.GetSimpleAdvance(),
+                               mozilla::gfx::Point()};
+      aGlyph.SetComplex(true, true);
+      SetDetailedGlyphs(aIndex, 1, &details);
+    }
+  }
+
+  // For characters whose glyph data does not fit the "simple" glyph criteria
+  // in CompressedGlyph, we use a sorted array to store the association
+  // between the source character offset and an index into an array
+  // DetailedGlyphs. The CompressedGlyph record includes a count of
+  // the number of DetailedGlyph records that belong to the character,
+  // starting at the given index.
+  class DetailedGlyphStore {
+   public:
+    DetailedGlyphStore() = default;
+
+    // This is optimized for the most common calling patterns:
+    // we rarely need random access to the records, access is most commonly
+    // sequential through the textRun, so we record the last-used index
+    // and check whether the caller wants the same record again, or the
+    // next; if not, it's most likely we're starting over from the start
+    // of the run, so we check the first entry before resorting to binary
+    // search as a last resort.
+    // NOTE that this must not be called for a character offset that does
+    // not have any DetailedGlyph records; callers must have verified that
+    // mCharacterGlyphs[aOffset].GetGlyphCount() is greater than zero
+    // before calling this, otherwise the assertions here will fire (in a
+    // debug build), and we'll probably crash.
+    DetailedGlyph* Get(uint32_t aOffset) {
+      NS_ASSERTION(mOffsetToIndex.Length() > 0, "no detailed glyph records!");
+      DetailedGlyph* details = mDetails.Elements();
+      // check common cases (fwd iteration, initial entry, etc) first
+      if (mLastUsed < mOffsetToIndex.Length() - 1 &&
+          aOffset == mOffsetToIndex[mLastUsed + 1].mOffset) {
+        ++mLastUsed;
+      } else if (aOffset == mOffsetToIndex[0].mOffset) {
+        mLastUsed = 0;
+      } else if (aOffset == mOffsetToIndex[mLastUsed].mOffset) {
+        // do nothing
+      } else if (mLastUsed > 0 &&
+                 aOffset == mOffsetToIndex[mLastUsed - 1].mOffset) {
+        --mLastUsed;
+      } else {
+        mLastUsed = mOffsetToIndex.BinaryIndexOf(aOffset, CompareToOffset());
+      }
+      NS_ASSERTION(mLastUsed != nsTArray<DGRec>::NoIndex,
+                   "detailed glyph record missing!");
+      return details + mOffsetToIndex[mLastUsed].mIndex;
+    }
+
+    DetailedGlyph* Allocate(uint32_t aOffset, uint32_t aCount) {
+      uint32_t detailIndex = mDetails.Length();
+      DetailedGlyph* details = mDetails.AppendElements(aCount);
+      // We normally set up glyph records sequentially, so the common case
+      // here is to append new records to the mOffsetToIndex array;
+      // test for that before falling back to the InsertElementSorted
+      // method.
+      if (mOffsetToIndex.Length() == 0 ||
+          aOffset > mOffsetToIndex[mOffsetToIndex.Length() - 1].mOffset) {
+        mOffsetToIndex.AppendElement(DGRec(aOffset, detailIndex));
+      } else {
+        mOffsetToIndex.InsertElementSorted(DGRec(aOffset, detailIndex),
+                                           CompareRecordOffsets());
+      }
+      return details;
+    }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
+      return aMallocSizeOf(this) +
+             mDetails.ShallowSizeOfExcludingThis(aMallocSizeOf) +
+             mOffsetToIndex.ShallowSizeOfExcludingThis(aMallocSizeOf);
+    }
+
+   private:
+    struct DGRec {
+      DGRec(const uint32_t& aOffset, const uint32_t& aIndex)
+          : mOffset(aOffset), mIndex(aIndex) {}
+      uint32_t mOffset;  // source character offset in the textrun
+      uint32_t mIndex;   // index where this char's DetailedGlyphs begin
+    };
+
+    struct CompareToOffset {
+      bool Equals(const DGRec& a, const uint32_t& b) const {
+        return a.mOffset == b;
+      }
+      bool LessThan(const DGRec& a, const uint32_t& b) const {
+        return a.mOffset < b;
+      }
+    };
+
+    struct CompareRecordOffsets {
+      bool Equals(const DGRec& a, const DGRec& b) const {
+        return a.mOffset == b.mOffset;
+      }
+      bool LessThan(const DGRec& a, const DGRec& b) const {
+        return a.mOffset < b.mOffset;
+      }
+    };
+
+    // Concatenated array of all the DetailedGlyph records needed for the
+    // textRun; individual character offsets are associated with indexes
+    // into this array via the mOffsetToIndex table.
+    nsTArray<DetailedGlyph> mDetails;
+
+    // For each character offset that needs DetailedGlyphs, we record the
+    // index in mDetails where the list of glyphs begins. This array is
+    // sorted by mOffset.
+    nsTArray<DGRec> mOffsetToIndex;
+
+    // Records the most recently used index into mOffsetToIndex, so that
+    // we can support sequential access more quickly than just doing
+    // a binary search each time.
+    nsTArray<DGRec>::index_type mLastUsed = 0;
+  };
+
+  mozilla::UniquePtr<DetailedGlyphStore> mDetailedGlyphs;
+
+  // Number of char16_t characters and CompressedGlyph glyph records
+  uint32_t mLength;
+
+  // Shaping flags (direction, ligature-suppression)
+  mozilla::gfx::ShapedTextFlags mFlags;
+
+  uint16_t mAppUnitsPerDevUnit;
+};
+
+/*
+ * gfxShapedWord: an individual (space-delimited) run of text shaped with a
+ * particular font, without regard to external context.
+ *
+ * The glyph data is copied into gfxTextRuns as needed from the cache of
+ * ShapedWords associated with each gfxFont instance.
+ */
+class gfxShapedWord final : public gfxShapedText {
+ public:
+  typedef mozilla::intl::Script Script;
+
+  // Create a ShapedWord that can hold glyphs for aLength characters,
+  // with mCharacterGlyphs sized appropriately.
+  //
+  // Returns null on allocation failure (does NOT use infallible alloc)
+  // so caller must check for success.
+  //
+  // This does NOT perform shaping, so the returned word contains no
+  // glyph data; the caller must call gfxFont::ShapeText() with appropriate
+  // parameters to set up the glyphs.
+  static gfxShapedWord* Create(const uint8_t* aText, uint32_t aLength,
+                               Script aRunScript, nsAtom* aLanguage,
+                               uint16_t aAppUnitsPerDevUnit,
+                               mozilla::gfx::ShapedTextFlags aFlags,
+                               gfxFontShaper::RoundingFlags aRounding) {
+    NS_ASSERTION(aLength <= gfxPlatform::GetPlatform()->WordCacheCharLimit(),
+                 "excessive length for gfxShapedWord!");
+
+    // Compute size needed including the mCharacterGlyphs array
+    // and a copy of the original text
+    uint32_t size = offsetof(gfxShapedWord, mCharGlyphsStorage) +
+                    aLength * (sizeof(CompressedGlyph) + sizeof(uint8_t));
+    void* storage = malloc(size);
+    if (!storage) {
+      return nullptr;
+    }
+
+    // Construct in the pre-allocated storage, using placement new
+    return new (storage) gfxShapedWord(aText, aLength, aRunScript, aLanguage,
+                                       aAppUnitsPerDevUnit, aFlags, aRounding);
+  }
+
+  static gfxShapedWord* Create(const char16_t* aText, uint32_t aLength,
+                               Script aRunScript, nsAtom* aLanguage,
+                               uint16_t aAppUnitsPerDevUnit,
+                               mozilla::gfx::ShapedTextFlags aFlags,
+                               gfxFontShaper::RoundingFlags aRounding) {
+    NS_ASSERTION(aLength <= gfxPlatform::GetPlatform()->WordCacheCharLimit(),
+                 "excessive length for gfxShapedWord!");
+
+    // In the 16-bit version of Create, if the TEXT_IS_8BIT flag is set,
+    // then we convert the text to an 8-bit version and call the 8-bit
+    // Create function instead.
+    if (aFlags & mozilla::gfx::ShapedTextFlags::TEXT_IS_8BIT) {
+      nsAutoCString narrowText;
+      LossyAppendUTF16toASCII(nsDependentSubstring(aText, aLength), narrowText);
+      return Create((const uint8_t*)(narrowText.BeginReading()), aLength,
+                    aRunScript, aLanguage, aAppUnitsPerDevUnit, aFlags,
+                    aRounding);
+    }
+
+    uint32_t size = offsetof(gfxShapedWord, mCharGlyphsStorage) +
+                    aLength * (sizeof(CompressedGlyph) + sizeof(char16_t));
+    void* storage = malloc(size);
+    if (!storage) {
+      return nullptr;
+    }
+
+    return new (storage) gfxShapedWord(aText, aLength, aRunScript, aLanguage,
+                                       aAppUnitsPerDevUnit, aFlags, aRounding);
+  }
+
+  // Override operator delete to properly free the object that was
+  // allocated via malloc.
+  void operator delete(void* p) { free(p); }
+
+  const CompressedGlyph* GetCharacterGlyphs() const override {
+    return &mCharGlyphsStorage[0];
+  }
+  CompressedGlyph* GetCharacterGlyphs() override {
+    return &mCharGlyphsStorage[0];
+  }
+
+  const uint8_t* Text8Bit() const {
+    NS_ASSERTION(TextIs8Bit(), "invalid use of Text8Bit()");
+    return reinterpret_cast<const uint8_t*>(mCharGlyphsStorage + GetLength());
+  }
+
+  const char16_t* TextUnicode() const {
+    NS_ASSERTION(!TextIs8Bit(), "invalid use of TextUnicode()");
+    return reinterpret_cast<const char16_t*>(mCharGlyphsStorage + GetLength());
+  }
+
+  char16_t GetCharAt(uint32_t aOffset) const {
+    NS_ASSERTION(aOffset < GetLength(), "aOffset out of range");
+    return TextIs8Bit() ? char16_t(Text8Bit()[aOffset])
+                        : TextUnicode()[aOffset];
+  }
+
+  Script GetScript() const { return mScript; }
+  nsAtom* GetLanguage() const { return mLanguage.get(); }
+
+  gfxFontShaper::RoundingFlags GetRounding() const { return mRounding; }
+
+  void ResetAge() { mAgeCounter = 0; }
+  uint32_t IncrementAge() { return ++mAgeCounter; }
+
+  // Helper used when hashing a word for the shaped-word caches
+  static uint32_t HashMix(uint32_t aHash, char16_t aCh) {
+    return (aHash >> 28) ^ (aHash << 4) ^ aCh;
+  }
+
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ private:
+  // so that gfxTextRun can share our DetailedGlyphStore class
+  friend class gfxTextRun;
+
+  // Construct storage for a ShapedWord, ready to receive glyph data
+  gfxShapedWord(const uint8_t* aText, uint32_t aLength, Script aRunScript,
+                nsAtom* aLanguage, uint16_t aAppUnitsPerDevUnit,
+                mozilla::gfx::ShapedTextFlags aFlags,
+                gfxFontShaper::RoundingFlags aRounding)
+      : gfxShapedText(aLength,
+                      aFlags | mozilla::gfx::ShapedTextFlags::TEXT_IS_8BIT,
+                      aAppUnitsPerDevUnit),
+        mLanguage(aLanguage),
+        mScript(aRunScript),
+        mRounding(aRounding),
+        mAgeCounter(0) {
+    memset(mCharGlyphsStorage, 0, aLength * sizeof(CompressedGlyph));
+    uint8_t* text = reinterpret_cast<uint8_t*>(&mCharGlyphsStorage[aLength]);
+    memcpy(text, aText, aLength * sizeof(uint8_t));
+    SetupClusterBoundaries(0, aText, aLength);
+  }
+
+  gfxShapedWord(const char16_t* aText, uint32_t aLength, Script aRunScript,
+                nsAtom* aLanguage, uint16_t aAppUnitsPerDevUnit,
+                mozilla::gfx::ShapedTextFlags aFlags,
+                gfxFontShaper::RoundingFlags aRounding)
+      : gfxShapedText(aLength, aFlags, aAppUnitsPerDevUnit),
+        mLanguage(aLanguage),
+        mScript(aRunScript),
+        mRounding(aRounding),
+        mAgeCounter(0) {
+    memset(mCharGlyphsStorage, 0, aLength * sizeof(CompressedGlyph));
+    char16_t* text = reinterpret_cast<char16_t*>(&mCharGlyphsStorage[aLength]);
+    memcpy(text, aText, aLength * sizeof(char16_t));
+    SetupClusterBoundaries(0, aText, aLength);
+  }
+
+  RefPtr<nsAtom> mLanguage;
+  Script mScript;
+
+  gfxFontShaper::RoundingFlags mRounding;
+
+  // With multithreaded shaping, this may be updated by any thread.
+  std::atomic<uint32_t> mAgeCounter;
+
+  // The mCharGlyphsStorage array is actually a variable-size member;
+  // when the ShapedWord is created, its size will be increased as necessary
+  // to allow the proper number of glyphs to be stored.
+  // The original text, in either 8-bit or 16-bit form, will be stored
+  // immediately following the CompressedGlyphs.
+  CompressedGlyph mCharGlyphsStorage[1];
+};
+
+class GlyphBufferAzure;
+struct TextRunDrawParams;
+struct FontDrawParams;
+struct EmphasisMarkDrawParams;
+
+class gfxFont {
+  friend class gfxHarfBuzzShaper;
+  friend class gfxGraphiteShaper;
+
+ protected:
+  using DrawTarget = mozilla::gfx::DrawTarget;
+  using Script = mozilla::intl::Script;
+  using SVGContextPaint = mozilla::SVGContextPaint;
+
+  using RoundingFlags = gfxFontShaper::RoundingFlags;
+  using ShapedTextFlags = mozilla::gfx::ShapedTextFlags;
+
+ public:
+  using FontSlantStyle = mozilla::FontSlantStyle;
+  using FontSizeAdjust = mozilla::StyleFontSizeAdjust;
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DESTROY(gfxFont, MaybeDestroy())
+  int32_t GetRefCount() { return int32_t(mRefCnt); }
+
+  // options to specify the kind of AA to be used when creating a font
+  typedef enum : uint8_t {
+    kAntialiasDefault,
+    kAntialiasNone,
+    kAntialiasGrayscale,
+    kAntialiasSubpixel
+  } AntialiasOption;
+
+ protected:
+  gfxFont(const RefPtr<mozilla::gfx::UnscaledFont>& aUnscaledFont,
+          gfxFontEntry* aFontEntry, const gfxFontStyle* aFontStyle,
+          AntialiasOption anAAOption = kAntialiasDefault);
+
+  virtual ~gfxFont();
+
+  void MaybeDestroy() {
+    bool destroy = true;
+    if (gfxFontCache* fc = gfxFontCache::GetCache()) {
+      destroy = fc->MaybeDestroy(this);
+    }
+    if (destroy) {
+      Destroy();
+    }
+  }
+
+ public:
+  void Destroy() {
+    MOZ_ASSERT(GetRefCount() == 0);
+    delete this;
+  }
+
+  bool Valid() const { return mIsValid; }
+
+  // options for the kind of bounding box to return from measurement
+  typedef enum {
+    LOOSE_INK_EXTENTS,
+    // A box that encloses all the painted pixels, and may
+    // include sidebearings and/or additional ascent/descent
+    // within the glyph cell even if the ink is smaller.
+    TIGHT_INK_EXTENTS,
+    // A box that tightly encloses all the painted pixels
+    // (although actually on Windows, at least, it may be
+    // slightly larger than strictly necessary because
+    // we can't get precise extents with ClearType).
+    TIGHT_HINTED_OUTLINE_EXTENTS
+    // A box that tightly encloses the glyph outline,
+    // ignoring possible antialiasing pixels that extend
+    // beyond this.
+    // NOTE: The default implementation of gfxFont::Measure(),
+    // which works with the glyph extents cache, does not
+    // differentiate between this and TIGHT_INK_EXTENTS.
+    // Whether the distinction is important depends on the
+    // antialiasing behavior of the platform; currently the
+    // distinction is only implemented in the gfxWindowsFont
+    // subclass, because of ClearType's tendency to paint
+    // outside the hinted outline.
+    // Also NOTE: it is relatively expensive to request this,
+    // as it does not use cached glyph extents in the font.
+  } BoundingBoxType;
+
+  const nsCString& GetName() const { return mFontEntry->Name(); }
+  const gfxFontStyle* GetStyle() const { return &mStyle; }
+
+  virtual gfxFont* CopyWithAntialiasOption(AntialiasOption anAAOption) const {
+    // platforms where this actually matters should override
+    return nullptr;
+  }
+
+  gfxFloat GetAdjustedSize() const {
+    // mAdjustedSize is cached here if not already set to a non-zero value;
+    // but it may be overridden by a value computed in metrics initialization
+    // from font-size-adjust.
+    if (mAdjustedSize < 0.0) {
+      mAdjustedSize = mStyle.AdjustedSizeMustBeZero()
+                          ? 0.0
+                          : mStyle.size * mFontEntry->mSizeAdjust;
+    }
+    return mAdjustedSize;
+  }
+
+  float FUnitsToDevUnitsFactor() const {
+    // check this was set up during font initialization
+    NS_ASSERTION(mFUnitsConvFactor >= 0.0f, "mFUnitsConvFactor not valid");
+    return mFUnitsConvFactor;
+  }
+
+  // check whether this is an sfnt we can potentially use with harfbuzz
+  bool FontCanSupportHarfBuzz() const { return mFontEntry->HasCmapTable(); }
+
+  // check whether this is an sfnt we can potentially use with Graphite
+  bool FontCanSupportGraphite() const {
+    return mFontEntry->HasGraphiteTables();
+  }
+
+  // Whether this is a font that may be doing full-color rendering,
+  // and therefore needs us to use a mask for text-shadow even when
+  // we're not actually blurring.
+  bool AlwaysNeedsMaskForShadow() const {
+    return mFontEntry->TryGetColorGlyphs() || mFontEntry->TryGetSVGData(this) ||
+           mFontEntry->HasFontTable(TRUETYPE_TAG('C', 'B', 'D', 'T')) ||
+           mFontEntry->HasFontTable(TRUETYPE_TAG('s', 'b', 'i', 'x'));
+  }
+
+  // whether a feature is supported by the font (limited to a small set
+  // of features for which some form of fallback needs to be implemented)
+  bool SupportsFeature(Script aScript, uint32_t aFeatureTag);
+
+  // whether the font supports "real" small caps, petite caps etc.
+  // aFallbackToSmallCaps true when petite caps should fallback to small caps
+  bool SupportsVariantCaps(Script aScript, uint32_t aVariantCaps,
+                           bool& aFallbackToSmallCaps,
+                           bool& aSyntheticLowerToSmallCaps,
+                           bool& aSyntheticUpperToSmallCaps);
+
+  // whether the font supports subscript/superscript feature
+  // for fallback, need to verify that all characters in the run
+  // have variant substitutions
+  bool SupportsSubSuperscript(uint32_t aSubSuperscript, const uint8_t* aString,
+                              uint32_t aLength, Script aRunScript);
+
+  bool SupportsSubSuperscript(uint32_t aSubSuperscript, const char16_t* aString,
+                              uint32_t aLength, Script aRunScript);
+
+  // whether the specified feature will apply to the given character
+  bool FeatureWillHandleChar(Script aRunScript, uint32_t aFeature,
+                             uint32_t aUnicode);
+
+  // Subclasses may choose to look up glyph ids for characters.
+  // If they do not override this, gfxHarfBuzzShaper will fetch the cmap
+  // table and use that.
+  virtual bool ProvidesGetGlyph() const { return false; }
+  // Map unicode character to glyph ID.
+  // Only used if ProvidesGetGlyph() returns true.
+  virtual uint32_t GetGlyph(uint32_t unicode, uint32_t variation_selector) {
+    return 0;
+  }
+
+  // Return the advance of a glyph.
+  gfxFloat GetGlyphAdvance(uint16_t aGID, bool aVertical = false);
+
+  // Return the advance of a given Unicode char in isolation.
+  // Returns -1.0 if the char is not supported.
+  gfxFloat GetCharAdvance(uint32_t aUnicode, bool aVertical = false);
+
+  gfxFloat SynthesizeSpaceWidth(uint32_t aCh);
+
+  // Work out whether cairo will snap inter-glyph spacing to pixels
+  // when rendering to the given drawTarget.
+  RoundingFlags GetRoundOffsetsToPixels(DrawTarget* aDrawTarget);
+
+  virtual bool ShouldHintMetrics() const { return true; }
+  virtual bool ShouldRoundXOffset(cairo_t* aCairo) const { return true; }
+
+  // Return the font's owned harfbuzz shaper, creating and initializing it if
+  // necessary; returns null if shaper initialization has failed.
+  gfxHarfBuzzShaper* GetHarfBuzzShaper();
+
+  // Font metrics
+  struct Metrics {
+    gfxFloat capHeight;
+    gfxFloat xHeight;
+    gfxFloat strikeoutSize;
+    gfxFloat strikeoutOffset;
+    gfxFloat underlineSize;
+    gfxFloat underlineOffset;
+
+    gfxFloat internalLeading;
+    gfxFloat externalLeading;
+
+    gfxFloat emHeight;
+    gfxFloat emAscent;
+    gfxFloat emDescent;
+    gfxFloat maxHeight;
+    gfxFloat maxAscent;
+    gfxFloat maxDescent;
+    gfxFloat maxAdvance;
+
+    gfxFloat aveCharWidth;
+    gfxFloat spaceWidth;
+    gfxFloat zeroWidth;         // -1 if there was no zero glyph
+    gfxFloat ideographicWidth;  // -1 if kWaterIdeograph is not supported
+
+    gfxFloat ZeroOrAveCharWidth() const {
+      return zeroWidth >= 0 ? zeroWidth : aveCharWidth;
+    }
+  };
+  // Unicode character used as basis for 'ic' unit:
+  static constexpr uint32_t kWaterIdeograph = 0x6C34;
+
+  typedef nsFontMetrics::FontOrientation Orientation;
+
+  const Metrics& GetMetrics(Orientation aOrientation) {
+    if (aOrientation == nsFontMetrics::eHorizontal) {
+      return GetHorizontalMetrics();
+    }
+    if (!mVerticalMetrics) {
+      CreateVerticalMetrics();
+    }
+    return *mVerticalMetrics;
+  }
+
+  struct Baselines {
+    gfxFloat mAlphabetic;
+    gfxFloat mHanging;
+    gfxFloat mIdeographic;
+  };
+  Baselines GetBaselines(Orientation aOrientation);
+
+  /**
+   * We let layout specify spacing on either side of any
+   * character. We need to specify both before and after
+   * spacing so that substring measurement can do the right things.
+   * These values are in appunits. They're always an integral number of
+   * appunits, but we specify them in floats in case very large spacing
+   * values are required.
+   */
+  struct Spacing {
+    gfxFloat mBefore;
+    gfxFloat mAfter;
+  };
+  /**
+   * Metrics for a particular string
+   */
+  struct RunMetrics {
+    RunMetrics() { mAdvanceWidth = mAscent = mDescent = 0.0; }
+
+    void CombineWith(const RunMetrics& aOther, bool aOtherIsOnLeft);
+
+    // can be negative (partly due to negative spacing).
+    // Advance widths should be additive: the advance width of the
+    // (offset1, length1) plus the advance width of (offset1 + length1,
+    // length2) should be the advance width of (offset1, length1 + length2)
+    gfxFloat mAdvanceWidth;
+
+    // For zero-width substrings, these must be zero!
+    gfxFloat mAscent;   // always non-negative
+    gfxFloat mDescent;  // always non-negative
+
+    // Bounding box that is guaranteed to include everything drawn.
+    // If a tight boundingBox was requested when these metrics were
+    // generated, this will tightly wrap the glyphs, otherwise it is
+    // "loose" and may be larger than the true bounding box.
+    // Coordinates are relative to the baseline left origin, so typically
+    // mBoundingBox.y == -mAscent
+    gfxRect mBoundingBox;
+  };
+
+  /**
+   * Draw a series of glyphs to aContext. The direction of aTextRun must
+   * be honoured.
+   * @param aStart the first character to draw
+   * @param aEnd draw characters up to here
+   * @param aPt the baseline origin; the left end of the baseline
+   * for LTR textruns, the right end for RTL textruns.
+   * On return, this will be updated to the other end of the baseline.
+   * In application units, really!
+   * @param aRunParams record with drawing parameters, see TextRunDrawParams.
+   * Particular fields of interest include
+   * .spacing  spacing to insert before and after characters (for RTL
+   *   glyphs, before-spacing is inserted to the right of characters). There
+   *   are aEnd - aStart elements in this array, unless it's null to indicate
+   *   that there is no spacing.
+   * .drawMode  specifies whether the fill or stroke of the glyph should be
+   *   drawn, or if it should be drawn into the current path
+   * .contextPaint  information about how to construct the fill and
+   *   stroke pattern. Can be nullptr if we are not stroking the text, which
+   *   indicates that the current source from context should be used for fill
+   * .context  the Thebes graphics context to which we're drawing
+   * .dt  Moz2D DrawTarget to which we're drawing
+   *
+   * Callers guarantee:
+   * -- aStart and aEnd are aligned to cluster and ligature boundaries
+   * -- all glyphs use this font
+   */
+  void Draw(const gfxTextRun* aTextRun, uint32_t aStart, uint32_t aEnd,
+            mozilla::gfx::Point* aPt, TextRunDrawParams& aRunParams,
+            mozilla::gfx::ShapedTextFlags aOrientation);
+
+  /**
+   * Draw the emphasis marks for the given text run. Its prerequisite
+   * and output are similiar to the method Draw().
+   * @param aPt the baseline origin of the emphasis marks.
+   * @param aParams some drawing parameters, see EmphasisMarkDrawParams.
+   */
+  void DrawEmphasisMarks(const gfxTextRun* aShapedText,
+                         mozilla::gfx::Point* aPt, uint32_t aOffset,
+                         uint32_t aCount,
+                         const EmphasisMarkDrawParams& aParams);
+
+  /**
+   * Measure a run of characters. See gfxTextRun::Metrics.
+   * @param aTight if false, then return the union of the glyph extents
+   * with the font-box for the characters (the rectangle with x=0,width=
+   * the advance width for the character run,y=-(font ascent), and height=
+   * font ascent + font descent). Otherwise, we must return as tight as possible
+   * an approximation to the area actually painted by glyphs.
+   * @param aDrawTargetForTightBoundingBox when aTight is true, this must
+   * be non-null.
+   * @param aSpacing spacing to insert before and after glyphs. The bounding box
+   * need not include the spacing itself, but the spacing affects the glyph
+   * positions. null if there is no spacing.
+   *
+   * Callers guarantee:
+   * -- aStart and aEnd are aligned to cluster and ligature boundaries
+   * -- all glyphs use this font
+   *
+   * The default implementation just uses font metrics and aTextRun's
+   * advances, and assumes no characters fall outside the font box. In
+   * general this is insufficient, because that assumption is not always true.
+   */
+  virtual RunMetrics Measure(const gfxTextRun* aTextRun, uint32_t aStart,
+                             uint32_t aEnd, BoundingBoxType aBoundingBoxType,
+                             DrawTarget* aDrawTargetForTightBoundingBox,
+                             Spacing* aSpacing,
+                             mozilla::gfx::ShapedTextFlags aOrientation);
+  /**
+   * Line breaks have been changed at the beginning and/or end of a substring
+   * of the text. Reshaping may be required; glyph updating is permitted.
+   * @return true if anything was changed, false otherwise
+   */
+  bool NotifyLineBreaksChanged(gfxTextRun* aTextRun, uint32_t aStart,
+                               uint32_t aLength) {
+    return false;
+  }
+
+  // Expiration tracking
+  nsExpirationState* GetExpirationState() { return &mExpirationState; }
+
+  // Get the glyphID of a space
+  uint16_t GetSpaceGlyph() const { return mSpaceGlyph; }
+
+  gfxGlyphExtents* GetOrCreateGlyphExtents(int32_t aAppUnitsPerDevUnit);
+
+  void SetupGlyphExtents(DrawTarget* aDrawTarget, uint32_t aGlyphID,
+                         bool aNeedTight, gfxGlyphExtents* aExtents);
+
+  virtual bool AllowSubpixelAA() const { return true; }
+
+  bool ApplySyntheticBold() const { return mApplySyntheticBold; }
+
+  float AngleForSyntheticOblique() const;
+  float SkewForSyntheticOblique() const;
+
+  // Amount by which synthetic bold "fattens" the glyphs:
+  // For size S up to a threshold size T, we use (0.25 + 3S / 4T),
+  // so that the result ranges from 0.25 to 1.0; thereafter,
+  // simply use (S / T).
+  gfxFloat GetSyntheticBoldOffset() const {
+    gfxFloat size = GetAdjustedSize();
+    const gfxFloat threshold = 48.0;
+    return size < threshold ? (0.25 + 0.75 * size / threshold)
+                            : (size / threshold);
+  }
+
+  gfxFontEntry* GetFontEntry() const { return mFontEntry.get(); }
+  bool HasCharacter(uint32_t ch) const {
+    if (!mIsValid || (mUnicodeRangeMap && !mUnicodeRangeMap->test(ch))) {
+      return false;
+    }
+    return mFontEntry->HasCharacter(ch);
+  }
+
+  const gfxCharacterMap* GetUnicodeRangeMap() const {
+    return mUnicodeRangeMap.get();
+  }
+
+  void SetUnicodeRangeMap(gfxCharacterMap* aUnicodeRangeMap) {
+    mUnicodeRangeMap = aUnicodeRangeMap;
+  }
+
+  uint16_t GetUVSGlyph(uint32_t aCh, uint32_t aVS) const {
+    if (!mIsValid) {
+      return 0;
+    }
+    return mFontEntry->GetUVSGlyph(aCh, aVS);
+  }
+
+  template <typename T>
+  bool InitFakeSmallCapsRun(nsPresContext* aPresContext,
+                            DrawTarget* aDrawTarget, gfxTextRun* aTextRun,
+                            const T* aText, uint32_t aOffset, uint32_t aLength,
+                            FontMatchType aMatchType,
+                            mozilla::gfx::ShapedTextFlags aOrientation,
+                            Script aScript, nsAtom* aLanguage,
+                            bool aSyntheticLower, bool aSyntheticUpper);
+
+  // call the (virtual) InitTextRun method to do glyph generation/shaping,
+  // limiting the length of text passed by processing the run in multiple
+  // segments if necessary
+  template <typename T>
+  bool SplitAndInitTextRun(DrawTarget* aDrawTarget, gfxTextRun* aTextRun,
+                           const T* aString, uint32_t aRunStart,
+                           uint32_t aRunLength, Script aRunScript,
+                           nsAtom* aLanguage,
+                           mozilla::gfx::ShapedTextFlags aOrientation);
+
+  // Get a ShapedWord representing a single space for use in setting up a
+  // gfxTextRun.
+  bool ProcessSingleSpaceShapedWord(
+      DrawTarget* aDrawTarget, bool aVertical, int32_t aAppUnitsPerDevUnit,
+      mozilla::gfx::ShapedTextFlags aFlags, RoundingFlags aRounding,
+      const std::function<void(gfxShapedWord*)>& aCallback);
+
+  // Called by the gfxFontCache timer to increment the age of all the words,
+  // so that they'll expire after a sufficient period of non-use.
+  // Returns true if the cache is now empty, otherwise false.
+  bool AgeCachedWords();
+
+  // Discard all cached word records; called on memory-pressure notification.
+  void ClearCachedWords() {
+    mozilla::AutoWriteLock lock(mLock);
+    if (mWordCache) {
+      ClearCachedWordsLocked();
+    }
+  }
+  void ClearCachedWordsLocked() MOZ_REQUIRES(mLock) {
+    MOZ_ASSERT(mWordCache);
+    mWordCache->clear();
+  }
+
+  // Glyph rendering/geometry has changed, so invalidate data as necessary.
+  void NotifyGlyphsChanged() const;
+
+  virtual void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                      FontCacheSizes* aSizes) const;
+  virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                      FontCacheSizes* aSizes) const;
+
+  typedef enum {
+    FONT_TYPE_DWRITE,
+    FONT_TYPE_GDI,
+    FONT_TYPE_FT2,
+    FONT_TYPE_MAC,
+    FONT_TYPE_OS2,
+    FONT_TYPE_CAIRO,
+    FONT_TYPE_FONTCONFIG
+  } FontType;
+
+  virtual FontType GetType() const = 0;
+
+  const RefPtr<mozilla::gfx::UnscaledFont>& GetUnscaledFont() const {
+    return mUnscaledFont;
+  }
+
+  virtual already_AddRefed<mozilla::gfx::ScaledFont> GetScaledFont(
+      const TextRunDrawParams& aRunParams) = 0;
+  already_AddRefed<mozilla::gfx::ScaledFont> GetScaledFont(
+      mozilla::gfx::DrawTarget* aDrawTarget);
+
+  // gfxFont implementations may cache ScaledFont versions other than the
+  // default, so InitializeScaledFont must support explicitly specifying
+  // which ScaledFonts to initialize.
+  void InitializeScaledFont(
+      const RefPtr<mozilla::gfx::ScaledFont>& aScaledFont);
+
+  bool KerningDisabled() const { return mKerningSet && !mKerningEnabled; }
+
+  /**
+   * Subclass this object to be notified of glyph changes. Delete the object
+   * when no longer needed.
+   */
+  class GlyphChangeObserver {
+   public:
+    virtual ~GlyphChangeObserver() {
+      if (mFont) {
+        mFont->RemoveGlyphChangeObserver(this);
+      }
+    }
+    // This gets called when the gfxFont dies.
+    void ForgetFont() { mFont = nullptr; }
+    virtual void NotifyGlyphsChanged() = 0;
+
+   protected:
+    explicit GlyphChangeObserver(gfxFont* aFont) : mFont(aFont) {
+      mFont->AddGlyphChangeObserver(this);
+    }
+    // This pointer is nulled by ForgetFont in the gfxFont's
+    // destructor. Before the gfxFont dies.
+    gfxFont* MOZ_NON_OWNING_REF mFont;
+  };
+  friend class GlyphChangeObserver;
+
+  bool GlyphsMayChange() const {
+    // Currently only fonts with SVG glyphs can have animated glyphs
+    return mFontEntry->TryGetSVGData(this);
+  }
+
+  static void DestroySingletons() {
+    delete sScriptTagToCode;
+    delete sDefaultFeatures;
+  }
+
+  // Call TryGetMathTable() to try and load the Open Type MATH table.
+  // If (and ONLY if) TryGetMathTable() has returned true, the MathTable()
+  // method may be called to access the gfxMathTable data.
+  bool TryGetMathTable();
+  gfxMathTable* MathTable() const {
+    MOZ_RELEASE_ASSERT(mMathTable,
+                       "A successful call to TryGetMathTable() must be "
+                       "performed before calling this function");
+    return mMathTable;
+  }
+
+  // Return a cloned font resized and offset to simulate sub/superscript
+  // glyphs. This does not add a reference to the returned font.
+  already_AddRefed<gfxFont> GetSubSuperscriptFont(
+      int32_t aAppUnitsPerDevPixel) const;
+
+  bool HasColorGlyphFor(uint32_t aCh, uint32_t aNextCh);
+
+ protected:
+  virtual const Metrics& GetHorizontalMetrics() const = 0;
+
+  void CreateVerticalMetrics();
+
+  bool MeasureGlyphs(const gfxTextRun* aTextRun, uint32_t aStart, uint32_t aEnd,
+                     BoundingBoxType aBoundingBoxType,
+                     DrawTarget* aRefDrawTarget, Spacing* aSpacing,
+                     gfxGlyphExtents* aExtents, bool aIsRTL,
+                     bool aNeedsGlyphExtents, RunMetrics& aMetrics,
+                     gfxFloat* aAdvanceMin, gfxFloat* aAdvanceMax);
+
+  bool MeasureGlyphs(const gfxTextRun* aTextRun, uint32_t aStart, uint32_t aEnd,
+                     BoundingBoxType aBoundingBoxType,
+                     DrawTarget* aRefDrawTarget, Spacing* aSpacing, bool aIsRTL,
+                     RunMetrics& aMetrics);
+
+  // Template parameters for DrawGlyphs/DrawOneGlyph, used to select
+  // simplified versions of the methods in the most common cases.
+  enum class FontComplexityT { SimpleFont, ComplexFont };
+  enum class SpacingT { NoSpacing, HasSpacing };
+
+  // Output a run of glyphs at *aPt, which is updated to follow the last glyph
+  // in the run. This method also takes account of any letter-spacing provided
+  // in aRunParams.
+  template <FontComplexityT FC, SpacingT S>
+  bool DrawGlyphs(const gfxShapedText* aShapedText,
+                  uint32_t aOffset,  // offset in the textrun
+                  uint32_t aCount,   // length of run to draw
+                  mozilla::gfx::Point* aPt,
+                  // transform for mOffset field in DetailedGlyph records,
+                  // to account for rotations (may be null)
+                  const mozilla::gfx::Matrix* aOffsetMatrix,
+                  GlyphBufferAzure& aBuffer);
+
+  // Output a single glyph at *aPt.
+  // Normal glyphs are simply accumulated in aBuffer until it is full and
+  // gets flushed, but SVG or color-font glyphs will instead be rendered
+  // directly to the destination (found from the buffer's parameters).
+  template <FontComplexityT FC>
+  void DrawOneGlyph(uint32_t aGlyphID, const mozilla::gfx::Point& aPt,
+                    GlyphBufferAzure& aBuffer, bool* aEmittedGlyphs);
+
+  // Helper for DrawOneGlyph to handle missing glyphs, rendering either
+  // nothing (for default-ignorables) or a missing-glyph hexbox.
+  bool DrawMissingGlyph(const TextRunDrawParams& aRunParams,
+                        const FontDrawParams& aFontParams,
+                        const gfxShapedText::DetailedGlyph* aDetails,
+                        const mozilla::gfx::Point& aPt);
+
+  // set the font size and offset used for
+  // synthetic subscript/superscript glyphs
+  void CalculateSubSuperSizeAndOffset(int32_t aAppUnitsPerDevPixel,
+                                      gfxFloat& aSubSuperSizeRatio,
+                                      float& aBaselineOffset);
+
+  // Return a font that is a "clone" of this one, but reduced to 80% size
+  // (and with variantCaps set to normal). This does not add a reference to
+  // the returned font.
+  already_AddRefed<gfxFont> GetSmallCapsFont() const;
+
+  // subclasses may provide (possibly hinted) glyph widths (in font units);
+  // if they do not override this, harfbuzz will use unhinted widths
+  // derived from the font tables
+  virtual bool ProvidesGlyphWidths() const { return false; }
+
+  // The return value is interpreted as a horizontal advance in 16.16 fixed
+  // point format.
+  virtual int32_t GetGlyphWidth(uint16_t aGID) { return -1; }
+
+  virtual bool GetGlyphBounds(uint16_t aGID, gfxRect* aBounds,
+                              bool aTight = false) {
+    return false;
+  }
+
+  bool IsSpaceGlyphInvisible(DrawTarget* aRefDrawTarget,
+                             const gfxTextRun* aTextRun);
+
+  void AddGlyphChangeObserver(GlyphChangeObserver* aObserver);
+  void RemoveGlyphChangeObserver(GlyphChangeObserver* aObserver);
+
+  // whether font contains substitution lookups containing spaces
+  bool HasSubstitutionRulesWithSpaceLookups(Script aRunScript) const;
+
+  // do spaces participate in shaping rules? if so, can't used word cache
+  // Note that this function uses HasGraphiteSpaceContextuals, so it can only
+  // return a "hint" to the correct answer. The  calling code must ensure it
+  // performs safe actions independent of the value returned.
+  tainted_boolean_hint SpaceMayParticipateInShaping(Script aRunScript) const;
+
+  // For 8-bit text, expand to 16-bit and then call the following method.
+  bool ShapeText(DrawTarget* aContext, const uint8_t* aText,
+                 uint32_t aOffset,  // dest offset in gfxShapedText
+                 uint32_t aLength, Script aScript, nsAtom* aLanguage,
+                 bool aVertical, RoundingFlags aRounding,
+                 gfxShapedText* aShapedText);  // where to store the result
+
+  // Call the appropriate shaper to generate glyphs for aText and store
+  // them into aShapedText.
+  virtual bool ShapeText(DrawTarget* aContext, const char16_t* aText,
+                         uint32_t aOffset, uint32_t aLength, Script aScript,
+                         nsAtom* aLanguage, bool aVertical,
+                         RoundingFlags aRounding, gfxShapedText* aShapedText);
+
+  // Helper to adjust for synthetic bold and set character-type flags
+  // in the shaped text; implementations of ShapeText should call this
+  // after glyph shaping has been completed.
+  void PostShapingFixup(DrawTarget* aContext, const char16_t* aText,
+                        uint32_t aOffset,  // position within aShapedText
+                        uint32_t aLength, bool aVertical,
+                        gfxShapedText* aShapedText);
+
+  // Shape text directly into a range within a textrun, without using the
+  // font's word cache. Intended for use when the font has layout features
+  // that involve space, and therefore require shaping complete runs rather
+  // than isolated words, or for long strings that are inefficient to cache.
+  // This will split the text on "invalid" characters (tab/newline) that are
+  // not handled via normal shaping, but does not otherwise divide up the
+  // text.
+  template <typename T>
+  bool ShapeTextWithoutWordCache(DrawTarget* aDrawTarget, const T* aText,
+                                 uint32_t aOffset, uint32_t aLength,
+                                 Script aScript, nsAtom* aLanguage,
+                                 bool aVertical, RoundingFlags aRounding,
+                                 gfxTextRun* aTextRun);
+
+  // Shape a fragment of text (a run that is known to contain only
+  // "valid" characters, no newlines/tabs/other control chars).
+  // All non-wordcache shaping goes through here; this is the function
+  // that will ensure we don't pass excessively long runs to the various
+  // platform shapers.
+  template <typename T>
+  bool ShapeFragmentWithoutWordCache(DrawTarget* aDrawTarget, const T* aText,
+                                     uint32_t aOffset, uint32_t aLength,
+                                     Script aScript, nsAtom* aLanguage,
+                                     bool aVertical, RoundingFlags aRounding,
+                                     gfxTextRun* aTextRun);
+
+  void CheckForFeaturesInvolvingSpace() const;
+
+  // Get a ShapedWord representing the given text (either 8- or 16-bit)
+  // for use in setting up a gfxTextRun.
+  template <typename T, typename Func>
+  bool ProcessShapedWordInternal(DrawTarget* aDrawTarget, const T* aText,
+                                 uint32_t aLength, uint32_t aHash,
+                                 Script aRunScript, nsAtom* aLanguage,
+                                 bool aVertical, int32_t aAppUnitsPerDevUnit,
+                                 mozilla::gfx::ShapedTextFlags aFlags,
+                                 RoundingFlags aRounding,
+                                 gfxTextPerfMetrics* aTextPerf, Func aCallback);
+
+  // whether a given feature is included in feature settings from both the
+  // font and the style. aFeatureOn set if resolved feature value is non-zero
+  bool HasFeatureSet(uint32_t aFeature, bool& aFeatureOn);
+
+  // used when analyzing whether a font has space contextual lookups
+  static mozilla::Atomic<nsTHashMap<nsUint32HashKey, Script>*> sScriptTagToCode;
+  static mozilla::Atomic<nsTHashSet<uint32_t>*> sDefaultFeatures;
+
+  RefPtr<gfxFontEntry> mFontEntry;
+  mutable mozilla::RWLock mLock;
+
+  // Note that WordCacheKey contains a pointer to the text of the word, which
+  // must be valid for as long as the key is in use. When using for a Lookup,
+  // the string may be local/temporary, but when storing in the HashMap, we
+  // set the Key text pointer to reference the text in the associated
+  // gfxShapedWord that is being stored.
+  struct WordCacheKey {
+    union {
+      const uint8_t* mSingle;
+      const char16_t* mDouble;
+    } mText;
+    uint32_t mLength;
+    ShapedTextFlags mFlags;
+    Script mScript;
+    RefPtr<nsAtom> mLanguage;
+    int32_t mAppUnitsPerDevUnit;
+    PLDHashNumber mHashKey;
+    bool mTextIs8Bit;
+    RoundingFlags mRounding;
+
+    WordCacheKey(const uint8_t* aText, uint32_t aLength, uint32_t aStringHash,
+                 Script aScriptCode, nsAtom* aLanguage,
+                 int32_t aAppUnitsPerDevUnit, ShapedTextFlags aFlags,
+                 RoundingFlags aRounding)
+        : mLength(aLength),
+          mFlags(aFlags),
+          mScript(aScriptCode),
+          mLanguage(aLanguage),
+          mAppUnitsPerDevUnit(aAppUnitsPerDevUnit),
+          mHashKey(aStringHash + static_cast<int32_t>(aScriptCode) +
+                   aAppUnitsPerDevUnit * 0x100 + uint16_t(aFlags) * 0x10000 +
+                   int(aRounding) + (aLanguage ? aLanguage->hash() : 0)),
+          mTextIs8Bit(true),
+          mRounding(aRounding) {
+      NS_ASSERTION(aFlags & ShapedTextFlags::TEXT_IS_8BIT,
+                   "8-bit flag should have been set");
+      mText.mSingle = aText;
+    }
+
+    WordCacheKey(const char16_t* aText, uint32_t aLength, uint32_t aStringHash,
+                 Script aScriptCode, nsAtom* aLanguage,
+                 int32_t aAppUnitsPerDevUnit, ShapedTextFlags aFlags,
+                 RoundingFlags aRounding)
+        : mLength(aLength),
+          mFlags(aFlags),
+          mScript(aScriptCode),
+          mLanguage(aLanguage),
+          mAppUnitsPerDevUnit(aAppUnitsPerDevUnit),
+          mHashKey(aStringHash + static_cast<int32_t>(aScriptCode) +
+                   aAppUnitsPerDevUnit * 0x100 + uint16_t(aFlags) * 0x10000 +
+                   int(aRounding)),
+          mTextIs8Bit(false),
+          mRounding(aRounding) {
+      // We can NOT assert that TEXT_IS_8BIT is false in aFlags here,
+      // because this might be an 8bit-only word from a 16-bit textrun,
+      // in which case the text we're passed is still in 16-bit form,
+      // and we'll have to use an 8-to-16bit comparison in KeyEquals.
+      mText.mDouble = aText;
+    }
+
+    bool Matches(const WordCacheKey& aLookup) const;
+
+    class HashPolicy {
+     public:
+      typedef WordCacheKey Key;
+      typedef WordCacheKey Lookup;
+      static mozilla::HashNumber hash(const Lookup& aLookup) {
+        return aLookup.mHashKey;
+      }
+      static bool match(const Key& aKey, const Lookup& aLookup);
+    };
+  };
+
+  mozilla::UniquePtr<
+      mozilla::HashMap<WordCacheKey, mozilla::UniquePtr<gfxShapedWord>,
+                       WordCacheKey::HashPolicy>>
+      mWordCache MOZ_GUARDED_BY(mLock);
+
+  static const uint32_t kShapedWordCacheMaxAge = 3;
+
+  nsTArray<mozilla::UniquePtr<gfxGlyphExtents>> mGlyphExtentsArray
+      MOZ_GUARDED_BY(mLock);
+  mozilla::UniquePtr<nsTHashSet<GlyphChangeObserver*>> mGlyphChangeObservers
+      MOZ_GUARDED_BY(mLock);
+
+  // a copy of the font without antialiasing, if needed for separate
+  // measurement by mathml code
+  mozilla::Atomic<gfxFont*> mNonAAFont;
+
+  // we create either or both of these shapers when needed, depending
+  // whether the font has graphite tables, and whether graphite shaping
+  // is actually enabled
+  mozilla::Atomic<gfxHarfBuzzShaper*> mHarfBuzzShaper;
+  mozilla::Atomic<gfxGraphiteShaper*> mGraphiteShaper;
+
+  // If a userfont with unicode-range specified, contains map of *possible*
+  // ranges supported by font. This is set during user-font initialization,
+  // before the font is available to other threads, and thereafter is inert
+  // so no guard is needed.
+  RefPtr<gfxCharacterMap> mUnicodeRangeMap;
+
+  // This is immutable once initialized by the constructor, so does not need
+  // locking.
+  RefPtr<mozilla::gfx::UnscaledFont> mUnscaledFont;
+
+  mozilla::Atomic<mozilla::gfx::ScaledFont*> mAzureScaledFont;
+
+  // For vertical metrics, created on demand.
+  mozilla::Atomic<Metrics*> mVerticalMetrics;
+
+  // Table used for MathML layout.
+  mozilla::Atomic<gfxMathTable*> mMathTable;
+
+  gfxFontStyle mStyle;
+  mutable gfxFloat mAdjustedSize;
+
+  // Tracking adjustment to be applied for CSS px size mCachedTrackingSize.
+  gfxFloat mTracking = 0.0;
+  gfxFloat mCachedTrackingSize = -1.0;
+
+  // Conversion factor from font units to dev units; note that this may be
+  // zero (in the degenerate case where mAdjustedSize has become zero).
+  // This is OK because we only multiply by this factor, never divide.
+  float mFUnitsConvFactor;
+
+  // This is guarded by gfxFontCache::GetCache()->GetMutex() but it is difficult
+  // to annotate that fact.
+  nsExpirationState mExpirationState;
+
+  // Glyph ID of the font's <space> glyph, zero if missing
+  uint16_t mSpaceGlyph = 0;
+
+  // the AA setting requested for this font - may affect glyph bounds
+  AntialiasOption mAntialiasOption;
+
+  bool mIsValid;
+
+  // use synthetic bolding for environments where this is not supported
+  // by the platform
+  bool mApplySyntheticBold;
+
+  bool mKerningSet;      // kerning explicitly set?
+  bool mKerningEnabled;  // if set, on or off?
+
+  mozilla::Atomic<bool> mMathInitialized;  // TryGetMathTable() called?
+
+  // Helper for subclasses that want to initialize standard metrics from the
+  // tables of sfnt (TrueType/OpenType) fonts.
+  // This will use mFUnitsConvFactor if it is already set, else compute it
+  // from mAdjustedSize and the unitsPerEm in the font's 'head' table.
+  // Returns TRUE and sets mIsValid=TRUE if successful;
+  // Returns TRUE but leaves mIsValid=FALSE if the font seems to be broken.
+  // Returns FALSE if the font does not appear to be an sfnt at all,
+  // and should be handled (if possible) using other APIs.
+  bool InitMetricsFromSfntTables(Metrics& aMetrics);
+
+  // Helper to calculate various derived metrics from the results of
+  // InitMetricsFromSfntTables or equivalent platform code
+  void CalculateDerivedMetrics(Metrics& aMetrics);
+
+  // some fonts have bad metrics, this method sanitize them.
+  // if this font has bad underline offset, aIsBadUnderlineFont should be true.
+  void SanitizeMetrics(Metrics* aMetrics, bool aIsBadUnderlineFont);
+
+  bool RenderSVGGlyph(gfxContext* aContext,
+                      mozilla::layout::TextDrawTarget* aTextDrawer,
+                      mozilla::gfx::Point aPoint, uint32_t aGlyphId,
+                      SVGContextPaint* aContextPaint) const;
+  bool RenderSVGGlyph(gfxContext* aContext,
+                      mozilla::layout::TextDrawTarget* aTextDrawer,
+                      mozilla::gfx::Point aPoint, uint32_t aGlyphId,
+                      SVGContextPaint* aContextPaint,
+                      gfxTextRunDrawCallbacks* aCallbacks,
+                      bool& aEmittedGlyphs) const;
+
+  bool RenderColorGlyph(DrawTarget* aDrawTarget, gfxContext* aContext,
+                        mozilla::layout::TextDrawTarget* aTextDrawer,
+                        const FontDrawParams& aFontParams,
+                        const mozilla::gfx::Point& aPoint, uint32_t aGlyphId);
+
+  class ColorGlyphCache {
+   public:
+    ColorGlyphCache() = default;
+    ~ColorGlyphCache() = default;
+
+    void SetColors(mozilla::gfx::sRGBColor aCurrentColor,
+                   mozilla::gfx::FontPalette* aPalette);
+
+    mozilla::HashMap<uint32_t, RefPtr<mozilla::gfx::SourceSurface>> mCache;
+
+   private:
+    mozilla::gfx::sRGBColor mCurrentColor;
+    RefPtr<mozilla::gfx::FontPalette> mPalette;
+  };
+  mozilla::UniquePtr<ColorGlyphCache> mColorGlyphCache;
+
+  // Subclasses can override to return true if the platform is able to render
+  // COLR-font glyphs directly, instead of us painting the layers explicitly.
+  // (Currently used only for COLR.v0 fonts on macOS.)
+  virtual bool UseNativeColrFontSupport() const { return false; }
+
+  // Bug 674909. When synthetic bolding text by drawing twice, need to
+  // render using a pixel offset in device pixels, otherwise text
+  // doesn't appear bolded, it appears as if a bad text shadow exists
+  // when a non-identity transform exists.  Use an offset factor so that
+  // the second draw occurs at a constant offset in device pixels.
+  // This helper calculates the scale factor we need to apply to the
+  // synthetic-bold offset.
+  static mozilla::gfx::Float CalcXScale(DrawTarget* aDrawTarget);
+};
+
+// proportion of ascent used for x-height, if unable to read value from font
+#define DEFAULT_XHEIGHT_FACTOR 0.56f
+
+// Parameters passed to gfxFont methods for drawing glyphs from a textrun.
+// The TextRunDrawParams are set up once per textrun; the FontDrawParams
+// are dependent on the specific font, so they are set per GlyphRun.
+
+struct MOZ_STACK_CLASS TextRunDrawParams {
+  explicit TextRunDrawParams(mozilla::gfx::PaletteCache& aPaletteCache)
+      : paletteCache(aPaletteCache) {}
+
+  mozilla::gfx::PaletteCache& paletteCache;
+  RefPtr<mozilla::gfx::DrawTarget> dt;
+  gfxContext* context = nullptr;
+  gfxFont::Spacing* spacing = nullptr;
+  gfxTextRunDrawCallbacks* callbacks = nullptr;
+  mozilla::SVGContextPaint* runContextPaint = nullptr;
+  mozilla::layout::TextDrawTarget* textDrawer = nullptr;
+  mozilla::LayoutDeviceRect clipRect;
+  mozilla::gfx::Float direction = 1.0f;
+  double devPerApp = 1.0;
+  nscolor textStrokeColor = 0;
+  gfxPattern* textStrokePattern = nullptr;
+  const mozilla::gfx::StrokeOptions* strokeOpts = nullptr;
+  const mozilla::gfx::DrawOptions* drawOpts = nullptr;
+  nsAtom* fontPalette = nullptr;
+  DrawMode drawMode = DrawMode::GLYPH_FILL;
+  bool isVerticalRun = false;
+  bool isRTL = false;
+  bool paintSVGGlyphs = true;
+  bool allowGDI = true;
+  bool hasTextShadow = false;
+};
+
+struct MOZ_STACK_CLASS FontDrawParams {
+  RefPtr<mozilla::gfx::ScaledFont> scaledFont;
+  mozilla::SVGContextPaint* contextPaint;
+  mozilla::gfx::Float synBoldOnePixelOffset;
+  mozilla::gfx::Float obliqueSkew;
+  int32_t extraStrikes;
+  mozilla::gfx::DrawOptions drawOptions;
+  gfxFloat advanceDirection;
+  mozilla::gfx::sRGBColor currentColor;
+  RefPtr<mozilla::gfx::FontPalette> palette;
+  mozilla::gfx::Rect fontExtents;
+  bool isVerticalFont;
+  bool haveSVGGlyphs;
+  bool haveColorGlyphs;
+  bool hasTextShadow;  // whether we're rendering with a text-shadow
+};
+
+struct MOZ_STACK_CLASS EmphasisMarkDrawParams {
+  EmphasisMarkDrawParams(gfxContext* aContext,
+                         mozilla::gfx::PaletteCache& aPaletteCache)
+      : context(aContext), paletteCache(aPaletteCache) {}
+  gfxContext* context;
+  mozilla::gfx::PaletteCache& paletteCache;
+  gfxFont::Spacing* spacing;
+  gfxTextRun* mark;
+  gfxFloat advance;
+  gfxFloat direction;
+  bool isVertical;
+};
+
+#endif