Add m-esr52 at 52.6.0

1 files changed, 2223 insertions, 0 deletions

diff --git a/gfx/thebes/gfxFont.h b/gfx/thebes/gfxFont.h
new file mode 100644
index 000000000..ead0b7666
--- /dev/null
+++ b/gfx/thebes/gfxFont.h
@@ -0,0 +1,2223 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=4 et sw=4 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 "gfxTypes.h"
+#include "gfxFontEntry.h"
+#include "nsString.h"
+#include "gfxPoint.h"
+#include "gfxPattern.h"
+#include "nsTArray.h"
+#include "nsTHashtable.h"
+#include "nsHashKeys.h"
+#include "gfxRect.h"
+#include "nsExpirationTracker.h"
+#include "gfxPlatform.h"
+#include "nsIAtom.h"
+#include "mozilla/HashFunctions.h"
+#include "nsIMemoryReporter.h"
+#include "nsIObserver.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Attributes.h"
+#include <algorithm>
+#include "DrawMode.h"
+#include "nsDataHashtable.h"
+#include "harfbuzz/hb.h"
+#include "mozilla/gfx/2D.h"
+#include "nsColor.h"
+
+typedef struct _cairo cairo_t;
+typedef struct _cairo_scaled_font cairo_scaled_font_t;
+//typedef struct gr_face            gr_face;
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+class gfxContext;
+class gfxTextRun;
+class gfxFont;
+class gfxGlyphExtents;
+class gfxShapedText;
+class gfxShapedWord;
+class gfxSkipChars;
+class gfxMathTable;
+
+#define FONT_MAX_SIZE                  2000.0
+
+#define NO_FONT_LANGUAGE_OVERRIDE      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.3
+#elif defined(MOZ_WIDGET_GTK)
+#define OBLIQUE_SKEW_FACTOR  0.2
+#else
+#define OBLIQUE_SKEW_FACTOR  0.25
+#endif
+
+struct gfxTextRunDrawCallbacks;
+
+namespace mozilla {
+class SVGContextPaint;
+namespace gfx {
+class GlyphRenderingOptions;
+} // namespace gfx
+} // namespace mozilla
+
+struct gfxFontStyle {
+    gfxFontStyle();
+    gfxFontStyle(uint8_t aStyle, uint16_t aWeight, int16_t aStretch,
+                 gfxFloat aSize, nsIAtom *aLanguage, bool aExplicitLanguage,
+                 float aSizeAdjust, bool aSystemFont,
+                 bool aPrinterFont,
+                 bool aWeightSynthesis, bool aStyleSynthesis,
+                 const nsString& aLanguageOverride);
+    gfxFontStyle(const gfxFontStyle& aStyle);
+
+    // the language (may be an internal langGroup code rather than an actual
+    // language code) specified in the document or element's lang property,
+    // or inferred from the charset
+    RefPtr<nsIAtom> language;
+
+    // Features are composed of (1) features from style rules (2) features
+    // from feature setttings rules and (3) family-specific features.  (1) and
+    // (3) are guaranteed to be mutually exclusive
+
+    // custom opentype feature settings
+    nsTArray<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
+    nsTArray<gfxAlternateValue> alternateValues;
+
+    // -- object used to look these up once the font is matched
+    RefPtr<gfxFontFeatureValueSet> featureValueLookup;
+
+    // The logical size of the font, in pixels
+    gfxFloat size;
+
+    // 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 weight of the font: 100, 200, ... 900.
+    uint16_t weight;
+
+    // The stretch of the font (the sum of various NS_FONT_STRETCH_*
+    // constants; see gfxFontConstants.h).
+    int8_t stretch;
+
+    // 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;
+
+    // The style of font (normal, italic, oblique)
+    uint8_t style : 2;
+
+    // Whether synthetic styles are allowed
+    bool allowSyntheticWeight : 1;
+    bool allowSyntheticStyle : 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;
+
+    // whether the |language| field comes from explicit lang tagging in the
+    // document, or was inferred from charset/system locale
+    bool explicitLanguage : 1;
+
+    // caps variant (small-caps, petite-caps, etc.)
+    uint8_t variantCaps;
+
+    // sub/superscript variant
+    uint8_t variantSubSuper;
+
+    // Return the final adjusted font size for the given aspect ratio.
+    // Not meant to be called when sizeAdjust = -1.0.
+    gfxFloat GetAdjustedSize(gfxFloat aspect) const {
+        NS_ASSERTION(sizeAdjust >= 0.0, "Not meant to be called when sizeAdjust = -1.0");
+        gfxFloat adjustedSize = std::max(NS_round(size*(sizeAdjust/aspect)), 1.0);
+        return std::min(adjustedSize, FONT_MAX_SIZE);
+    }
+
+    PLDHashNumber Hash() const {
+        return ((style + (systemFont << 7) +
+            (weight << 8)) + uint32_t(size*1000) + uint32_t(sizeAdjust*1000)) ^
+            nsISupportsHashKey::HashKey(language);
+    }
+
+    int8_t ComputeWeight() const;
+
+    // Adjust this style to simulate sub/superscript (as requested in the
+    // variantSubSuper field) using size and baselineOffset instead.
+    void AdjustForSubSuperscript(int32_t aAppUnitsPerDevPixel);
+
+    bool Equals(const gfxFontStyle& other) const {
+        return
+            (*reinterpret_cast<const uint64_t*>(&size) ==
+             *reinterpret_cast<const uint64_t*>(&other.size)) &&
+            (style == other.style) &&
+            (variantCaps == other.variantCaps) &&
+            (variantSubSuper == other.variantSubSuper) &&
+            (allowSyntheticWeight == other.allowSyntheticWeight) &&
+            (allowSyntheticStyle == other.allowSyntheticStyle) &&
+            (systemFont == other.systemFont) &&
+            (printerFont == other.printerFont) &&
+            (useGrayscaleAntialiasing == other.useGrayscaleAntialiasing) &&
+            (explicitLanguage == other.explicitLanguage) &&
+            (weight == other.weight) &&
+            (stretch == other.stretch) &&
+            (language == other.language) &&
+            (baselineOffset == other.baselineOffset) &&
+            (*reinterpret_cast<const uint32_t*>(&sizeAdjust) ==
+             *reinterpret_cast<const uint32_t*>(&other.sizeAdjust)) &&
+            (featureSettings == other.featureSettings) &&
+            (languageOverride == other.languageOverride) &&
+            (alternateValues == other.alternateValues) &&
+            (featureValueLookup == other.featureValueLookup);
+    }
+
+    static void ParseFontFeatureSettings(const nsString& aFeatureString,
+                                         nsTArray<gfxFontFeature>& aFeatures);
+
+    static uint32_t ParseFontLanguageOverride(const nsString& aLangTag);
+};
+
+struct gfxTextRange {
+    enum {
+        // flags for recording the kind of font-matching that was used
+        kFontGroup      = 0x0001,
+        kPrefsFallback  = 0x0002,
+        kSystemFallback = 0x0004
+    };
+    gfxTextRange(uint32_t aStart, uint32_t aEnd,
+                 gfxFont* aFont, uint8_t aMatchType,
+                 uint16_t aOrientation)
+        : start(aStart),
+          end(aEnd),
+          font(aFont),
+          matchType(aMatchType),
+          orientation(aOrientation)
+    { }
+    uint32_t Length() const { return end - start; }
+    uint32_t start, end;
+    RefPtr<gfxFont> font;
+    uint8_t matchType;
+    uint16_t orientation;
+};
+
+
+/**
+ * Font cache design:
+ * 
+ * The mFonts hashtable contains most fonts, indexed by (gfxFontEntry*, style).
+ * It does not add a reference to the fonts it contains.
+ * When a font's refcount decreases to zero, instead of deleting it we
+ * add it to our expiration tracker.
+ * The expiration tracker tracks fonts with zero refcount. After a certain
+ * period of time, such fonts expire and are deleted.
+ *
+ * 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 nsExpirationTracker<gfxFont,3> {
+public:
+    enum {
+        FONT_TIMEOUT_SECONDS = 10,
+        SHAPED_WORD_TIMEOUT_SECONDS = 60
+    };
+
+    gfxFontCache();
+    ~gfxFontCache();
+
+    /*
+     * 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 an addrefed pointer, or 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; we'll forget about the old one.
+    void AddNew(gfxFont *aFont);
+
+    // The font's refcount has gone to zero; give ownership of it to
+    // the cache. We delete it if it's not acquired again after a certain
+    // amount of time.
+    void NotifyReleased(gfxFont *aFont);
+
+    // This gets called when the timeout has expired on a zero-refcount
+    // font; we just delete it.
+    virtual void NotifyExpired(gfxFont *aFont) override;
+
+    // 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() {
+        mFonts.Clear();
+        AgeAllGenerations();
+    }
+
+    void FlushShapedWordCaches();
+
+    void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                FontCacheSizes* aSizes) const;
+    void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                FontCacheSizes* aSizes) const;
+
+protected:
+    class MemoryReporter final : public nsIMemoryReporter
+    {
+        ~MemoryReporter() {}
+    public:
+        NS_DECL_ISUPPORTS
+        NS_DECL_NSIMEMORYREPORTER
+    };
+
+    // Observer for notifications that the font cache cares about
+    class Observer final
+        : public nsIObserver
+    {
+        ~Observer() {}
+    public:
+        NS_DECL_ISUPPORTS
+        NS_DECL_NSIOBSERVER
+    };
+
+    void DestroyFont(gfxFont *aFont);
+
+    static gfxFontCache *gGlobalCache;
+
+    struct 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) : mFont(nullptr) { }
+        HashEntry(const HashEntry& toCopy) : mFont(toCopy.mFont) { }
+        ~HashEntry() { }
+
+        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* mFont;
+    };
+
+    nsTHashtable<HashEntry> mFonts;
+
+    static void WordCacheExpirationTimerCallback(nsITimer* aTimer, void* aCache);
+    nsCOMPtr<nsITimer>      mWordCacheExpirationTimer;
+};
+
+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));
+    }
+};
+
+class gfxTextRunFactory {
+    NS_INLINE_DECL_REFCOUNTING(gfxTextRunFactory)
+
+public:
+    typedef mozilla::gfx::DrawTarget DrawTarget;
+
+    // Flags in the mask 0xFFFF0000 are reserved for textrun clients
+    // Flags in the mask 0x0000F000 are reserved for per-platform fonts
+    // Flags in the mask 0x00000FFF are set by the textrun creator.
+    enum {
+        CACHE_TEXT_FLAGS    = 0xF0000000,
+        USER_TEXT_FLAGS     = 0x0FFF0000,
+        TEXTRUN_TEXT_FLAGS  = 0x0000FFFF,
+        SETTABLE_FLAGS      = CACHE_TEXT_FLAGS | USER_TEXT_FLAGS,
+
+        /**
+         * When set, the text string pointer used to create the text run
+         * is guaranteed to be available during the lifetime of the text run.
+         */
+        TEXT_IS_PERSISTENT           = 0x0001,
+        /**
+         * When set, the text is known to be all-ASCII (< 128).
+         */
+        TEXT_IS_ASCII                = 0x0002,
+        /**
+         * When set, the text is RTL.
+         */
+        TEXT_IS_RTL                  = 0x0004,
+        /**
+         * When set, spacing is enabled and the textrun needs to call GetSpacing
+         * on the spacing provider.
+         */
+        TEXT_ENABLE_SPACING          = 0x0008,
+        /**
+         * When set, GetHyphenationBreaks may return true for some character
+         * positions, otherwise it will always return false for all characters.
+         */
+        TEXT_ENABLE_HYPHEN_BREAKS    = 0x0010,
+        /**
+         * When set, the text has no characters above 255 and it is stored
+         * in the textrun in 8-bit format.
+         */
+        TEXT_IS_8BIT                 = 0x0020,
+        /**
+         * 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       = 0x0040,
+        /**
+         * When set, optional ligatures are disabled. Ligatures that are
+         * required for legible text should still be enabled.
+         */
+        TEXT_DISABLE_OPTIONAL_LIGATURES = 0x0080,
+        /**
+         * 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          = 0x0100,
+        /**
+         * For internal use by the memory reporter when accounting for
+         * storage used by textruns.
+         * Because the reporter may visit each textrun multiple times while
+         * walking the frame trees and textrun cache, it needs to mark
+         * textruns that have been seen so as to avoid multiple-accounting.
+         */
+        TEXT_RUN_SIZE_ACCOUNTED      = 0x0200,
+        /**
+         * When set, the textrun should discard control characters instead of
+         * turning them into hexboxes.
+         */
+        TEXT_HIDE_CONTROL_CHARACTERS = 0x0400,
+
+        /**
+         * 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                    = 0xF000,
+        TEXT_ORIENT_HORIZONTAL              = 0x0000,
+        TEXT_ORIENT_VERTICAL_UPRIGHT        = 0x1000,
+        TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT = 0x2000,
+        TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT  = 0x4000,
+        TEXT_ORIENT_VERTICAL_MIXED          = 0x8000,
+
+        /**
+         * 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 = 0x20000000,
+        /**
+         * 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 = 0x40000000,
+
+        // Set if the textrun should use the OpenType 'math' script.
+        TEXT_USE_MATH_SCRIPT = 0x80000000,
+    };
+
+    /**
+     * This record contains all the parameters needed to initialize a textrun.
+     */
+    struct 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::unicode::Script Script;
+
+    explicit gfxFontShaper(gfxFont *aFont)
+        : mFont(aFont)
+    {
+        NS_ASSERTION(aFont, "shaper requires a valid font!");
+    }
+
+    virtual ~gfxFontShaper() { }
+
+    // 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,
+                           bool            aVertical,
+                           gfxShapedText  *aShapedText) = 0;
+
+    gfxFont *GetFont() const { return mFont; }
+
+    static void
+    MergeFontFeatures(const gfxFontStyle *aStyle,
+                      const nsTArray<gfxFontFeature>& aFontFeatures,
+                      bool aDisableLigatures,
+                      const nsAString& aFamilyName,
+                      bool aAddSmallCaps,
+                      void (*aHandleFeature)(const uint32_t&,
+                                             uint32_t&, void*),
+                      void* aHandleFeatureData);
+
+protected:
+    // Work out whether cairo will snap inter-glyph spacing to pixels.
+    static void GetRoundOffsetsToPixels(DrawTarget* aDrawTarget,
+                                        bool* aRoundX, bool* aRoundY);
+
+    // 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;
+};
+
+
+/*
+ * 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::unicode::Script Script;
+
+    gfxShapedText(uint32_t aLength, uint32_t aFlags,
+                  int32_t aAppUnitsPerDevUnit)
+        : mLength(aLength)
+        , mFlags(aFlags)
+        , mAppUnitsPerDevUnit(aAppUnitsPerDevUnit)
+    { }
+
+    virtual ~gfxShapedText() { }
+
+    /**
+     * 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:
+        CompressedGlyph() { mValue = 0; }
+
+        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,
+
+            // 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,
+
+            FLAG_CHAR_IS_SPACE     = 0x10000000U,
+
+            // The advance is stored in appunits
+            ADVANCE_MASK  = 0x0FFF0000U,
+            ADVANCE_SHIFT = 16,
+
+            GLYPH_MASK = 0x0000FFFFU,
+
+            // Non-simple glyphs may or may not have glyph data in the
+            // corresponding mDetailedGlyphs entry. They have the following
+            // flag bits:
+
+            // 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              = 0x01,
+            FLAG_NOT_CLUSTER_START        = 0x02,
+            FLAG_NOT_LIGATURE_GROUP_START = 0x04,
+
+            FLAG_CHAR_IS_TAB              = 0x08,
+            FLAG_CHAR_IS_NEWLINE          = 0x10,
+            // 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    = 0x20,
+            CHAR_TYPE_FLAGS_MASK          = 0x38,
+
+            GLYPH_COUNT_MASK = 0x00FFFF00U,
+            GLYPH_COUNT_SHIFT = 8
+        };
+
+        // "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) != 0; }
+        uint32_t GetSimpleAdvance() const { return (mValue & ADVANCE_MASK) >> ADVANCE_SHIFT; }
+        uint32_t GetSimpleGlyph() const { return mValue & GLYPH_MASK; }
+
+        bool IsMissing() const { return (mValue & (FLAG_NOT_MISSING|FLAG_IS_SIMPLE_GLYPH)) == 0; }
+        bool IsClusterStart() const {
+            return (mValue & FLAG_IS_SIMPLE_GLYPH) || !(mValue & FLAG_NOT_CLUSTER_START);
+        }
+        bool IsLigatureGroupStart() const {
+            return (mValue & FLAG_IS_SIMPLE_GLYPH) || !(mValue & FLAG_NOT_LIGATURE_GROUP_START);
+        }
+        bool IsLigatureContinuation() const {
+            return (mValue & FLAG_IS_SIMPLE_GLYPH) == 0 &&
+                (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) != 0;
+        }
+
+        bool CharIsTab() const {
+            return !IsSimpleGlyph() && (mValue & FLAG_CHAR_IS_TAB) != 0;
+        }
+        bool CharIsNewline() const {
+            return !IsSimpleGlyph() && (mValue & FLAG_CHAR_IS_NEWLINE) != 0;
+        }
+        bool CharMayHaveEmphasisMark() const {
+            return !CharIsSpace() &&
+                (IsSimpleGlyph() || !(mValue & FLAG_CHAR_NO_EMPHASIS_MARK));
+        }
+
+        uint32_t CharTypeFlags() const {
+            return IsSimpleGlyph() ? 0 : (mValue & CHAR_TYPE_FLAGS_MASK);
+        }
+
+        void SetClusterStart(bool aIsClusterStart) {
+            NS_ASSERTION(!IsSimpleGlyph(),
+                         "can't call SetClusterStart on simple glyphs");
+            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) {
+            NS_ASSERTION(aCanBreakBefore <= 2,
+                         "Bogus break-before value!");
+            uint32_t breakMask = (uint32_t(aCanBreakBefore) << FLAGS_CAN_BREAK_SHIFT);
+            uint32_t toggle = breakMask ^ (mValue & FLAGS_CAN_BREAK_BEFORE);
+            mValue ^= toggle;
+            return toggle;
+        }
+
+        CompressedGlyph& SetSimpleGlyph(uint32_t aAdvanceAppUnits, uint32_t aGlyph) {
+            NS_ASSERTION(IsSimpleAdvance(aAdvanceAppUnits), "Advance overflow");
+            NS_ASSERTION(IsSimpleGlyphID(aGlyph), "Glyph overflow");
+            NS_ASSERTION(!CharTypeFlags(), "Char type flags lost");
+            mValue = (mValue & (FLAGS_CAN_BREAK_BEFORE | FLAG_CHAR_IS_SPACE)) |
+                FLAG_IS_SIMPLE_GLYPH |
+                (aAdvanceAppUnits << ADVANCE_SHIFT) | aGlyph;
+            return *this;
+        }
+        CompressedGlyph& SetComplex(bool aClusterStart, bool aLigatureStart,
+                uint32_t aGlyphCount) {
+            mValue = (mValue & (FLAGS_CAN_BREAK_BEFORE | FLAG_CHAR_IS_SPACE)) |
+                FLAG_NOT_MISSING |
+                CharTypeFlags() |
+                (aClusterStart ? 0 : FLAG_NOT_CLUSTER_START) |
+                (aLigatureStart ? 0 : FLAG_NOT_LIGATURE_GROUP_START) |
+                (aGlyphCount << GLYPH_COUNT_SHIFT);
+            return *this;
+        }
+        /**
+         * Missing glyphs are treated as ligature group starts; don't mess with
+         * the cluster-start flag (see bugs 618870 and 619286).
+         */
+        CompressedGlyph& SetMissing(uint32_t aGlyphCount) {
+            mValue = (mValue & (FLAGS_CAN_BREAK_BEFORE | FLAG_NOT_CLUSTER_START |
+                                FLAG_CHAR_IS_SPACE)) |
+                CharTypeFlags() |
+                (aGlyphCount << GLYPH_COUNT_SHIFT);
+            return *this;
+        }
+        uint32_t GetGlyphCount() const {
+            NS_ASSERTION(!IsSimpleGlyph(), "Expected non-simple-glyph");
+            return (mValue & GLYPH_COUNT_MASK) >> GLYPH_COUNT_SHIFT;
+        }
+
+        void SetIsSpace() {
+            mValue |= FLAG_CHAR_IS_SPACE;
+        }
+        void SetIsTab() {
+            NS_ASSERTION(!IsSimpleGlyph(), "Expected non-simple-glyph");
+            mValue |= FLAG_CHAR_IS_TAB;
+        }
+        void SetIsNewline() {
+            NS_ASSERTION(!IsSimpleGlyph(), "Expected non-simple-glyph");
+            mValue |= FLAG_CHAR_IS_NEWLINE;
+        }
+        void SetNoEmphasisMark() {
+            NS_ASSERTION(!IsSimpleGlyph(), "Expected non-simple-glyph");
+            mValue |= FLAG_CHAR_NO_EMPHASIS_MARK;
+        }
+
+    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, x-offset and y-offset of the glyph, in appunits
+         *  mAdvance is in the text direction (RTL or LTR)
+         *  mXOffset is always from left to right
+         *  mYOffset is always from top to bottom */   
+        int32_t  mAdvance;
+        float    mXOffset, mYOffset;
+    };
+
+    void SetGlyphs(uint32_t aCharIndex, CompressedGlyph aGlyph,
+                   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 AdjustAdvancesForSyntheticBold(float aSynBoldOffset,
+                                        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);
+
+    uint32_t GetFlags() const {
+        return mFlags;
+    }
+
+    bool IsVertical() const {
+        return (GetFlags() & gfxTextRunFactory::TEXT_ORIENT_MASK) !=
+                gfxTextRunFactory::TEXT_ORIENT_HORIZONTAL;
+    }
+
+    bool UseCenterBaseline() const {
+        uint32_t orient = GetFlags() & gfxTextRunFactory::TEXT_ORIENT_MASK;
+        return orient == gfxTextRunFactory::TEXT_ORIENT_VERTICAL_MIXED ||
+               orient == gfxTextRunFactory::TEXT_ORIENT_VERTICAL_UPRIGHT;
+    }
+
+    bool IsRightToLeft() const {
+        return (GetFlags() & gfxTextRunFactory::TEXT_IS_RTL) != 0;
+    }
+
+    bool IsSidewaysLeft() const {
+        return (GetFlags() & gfxTextRunFactory::TEXT_ORIENT_MASK) ==
+               gfxTextRunFactory::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() &
+                gfxTextRunFactory::TEXT_DISABLE_OPTIONAL_LIGATURES) != 0;
+    }
+
+    bool TextIs8Bit() const {
+        return (GetFlags() & gfxTextRunFactory::TEXT_IS_8BIT) != 0;
+    }
+
+    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(),
+                0, 0
+            };
+            SetGlyphs(aIndex, CompressedGlyph().SetComplex(true, true, 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()
+            : mLastUsed(0)
+        { }
+
+        // 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;
+    };
+
+    mozilla::UniquePtr<DetailedGlyphStore>   mDetailedGlyphs;
+
+    // Number of char16_t characters and CompressedGlyph glyph records
+    uint32_t                        mLength;
+
+    // Shaping flags (direction, ligature-suppression)
+    uint32_t                        mFlags;
+
+    int32_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::unicode::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,
+                                 int32_t aAppUnitsPerDevUnit,
+                                 uint32_t aFlags) {
+        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,
+                                           aAppUnitsPerDevUnit, aFlags);
+    }
+
+    static gfxShapedWord* Create(const char16_t *aText, uint32_t aLength,
+                                 Script aRunScript,
+                                 int32_t aAppUnitsPerDevUnit,
+                                 uint32_t aFlags) {
+        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 & gfxTextRunFactory::TEXT_IS_8BIT) {
+            nsAutoCString narrowText;
+            LossyAppendUTF16toASCII(nsDependentSubstring(aText, aLength),
+                                    narrowText);
+            return Create((const uint8_t*)(narrowText.BeginReading()),
+                          aLength, aRunScript, aAppUnitsPerDevUnit, aFlags);
+        }
+
+        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,
+                                           aAppUnitsPerDevUnit, aFlags);
+    }
+
+    // Override operator delete to properly free the object that was
+    // allocated via malloc.
+    void operator delete(void* p) {
+        free(p);
+    }
+
+    virtual const CompressedGlyph *GetCharacterGlyphs() const override {
+        return &mCharGlyphsStorage[0];
+    }
+    virtual 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;
+    }
+
+    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;
+    }
+
+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,
+                  int32_t aAppUnitsPerDevUnit, uint32_t aFlags)
+        : gfxShapedText(aLength, aFlags | gfxTextRunFactory::TEXT_IS_8BIT,
+                        aAppUnitsPerDevUnit)
+        , mScript(aRunScript)
+        , mAgeCounter(0)
+    {
+        memset(mCharGlyphsStorage, 0, aLength * sizeof(CompressedGlyph));
+        uint8_t *text = reinterpret_cast<uint8_t*>(&mCharGlyphsStorage[aLength]);
+        memcpy(text, aText, aLength * sizeof(uint8_t));
+    }
+
+    gfxShapedWord(const char16_t *aText, uint32_t aLength,
+                  Script aRunScript,
+                  int32_t aAppUnitsPerDevUnit, uint32_t aFlags)
+        : gfxShapedText(aLength, aFlags, aAppUnitsPerDevUnit)
+        , mScript(aRunScript)
+        , 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);
+    }
+
+    Script           mScript;
+
+    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:
+    typedef mozilla::gfx::DrawTarget DrawTarget;
+    typedef mozilla::unicode::Script Script;
+    typedef mozilla::SVGContextPaint SVGContextPaint;
+
+public:
+    nsrefcnt AddRef(void) {
+        NS_PRECONDITION(int32_t(mRefCnt) >= 0, "illegal refcnt");
+        if (mExpirationState.IsTracked()) {
+            gfxFontCache::GetCache()->RemoveObject(this);
+        }
+        ++mRefCnt;
+        NS_LOG_ADDREF(this, mRefCnt, "gfxFont", sizeof(*this));
+        return mRefCnt;
+    }
+    nsrefcnt Release(void) {
+        NS_PRECONDITION(0 != mRefCnt, "dup release");
+        --mRefCnt;
+        NS_LOG_RELEASE(this, mRefCnt, "gfxFont");
+        if (mRefCnt == 0) {
+            NotifyReleased();
+            // |this| may have been deleted.
+            return 0;
+        }
+        return mRefCnt;
+    }
+
+    int32_t GetRefCount() { return mRefCnt; }
+
+    // options to specify the kind of AA to be used when creating a font
+    typedef enum {
+        kAntialiasDefault,
+        kAntialiasNone,
+        kAntialiasGrayscale,
+        kAntialiasSubpixel
+    } AntialiasOption;
+
+protected:
+    nsAutoRefCnt mRefCnt;
+    cairo_scaled_font_t *mScaledFont;
+
+    void NotifyReleased() {
+        gfxFontCache *cache = gfxFontCache::GetCache();
+        if (cache) {
+            // Don't delete just yet; return the object to the cache for
+            // possibly recycling within some time limit
+            cache->NotifyReleased(this);
+        } else {
+            // The cache may have already been shut down.
+            delete this;
+        }
+    }
+
+    gfxFont(gfxFontEntry *aFontEntry, const gfxFontStyle *aFontStyle,
+            AntialiasOption anAAOption = kAntialiasDefault,
+            cairo_scaled_font_t *aScaledFont = nullptr);
+
+public:
+    virtual ~gfxFont();
+
+    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 nsString& GetName() const { return mFontEntry->Name(); }
+    const gfxFontStyle *GetStyle() const { return &mStyle; }
+
+    virtual cairo_scaled_font_t* GetCairoScaledFont() { return mScaledFont; }
+
+    virtual gfxFont* CopyWithAntialiasOption(AntialiasOption anAAOption) {
+        // platforms where this actually matters should override
+        return nullptr;
+    }
+
+    gfxFloat GetAdjustedSize() const {
+        return mAdjustedSize > 0.0
+                 ? mAdjustedSize
+                 : (mStyle.sizeAdjust == 0.0 ? 0.0 : mStyle.size);
+    }
+
+    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() {
+        return mFontEntry->HasCmapTable();
+    }
+
+    // check whether this is an sfnt we can potentially use with Graphite
+    bool FontCanSupportGraphite() {
+        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() {
+        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);
+
+    // 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 horizontal advance of a glyph.
+    gfxFloat GetGlyphHAdvance(DrawTarget* aDrawTarget, uint16_t aGID);
+
+    // Return Azure GlyphRenderingOptions for drawing this font.
+    virtual already_AddRefed<mozilla::gfx::GlyphRenderingOptions>
+      GetGlyphRenderingOptions(const TextRunDrawParams* aRunParams = nullptr)
+    { return nullptr; }
+
+    gfxFloat SynthesizeSpaceWidth(uint32_t aCh);
+
+    // 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 zeroOrAveCharWidth;  // width of '0', or if there is
+                                      // no '0' glyph in this font,
+                                      // equal to .aveCharWidth
+    };
+
+    enum Orientation {
+        eHorizontal,
+        eVertical
+    };
+
+    const Metrics& GetMetrics(Orientation aOrientation)
+    {
+        if (aOrientation == eHorizontal) {
+            return GetHorizontalMetrics();
+        }
+        if (!mVerticalMetrics) {
+            mVerticalMetrics.reset(CreateVerticalMetrics());
+        }
+        return *mVerticalMetrics;
+    }
+
+    /**
+     * 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,
+              gfxPoint *aPt, const TextRunDrawParams& aRunParams,
+              uint16_t 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, gfxPoint* 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, uint16_t 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
+    virtual uint32_t GetSpaceGlyph() = 0;
+
+    gfxGlyphExtents *GetOrCreateGlyphExtents(int32_t aAppUnitsPerDevUnit);
+
+    // You need to call SetupCairoFont on aDrawTarget just before calling this.
+    virtual void SetupGlyphExtents(DrawTarget* aDrawTarget, uint32_t aGlyphID,
+                                   bool aNeedTight, gfxGlyphExtents *aExtents);
+
+    // This is called by the default Draw() implementation above.
+    virtual bool SetupCairoFont(DrawTarget* aDrawTarget) = 0;
+
+    virtual bool AllowSubpixelAA() { return true; }
+
+    bool IsSyntheticBold() { return mApplySyntheticBold; }
+
+    // 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() {
+        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) {
+        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) {
+        if (!mIsValid) {
+            return 0;
+        }
+        return mFontEntry->GetUVSGlyph(aCh, aVS); 
+    }
+
+    template<typename T>
+    bool InitFakeSmallCapsRun(DrawTarget *aDrawTarget,
+                              gfxTextRun *aTextRun,
+                              const T    *aText,
+                              uint32_t    aOffset,
+                              uint32_t    aLength,
+                              uint8_t     aMatchType,
+                              uint16_t    aOrientation,
+                              Script      aScript,
+                              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,
+                             bool aVertical);
+
+    // Get a ShapedWord representing the given text (either 8- or 16-bit)
+    // for use in setting up a gfxTextRun.
+    template<typename T>
+    gfxShapedWord* GetShapedWord(DrawTarget *aDrawTarget,
+                                 const T *aText,
+                                 uint32_t aLength,
+                                 uint32_t aHash,
+                                 Script aRunScript,
+                                 bool aVertical,
+                                 int32_t aAppUnitsPerDevUnit,
+                                 uint32_t aFlags,
+                                 gfxTextPerfMetrics *aTextPerf);
+
+    // Ensure the ShapedWord cache is initialized. This MUST be called before
+    // any attempt to use GetShapedWord().
+    void InitWordCache() {
+        if (!mWordCache) {
+            mWordCache = mozilla::MakeUnique<nsTHashtable<CacheHashEntry>>();
+        }
+    }
+
+    // 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
+    void AgeCachedWords();
+
+    // Discard all cached word records; called on memory-pressure notification.
+    void ClearCachedWords() {
+        if (mWordCache) {
+            mWordCache->Clear();
+        }
+    }
+
+    // Glyph rendering/geometry has changed, so invalidate data as necessary.
+    void NotifyGlyphsChanged();
+
+    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;
+
+    virtual already_AddRefed<mozilla::gfx::ScaledFont> GetScaledFont(DrawTarget* aTarget)
+    { return gfxPlatform::GetPlatform()->GetScaledFontForFont(aTarget, this); }
+
+    bool KerningDisabled() {
+        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()
+    {
+        // 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() {
+        MOZ_RELEASE_ASSERT(mMathTable, "A successful call to TryGetMathTable() must be performed before calling this function");
+        return mMathTable.get();
+    }
+
+    // return a cloned font resized and offset to simulate sub/superscript glyphs
+    virtual already_AddRefed<gfxFont>
+    GetSubSuperscriptFont(int32_t aAppUnitsPerDevPixel);
+
+    /**
+     * Return the reference cairo_t object from aDT.
+     */
+    static cairo_t* RefCairo(mozilla::gfx::DrawTarget* aDT);
+
+protected:
+    virtual const Metrics& GetHorizontalMetrics() = 0;
+
+    const Metrics* CreateVerticalMetrics();
+
+    // Output a single glyph at *aPt, which is updated by the glyph's advance.
+    // 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).
+    void DrawOneGlyph(uint32_t           aGlyphID,
+                      double             aAdvance,
+                      gfxPoint          *aPt,
+                      GlyphBufferAzure&  aBuffer,
+                      bool              *aEmittedGlyphs) const;
+
+    // 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.
+    bool DrawGlyphs(const gfxShapedText      *aShapedText,
+                    uint32_t                  aOffset, // offset in the textrun
+                    uint32_t                  aCount, // length of run to draw
+                    gfxPoint                 *aPt,
+                    const TextRunDrawParams&  aRunParams,
+                    const FontDrawParams&     aFontParams);
+
+    // 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).
+    // Default implementation relies on gfxFontEntry::CreateFontInstance;
+    // backends that don't implement that will need to override this and use
+    // an alternative technique. (gfxFontconfigFonts, I'm looking at you...)
+    virtual already_AddRefed<gfxFont> GetSmallCapsFont();
+
+    // 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(DrawTarget& aDrawTarget, uint16_t aGID) {
+        return -1;
+    }
+
+    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);
+
+    // do spaces participate in shaping rules? if so, can't used word cache
+    bool SpaceMayParticipateInShaping(Script aRunScript);
+
+    // 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,
+                   bool           aVertical,
+                   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,
+                           bool             aVertical,
+                           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,
+                                   bool        aVertical,
+                                   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,
+                                       bool        aVertical,
+                                       gfxTextRun *aTextRun);
+
+    void CheckForFeaturesInvolvingSpace();
+
+    // 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 nsDataHashtable<nsUint32HashKey,Script> *sScriptTagToCode;
+    static nsTHashtable<nsUint32HashKey>           *sDefaultFeatures;
+
+    RefPtr<gfxFontEntry> mFontEntry;
+
+    struct CacheHashKey {
+        union {
+            const uint8_t   *mSingle;
+            const char16_t *mDouble;
+        }                mText;
+        uint32_t         mLength;
+        uint32_t         mFlags;
+        Script           mScript;
+        int32_t          mAppUnitsPerDevUnit;
+        PLDHashNumber    mHashKey;
+        bool             mTextIs8Bit;
+
+        CacheHashKey(const uint8_t *aText, uint32_t aLength,
+                     uint32_t aStringHash,
+                     Script aScriptCode, int32_t aAppUnitsPerDevUnit,
+                     uint32_t aFlags)
+            : mLength(aLength),
+              mFlags(aFlags),
+              mScript(aScriptCode),
+              mAppUnitsPerDevUnit(aAppUnitsPerDevUnit),
+              mHashKey(aStringHash + static_cast<int32_t>(aScriptCode) +
+                  aAppUnitsPerDevUnit * 0x100 + aFlags * 0x10000),
+              mTextIs8Bit(true)
+        {
+            NS_ASSERTION(aFlags & gfxTextRunFactory::TEXT_IS_8BIT,
+                         "8-bit flag should have been set");
+            mText.mSingle = aText;
+        }
+
+        CacheHashKey(const char16_t *aText, uint32_t aLength,
+                     uint32_t aStringHash,
+                     Script aScriptCode, int32_t aAppUnitsPerDevUnit,
+                     uint32_t aFlags)
+            : mLength(aLength),
+              mFlags(aFlags),
+              mScript(aScriptCode),
+              mAppUnitsPerDevUnit(aAppUnitsPerDevUnit),
+              mHashKey(aStringHash + static_cast<int32_t>(aScriptCode) +
+                  aAppUnitsPerDevUnit * 0x100 + aFlags * 0x10000),
+              mTextIs8Bit(false)
+        {
+            // 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;
+        }
+    };
+
+    class CacheHashEntry : public PLDHashEntryHdr {
+    public:
+        typedef const CacheHashKey &KeyType;
+        typedef const CacheHashKey *KeyTypePointer;
+
+        // When constructing a new entry in the hashtable, the caller of Put()
+        // will fill us in.
+        explicit CacheHashEntry(KeyTypePointer aKey) { }
+        CacheHashEntry(const CacheHashEntry& toCopy) { NS_ERROR("Should not be called"); }
+        ~CacheHashEntry() { }
+
+        bool KeyEquals(const KeyTypePointer aKey) const;
+
+        static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+
+        static PLDHashNumber HashKey(const KeyTypePointer aKey) {
+            return aKey->mHashKey;
+        }
+
+        size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+        {
+            return aMallocSizeOf(mShapedWord.get());
+        }
+
+        enum { ALLOW_MEMMOVE = true };
+
+        mozilla::UniquePtr<gfxShapedWord> mShapedWord;
+    };
+
+    mozilla::UniquePtr<nsTHashtable<CacheHashEntry> > mWordCache;
+
+    static const uint32_t  kShapedWordCacheMaxAge = 3;
+
+    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?
+
+    bool                       mMathInitialized; // TryGetMathTable() called?
+
+    nsExpirationState          mExpirationState;
+    gfxFontStyle               mStyle;
+    nsTArray<mozilla::UniquePtr<gfxGlyphExtents>> mGlyphExtentsArray;
+    mozilla::UniquePtr<nsTHashtable<nsPtrHashKey<GlyphChangeObserver>>>
+                               mGlyphChangeObservers;
+
+    gfxFloat                   mAdjustedSize;
+
+    // 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;
+
+    // the AA setting requested for this font - may affect glyph bounds
+    AntialiasOption            mAntialiasOption;
+
+    // a copy of the font without antialiasing, if needed for separate
+    // measurement by mathml code
+    mozilla::UniquePtr<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::UniquePtr<gfxFontShaper>   mHarfBuzzShaper;
+    mozilla::UniquePtr<gfxFontShaper>   mGraphiteShaper;
+
+    // if a userfont with unicode-range specified, contains map of *possible*
+    // ranges supported by font
+    RefPtr<gfxCharacterMap> mUnicodeRangeMap;
+
+    RefPtr<mozilla::gfx::ScaledFont> mAzureScaledFont;
+
+    // For vertical metrics, created on demand.
+    mozilla::UniquePtr<const Metrics> mVerticalMetrics;
+
+    // Table used for MathML layout.
+    mozilla::UniquePtr<gfxMathTable> mMathTable;
+
+    // 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, gfxPoint aPoint,
+                        uint32_t aGlyphId, SVGContextPaint* aContextPaint) const;
+    bool RenderSVGGlyph(gfxContext *aContext, gfxPoint aPoint,
+                        uint32_t aGlyphId, SVGContextPaint* aContextPaint,
+                        gfxTextRunDrawCallbacks *aCallbacks,
+                        bool& aEmittedGlyphs) const;
+
+    bool RenderColorGlyph(DrawTarget* aDrawTarget,
+                          gfxContext* aContext,
+                          mozilla::gfx::ScaledFont* scaledFont,
+                          mozilla::gfx::GlyphRenderingOptions* renderingOptions,
+                          mozilla::gfx::DrawOptions drawOptions,
+                          const mozilla::gfx::Point& aPoint,
+                          uint32_t aGlyphId) const;
+
+    // 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 double 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 TextRunDrawParams {
+    RefPtr<mozilla::gfx::DrawTarget> dt;
+    gfxContext              *context;
+    gfxFont::Spacing        *spacing;
+    gfxTextRunDrawCallbacks *callbacks;
+    mozilla::SVGContextPaint *runContextPaint;
+    mozilla::gfx::Color      fontSmoothingBGColor;
+    gfxFloat                 direction;
+    double                   devPerApp;
+    nscolor                  textStrokeColor;
+    gfxPattern              *textStrokePattern;
+    const mozilla::gfx::StrokeOptions *strokeOpts;
+    const mozilla::gfx::DrawOptions   *drawOpts;
+    DrawMode                 drawMode;
+    bool                     isVerticalRun;
+    bool                     isRTL;
+    bool                     paintSVGGlyphs;
+};
+
+struct FontDrawParams {
+    RefPtr<mozilla::gfx::ScaledFont>            scaledFont;
+    RefPtr<mozilla::gfx::GlyphRenderingOptions> renderingOptions;
+    mozilla::SVGContextPaint *contextPaint;
+    mozilla::gfx::Matrix     *passedInvMatrix;
+    mozilla::gfx::Matrix      matInv;
+    double                    synBoldOnePixelOffset;
+    int32_t                   extraStrikes;
+    mozilla::gfx::DrawOptions drawOptions;
+    bool                      isVerticalFont;
+    bool                      haveSVGGlyphs;
+    bool                      haveColorGlyphs;
+};
+
+struct EmphasisMarkDrawParams {
+    gfxContext* context;
+    gfxFont::Spacing* spacing;
+    gfxTextRun* mark;
+    gfxFloat advance;
+    gfxFloat direction;
+    bool isVertical;
+};
+
+#endif