Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 2261 insertions, 0 deletions

diff --git a/layout/mathml/nsMathMLChar.cpp b/layout/mathml/nsMathMLChar.cpp
new file mode 100644
index 0000000000..8ea4bd34ba
--- /dev/null
+++ b/layout/mathml/nsMathMLChar.cpp
@@ -0,0 +1,2261 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMathMLChar.h"
+
+#include "gfxContext.h"
+#include "gfxTextRun.h"
+#include "gfxUtils.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/intl/UnicodeScriptCodes.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Unused.h"
+#include "mozilla/StaticPrefs_mathml.h"
+
+#include "nsCOMPtr.h"
+#include "nsDeviceContext.h"
+#include "nsFontMetrics.h"
+#include "nsIFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsPresContext.h"
+#include "nsUnicharUtils.h"
+
+#include "mozilla/Preferences.h"
+#include "nsIPersistentProperties2.h"
+#include "nsIObserverService.h"
+#include "nsIObserver.h"
+#include "nsNetUtil.h"
+#include "nsContentUtils.h"
+
+#include "mozilla/LookAndFeel.h"
+#include "nsCSSRendering.h"
+#include "mozilla/Sprintf.h"
+
+#include "nsDisplayList.h"
+
+#include "nsMathMLOperators.h"
+#include <algorithm>
+
+#include "gfxMathTable.h"
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::image;
+
+// #define NOISY_SEARCH 1
+
+// BUG 848725 Drawing failure with stretchy horizontal parenthesis when no fonts
+// are installed. "kMaxScaleFactor" is required to limit the scale for the
+// vertical and horizontal stretchy operators.
+static const float kMaxScaleFactor = 20.0;
+static const float kLargeOpFactor = float(M_SQRT2);
+static const float kIntegralFactor = 2.0;
+
+static void NormalizeDefaultFont(nsFont& aFont, float aFontSizeInflation) {
+  aFont.size.ScaleBy(aFontSizeInflation);
+}
+
+// -----------------------------------------------------------------------------
+static const nsGlyphCode kNullGlyph = {{{0, 0}}, 0};
+
+// -----------------------------------------------------------------------------
+// nsGlyphTable is a class that provides an interface for accessing glyphs
+// of stretchy chars. It acts like a table that stores the variants of bigger
+// sizes (if any) and the partial glyphs needed to build extensible symbols.
+//
+// Bigger sizes (if any) of the char can then be retrieved with BigOf(...).
+// Partial glyphs can be retrieved with ElementAt(...).
+//
+// A table consists of "nsGlyphCode"s which are viewed either as Unicode
+// points (for nsPropertiesTable) or as direct glyph indices (for
+// nsOpenTypeTable)
+// -----------------------------------------------------------------------------
+
+class nsGlyphTable {
+ public:
+  virtual ~nsGlyphTable() = default;
+
+  virtual const nsCString& FontNameFor(const nsGlyphCode& aGlyphCode) const = 0;
+
+  // Getters for the parts
+  virtual nsGlyphCode ElementAt(DrawTarget* aDrawTarget,
+                                int32_t aAppUnitsPerDevPixel,
+                                gfxFontGroup* aFontGroup, char16_t aChar,
+                                bool aVertical, uint32_t aPosition) = 0;
+  virtual nsGlyphCode BigOf(DrawTarget* aDrawTarget,
+                            int32_t aAppUnitsPerDevPixel,
+                            gfxFontGroup* aFontGroup, char16_t aChar,
+                            bool aVertical, uint32_t aSize) = 0;
+
+  // True if this table contains parts to render this char
+  virtual bool HasPartsOf(DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+                          gfxFontGroup* aFontGroup, char16_t aChar,
+                          bool aVertical) = 0;
+
+  virtual already_AddRefed<gfxTextRun> MakeTextRun(
+      DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+      gfxFontGroup* aFontGroup, const nsGlyphCode& aGlyph) = 0;
+
+ protected:
+  nsGlyphTable() : mCharCache(0) {}
+  // For speedy re-use, we always cache the last data used in the table.
+  // mCharCache is the Unicode point of the last char that was queried in this
+  // table.
+  char16_t mCharCache;
+};
+
+// An instance of nsPropertiesTable is associated with one primary font. Extra
+// glyphs can be taken in other additional fonts when stretching certain
+// characters.
+// These supplementary fonts are referred to as "external" fonts to the table.
+
+// General format of MathFont Property Files from which glyph data are
+// retrieved:
+// -----------------------------------------------------------------------------
+// Each font should have its set of glyph data. For example, the glyph data for
+// the "Symbol" font and the "MT Extra" font are in "mathfontSymbol.properties"
+// and "mathfontMTExtra.properties", respectively. The mathfont property file
+// is a set of all the stretchy MathML characters that can be rendered with that
+// font using larger and/or partial glyphs. The entry of each stretchy character
+// in the mathfont property file gives, in that order, the 4 partial glyphs:
+// Top (or Left), Middle, Bottom (or Right), Glue; and the variants of bigger
+// sizes (if any).
+// A position that is not relevant to a particular character is indicated there
+// with the UNICODE REPLACEMENT CHARACTER 0xFFFD.
+// -----------------------------------------------------------------------------
+
+#define NS_TABLE_STATE_ERROR -1
+#define NS_TABLE_STATE_EMPTY 0
+#define NS_TABLE_STATE_READY 1
+
+// helper to trim off comments from data in a MathFont Property File
+static void Clean(nsString& aValue) {
+  // chop the trailing # comment portion if any ...
+  int32_t comment = aValue.RFindChar('#');
+  if (comment > 0) aValue.Truncate(comment);
+  aValue.CompressWhitespace();
+}
+
+// helper to load a MathFont Property File
+static nsresult LoadProperties(const nsACString& aName,
+                               nsCOMPtr<nsIPersistentProperties>& aProperties) {
+  nsAutoCString uriStr;
+  uriStr.AssignLiteral("resource://gre/res/fonts/mathfont");
+  uriStr.Append(aName);
+  uriStr.StripWhitespace();  // that may come from aName
+  uriStr.AppendLiteral(".properties");
+  return NS_LoadPersistentPropertiesFromURISpec(getter_AddRefs(aProperties),
+                                                uriStr);
+}
+
+class nsPropertiesTable final : public nsGlyphTable {
+ public:
+  explicit nsPropertiesTable(const nsACString& aPrimaryFontName)
+      : mState(NS_TABLE_STATE_EMPTY) {
+    MOZ_COUNT_CTOR(nsPropertiesTable);
+    mGlyphCodeFonts.AppendElement(aPrimaryFontName);
+  }
+
+  MOZ_COUNTED_DTOR(nsPropertiesTable)
+
+  const nsCString& PrimaryFontName() const { return mGlyphCodeFonts[0]; }
+
+  const nsCString& FontNameFor(const nsGlyphCode& aGlyphCode) const override {
+    NS_ASSERTION(!aGlyphCode.IsGlyphID(),
+                 "nsPropertiesTable can only access glyphs by code point");
+    return mGlyphCodeFonts[aGlyphCode.font];
+  }
+
+  virtual nsGlyphCode ElementAt(DrawTarget* aDrawTarget,
+                                int32_t aAppUnitsPerDevPixel,
+                                gfxFontGroup* aFontGroup, char16_t aChar,
+                                bool aVertical, uint32_t aPosition) override;
+
+  virtual nsGlyphCode BigOf(DrawTarget* aDrawTarget,
+                            int32_t aAppUnitsPerDevPixel,
+                            gfxFontGroup* aFontGroup, char16_t aChar,
+                            bool aVertical, uint32_t aSize) override {
+    return ElementAt(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar,
+                     aVertical, 4 + aSize);
+  }
+
+  virtual bool HasPartsOf(DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+                          gfxFontGroup* aFontGroup, char16_t aChar,
+                          bool aVertical) override {
+    return (ElementAt(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar,
+                      aVertical, 0)
+                .Exists() ||
+            ElementAt(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar,
+                      aVertical, 1)
+                .Exists() ||
+            ElementAt(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar,
+                      aVertical, 2)
+                .Exists() ||
+            ElementAt(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar,
+                      aVertical, 3)
+                .Exists());
+  }
+
+  virtual already_AddRefed<gfxTextRun> MakeTextRun(
+      DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+      gfxFontGroup* aFontGroup, const nsGlyphCode& aGlyph) override;
+
+ private:
+  // mGlyphCodeFonts[0] is the primary font associated to this table. The
+  // others are possible "external" fonts for glyphs not in the primary font
+  // but which are needed to stretch certain characters in the table
+  nsTArray<nsCString> mGlyphCodeFonts;
+
+  // Tri-state variable for error/empty/ready
+  int32_t mState;
+
+  // The set of glyph data in this table, as provided by the MathFont Property
+  // File
+  nsCOMPtr<nsIPersistentProperties> mGlyphProperties;
+
+  // mGlyphCache is a buffer containing the glyph data associated with
+  // mCharCache.
+  // For a property line 'key = value' in the MathFont Property File,
+  // mCharCache will retain the 'key' -- which is a Unicode point, while
+  // mGlyphCache will retain the 'value', which is a consecutive list of
+  // nsGlyphCodes, i.e., the pairs of 'code@font' needed by the char -- in
+  // which 'code@0' can be specified
+  // without the optional '@0'. However, to ease subsequent processing,
+  // mGlyphCache excludes the '@' symbol and explicitly inserts all optional '0'
+  // that indicates the primary font identifier. Specifically therefore, the
+  // k-th glyph is characterized by :
+  // 1) mGlyphCache[3*k],mGlyphCache[3*k+1] : its Unicode point
+  // 2) mGlyphCache[3*k+2] : the numeric identifier of the font where it comes
+  // from.
+  // A font identifier of '0' means the default primary font associated to this
+  // table. Other digits map to the "external" fonts that may have been
+  // specified in the MathFont Property File.
+  nsString mGlyphCache;
+};
+
+/* virtual */
+nsGlyphCode nsPropertiesTable::ElementAt(DrawTarget* /* aDrawTarget */,
+                                         int32_t /* aAppUnitsPerDevPixel */,
+                                         gfxFontGroup* /* aFontGroup */,
+                                         char16_t aChar, bool /* aVertical */,
+                                         uint32_t aPosition) {
+  if (mState == NS_TABLE_STATE_ERROR) return kNullGlyph;
+  // Load glyph properties if this is the first time we have been here
+  if (mState == NS_TABLE_STATE_EMPTY) {
+    nsresult rv = LoadProperties(PrimaryFontName(), mGlyphProperties);
+#ifdef DEBUG
+    nsAutoCString uriStr;
+    uriStr.AssignLiteral("resource://gre/res/fonts/mathfont");
+    uriStr.Append(PrimaryFontName());
+    uriStr.StripWhitespace();  // that may come from mGlyphCodeFonts
+    uriStr.AppendLiteral(".properties");
+    printf("Loading %s ... %s\n", uriStr.get(),
+           (NS_FAILED(rv)) ? "Failed" : "Done");
+#endif
+    if (NS_FAILED(rv)) {
+      mState = NS_TABLE_STATE_ERROR;  // never waste time with this table again
+      return kNullGlyph;
+    }
+    mState = NS_TABLE_STATE_READY;
+
+    // see if there are external fonts needed for certain chars in this table
+    nsAutoCString key;
+    nsAutoString value;
+    for (int32_t i = 1;; i++) {
+      key.AssignLiteral("external.");
+      key.AppendInt(i, 10);
+      rv = mGlyphProperties->GetStringProperty(key, value);
+      if (NS_FAILED(rv)) {
+        break;
+      }
+      Clean(value);
+      mGlyphCodeFonts.AppendElement(NS_ConvertUTF16toUTF8(value));
+    }
+  }
+
+  // Update our cache if it is not associated to this character
+  if (mCharCache != aChar) {
+    // The key in the property file is interpreted as ASCII and kept
+    // as such ...
+    char key[10];
+    SprintfLiteral(key, "\\u%04X", aChar);
+    nsAutoString value;
+    nsresult rv =
+        mGlyphProperties->GetStringProperty(nsDependentCString(key), value);
+    if (NS_FAILED(rv)) return kNullGlyph;
+    Clean(value);
+    // See if this char uses external fonts; e.g., if the 2nd glyph is taken
+    // from the external font '1', the property line looks like
+    // \uNNNN = \uNNNN\uNNNN@1\uNNNN.
+    // This is where mGlyphCache is pre-processed to explicitly store all glyph
+    // codes as combined pairs of 'code@font', excluding the '@' separator. This
+    // means that mGlyphCache[3*k],mGlyphCache[3*k+1] will later be rendered
+    // with mGlyphCodeFonts[mGlyphCache[3*k+2]]
+    // Note: font identifier is internally an ASCII digit to avoid the null
+    // char issue
+    nsAutoString buffer;
+    int32_t length = value.Length();
+    int32_t i = 0;  // index in value
+    while (i < length) {
+      char16_t code = value[i];
+      ++i;
+      buffer.Append(code);
+      // Read the next word if we have a non-BMP character.
+      if (i < length && NS_IS_HIGH_SURROGATE(code)) {
+        code = value[i];
+        ++i;
+      } else {
+        code = char16_t('\0');
+      }
+      buffer.Append(code);
+
+      // See if an external font is needed for the code point.
+      // Limit of 9 external fonts
+      char16_t font = 0;
+      if (i + 1 < length && value[i] == char16_t('@') &&
+          value[i + 1] >= char16_t('0') && value[i + 1] <= char16_t('9')) {
+        ++i;
+        font = value[i] - '0';
+        ++i;
+        if (font >= mGlyphCodeFonts.Length()) {
+          NS_ERROR("Nonexistent font referenced in glyph table");
+          return kNullGlyph;
+        }
+      }
+      buffer.Append(font);
+    }
+    // update our cache with the new settings
+    mGlyphCache.Assign(buffer);
+    mCharCache = aChar;
+  }
+
+  // 3* is to account for the code@font pairs
+  uint32_t index = 3 * aPosition;
+  if (index + 2 >= mGlyphCache.Length()) return kNullGlyph;
+  nsGlyphCode ch;
+  ch.code[0] = mGlyphCache.CharAt(index);
+  ch.code[1] = mGlyphCache.CharAt(index + 1);
+  ch.font = mGlyphCache.CharAt(index + 2);
+  return ch.code[0] == char16_t(0xFFFD) ? kNullGlyph : ch;
+}
+
+/* virtual */
+already_AddRefed<gfxTextRun> nsPropertiesTable::MakeTextRun(
+    DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+    gfxFontGroup* aFontGroup, const nsGlyphCode& aGlyph) {
+  NS_ASSERTION(!aGlyph.IsGlyphID(),
+               "nsPropertiesTable can only access glyphs by code point");
+  return aFontGroup->MakeTextRun(aGlyph.code, aGlyph.Length(), aDrawTarget,
+                                 aAppUnitsPerDevPixel, gfx::ShapedTextFlags(),
+                                 nsTextFrameUtils::Flags(), nullptr);
+}
+
+// An instance of nsOpenTypeTable is associated with one gfxFontEntry that
+// corresponds to an Open Type font with a MATH table. All the glyphs come from
+// the same font and the calls to access size variants and parts are directly
+// forwarded to the gfx code.
+class nsOpenTypeTable final : public nsGlyphTable {
+ public:
+  MOZ_COUNTED_DTOR(nsOpenTypeTable)
+
+  virtual nsGlyphCode ElementAt(DrawTarget* aDrawTarget,
+                                int32_t aAppUnitsPerDevPixel,
+                                gfxFontGroup* aFontGroup, char16_t aChar,
+                                bool aVertical, uint32_t aPosition) override;
+  virtual nsGlyphCode BigOf(DrawTarget* aDrawTarget,
+                            int32_t aAppUnitsPerDevPixel,
+                            gfxFontGroup* aFontGroup, char16_t aChar,
+                            bool aVertical, uint32_t aSize) override;
+  virtual bool HasPartsOf(DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+                          gfxFontGroup* aFontGroup, char16_t aChar,
+                          bool aVertical) override;
+
+  const nsCString& FontNameFor(const nsGlyphCode& aGlyphCode) const override {
+    NS_ASSERTION(aGlyphCode.IsGlyphID(),
+                 "nsOpenTypeTable can only access glyphs by id");
+    return mFontFamilyName;
+  }
+
+  virtual already_AddRefed<gfxTextRun> MakeTextRun(
+      DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+      gfxFontGroup* aFontGroup, const nsGlyphCode& aGlyph) override;
+
+  // This returns a new OpenTypeTable instance to give access to OpenType MATH
+  // table or nullptr if the font does not have such table. Ownership is passed
+  // to the caller.
+  static UniquePtr<nsOpenTypeTable> Create(gfxFont* aFont) {
+    if (!aFont->TryGetMathTable()) {
+      return nullptr;
+    }
+    return WrapUnique(new nsOpenTypeTable(aFont));
+  }
+
+ private:
+  RefPtr<gfxFont> mFont;
+  nsCString mFontFamilyName;
+  uint32_t mGlyphID;
+
+  explicit nsOpenTypeTable(gfxFont* aFont)
+      : mFont(aFont),
+        mFontFamilyName(aFont->GetFontEntry()->FamilyName()),
+        mGlyphID(0) {
+    MOZ_COUNT_CTOR(nsOpenTypeTable);
+  }
+
+  void UpdateCache(DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+                   gfxFontGroup* aFontGroup, char16_t aChar);
+};
+
+void nsOpenTypeTable::UpdateCache(DrawTarget* aDrawTarget,
+                                  int32_t aAppUnitsPerDevPixel,
+                                  gfxFontGroup* aFontGroup, char16_t aChar) {
+  if (mCharCache != aChar) {
+    RefPtr<gfxTextRun> textRun = aFontGroup->MakeTextRun(
+        &aChar, 1, aDrawTarget, aAppUnitsPerDevPixel, gfx::ShapedTextFlags(),
+        nsTextFrameUtils::Flags(), nullptr);
+    const gfxTextRun::CompressedGlyph& data = textRun->GetCharacterGlyphs()[0];
+    if (data.IsSimpleGlyph()) {
+      mGlyphID = data.GetSimpleGlyph();
+    } else if (data.GetGlyphCount() == 1) {
+      mGlyphID = textRun->GetDetailedGlyphs(0)->mGlyphID;
+    } else {
+      mGlyphID = 0;
+    }
+    mCharCache = aChar;
+  }
+}
+
+/* virtual */
+nsGlyphCode nsOpenTypeTable::ElementAt(DrawTarget* aDrawTarget,
+                                       int32_t aAppUnitsPerDevPixel,
+                                       gfxFontGroup* aFontGroup, char16_t aChar,
+                                       bool aVertical, uint32_t aPosition) {
+  UpdateCache(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar);
+
+  uint32_t parts[4];
+  if (!mFont->MathTable()->VariantsParts(mGlyphID, aVertical, parts)) {
+    return kNullGlyph;
+  }
+
+  uint32_t glyphID = parts[aPosition];
+  if (!glyphID) {
+    return kNullGlyph;
+  }
+  nsGlyphCode glyph;
+  glyph.glyphID = glyphID;
+  glyph.font = -1;
+  return glyph;
+}
+
+/* virtual */
+nsGlyphCode nsOpenTypeTable::BigOf(DrawTarget* aDrawTarget,
+                                   int32_t aAppUnitsPerDevPixel,
+                                   gfxFontGroup* aFontGroup, char16_t aChar,
+                                   bool aVertical, uint32_t aSize) {
+  UpdateCache(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar);
+
+  uint32_t glyphID =
+      mFont->MathTable()->VariantsSize(mGlyphID, aVertical, aSize);
+  if (!glyphID) {
+    return kNullGlyph;
+  }
+
+  nsGlyphCode glyph;
+  glyph.glyphID = glyphID;
+  glyph.font = -1;
+  return glyph;
+}
+
+/* virtual */
+bool nsOpenTypeTable::HasPartsOf(DrawTarget* aDrawTarget,
+                                 int32_t aAppUnitsPerDevPixel,
+                                 gfxFontGroup* aFontGroup, char16_t aChar,
+                                 bool aVertical) {
+  UpdateCache(aDrawTarget, aAppUnitsPerDevPixel, aFontGroup, aChar);
+
+  uint32_t parts[4];
+  if (!mFont->MathTable()->VariantsParts(mGlyphID, aVertical, parts)) {
+    return false;
+  }
+
+  return parts[0] || parts[1] || parts[2] || parts[3];
+}
+
+/* virtual */
+already_AddRefed<gfxTextRun> nsOpenTypeTable::MakeTextRun(
+    DrawTarget* aDrawTarget, int32_t aAppUnitsPerDevPixel,
+    gfxFontGroup* aFontGroup, const nsGlyphCode& aGlyph) {
+  NS_ASSERTION(aGlyph.IsGlyphID(),
+               "nsOpenTypeTable can only access glyphs by id");
+
+  gfxTextRunFactory::Parameters params = {
+      aDrawTarget, nullptr, nullptr, nullptr, 0, aAppUnitsPerDevPixel};
+  RefPtr<gfxTextRun> textRun =
+      gfxTextRun::Create(&params, 1, aFontGroup, gfx::ShapedTextFlags(),
+                         nsTextFrameUtils::Flags());
+  RefPtr<gfxFont> font = aFontGroup->GetFirstValidFont();
+  textRun->AddGlyphRun(font, FontMatchType::Kind::kFontGroup, 0, false,
+                       gfx::ShapedTextFlags::TEXT_ORIENT_HORIZONTAL, false);
+  // We don't care about CSS writing mode here;
+  // math runs are assumed to be horizontal.
+  gfxTextRun::DetailedGlyph detailedGlyph;
+  detailedGlyph.mGlyphID = aGlyph.glyphID;
+  detailedGlyph.mAdvance = NSToCoordRound(
+      aAppUnitsPerDevPixel * font->GetGlyphAdvance(aGlyph.glyphID));
+  textRun->SetDetailedGlyphs(0, 1, &detailedGlyph);
+
+  return textRun.forget();
+}
+
+// -----------------------------------------------------------------------------
+// This is the list of all the applicable glyph tables.
+// We will maintain a single global instance that will only reveal those
+// glyph tables that are associated to fonts currently installed on the
+// user' system. The class is an XPCOM shutdown observer to allow us to
+// free its allocated data at shutdown
+
+class nsGlyphTableList final : public nsIObserver {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  nsPropertiesTable mUnicodeTable;
+
+  nsGlyphTableList() : mUnicodeTable("Unicode"_ns) {}
+
+  nsresult Initialize();
+  nsresult Finalize();
+
+  // Add a glyph table in the list, return the new table that was added
+  nsGlyphTable* AddGlyphTable(const nsACString& aPrimaryFontName);
+
+  // Find the glyph table in the list corresponding to the given font family.
+  nsGlyphTable* GetGlyphTableFor(const nsACString& aFamily);
+
+ private:
+  ~nsGlyphTableList() = default;
+
+  nsPropertiesTable* PropertiesTableAt(int32_t aIndex) {
+    return &mPropertiesTableList.ElementAt(aIndex);
+  }
+  int32_t PropertiesTableCount() { return mPropertiesTableList.Length(); }
+  // List of glyph tables;
+  nsTArray<nsPropertiesTable> mPropertiesTableList;
+};
+
+NS_IMPL_ISUPPORTS(nsGlyphTableList, nsIObserver)
+
+// -----------------------------------------------------------------------------
+// Here is the global list of applicable glyph tables that we will be using
+static nsGlyphTableList* gGlyphTableList = nullptr;
+
+static bool gGlyphTableInitialized = false;
+
+// XPCOM shutdown observer
+NS_IMETHODIMP
+nsGlyphTableList::Observe(nsISupports* aSubject, const char* aTopic,
+                          const char16_t* someData) {
+  Finalize();
+  return NS_OK;
+}
+
+// Add an observer to XPCOM shutdown so that we can free our data at shutdown
+nsresult nsGlyphTableList::Initialize() {
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (!obs) return NS_ERROR_FAILURE;
+
+  nsresult rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+// Remove our observer and free the memory that were allocated for us
+nsresult nsGlyphTableList::Finalize() {
+  // Remove our observer from the observer service
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs)
+    rv = obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+  else
+    rv = NS_ERROR_FAILURE;
+
+  gGlyphTableInitialized = false;
+  // our oneself will be destroyed when our |Release| is called by the observer
+  NS_IF_RELEASE(gGlyphTableList);
+  return rv;
+}
+
+nsGlyphTable* nsGlyphTableList::AddGlyphTable(
+    const nsACString& aPrimaryFontName) {
+  // See if there is already a special table for this family.
+  nsGlyphTable* glyphTable = GetGlyphTableFor(aPrimaryFontName);
+  if (glyphTable != &mUnicodeTable) return glyphTable;
+
+  // allocate a table
+  glyphTable = mPropertiesTableList.AppendElement(aPrimaryFontName);
+  return glyphTable;
+}
+
+nsGlyphTable* nsGlyphTableList::GetGlyphTableFor(const nsACString& aFamily) {
+  for (int32_t i = 0; i < PropertiesTableCount(); i++) {
+    nsPropertiesTable* glyphTable = PropertiesTableAt(i);
+    const nsCString& primaryFontName = glyphTable->PrimaryFontName();
+    // TODO: would be nice to consider StripWhitespace and other aliasing
+    if (primaryFontName.Equals(aFamily, nsCaseInsensitiveCStringComparator)) {
+      return glyphTable;
+    }
+  }
+  // Fall back to default Unicode table
+  return &mUnicodeTable;
+}
+
+// -----------------------------------------------------------------------------
+
+static nsresult InitCharGlobals() {
+  NS_ASSERTION(!gGlyphTableInitialized, "Error -- already initialized");
+  gGlyphTableInitialized = true;
+
+  // Allocate the placeholders for the preferred parts and variants
+  nsresult rv = NS_ERROR_OUT_OF_MEMORY;
+  RefPtr<nsGlyphTableList> glyphTableList = new nsGlyphTableList();
+  if (glyphTableList) {
+    rv = glyphTableList->Initialize();
+  }
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  // The gGlyphTableList has been successfully registered as a shutdown
+  // observer and will be deleted at shutdown. We now add some private
+  // per font-family tables for stretchy operators, in order of preference.
+  // Do not include the Unicode table in this list.
+  if (!glyphTableList->AddGlyphTable("STIXGeneral"_ns)) {
+    rv = NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  glyphTableList.forget(&gGlyphTableList);
+  return rv;
+}
+
+// -----------------------------------------------------------------------------
+// And now the implementation of nsMathMLChar
+
+nsMathMLChar::~nsMathMLChar() { MOZ_COUNT_DTOR(nsMathMLChar); }
+
+ComputedStyle* nsMathMLChar::GetComputedStyle() const {
+  NS_ASSERTION(mComputedStyle, "chars should always have a ComputedStyle");
+  return mComputedStyle;
+}
+
+void nsMathMLChar::SetComputedStyle(ComputedStyle* aComputedStyle) {
+  MOZ_ASSERT(aComputedStyle);
+  mComputedStyle = aComputedStyle;
+}
+
+void nsMathMLChar::SetData(nsString& aData) {
+  if (!gGlyphTableInitialized) {
+    InitCharGlobals();
+  }
+  mData = aData;
+  // some assumptions until proven otherwise
+  // note that mGlyph is not initialized
+  mDirection = NS_STRETCH_DIRECTION_UNSUPPORTED;
+  mBoundingMetrics = nsBoundingMetrics();
+  // check if stretching is applicable ...
+  if (gGlyphTableList && (1 == mData.Length())) {
+    mDirection = nsMathMLOperators::GetStretchyDirection(mData);
+    // default tentative table (not the one that is necessarily going
+    // to be used)
+  }
+}
+
+// -----------------------------------------------------------------------------
+/*
+ The Stretch:
+ @param aContainerSize - suggested size for the stretched char
+ @param aDesiredStretchSize - OUT parameter. The desired size
+ after stretching. If no stretching is done, the output will
+ simply give the base size.
+
+ How it works?
+ Summary:-
+ The Stretch() method first looks for a glyph of appropriate
+ size; If a glyph is found, it is cached by this object and
+ its size is returned in aDesiredStretchSize. The cached
+ glyph will then be used at the painting stage.
+ If no glyph of appropriate size is found, a search is made
+ to see if the char can be built by parts.
+
+ Details:-
+ A character gets stretched through the following pipeline :
+
+ 1) If the base size of the char is sufficient to cover the
+    container' size, we use that. If not, it will still be
+    used as a fallback if the other stages in the pipeline fail.
+    Issues :
+    a) The base size, the parts and the variants of a char can
+       be in different fonts. For eg., the base size for '(' should
+       come from a normal ascii font if CMEX10 is used, since CMEX10
+       only contains the stretched versions. Hence, there are two
+       ComputedStyles in use throughout the process. The leaf style
+       context of the char holds fonts with which to try to stretch
+       the char. The parent ComputedStyle of the char contains fonts
+       for normal rendering. So the parent context is the one used
+       to get the initial base size at the start of the pipeline.
+    b) For operators that can be largeop's in display mode,
+       we will skip the base size even if it fits, so that
+       the next stage in the pipeline is given a chance to find
+       a largeop variant. If the next stage fails, we fallback
+       to the base size.
+
+ 2) We search for the first larger variant of the char that fits the
+    container' size.  We first search for larger variants using the glyph
+    table corresponding to the first existing font specified in the list of
+    stretchy fonts held by the leaf ComputedStyle (from -moz-math-stretchy in
+    mathml.css).  Generic fonts are resolved by the preference
+    "font.mathfont-family".
+    Issues :
+    a) the largeop and display settings determine the starting
+       size when we do the above search, regardless of whether
+       smaller variants already fit the container' size.
+    b) if it is a largeopOnly request (i.e., a displaystyle operator
+       with largeop=true and stretchy=false), we break after finding
+       the first starting variant, regardless of whether that
+       variant fits the container's size.
+
+ 3) If a variant of appropriate size wasn't found, we see if the char
+    can be built by parts using the same glyph table.
+    Issue:
+       There are chars that have no middle and glue glyphs. For
+       such chars, the parts need to be joined using the rule.
+       By convention (TeXbook p.225), the descent of the parts is
+       zero while their ascent gives the thickness of the rule that
+       should be used to join them.
+
+ 4) If a match was not found in that glyph table, repeat from 2 to search the
+    ordered list of stretchy fonts for the first font with a glyph table that
+    provides a fit to the container size.  If no fit is found, the closest fit
+    is used.
+
+ Of note:
+ When the pipeline completes successfully, the desired size of the
+ stretched char can actually be slightly larger or smaller than
+ aContainerSize. But it is the responsibility of the caller to
+ account for the spacing when setting aContainerSize, and to leave
+ any extra margin when placing the stretched char.
+*/
+// -----------------------------------------------------------------------------
+
+// plain TeX settings (TeXbook p.152)
+#define NS_MATHML_DELIMITER_FACTOR 0.901f
+#define NS_MATHML_DELIMITER_SHORTFALL_POINTS 5.0f
+
+static bool IsSizeOK(nscoord a, nscoord b, uint32_t aHint) {
+  // Normal: True if 'a' is around +/-10% of the target 'b' (10% is
+  // 1-DelimiterFactor). This often gives a chance to the base size to
+  // win, especially in the context of sloppy markups without protective
+  // <mrow></mrow>
+  bool isNormal =
+      (aHint & NS_STRETCH_NORMAL) &&
+      Abs<float>(a - b) < (1.0f - NS_MATHML_DELIMITER_FACTOR) * float(b);
+
+  // Nearer: True if 'a' is around max{ +/-10% of 'b' , 'b' - 5pt },
+  // as documented in The TeXbook, Ch.17, p.152.
+  // i.e. within 10% and within 5pt
+  bool isNearer = false;
+  if (aHint & (NS_STRETCH_NEARER | NS_STRETCH_LARGEOP)) {
+    float c = std::max(float(b) * NS_MATHML_DELIMITER_FACTOR,
+                       float(b) - nsPresContext::CSSPointsToAppUnits(
+                                      NS_MATHML_DELIMITER_SHORTFALL_POINTS));
+    isNearer = Abs<float>(b - a) <= float(b) - c;
+  }
+
+  // Smaller: Mainly for transitory use, to compare two candidate
+  // choices
+  bool isSmaller = (aHint & NS_STRETCH_SMALLER) &&
+                   float(a) >= NS_MATHML_DELIMITER_FACTOR * float(b) && a <= b;
+
+  // Larger: Critical to the sqrt code to ensure that the radical
+  // size is tall enough
+  bool isLarger = (aHint & (NS_STRETCH_LARGER | NS_STRETCH_LARGEOP)) && a >= b;
+
+  return (isNormal || isSmaller || isNearer || isLarger);
+}
+
+static bool IsSizeBetter(nscoord a, nscoord olda, nscoord b, uint32_t aHint) {
+  if (0 == olda) return true;
+  if (aHint & (NS_STRETCH_LARGER | NS_STRETCH_LARGEOP))
+    return (a >= olda) ? (olda < b) : (a >= b);
+  if (aHint & NS_STRETCH_SMALLER) return (a <= olda) ? (olda > b) : (a <= b);
+
+  // XXXkt prob want log scale here i.e. 1.5 is closer to 1 than 0.5
+  return Abs(a - b) < Abs(olda - b);
+}
+
+// We want to place the glyphs even when they don't fit at their
+// full extent, i.e., we may clip to tolerate a small amount of
+// overlap between the parts. This is important to cater for fonts
+// with long glues.
+static nscoord ComputeSizeFromParts(nsPresContext* aPresContext,
+                                    nsGlyphCode* aGlyphs, nscoord* aSizes,
+                                    nscoord aTargetSize) {
+  enum { first, middle, last, glue };
+  // Add the parts that cannot be left out.
+  nscoord sum = 0;
+  for (int32_t i = first; i <= last; i++) {
+    sum += aSizes[i];
+  }
+
+  // Determine how much is used in joins
+  nscoord oneDevPixel = aPresContext->AppUnitsPerDevPixel();
+  int32_t joins = aGlyphs[middle] == aGlyphs[glue] ? 1 : 2;
+
+  // Pick a maximum size using a maximum number of glue glyphs that we are
+  // prepared to draw for one character.
+  const int32_t maxGlyphs = 1000;
+
+  // This also takes into account the fact that, if the glue has no size,
+  // then the character can't be lengthened.
+  nscoord maxSize = sum - 2 * joins * oneDevPixel + maxGlyphs * aSizes[glue];
+  if (maxSize < aTargetSize) return maxSize;  // settle with the maximum size
+
+  // Get the minimum allowable size using some flex.
+  nscoord minSize = NSToCoordRound(NS_MATHML_DELIMITER_FACTOR * sum);
+
+  if (minSize > aTargetSize) return minSize;  // settle with the minimum size
+
+  // Fill-up the target area
+  return aTargetSize;
+}
+
+// Update the font if there is a family change and returns the font group.
+bool nsMathMLChar::SetFontFamily(nsPresContext* aPresContext,
+                                 const nsGlyphTable* aGlyphTable,
+                                 const nsGlyphCode& aGlyphCode,
+                                 const StyleFontFamilyList& aDefaultFamilyList,
+                                 nsFont& aFont,
+                                 RefPtr<gfxFontGroup>* aFontGroup) {
+  StyleFontFamilyList glyphCodeFont;
+  if (aGlyphCode.font) {
+    glyphCodeFont = StyleFontFamilyList::WithOneUnquotedFamily(
+        aGlyphTable->FontNameFor(aGlyphCode));
+  }
+
+  const StyleFontFamilyList& familyList =
+      aGlyphCode.font ? glyphCodeFont : aDefaultFamilyList;
+
+  if (!*aFontGroup || aFont.family.families != familyList) {
+    nsFont font = aFont;
+    font.family.families = familyList;
+    const nsStyleFont* styleFont = mComputedStyle->StyleFont();
+    nsFontMetrics::Params params;
+    params.language = styleFont->mLanguage;
+    params.explicitLanguage = styleFont->mExplicitLanguage;
+    params.userFontSet = aPresContext->GetUserFontSet();
+    params.textPerf = aPresContext->GetTextPerfMetrics();
+    params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup();
+    RefPtr<nsFontMetrics> fm = aPresContext->GetMetricsFor(font, params);
+    // Set the font if it is an unicode table or if the same family name has
+    // been found.
+    const bool shouldSetFont = [&] {
+      if (aGlyphTable == &gGlyphTableList->mUnicodeTable) {
+        return true;
+      }
+
+      if (familyList.list.IsEmpty()) {
+        return false;
+      }
+
+      const auto& firstFontInList = familyList.list.AsSpan()[0];
+
+      RefPtr<gfxFont> firstFont = fm->GetThebesFontGroup()->GetFirstValidFont();
+      RefPtr<nsAtom> firstFontName =
+          NS_Atomize(firstFont->GetFontEntry()->FamilyName());
+
+      return firstFontInList.IsFamilyName() &&
+             firstFontInList.AsFamilyName().name.AsAtom() == firstFontName;
+    }();
+    if (!shouldSetFont) {
+      return false;
+    }
+    aFont.family.families = familyList;
+    *aFontGroup = fm->GetThebesFontGroup();
+  }
+  return true;
+}
+
+static nsBoundingMetrics MeasureTextRun(DrawTarget* aDrawTarget,
+                                        gfxTextRun* aTextRun) {
+  gfxTextRun::Metrics metrics =
+      aTextRun->MeasureText(gfxFont::TIGHT_HINTED_OUTLINE_EXTENTS, aDrawTarget);
+
+  nsBoundingMetrics bm;
+  bm.leftBearing = NSToCoordFloor(metrics.mBoundingBox.X());
+  bm.rightBearing = NSToCoordCeil(metrics.mBoundingBox.XMost());
+  bm.ascent = NSToCoordCeil(-metrics.mBoundingBox.Y());
+  bm.descent = NSToCoordCeil(metrics.mBoundingBox.YMost());
+  bm.width = NSToCoordRound(metrics.mAdvanceWidth);
+
+  return bm;
+}
+
+class nsMathMLChar::StretchEnumContext {
+ public:
+  StretchEnumContext(nsMathMLChar* aChar, nsPresContext* aPresContext,
+                     DrawTarget* aDrawTarget, float aFontSizeInflation,
+                     nsStretchDirection aStretchDirection, nscoord aTargetSize,
+                     uint32_t aStretchHint,
+                     nsBoundingMetrics& aStretchedMetrics,
+                     const StyleFontFamilyList& aFamilyList, bool& aGlyphFound)
+      : mChar(aChar),
+        mPresContext(aPresContext),
+        mDrawTarget(aDrawTarget),
+        mFontSizeInflation(aFontSizeInflation),
+        mDirection(aStretchDirection),
+        mTargetSize(aTargetSize),
+        mStretchHint(aStretchHint),
+        mBoundingMetrics(aStretchedMetrics),
+        mFamilyList(aFamilyList),
+        mTryVariants(true),
+        mTryParts(true),
+        mGlyphFound(aGlyphFound) {}
+
+  static bool EnumCallback(const StyleSingleFontFamily& aFamily, void* aData);
+
+ private:
+  bool TryVariants(nsGlyphTable* aGlyphTable, RefPtr<gfxFontGroup>* aFontGroup,
+                   const StyleFontFamilyList& aFamilyList);
+  bool TryParts(nsGlyphTable* aGlyphTable, RefPtr<gfxFontGroup>* aFontGroup,
+                const StyleFontFamilyList& aFamilyList);
+
+  nsMathMLChar* mChar;
+  nsPresContext* mPresContext;
+  DrawTarget* mDrawTarget;
+  float mFontSizeInflation;
+  const nsStretchDirection mDirection;
+  const nscoord mTargetSize;
+  const uint32_t mStretchHint;
+  nsBoundingMetrics& mBoundingMetrics;
+  // Font families to search
+  const StyleFontFamilyList& mFamilyList;
+
+ public:
+  bool mTryVariants;
+  bool mTryParts;
+
+ private:
+  AutoTArray<nsGlyphTable*, 16> mTablesTried;
+  bool& mGlyphFound;
+};
+
+// 2. See if there are any glyphs of the appropriate size.
+// Returns true if the size is OK, false to keep searching.
+// Always updates the char if a better match is found.
+bool nsMathMLChar::StretchEnumContext::TryVariants(
+    nsGlyphTable* aGlyphTable, RefPtr<gfxFontGroup>* aFontGroup,
+    const StyleFontFamilyList& aFamilyList) {
+  // Use our stretchy ComputedStyle now that stretching is in progress
+  ComputedStyle* sc = mChar->mComputedStyle;
+  nsFont font = sc->StyleFont()->mFont;
+  NormalizeDefaultFont(font, mFontSizeInflation);
+
+  bool isVertical = (mDirection == NS_STRETCH_DIRECTION_VERTICAL);
+  nscoord oneDevPixel = mPresContext->AppUnitsPerDevPixel();
+  char16_t uchar = mChar->mData[0];
+  bool largeop = (NS_STRETCH_LARGEOP & mStretchHint) != 0;
+  bool largeopOnly = largeop && (NS_STRETCH_VARIABLE_MASK & mStretchHint) == 0;
+  bool maxWidth = (NS_STRETCH_MAXWIDTH & mStretchHint) != 0;
+
+  nscoord bestSize =
+      isVertical ? mBoundingMetrics.ascent + mBoundingMetrics.descent
+                 : mBoundingMetrics.rightBearing - mBoundingMetrics.leftBearing;
+  bool haveBetter = false;
+
+  // start at size = 1 (size = 0 is the char at its normal size)
+  int32_t size = 1;
+  nsGlyphCode ch;
+  nscoord displayOperatorMinHeight = 0;
+  if (largeopOnly) {
+    NS_ASSERTION(isVertical, "Stretching should be in the vertical direction");
+    ch = aGlyphTable->BigOf(mDrawTarget, oneDevPixel, *aFontGroup, uchar,
+                            isVertical, 0);
+    if (ch.IsGlyphID()) {
+      RefPtr<gfxFont> mathFont = aFontGroup->get()->GetFirstMathFont();
+      // For OpenType MATH fonts, we will rely on the DisplayOperatorMinHeight
+      // to select the right size variant. Note that the value is sometimes too
+      // small so we use kLargeOpFactor/kIntegralFactor as a minimum value.
+      if (mathFont) {
+        displayOperatorMinHeight = mathFont->MathTable()->Constant(
+            gfxMathTable::DisplayOperatorMinHeight, oneDevPixel);
+        RefPtr<gfxTextRun> textRun =
+            aGlyphTable->MakeTextRun(mDrawTarget, oneDevPixel, *aFontGroup, ch);
+        nsBoundingMetrics bm = MeasureTextRun(mDrawTarget, textRun.get());
+        float largeopFactor = kLargeOpFactor;
+        if (nsMathMLOperators::IsIntegralOperator(mChar->mData)) {
+          // integrals are drawn taller
+          largeopFactor = kIntegralFactor;
+        }
+        nscoord minHeight = largeopFactor * (bm.ascent + bm.descent);
+        if (displayOperatorMinHeight < minHeight) {
+          displayOperatorMinHeight = minHeight;
+        }
+      }
+    }
+  }
+#ifdef NOISY_SEARCH
+  printf("  searching in %s ...\n", NS_LossyConvertUTF16toASCII(aFamily).get());
+#endif
+  while ((ch = aGlyphTable->BigOf(mDrawTarget, oneDevPixel, *aFontGroup, uchar,
+                                  isVertical, size))
+             .Exists()) {
+    if (!mChar->SetFontFamily(mPresContext, aGlyphTable, ch, aFamilyList, font,
+                              aFontGroup)) {
+      // if largeopOnly is set, break now
+      if (largeopOnly) break;
+      ++size;
+      continue;
+    }
+
+    RefPtr<gfxTextRun> textRun =
+        aGlyphTable->MakeTextRun(mDrawTarget, oneDevPixel, *aFontGroup, ch);
+    nsBoundingMetrics bm = MeasureTextRun(mDrawTarget, textRun.get());
+    if (ch.IsGlyphID()) {
+      RefPtr<gfxFont> mathFont = aFontGroup->get()->GetFirstMathFont();
+      if (mathFont) {
+        // MeasureTextRun should have set the advance width to the right
+        // bearing for OpenType MATH fonts. We now subtract the italic
+        // correction, so that nsMathMLmmultiscripts will place the scripts
+        // correctly.
+        // Note that STIX-Word does not provide italic corrections but its
+        // advance widths do not match right bearings.
+        // (http://sourceforge.net/p/stixfonts/tracking/50/)
+        gfxFloat italicCorrection =
+            mathFont->MathTable()->ItalicsCorrection(ch.glyphID);
+        if (italicCorrection) {
+          bm.width -= NSToCoordRound(italicCorrection * oneDevPixel);
+          if (bm.width < 0) {
+            bm.width = 0;
+          }
+        }
+      }
+    }
+
+    nscoord charSize =
+        isVertical ? bm.ascent + bm.descent : bm.rightBearing - bm.leftBearing;
+
+    if (largeopOnly ||
+        IsSizeBetter(charSize, bestSize, mTargetSize, mStretchHint)) {
+      mGlyphFound = true;
+      if (maxWidth) {
+        // IsSizeBetter() checked that charSize < maxsize;
+        // Leave ascent, descent, and bestsize as these contain maxsize.
+        if (mBoundingMetrics.width < bm.width)
+          mBoundingMetrics.width = bm.width;
+        if (mBoundingMetrics.leftBearing > bm.leftBearing)
+          mBoundingMetrics.leftBearing = bm.leftBearing;
+        if (mBoundingMetrics.rightBearing < bm.rightBearing)
+          mBoundingMetrics.rightBearing = bm.rightBearing;
+        // Continue to check other sizes unless largeopOnly
+        haveBetter = largeopOnly;
+      } else {
+        mBoundingMetrics = bm;
+        haveBetter = true;
+        bestSize = charSize;
+        mChar->mGlyphs[0] = std::move(textRun);
+        mChar->mDraw = DRAW_VARIANT;
+      }
+#ifdef NOISY_SEARCH
+      printf("    size:%d Current best\n", size);
+#endif
+    } else {
+#ifdef NOISY_SEARCH
+      printf("    size:%d Rejected!\n", size);
+#endif
+      if (haveBetter) break;  // Not making an futher progress, stop searching
+    }
+
+    // If this a largeop only operator, we stop if the glyph is large enough.
+    if (largeopOnly && (bm.ascent + bm.descent) >= displayOperatorMinHeight) {
+      break;
+    }
+    ++size;
+  }
+
+  return haveBetter &&
+         (largeopOnly || IsSizeOK(bestSize, mTargetSize, mStretchHint));
+}
+
+// 3. Build by parts.
+// Returns true if the size is OK, false to keep searching.
+// Always updates the char if a better match is found.
+bool nsMathMLChar::StretchEnumContext::TryParts(
+    nsGlyphTable* aGlyphTable, RefPtr<gfxFontGroup>* aFontGroup,
+    const StyleFontFamilyList& aFamilyList) {
+  // Use our stretchy ComputedStyle now that stretching is in progress
+  nsFont font = mChar->mComputedStyle->StyleFont()->mFont;
+  NormalizeDefaultFont(font, mFontSizeInflation);
+
+  // Compute the bounding metrics of all partial glyphs
+  RefPtr<gfxTextRun> textRun[4];
+  nsGlyphCode chdata[4];
+  nsBoundingMetrics bmdata[4];
+  nscoord sizedata[4];
+
+  bool isVertical = (mDirection == NS_STRETCH_DIRECTION_VERTICAL);
+  nscoord oneDevPixel = mPresContext->AppUnitsPerDevPixel();
+  char16_t uchar = mChar->mData[0];
+  bool maxWidth = (NS_STRETCH_MAXWIDTH & mStretchHint) != 0;
+  if (!aGlyphTable->HasPartsOf(mDrawTarget, oneDevPixel, *aFontGroup, uchar,
+                               isVertical))
+    return false;  // to next table
+
+  for (int32_t i = 0; i < 4; i++) {
+    nsGlyphCode ch = aGlyphTable->ElementAt(mDrawTarget, oneDevPixel,
+                                            *aFontGroup, uchar, isVertical, i);
+    chdata[i] = ch;
+    if (ch.Exists()) {
+      if (!mChar->SetFontFamily(mPresContext, aGlyphTable, ch, aFamilyList,
+                                font, aFontGroup))
+        return false;
+
+      textRun[i] =
+          aGlyphTable->MakeTextRun(mDrawTarget, oneDevPixel, *aFontGroup, ch);
+      nsBoundingMetrics bm = MeasureTextRun(mDrawTarget, textRun[i].get());
+      bmdata[i] = bm;
+      sizedata[i] = isVertical ? bm.ascent + bm.descent
+                               : bm.rightBearing - bm.leftBearing;
+    } else {
+      // Null glue indicates that a rule will be drawn, which can stretch to
+      // fill any space.
+      textRun[i] = nullptr;
+      bmdata[i] = nsBoundingMetrics();
+      sizedata[i] = i == 3 ? mTargetSize : 0;
+    }
+  }
+
+  // For the Unicode table, we check that all the glyphs are actually found and
+  // come from the same font.
+  if (aGlyphTable == &gGlyphTableList->mUnicodeTable) {
+    gfxFont* unicodeFont = nullptr;
+    for (int32_t i = 0; i < 4; i++) {
+      if (!textRun[i]) {
+        continue;
+      }
+      if (textRun[i]->GetLength() != 1 ||
+          textRun[i]->GetCharacterGlyphs()[0].IsMissing()) {
+        return false;
+      }
+      uint32_t numGlyphRuns;
+      const gfxTextRun::GlyphRun* glyphRuns =
+          textRun[i]->GetGlyphRuns(&numGlyphRuns);
+      if (numGlyphRuns != 1) {
+        return false;
+      }
+      if (!unicodeFont) {
+        unicodeFont = glyphRuns[0].mFont;
+      } else if (unicodeFont != glyphRuns[0].mFont) {
+        return false;
+      }
+    }
+  }
+
+  // Build by parts if we have successfully computed the
+  // bounding metrics of all parts.
+  nscoord computedSize =
+      ComputeSizeFromParts(mPresContext, chdata, sizedata, mTargetSize);
+
+  nscoord currentSize =
+      isVertical ? mBoundingMetrics.ascent + mBoundingMetrics.descent
+                 : mBoundingMetrics.rightBearing - mBoundingMetrics.leftBearing;
+
+  if (!IsSizeBetter(computedSize, currentSize, mTargetSize, mStretchHint)) {
+#ifdef NOISY_SEARCH
+    printf("    Font %s Rejected!\n",
+           NS_LossyConvertUTF16toASCII(fontName).get());
+#endif
+    return false;  // to next table
+  }
+
+#ifdef NOISY_SEARCH
+  printf("    Font %s Current best!\n",
+         NS_LossyConvertUTF16toASCII(fontName).get());
+#endif
+
+  // The computed size is the best we have found so far...
+  // now is the time to compute and cache our bounding metrics
+  if (isVertical) {
+    int32_t i;
+    // Try and find the first existing part and then determine the extremal
+    // horizontal metrics of the parts.
+    for (i = 0; i <= 3 && !textRun[i]; i++)
+      ;
+    if (i == 4) {
+      NS_ERROR("Cannot stretch - All parts missing");
+      return false;
+    }
+    nscoord lbearing = bmdata[i].leftBearing;
+    nscoord rbearing = bmdata[i].rightBearing;
+    nscoord width = bmdata[i].width;
+    i++;
+    for (; i <= 3; i++) {
+      if (!textRun[i]) continue;
+      lbearing = std::min(lbearing, bmdata[i].leftBearing);
+      rbearing = std::max(rbearing, bmdata[i].rightBearing);
+      width = std::max(width, bmdata[i].width);
+    }
+    if (maxWidth) {
+      lbearing = std::min(lbearing, mBoundingMetrics.leftBearing);
+      rbearing = std::max(rbearing, mBoundingMetrics.rightBearing);
+      width = std::max(width, mBoundingMetrics.width);
+    }
+    mBoundingMetrics.width = width;
+    // When maxWidth, updating ascent and descent indicates that no characters
+    // larger than this character's minimum size need to be checked as they
+    // will not be used.
+    mBoundingMetrics.ascent = bmdata[0].ascent;  // not used except with descent
+                                                 // for height
+    mBoundingMetrics.descent = computedSize - mBoundingMetrics.ascent;
+    mBoundingMetrics.leftBearing = lbearing;
+    mBoundingMetrics.rightBearing = rbearing;
+  } else {
+    int32_t i;
+    // Try and find the first existing part and then determine the extremal
+    // vertical metrics of the parts.
+    for (i = 0; i <= 3 && !textRun[i]; i++)
+      ;
+    if (i == 4) {
+      NS_ERROR("Cannot stretch - All parts missing");
+      return false;
+    }
+    nscoord ascent = bmdata[i].ascent;
+    nscoord descent = bmdata[i].descent;
+    i++;
+    for (; i <= 3; i++) {
+      if (!textRun[i]) continue;
+      ascent = std::max(ascent, bmdata[i].ascent);
+      descent = std::max(descent, bmdata[i].descent);
+    }
+    mBoundingMetrics.width = computedSize;
+    mBoundingMetrics.ascent = ascent;
+    mBoundingMetrics.descent = descent;
+    mBoundingMetrics.leftBearing = 0;
+    mBoundingMetrics.rightBearing = computedSize;
+  }
+  mGlyphFound = true;
+  if (maxWidth) return false;  // Continue to check other sizes
+
+  // reset
+  mChar->mDraw = DRAW_PARTS;
+  for (int32_t i = 0; i < 4; i++) {
+    mChar->mGlyphs[i] = std::move(textRun[i]);
+    mChar->mBmData[i] = bmdata[i];
+  }
+
+  return IsSizeOK(computedSize, mTargetSize, mStretchHint);
+}
+
+// Returns true iff stretching succeeded with the given family.
+// This is called for each family, whether it exists or not.
+bool nsMathMLChar::StretchEnumContext::EnumCallback(
+    const StyleSingleFontFamily& aFamily, void* aData) {
+  StretchEnumContext* context = static_cast<StretchEnumContext*>(aData);
+
+  // for comparisons, force use of unquoted names
+  StyleFontFamilyList family;
+  if (aFamily.IsFamilyName()) {
+    family = StyleFontFamilyList::WithOneUnquotedFamily(
+        nsAtomCString(aFamily.AsFamilyName().name.AsAtom()));
+  }
+
+  // Check font family if it is not a generic one
+  // We test with the kNullGlyph
+  ComputedStyle* sc = context->mChar->mComputedStyle;
+  nsFont font = sc->StyleFont()->mFont;
+  NormalizeDefaultFont(font, context->mFontSizeInflation);
+  RefPtr<gfxFontGroup> fontGroup;
+  if (!aFamily.IsGeneric() &&
+      !context->mChar->SetFontFamily(context->mPresContext, nullptr, kNullGlyph,
+                                     family, font, &fontGroup)) {
+    return false;  // Could not set the family
+  }
+
+  // Determine the glyph table to use for this font.
+  UniquePtr<nsOpenTypeTable> openTypeTable;
+  nsGlyphTable* glyphTable;
+  if (aFamily.IsGeneric()) {
+    // This is a generic font, use the Unicode table.
+    glyphTable = &gGlyphTableList->mUnicodeTable;
+  } else {
+    // If the font contains an Open Type MATH table, use it.
+    RefPtr<gfxFont> font = fontGroup->GetFirstValidFont();
+    openTypeTable = nsOpenTypeTable::Create(font);
+    if (openTypeTable) {
+      glyphTable = openTypeTable.get();
+    } else if (StaticPrefs::mathml_stixgeneral_operator_stretching_disabled()) {
+      glyphTable = &gGlyphTableList->mUnicodeTable;
+    } else {
+      // Otherwise try to find a .properties file corresponding to that font
+      // family or fallback to the Unicode table.
+      glyphTable = gGlyphTableList->GetGlyphTableFor(
+          nsAtomCString(aFamily.AsFamilyName().name.AsAtom()));
+    }
+  }
+
+  if (!openTypeTable) {
+    if (context->mTablesTried.Contains(glyphTable))
+      return false;  // already tried this one
+
+    // Only try this table once.
+    context->mTablesTried.AppendElement(glyphTable);
+  }
+
+  // If the unicode table is being used, then search all font families.  If a
+  // special table is being used then the font in this family should have the
+  // specified glyphs.
+  const StyleFontFamilyList& familyList =
+      glyphTable == &gGlyphTableList->mUnicodeTable ? context->mFamilyList
+                                                    : family;
+
+  return (context->mTryVariants &&
+          context->TryVariants(glyphTable, &fontGroup, familyList)) ||
+         (context->mTryParts &&
+          context->TryParts(glyphTable, &fontGroup, familyList));
+}
+
+static void AppendFallbacks(nsTArray<StyleSingleFontFamily>& aNames,
+                            const nsTArray<nsCString>& aFallbacks) {
+  for (const nsCString& fallback : aFallbacks) {
+    aNames.AppendElement(StyleSingleFontFamily::FamilyName(
+        StyleFamilyName{StyleAtom(NS_Atomize(fallback)),
+                        StyleFontFamilyNameSyntax::Identifiers}));
+  }
+}
+
+// insert math fallback families just before the first generic or at the end
+// when no generic present
+static void InsertMathFallbacks(StyleFontFamilyList& aFamilyList,
+                                nsTArray<nsCString>& aFallbacks) {
+  nsTArray<StyleSingleFontFamily> mergedList;
+
+  bool inserted = false;
+  for (const auto& name : aFamilyList.list.AsSpan()) {
+    if (!inserted && name.IsGeneric()) {
+      inserted = true;
+      AppendFallbacks(mergedList, aFallbacks);
+    }
+    mergedList.AppendElement(name);
+  }
+
+  if (!inserted) {
+    AppendFallbacks(mergedList, aFallbacks);
+  }
+  aFamilyList = StyleFontFamilyList::WithNames(std::move(mergedList));
+}
+
+nsresult nsMathMLChar::StretchInternal(
+    nsIFrame* aForFrame, DrawTarget* aDrawTarget, float aFontSizeInflation,
+    nsStretchDirection& aStretchDirection,
+    const nsBoundingMetrics& aContainerSize,
+    nsBoundingMetrics& aDesiredStretchSize, uint32_t aStretchHint,
+    // These are currently only used when
+    // aStretchHint & NS_STRETCH_MAXWIDTH:
+    float aMaxSize, bool aMaxSizeIsAbsolute) {
+  nsPresContext* presContext = aForFrame->PresContext();
+
+  // if we have been called before, and we didn't actually stretch, our
+  // direction may have been set to NS_STRETCH_DIRECTION_UNSUPPORTED.
+  // So first set our direction back to its instrinsic value
+  nsStretchDirection direction = nsMathMLOperators::GetStretchyDirection(mData);
+
+  // Set default font and get the default bounding metrics
+  // mComputedStyle is a leaf context used only when stretching happens.
+  // For the base size, the default font should come from the parent context
+  nsFont font = aForFrame->StyleFont()->mFont;
+  NormalizeDefaultFont(font, aFontSizeInflation);
+
+  const nsStyleFont* styleFont = mComputedStyle->StyleFont();
+  nsFontMetrics::Params params;
+  params.language = styleFont->mLanguage;
+  params.explicitLanguage = styleFont->mExplicitLanguage;
+  params.userFontSet = presContext->GetUserFontSet();
+  params.textPerf = presContext->GetTextPerfMetrics();
+  RefPtr<nsFontMetrics> fm = presContext->GetMetricsFor(font, params);
+  uint32_t len = uint32_t(mData.Length());
+  mGlyphs[0] = fm->GetThebesFontGroup()->MakeTextRun(
+      static_cast<const char16_t*>(mData.get()), len, aDrawTarget,
+      presContext->AppUnitsPerDevPixel(), gfx::ShapedTextFlags(),
+      nsTextFrameUtils::Flags(), presContext->MissingFontRecorder());
+  aDesiredStretchSize = MeasureTextRun(aDrawTarget, mGlyphs[0].get());
+
+  bool maxWidth = (NS_STRETCH_MAXWIDTH & aStretchHint) != 0;
+  if (!maxWidth) {
+    mUnscaledAscent = aDesiredStretchSize.ascent;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // 1. Check the common situations where stretching is not actually needed
+  //////////////////////////////////////////////////////////////////////////////
+
+  // quick return if there is nothing special about this char
+  if ((aStretchDirection != direction &&
+       aStretchDirection != NS_STRETCH_DIRECTION_DEFAULT) ||
+      (aStretchHint & ~NS_STRETCH_MAXWIDTH) == NS_STRETCH_NONE) {
+    mDirection = NS_STRETCH_DIRECTION_UNSUPPORTED;
+    return NS_OK;
+  }
+
+  // if no specified direction, attempt to stretch in our preferred direction
+  if (aStretchDirection == NS_STRETCH_DIRECTION_DEFAULT) {
+    aStretchDirection = direction;
+  }
+
+  // see if this is a particular largeop or largeopOnly request
+  bool largeop = (NS_STRETCH_LARGEOP & aStretchHint) != 0;
+  bool stretchy = (NS_STRETCH_VARIABLE_MASK & aStretchHint) != 0;
+  bool largeopOnly = largeop && !stretchy;
+
+  bool isVertical = (direction == NS_STRETCH_DIRECTION_VERTICAL);
+
+  nscoord targetSize =
+      isVertical ? aContainerSize.ascent + aContainerSize.descent
+                 : aContainerSize.rightBearing - aContainerSize.leftBearing;
+
+  if (maxWidth) {
+    // See if it is only necessary to consider glyphs up to some maximum size.
+    // Set the current height to the maximum size, and set aStretchHint to
+    // NS_STRETCH_SMALLER if the size is variable, so that only smaller sizes
+    // are considered.  targetSize from GetMaxWidth() is 0.
+    if (stretchy) {
+      // variable size stretch - consider all sizes < maxsize
+      aStretchHint =
+          (aStretchHint & ~NS_STRETCH_VARIABLE_MASK) | NS_STRETCH_SMALLER;
+    }
+
+    // Use NS_MATHML_DELIMITER_FACTOR to allow some slightly larger glyphs as
+    // maxsize is not enforced exactly.
+    if (aMaxSize == NS_MATHML_OPERATOR_SIZE_INFINITY) {
+      aDesiredStretchSize.ascent = nscoord_MAX;
+      aDesiredStretchSize.descent = 0;
+    } else {
+      nscoord height = aDesiredStretchSize.ascent + aDesiredStretchSize.descent;
+      if (height == 0) {
+        if (aMaxSizeIsAbsolute) {
+          aDesiredStretchSize.ascent =
+              NSToCoordRound(aMaxSize / NS_MATHML_DELIMITER_FACTOR);
+          aDesiredStretchSize.descent = 0;
+        }
+        // else: leave height as 0
+      } else {
+        float scale = aMaxSizeIsAbsolute ? aMaxSize / height : aMaxSize;
+        scale /= NS_MATHML_DELIMITER_FACTOR;
+        aDesiredStretchSize.ascent =
+            NSToCoordRound(scale * aDesiredStretchSize.ascent);
+        aDesiredStretchSize.descent =
+            NSToCoordRound(scale * aDesiredStretchSize.descent);
+      }
+    }
+  }
+
+  nsBoundingMetrics initialSize = aDesiredStretchSize;
+  nscoord charSize = isVertical
+                         ? initialSize.ascent + initialSize.descent
+                         : initialSize.rightBearing - initialSize.leftBearing;
+
+  bool done = false;
+
+  if (!maxWidth && !largeop) {
+    // Doing Stretch() not GetMaxWidth(),
+    // and not a largeop in display mode; we're done if size fits
+    if ((targetSize <= 0) || ((isVertical && charSize >= targetSize) ||
+                              IsSizeOK(charSize, targetSize, aStretchHint)))
+      done = true;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // 2/3. Search for a glyph or set of part glyphs of appropriate size
+  //////////////////////////////////////////////////////////////////////////////
+
+  bool glyphFound = false;
+
+  if (!done) {  // normal case
+    // Use the css font-family but add preferred fallback fonts.
+    font = mComputedStyle->StyleFont()->mFont;
+    NormalizeDefaultFont(font, aFontSizeInflation);
+
+    // really shouldn't be doing things this way but for now
+    // insert fallbacks into the list
+    AutoTArray<nsCString, 16> mathFallbacks;
+    nsAutoCString value;
+    gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+    pfl->Lock();
+    if (pfl->GetFontPrefs()->LookupName("serif.x-math"_ns, value)) {
+      gfxFontUtils::ParseFontList(value, mathFallbacks);
+    }
+    if (pfl->GetFontPrefs()->LookupNameList("serif.x-math"_ns, value)) {
+      gfxFontUtils::ParseFontList(value, mathFallbacks);
+    }
+    pfl->Unlock();
+    InsertMathFallbacks(font.family.families, mathFallbacks);
+
+#ifdef NOISY_SEARCH
+    nsAutoString fontlistStr;
+    font.fontlist.ToString(fontlistStr, false, true);
+    printf(
+        "Searching in " % s " for a glyph of appropriate size for: 0x%04X:%c\n",
+        NS_ConvertUTF16toUTF8(fontlistStr).get(), mData[0], mData[0] & 0x00FF);
+#endif
+    StretchEnumContext enumData(this, presContext, aDrawTarget,
+                                aFontSizeInflation, aStretchDirection,
+                                targetSize, aStretchHint, aDesiredStretchSize,
+                                font.family.families, glyphFound);
+    enumData.mTryParts = !largeopOnly;
+
+    for (const StyleSingleFontFamily& name :
+         font.family.families.list.AsSpan()) {
+      if (StretchEnumContext::EnumCallback(name, &enumData)) {
+        if (name.IsNamedFamily(u"STIXGeneral"_ns)) {
+          AutoTArray<nsString, 1> params{
+              u"https://developer.mozilla.org/docs/Mozilla/"
+              "MathML_Project/Fonts"_ns};
+          aForFrame->PresContext()->Document()->WarnOnceAbout(
+              dom::DeprecatedOperations::
+                  eMathML_DeprecatedStixgeneralOperatorStretching,
+              false, params);
+        }
+        break;
+      }
+    }
+  }
+
+  if (!maxWidth) {
+    // Now, we know how we are going to draw the char. Update the member
+    // variables accordingly.
+    mUnscaledAscent = aDesiredStretchSize.ascent;
+  }
+
+  if (glyphFound) {
+    return NS_OK;
+  }
+
+  // We did not find a size variant or a glyph assembly to stretch this
+  // operator. Verify whether a font with an OpenType MATH table is available
+  // and record missing math script otherwise.
+  gfxMissingFontRecorder* MFR = presContext->MissingFontRecorder();
+  RefPtr<gfxFont> firstMathFont = fm->GetThebesFontGroup()->GetFirstMathFont();
+  if (MFR && !firstMathFont) {
+    MFR->RecordScript(intl::Script::MATHEMATICAL_NOTATION);
+  }
+
+  // If the scale_stretchy_operators option is disabled, we are done.
+  if (!Preferences::GetBool("mathml.scale_stretchy_operators.enabled", true)) {
+    return NS_OK;
+  }
+
+  // stretchy character
+  if (stretchy) {
+    if (isVertical) {
+      float scale = std::min(
+          kMaxScaleFactor,
+          float(aContainerSize.ascent + aContainerSize.descent) /
+              (aDesiredStretchSize.ascent + aDesiredStretchSize.descent));
+      if (!largeop || scale > 1.0) {
+        // make the character match the desired height.
+        if (!maxWidth) {
+          mScaleY *= scale;
+        }
+        aDesiredStretchSize.ascent *= scale;
+        aDesiredStretchSize.descent *= scale;
+      }
+    } else {
+      float scale = std::min(
+          kMaxScaleFactor,
+          float(aContainerSize.rightBearing - aContainerSize.leftBearing) /
+              (aDesiredStretchSize.rightBearing -
+               aDesiredStretchSize.leftBearing));
+      if (!largeop || scale > 1.0) {
+        // make the character match the desired width.
+        if (!maxWidth) {
+          mScaleX *= scale;
+        }
+        aDesiredStretchSize.leftBearing *= scale;
+        aDesiredStretchSize.rightBearing *= scale;
+        aDesiredStretchSize.width *= scale;
+      }
+    }
+  }
+
+  // We do not have a char variant for this largeop in display mode, so we
+  // apply a scale transform to the base char.
+  if (largeop) {
+    float scale;
+    float largeopFactor = kLargeOpFactor;
+
+    // increase the width if it is not largeopFactor times larger
+    // than the initial one.
+    if ((aDesiredStretchSize.rightBearing - aDesiredStretchSize.leftBearing) <
+        largeopFactor * (initialSize.rightBearing - initialSize.leftBearing)) {
+      scale =
+          (largeopFactor *
+           (initialSize.rightBearing - initialSize.leftBearing)) /
+          (aDesiredStretchSize.rightBearing - aDesiredStretchSize.leftBearing);
+      if (!maxWidth) {
+        mScaleX *= scale;
+      }
+      aDesiredStretchSize.leftBearing *= scale;
+      aDesiredStretchSize.rightBearing *= scale;
+      aDesiredStretchSize.width *= scale;
+    }
+
+    // increase the height if it is not largeopFactor times larger
+    // than the initial one.
+    if (nsMathMLOperators::IsIntegralOperator(mData)) {
+      // integrals are drawn taller
+      largeopFactor = kIntegralFactor;
+    }
+    if ((aDesiredStretchSize.ascent + aDesiredStretchSize.descent) <
+        largeopFactor * (initialSize.ascent + initialSize.descent)) {
+      scale = (largeopFactor * (initialSize.ascent + initialSize.descent)) /
+              (aDesiredStretchSize.ascent + aDesiredStretchSize.descent);
+      if (!maxWidth) {
+        mScaleY *= scale;
+      }
+      aDesiredStretchSize.ascent *= scale;
+      aDesiredStretchSize.descent *= scale;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMathMLChar::Stretch(nsIFrame* aForFrame, DrawTarget* aDrawTarget,
+                               float aFontSizeInflation,
+                               nsStretchDirection aStretchDirection,
+                               const nsBoundingMetrics& aContainerSize,
+                               nsBoundingMetrics& aDesiredStretchSize,
+                               uint32_t aStretchHint, bool aRTL) {
+  NS_ASSERTION(
+      !(aStretchHint & ~(NS_STRETCH_VARIABLE_MASK | NS_STRETCH_LARGEOP)),
+      "Unexpected stretch flags");
+
+  mDraw = DRAW_NORMAL;
+  mMirrored = aRTL && nsMathMLOperators::IsMirrorableOperator(mData);
+  mScaleY = mScaleX = 1.0;
+  mDirection = aStretchDirection;
+  nsresult rv =
+      StretchInternal(aForFrame, aDrawTarget, aFontSizeInflation, mDirection,
+                      aContainerSize, aDesiredStretchSize, aStretchHint);
+
+  // Record the metrics
+  mBoundingMetrics = aDesiredStretchSize;
+
+  return rv;
+}
+
+// What happens here is that the StretchInternal algorithm is used but
+// modified by passing the NS_STRETCH_MAXWIDTH stretch hint.  That causes
+// StretchInternal to return horizontal bounding metrics that are the maximum
+// that might be returned from a Stretch.
+//
+// In order to avoid considering widths of some characters in fonts that will
+// not be used for any stretch size, StretchInternal sets the initial height
+// to infinity and looks for any characters smaller than this height.  When a
+// character built from parts is considered, (it will be used by Stretch for
+// any characters greater than its minimum size, so) the height is set to its
+// minimum size, so that only widths of smaller subsequent characters are
+// considered.
+nscoord nsMathMLChar::GetMaxWidth(nsIFrame* aForFrame, DrawTarget* aDrawTarget,
+                                  float aFontSizeInflation,
+                                  uint32_t aStretchHint) {
+  nsBoundingMetrics bm;
+  nsStretchDirection direction = NS_STRETCH_DIRECTION_VERTICAL;
+  const nsBoundingMetrics container;  // zero target size
+
+  StretchInternal(aForFrame, aDrawTarget, aFontSizeInflation, direction,
+                  container, bm, aStretchHint | NS_STRETCH_MAXWIDTH);
+
+  return std::max(bm.width, bm.rightBearing) - std::min(0, bm.leftBearing);
+}
+
+namespace mozilla {
+
+class nsDisplayMathMLSelectionRect final : public nsPaintedDisplayItem {
+ public:
+  nsDisplayMathMLSelectionRect(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
+                               const nsRect& aRect)
+      : nsPaintedDisplayItem(aBuilder, aFrame), mRect(aRect) {
+    MOZ_COUNT_CTOR(nsDisplayMathMLSelectionRect);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayMathMLSelectionRect)
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+  NS_DISPLAY_DECL_NAME("MathMLSelectionRect", TYPE_MATHML_SELECTION_RECT)
+ private:
+  nsRect mRect;
+};
+
+void nsDisplayMathMLSelectionRect::Paint(nsDisplayListBuilder* aBuilder,
+                                         gfxContext* aCtx) {
+  DrawTarget* drawTarget = aCtx->GetDrawTarget();
+  Rect rect = NSRectToSnappedRect(mRect + ToReferenceFrame(),
+                                  mFrame->PresContext()->AppUnitsPerDevPixel(),
+                                  *drawTarget);
+  // get color to use for selection from the look&feel object
+  nscolor bgColor = LookAndFeel::Color(LookAndFeel::ColorID::Highlight, mFrame);
+  drawTarget->FillRect(rect, ColorPattern(ToDeviceColor(bgColor)));
+}
+
+class nsDisplayMathMLCharForeground final : public nsPaintedDisplayItem {
+ public:
+  nsDisplayMathMLCharForeground(nsDisplayListBuilder* aBuilder,
+                                nsIFrame* aFrame, nsMathMLChar* aChar,
+                                const bool aIsSelected)
+      : nsPaintedDisplayItem(aBuilder, aFrame),
+        mChar(aChar),
+        mIsSelected(aIsSelected) {
+    MOZ_COUNT_CTOR(nsDisplayMathMLCharForeground);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayMathMLCharForeground)
+
+  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
+                           bool* aSnap) const override {
+    *aSnap = false;
+    nsRect rect;
+    mChar->GetRect(rect);
+    nsPoint offset = ToReferenceFrame() + rect.TopLeft();
+    nsBoundingMetrics bm;
+    mChar->GetBoundingMetrics(bm);
+    nsRect temp(offset.x + bm.leftBearing, offset.y,
+                bm.rightBearing - bm.leftBearing, bm.ascent + bm.descent);
+    // Bug 748220
+    temp.Inflate(mFrame->PresContext()->AppUnitsPerDevPixel());
+    return temp;
+  }
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder,
+                     gfxContext* aCtx) override {
+    mChar->PaintForeground(mFrame, *aCtx, ToReferenceFrame(), mIsSelected);
+  }
+
+  NS_DISPLAY_DECL_NAME("MathMLCharForeground", TYPE_MATHML_CHAR_FOREGROUND)
+
+  virtual nsRect GetComponentAlphaBounds(
+      nsDisplayListBuilder* aBuilder) const override {
+    bool snap;
+    return GetBounds(aBuilder, &snap);
+  }
+
+ private:
+  nsMathMLChar* mChar;
+  bool mIsSelected;
+};
+
+#ifdef DEBUG
+class nsDisplayMathMLCharDebug final : public nsPaintedDisplayItem {
+ public:
+  nsDisplayMathMLCharDebug(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
+                           const nsRect& aRect)
+      : nsPaintedDisplayItem(aBuilder, aFrame), mRect(aRect) {
+    MOZ_COUNT_CTOR(nsDisplayMathMLCharDebug);
+  }
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayMathMLCharDebug)
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+  NS_DISPLAY_DECL_NAME("MathMLCharDebug", TYPE_MATHML_CHAR_DEBUG)
+
+ private:
+  nsRect mRect;
+};
+
+void nsDisplayMathMLCharDebug::Paint(nsDisplayListBuilder* aBuilder,
+                                     gfxContext* aCtx) {
+  // for visual debug
+  Sides skipSides;
+  nsPresContext* presContext = mFrame->PresContext();
+  ComputedStyle* computedStyle = mFrame->Style();
+  nsRect rect = mRect + ToReferenceFrame();
+
+  PaintBorderFlags flags = aBuilder->ShouldSyncDecodeImages()
+                               ? PaintBorderFlags::SyncDecodeImages
+                               : PaintBorderFlags();
+
+  // Since this is used only for debugging, we don't need to worry about
+  // tracking the ImgDrawResult.
+  Unused << nsCSSRendering::PaintBorder(presContext, *aCtx, mFrame,
+                                        GetPaintRect(aBuilder, aCtx), rect,
+                                        computedStyle, flags, skipSides);
+
+  nsCSSRendering::PaintNonThemedOutline(presContext, *aCtx, mFrame,
+                                        GetPaintRect(aBuilder, aCtx), rect,
+                                        computedStyle);
+}
+#endif
+
+}  // namespace mozilla
+
+void nsMathMLChar::Display(nsDisplayListBuilder* aBuilder, nsIFrame* aForFrame,
+                           const nsDisplayListSet& aLists, uint32_t aIndex,
+                           const nsRect* aSelectedRect) {
+  ComputedStyle* computedStyle = mComputedStyle;
+  if (!computedStyle->StyleVisibility()->IsVisible()) {
+    return;
+  }
+
+  const bool isSelected = aSelectedRect && !aSelectedRect->IsEmpty();
+
+  if (isSelected) {
+    aLists.BorderBackground()->AppendNewToTop<nsDisplayMathMLSelectionRect>(
+        aBuilder, aForFrame, *aSelectedRect);
+  } else if (mRect.width && mRect.height) {
+#if defined(DEBUG) && defined(SHOW_BOUNDING_BOX)
+    // for visual debug
+    aLists.BorderBackground()->AppendNewToTop<nsDisplayMathMLCharDebug>(
+        aBuilder, aForFrame, mRect);
+#endif
+  }
+  aLists.Content()->AppendNewToTopWithIndex<nsDisplayMathMLCharForeground>(
+      aBuilder, aForFrame, aIndex, this, isSelected);
+}
+
+void nsMathMLChar::ApplyTransforms(gfxContext* aThebesContext,
+                                   int32_t aAppUnitsPerGfxUnit, nsRect& r) {
+  // apply the transforms
+  if (mMirrored) {
+    nsPoint pt = r.TopRight();
+    gfxPoint devPixelOffset(NSAppUnitsToFloatPixels(pt.x, aAppUnitsPerGfxUnit),
+                            NSAppUnitsToFloatPixels(pt.y, aAppUnitsPerGfxUnit));
+    aThebesContext->SetMatrixDouble(aThebesContext->CurrentMatrixDouble()
+                                        .PreTranslate(devPixelOffset)
+                                        .PreScale(-mScaleX, mScaleY));
+  } else {
+    nsPoint pt = r.TopLeft();
+    gfxPoint devPixelOffset(NSAppUnitsToFloatPixels(pt.x, aAppUnitsPerGfxUnit),
+                            NSAppUnitsToFloatPixels(pt.y, aAppUnitsPerGfxUnit));
+    aThebesContext->SetMatrixDouble(aThebesContext->CurrentMatrixDouble()
+                                        .PreTranslate(devPixelOffset)
+                                        .PreScale(mScaleX, mScaleY));
+  }
+
+  // update the bounding rectangle.
+  r.x = r.y = 0;
+  r.width /= mScaleX;
+  r.height /= mScaleY;
+}
+
+void nsMathMLChar::PaintForeground(nsIFrame* aForFrame,
+                                   gfxContext& aRenderingContext, nsPoint aPt,
+                                   bool aIsSelected) {
+  ComputedStyle* computedStyle = mComputedStyle;
+  nsPresContext* presContext = aForFrame->PresContext();
+
+  if (mDraw == DRAW_NORMAL) {
+    // normal drawing if there is nothing special about this char
+    // Use our parent element's style
+    computedStyle = aForFrame->Style();
+  }
+
+  // Set color ...
+  nscolor fgColor = computedStyle->GetVisitedDependentColor(
+      &nsStyleText::mWebkitTextFillColor);
+  if (aIsSelected) {
+    // get color to use for selection from the look&feel object
+    fgColor = LookAndFeel::Color(LookAndFeel::ColorID::Highlighttext, aForFrame,
+                                 fgColor);
+  }
+  aRenderingContext.SetColor(sRGBColor::FromABGR(fgColor));
+  aRenderingContext.Save();
+  nsRect r = mRect + aPt;
+  ApplyTransforms(&aRenderingContext,
+                  aForFrame->PresContext()->AppUnitsPerDevPixel(), r);
+
+  switch (mDraw) {
+    case DRAW_NORMAL:
+    case DRAW_VARIANT:
+      // draw a single glyph (base size or size variant)
+      // XXXfredw verify if mGlyphs[0] is non-null to workaround bug 973322.
+      if (mGlyphs[0]) {
+        mGlyphs[0]->Draw(Range(mGlyphs[0].get()),
+                         gfx::Point(0.0, mUnscaledAscent),
+                         gfxTextRun::DrawParams(&aRenderingContext));
+      }
+      break;
+    case DRAW_PARTS: {
+      // paint by parts
+      if (NS_STRETCH_DIRECTION_VERTICAL == mDirection)
+        PaintVertically(presContext, &aRenderingContext, r, fgColor);
+      else if (NS_STRETCH_DIRECTION_HORIZONTAL == mDirection)
+        PaintHorizontally(presContext, &aRenderingContext, r, fgColor);
+      break;
+    }
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unknown drawing method");
+      break;
+  }
+
+  aRenderingContext.Restore();
+}
+
+/* =============================================================================
+  Helper routines that actually do the job of painting the char by parts
+ */
+
+class AutoPushClipRect {
+  gfxContext* mThebesContext;
+
+ public:
+  AutoPushClipRect(gfxContext* aThebesContext, int32_t aAppUnitsPerGfxUnit,
+                   const nsRect& aRect)
+      : mThebesContext(aThebesContext) {
+    mThebesContext->Save();
+    gfxRect clip = nsLayoutUtils::RectToGfxRect(aRect, aAppUnitsPerGfxUnit);
+    mThebesContext->SnappedClip(clip);
+  }
+  ~AutoPushClipRect() { mThebesContext->Restore(); }
+};
+
+static nsPoint SnapToDevPixels(const gfxContext* aThebesContext,
+                               int32_t aAppUnitsPerGfxUnit,
+                               const nsPoint& aPt) {
+  gfxPoint pt(NSAppUnitsToFloatPixels(aPt.x, aAppUnitsPerGfxUnit),
+              NSAppUnitsToFloatPixels(aPt.y, aAppUnitsPerGfxUnit));
+  pt = aThebesContext->UserToDevice(pt);
+  pt.Round();
+  pt = aThebesContext->DeviceToUser(pt);
+  return nsPoint(NSFloatPixelsToAppUnits(pt.x, aAppUnitsPerGfxUnit),
+                 NSFloatPixelsToAppUnits(pt.y, aAppUnitsPerGfxUnit));
+}
+
+static void PaintRule(DrawTarget& aDrawTarget, int32_t aAppUnitsPerGfxUnit,
+                      nsRect& aRect, nscolor aColor) {
+  Rect rect = NSRectToSnappedRect(aRect, aAppUnitsPerGfxUnit, aDrawTarget);
+  ColorPattern color(ToDeviceColor(aColor));
+  aDrawTarget.FillRect(rect, color);
+}
+
+// paint a stretchy char by assembling glyphs vertically
+nsresult nsMathMLChar::PaintVertically(nsPresContext* aPresContext,
+                                       gfxContext* aThebesContext,
+                                       nsRect& aRect, nscolor aColor) {
+  DrawTarget& aDrawTarget = *aThebesContext->GetDrawTarget();
+
+  // Get the device pixel size in the vertical direction.
+  // (This makes no effort to optimize for non-translation transformations.)
+  nscoord oneDevPixel = aPresContext->AppUnitsPerDevPixel();
+
+  // get metrics data to be re-used later
+  int32_t i = 0;
+  nscoord dx = aRect.x;
+  nscoord offset[3], start[3], end[3];
+  for (i = 0; i <= 2; ++i) {
+    const nsBoundingMetrics& bm = mBmData[i];
+    nscoord dy;
+    if (0 == i) {  // top
+      dy = aRect.y + bm.ascent;
+    } else if (2 == i) {  // bottom
+      dy = aRect.y + aRect.height - bm.descent;
+    } else {  // middle
+      dy = aRect.y + bm.ascent + (aRect.height - (bm.ascent + bm.descent)) / 2;
+    }
+    // _cairo_scaled_font_show_glyphs snaps origins to device pixels.
+    // Do this now so that we can get the other dimensions right.
+    // (This may not achieve much with non-rectangular transformations.)
+    dy = SnapToDevPixels(aThebesContext, oneDevPixel, nsPoint(dx, dy)).y;
+    // abcissa passed to Draw
+    offset[i] = dy;
+    // _cairo_scaled_font_glyph_device_extents rounds outwards to the nearest
+    // pixel, so the bm values can include 1 row of faint pixels on each edge.
+    // Don't rely on this pixel as it can look like a gap.
+    if (bm.ascent + bm.descent >= 2 * oneDevPixel) {
+      start[i] = dy - bm.ascent + oneDevPixel;  // top join
+      end[i] = dy + bm.descent - oneDevPixel;   // bottom join
+    } else {
+      // To avoid overlaps, we don't add one pixel on each side when the part
+      // is too small.
+      start[i] = dy - bm.ascent;  // top join
+      end[i] = dy + bm.descent;   // bottom join
+    }
+  }
+
+  // If there are overlaps, then join at the mid point
+  for (i = 0; i < 2; ++i) {
+    if (end[i] > start[i + 1]) {
+      end[i] = (end[i] + start[i + 1]) / 2;
+      start[i + 1] = end[i];
+    }
+  }
+
+  nsRect unionRect = aRect;
+  unionRect.x += mBoundingMetrics.leftBearing;
+  unionRect.width =
+      mBoundingMetrics.rightBearing - mBoundingMetrics.leftBearing;
+  unionRect.Inflate(oneDevPixel);
+
+  gfxTextRun::DrawParams params(aThebesContext);
+
+  /////////////////////////////////////
+  // draw top, middle, bottom
+  for (i = 0; i <= 2; ++i) {
+    // glue can be null
+    if (mGlyphs[i]) {
+      nscoord dy = offset[i];
+      // Draw a glyph in a clipped area so that we don't have hairy chars
+      // pending outside
+      nsRect clipRect = unionRect;
+      // Clip at the join to get a solid edge (without overlap or gap), when
+      // this won't change the glyph too much.  If the glyph is too small to
+      // clip then we'll overlap rather than have a gap.
+      nscoord height = mBmData[i].ascent + mBmData[i].descent;
+      if (height * (1.0 - NS_MATHML_DELIMITER_FACTOR) > oneDevPixel) {
+        if (0 == i) {  // top
+          clipRect.height = end[i] - clipRect.y;
+        } else if (2 == i) {  // bottom
+          clipRect.height -= start[i] - clipRect.y;
+          clipRect.y = start[i];
+        } else {  // middle
+          clipRect.y = start[i];
+          clipRect.height = end[i] - start[i];
+        }
+      }
+      if (!clipRect.IsEmpty()) {
+        AutoPushClipRect clip(aThebesContext, oneDevPixel, clipRect);
+        mGlyphs[i]->Draw(Range(mGlyphs[i].get()), gfx::Point(dx, dy), params);
+      }
+    }
+  }
+
+  ///////////////
+  // fill the gap between top and middle, and between middle and bottom.
+  if (!mGlyphs[3]) {  // null glue : draw a rule
+    // figure out the dimensions of the rule to be drawn :
+    // set lbearing to rightmost lbearing among the two current successive
+    // parts.
+    // set rbearing to leftmost rbearing among the two current successive parts.
+    // this not only satisfies the convention used for over/underbraces
+    // in TeX, but also takes care of broken fonts like the stretchy integral
+    // in Symbol for small font sizes in unix.
+    nscoord lbearing, rbearing;
+    int32_t first = 0, last = 1;
+    while (last <= 2) {
+      if (mGlyphs[last]) {
+        lbearing = mBmData[last].leftBearing;
+        rbearing = mBmData[last].rightBearing;
+        if (mGlyphs[first]) {
+          if (lbearing < mBmData[first].leftBearing)
+            lbearing = mBmData[first].leftBearing;
+          if (rbearing > mBmData[first].rightBearing)
+            rbearing = mBmData[first].rightBearing;
+        }
+      } else if (mGlyphs[first]) {
+        lbearing = mBmData[first].leftBearing;
+        rbearing = mBmData[first].rightBearing;
+      } else {
+        NS_ERROR("Cannot stretch - All parts missing");
+        return NS_ERROR_UNEXPECTED;
+      }
+      // paint the rule between the parts
+      nsRect rule(aRect.x + lbearing, end[first], rbearing - lbearing,
+                  start[last] - end[first]);
+      PaintRule(aDrawTarget, oneDevPixel, rule, aColor);
+      first = last;
+      last++;
+    }
+  } else if (mBmData[3].ascent + mBmData[3].descent > 0) {
+    // glue is present
+    nsBoundingMetrics& bm = mBmData[3];
+    // Ensure the stride for the glue is not reduced to less than one pixel
+    if (bm.ascent + bm.descent >= 3 * oneDevPixel) {
+      // To protect against gaps, pretend the glue is smaller than it is,
+      // in order to trim off ends and thus get a solid edge for the join.
+      bm.ascent -= oneDevPixel;
+      bm.descent -= oneDevPixel;
+    }
+
+    nsRect clipRect = unionRect;
+
+    for (i = 0; i < 2; ++i) {
+      // Make sure not to draw outside the character
+      nscoord dy = std::max(end[i], aRect.y);
+      nscoord fillEnd = std::min(start[i + 1], aRect.YMost());
+      while (dy < fillEnd) {
+        clipRect.y = dy;
+        clipRect.height = std::min(bm.ascent + bm.descent, fillEnd - dy);
+        AutoPushClipRect clip(aThebesContext, oneDevPixel, clipRect);
+        dy += bm.ascent;
+        mGlyphs[3]->Draw(Range(mGlyphs[3].get()), gfx::Point(dx, dy), params);
+        dy += bm.descent;
+      }
+    }
+  }
+#ifdef DEBUG
+  else {
+    for (i = 0; i < 2; ++i) {
+      NS_ASSERTION(end[i] >= start[i + 1],
+                   "gap between parts with missing glue glyph");
+    }
+  }
+#endif
+  return NS_OK;
+}
+
+// paint a stretchy char by assembling glyphs horizontally
+nsresult nsMathMLChar::PaintHorizontally(nsPresContext* aPresContext,
+                                         gfxContext* aThebesContext,
+                                         nsRect& aRect, nscolor aColor) {
+  DrawTarget& aDrawTarget = *aThebesContext->GetDrawTarget();
+
+  // Get the device pixel size in the horizontal direction.
+  // (This makes no effort to optimize for non-translation transformations.)
+  nscoord oneDevPixel = aPresContext->AppUnitsPerDevPixel();
+
+  // get metrics data to be re-used later
+  int32_t i = 0;
+  nscoord dy = aRect.y + mBoundingMetrics.ascent;
+  nscoord offset[3], start[3], end[3];
+  for (i = 0; i <= 2; ++i) {
+    const nsBoundingMetrics& bm = mBmData[i];
+    nscoord dx;
+    if (0 == i) {  // left
+      dx = aRect.x - bm.leftBearing;
+    } else if (2 == i) {  // right
+      dx = aRect.x + aRect.width - bm.rightBearing;
+    } else {  // middle
+      dx = aRect.x + (aRect.width - bm.width) / 2;
+    }
+    // _cairo_scaled_font_show_glyphs snaps origins to device pixels.
+    // Do this now so that we can get the other dimensions right.
+    // (This may not achieve much with non-rectangular transformations.)
+    dx = SnapToDevPixels(aThebesContext, oneDevPixel, nsPoint(dx, dy)).x;
+    // abcissa passed to Draw
+    offset[i] = dx;
+    // _cairo_scaled_font_glyph_device_extents rounds outwards to the nearest
+    // pixel, so the bm values can include 1 row of faint pixels on each edge.
+    // Don't rely on this pixel as it can look like a gap.
+    if (bm.rightBearing - bm.leftBearing >= 2 * oneDevPixel) {
+      start[i] = dx + bm.leftBearing + oneDevPixel;  // left join
+      end[i] = dx + bm.rightBearing - oneDevPixel;   // right join
+    } else {
+      // To avoid overlaps, we don't add one pixel on each side when the part
+      // is too small.
+      start[i] = dx + bm.leftBearing;  // left join
+      end[i] = dx + bm.rightBearing;   // right join
+    }
+  }
+
+  // If there are overlaps, then join at the mid point
+  for (i = 0; i < 2; ++i) {
+    if (end[i] > start[i + 1]) {
+      end[i] = (end[i] + start[i + 1]) / 2;
+      start[i + 1] = end[i];
+    }
+  }
+
+  nsRect unionRect = aRect;
+  unionRect.Inflate(oneDevPixel);
+
+  gfxTextRun::DrawParams params(aThebesContext);
+
+  ///////////////////////////
+  // draw left, middle, right
+  for (i = 0; i <= 2; ++i) {
+    // glue can be null
+    if (mGlyphs[i]) {
+      nscoord dx = offset[i];
+      nsRect clipRect = unionRect;
+      // Clip at the join to get a solid edge (without overlap or gap), when
+      // this won't change the glyph too much.  If the glyph is too small to
+      // clip then we'll overlap rather than have a gap.
+      nscoord width = mBmData[i].rightBearing - mBmData[i].leftBearing;
+      if (width * (1.0 - NS_MATHML_DELIMITER_FACTOR) > oneDevPixel) {
+        if (0 == i) {  // left
+          clipRect.width = end[i] - clipRect.x;
+        } else if (2 == i) {  // right
+          clipRect.width -= start[i] - clipRect.x;
+          clipRect.x = start[i];
+        } else {  // middle
+          clipRect.x = start[i];
+          clipRect.width = end[i] - start[i];
+        }
+      }
+      if (!clipRect.IsEmpty()) {
+        AutoPushClipRect clip(aThebesContext, oneDevPixel, clipRect);
+        mGlyphs[i]->Draw(Range(mGlyphs[i].get()), gfx::Point(dx, dy), params);
+      }
+    }
+  }
+
+  ////////////////
+  // fill the gap between left and middle, and between middle and right.
+  if (!mGlyphs[3]) {  // null glue : draw a rule
+    // figure out the dimensions of the rule to be drawn :
+    // set ascent to lowest ascent among the two current successive parts.
+    // set descent to highest descent among the two current successive parts.
+    // this satisfies the convention used for over/underbraces, and helps
+    // fix broken fonts.
+    nscoord ascent, descent;
+    int32_t first = 0, last = 1;
+    while (last <= 2) {
+      if (mGlyphs[last]) {
+        ascent = mBmData[last].ascent;
+        descent = mBmData[last].descent;
+        if (mGlyphs[first]) {
+          if (ascent > mBmData[first].ascent) ascent = mBmData[first].ascent;
+          if (descent > mBmData[first].descent)
+            descent = mBmData[first].descent;
+        }
+      } else if (mGlyphs[first]) {
+        ascent = mBmData[first].ascent;
+        descent = mBmData[first].descent;
+      } else {
+        NS_ERROR("Cannot stretch - All parts missing");
+        return NS_ERROR_UNEXPECTED;
+      }
+      // paint the rule between the parts
+      nsRect rule(end[first], dy - ascent, start[last] - end[first],
+                  ascent + descent);
+      PaintRule(aDrawTarget, oneDevPixel, rule, aColor);
+      first = last;
+      last++;
+    }
+  } else if (mBmData[3].rightBearing - mBmData[3].leftBearing > 0) {
+    // glue is present
+    nsBoundingMetrics& bm = mBmData[3];
+    // Ensure the stride for the glue is not reduced to less than one pixel
+    if (bm.rightBearing - bm.leftBearing >= 3 * oneDevPixel) {
+      // To protect against gaps, pretend the glue is smaller than it is,
+      // in order to trim off ends and thus get a solid edge for the join.
+      bm.leftBearing += oneDevPixel;
+      bm.rightBearing -= oneDevPixel;
+    }
+
+    nsRect clipRect = unionRect;
+
+    for (i = 0; i < 2; ++i) {
+      // Make sure not to draw outside the character
+      nscoord dx = std::max(end[i], aRect.x);
+      nscoord fillEnd = std::min(start[i + 1], aRect.XMost());
+      while (dx < fillEnd) {
+        clipRect.x = dx;
+        clipRect.width =
+            std::min(bm.rightBearing - bm.leftBearing, fillEnd - dx);
+        AutoPushClipRect clip(aThebesContext, oneDevPixel, clipRect);
+        dx -= bm.leftBearing;
+        mGlyphs[3]->Draw(Range(mGlyphs[3].get()), gfx::Point(dx, dy), params);
+        dx += bm.rightBearing;
+      }
+    }
+  }
+#ifdef DEBUG
+  else {  // no glue
+    for (i = 0; i < 2; ++i) {
+      NS_ASSERTION(end[i] >= start[i + 1],
+                   "gap between parts with missing glue glyph");
+    }
+  }
+#endif
+  return NS_OK;
+}