The Tor Browser: comparison gfx/thebes/gfxFont.h

--1:000000000000
+:57bad8b508df
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+* 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 "nsString.h"
+#include "gfxPoint.h"
+#include "gfxFontUtils.h"
+#include "nsTArray.h"
+#include "nsTHashtable.h"
+#include "nsHashKeys.h"
+#include "gfxSkipChars.h"
+#include "gfxRect.h"
+#include "nsExpirationTracker.h"
+#include "gfxPlatform.h"
+#include "nsIAtom.h"
+#include "mozilla/HashFunctions.h"
+#include "nsIMemoryReporter.h"
+#include "nsIObserver.h"
+#include "gfxFontFeatures.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Attributes.h"
+#include <algorithm>
+#include "DrawMode.h"
+#include "nsUnicodeScriptCodes.h"
+#include "nsDataHashtable.h"
+#include "harfbuzz/hb.h"
+#include "mozilla/gfx/2D.h"
+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 gfxFontFamily;
+class gfxFontGroup;
+class gfxGraphiteShaper;
+class gfxHarfBuzzShaper;
+class gfxUserFontSet;
+class gfxUserFontData;
+class gfxShapedText;
+class gfxShapedWord;
+class gfxSVGGlyphs;
+class gfxMathTable;
+class gfxTextContextPaint;
+class FontInfoData;
+class nsILanguageAtomService;
+#define FONT_MAX_SIZE                  2000.0
+#define NO_FONT_LANGUAGE_OVERRIDE      0
+struct FontListSizes;
+struct gfxTextRunDrawCallbacks;
+namespace mozilla {
+namespace gfx {
+class GlyphRenderingOptions;
+}
+}
+struct gfxFontStyle {
+gfxFontStyle();
+gfxFontStyle(uint8_t aStyle, uint16_t aWeight, int16_t aStretch,
+gfxFloat aSize, nsIAtom *aLanguage,
+float aSizeAdjust, bool aSystemFont,
+bool aPrinterFont,
+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
+nsRefPtr<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
+nsRefPtr<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 0 means no adjustment
+// needs to be done.
+float sizeAdjust;
+// 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;
+// Return the final adjusted font size for the given aspect ratio.
+// Not meant to be called when sizeAdjust = 0.
+gfxFloat GetAdjustedSize(gfxFloat aspect) const {
+NS_ASSERTION(sizeAdjust != 0.0, "Not meant to be called when sizeAdjust = 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;
+bool Equals(const gfxFontStyle& other) const {
+return
+(*reinterpret_cast<const uint64_t*>(&size) ==
+*reinterpret_cast<const uint64_t*>(&other.size)) &&
+(style == other.style) &&
+(systemFont == other.systemFont) &&
+(printerFont == other.printerFont) &&
+(useGrayscaleAntialiasing == other.useGrayscaleAntialiasing) &&
+(weight == other.weight) &&
+(stretch == other.stretch) &&
+(language == other.language) &&
+(*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);
+};
+class gfxCharacterMap : public gfxSparseBitSet {
+public:
+nsrefcnt AddRef() {
+NS_PRECONDITION(int32_t(mRefCnt) >= 0, "illegal refcnt");
+++mRefCnt;
+NS_LOG_ADDREF(this, mRefCnt, "gfxCharacterMap", sizeof(*this));
+return mRefCnt;
+}
+nsrefcnt Release() {
+NS_PRECONDITION(0 != mRefCnt, "dup release");
+--mRefCnt;
+NS_LOG_RELEASE(this, mRefCnt, "gfxCharacterMap");
+if (mRefCnt == 0) {
+NotifyReleased();
+// |this| has been deleted.
+return 0;
+}
+return mRefCnt;
+}
+gfxCharacterMap() :
+mHash(0), mBuildOnTheFly(false), mShared(false)
+{ }
+void CalcHash() { mHash = GetChecksum(); }
+size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+return gfxSparseBitSet::SizeOfExcludingThis(aMallocSizeOf);
+}
+// hash of the cmap bitvector
+uint32_t mHash;
+// if cmap is built on the fly it's never shared
+bool mBuildOnTheFly;
+// cmap is shared globally
+bool mShared;
+protected:
+void NotifyReleased();
+nsAutoRefCnt mRefCnt;
+private:
+gfxCharacterMap(const gfxCharacterMap&);
+gfxCharacterMap& operator=(const gfxCharacterMap&);
+};
+class gfxFontEntry {
+public:
+NS_INLINE_DECL_REFCOUNTING(gfxFontEntry)
+gfxFontEntry(const nsAString& aName, bool aIsStandardFace = false);
+// unique name for the face, *not* the family; not necessarily the
+// "real" or user-friendly name, may be an internal identifier
+const nsString& Name() const { return mName; }
+// family name
+const nsString& FamilyName() const { return mFamilyName; }
+// The following two methods may be relatively expensive, as they
+// will (usually, except on Linux) load and parse the 'name' table;
+// they are intended only for the font-inspection API, not for
+// perf-critical layout/drawing work.
+// The "real" name of the face, if available from the font resource;
+// returns Name() if nothing better is available.
+virtual nsString RealFaceName();
+uint16_t Weight() const { return mWeight; }
+int16_t Stretch() const { return mStretch; }
+bool IsUserFont() const { return mIsUserFont; }
+bool IsLocalUserFont() const { return mIsLocalUserFont; }
+bool IsFixedPitch() const { return mFixedPitch; }
+bool IsItalic() const { return mItalic; }
+bool IsBold() const { return mWeight >= 600; } // bold == weights 600 and above
+bool IgnoreGDEF() const { return mIgnoreGDEF; }
+bool IgnoreGSUB() const { return mIgnoreGSUB; }
+virtual bool IsSymbolFont();
+virtual bool HasFontTable(uint32_t aTableTag);
+inline bool HasGraphiteTables() {
+if (!mCheckedForGraphiteTables) {
+CheckForGraphiteTables();
+mCheckedForGraphiteTables = true;
+}
+return mHasGraphiteTables;
+}
+inline bool HasCmapTable() {
+if (!mCharacterMap) {
+ReadCMAP();
+NS_ASSERTION(mCharacterMap, "failed to initialize character map");
+}
+return mHasCmapTable;
+}
+inline bool HasCharacter(uint32_t ch) {
+if (mCharacterMap && mCharacterMap->test(ch)) {
+return true;
+}
+return TestCharacterMap(ch);
+}
+virtual bool SkipDuringSystemFallback() { return false; }
+virtual bool TestCharacterMap(uint32_t aCh);
+nsresult InitializeUVSMap();
+uint16_t GetUVSGlyph(uint32_t aCh, uint32_t aVS);
+// All concrete gfxFontEntry subclasses (except gfxProxyFontEntry) need
+// to override this, otherwise the font will never be used as it will
+// be considered to support no characters.
+// ReadCMAP() must *always* set the mCharacterMap pointer to a valid
+// gfxCharacterMap, even if empty, as other code assumes this pointer
+// can be safely dereferenced.
+virtual nsresult ReadCMAP(FontInfoData *aFontInfoData = nullptr);
+bool TryGetSVGData(gfxFont* aFont);
+bool HasSVGGlyph(uint32_t aGlyphId);
+bool GetSVGGlyphExtents(gfxContext *aContext, uint32_t aGlyphId,
+gfxRect *aResult);
+bool RenderSVGGlyph(gfxContext *aContext, uint32_t aGlyphId, int aDrawMode,
+gfxTextContextPaint *aContextPaint);
+// Call this when glyph geometry or rendering has changed
+// (e.g. animated SVG glyphs)
+void NotifyGlyphsChanged();
+enum MathConstant {
+// The order of the constants must match the order of the fields
+// defined in the MATH table.
+ScriptPercentScaleDown,
+ScriptScriptPercentScaleDown,
+DelimitedSubFormulaMinHeight,
+DisplayOperatorMinHeight,
+MathLeading,
+AxisHeight,
+AccentBaseHeight,
+FlattenedAccentBaseHeight,
+SubscriptShiftDown,
+SubscriptTopMax,
+SubscriptBaselineDropMin,
+SuperscriptShiftUp,
+SuperscriptShiftUpCramped,
+SuperscriptBottomMin,
+SuperscriptBaselineDropMax,
+SubSuperscriptGapMin,
+SuperscriptBottomMaxWithSubscript,
+SpaceAfterScript,
+UpperLimitGapMin,
+UpperLimitBaselineRiseMin,
+LowerLimitGapMin,
+LowerLimitBaselineDropMin,
+StackTopShiftUp,
+StackTopDisplayStyleShiftUp,
+StackBottomShiftDown,
+StackBottomDisplayStyleShiftDown,
+StackGapMin,
+StackDisplayStyleGapMin,
+StretchStackTopShiftUp,
+StretchStackBottomShiftDown,
+StretchStackGapAboveMin,
+StretchStackGapBelowMin,
+FractionNumeratorShiftUp,
+FractionNumeratorDisplayStyleShiftUp,
+FractionDenominatorShiftDown,
+FractionDenominatorDisplayStyleShiftDown,
+FractionNumeratorGapMin,
+FractionNumDisplayStyleGapMin,
+FractionRuleThickness,
+FractionDenominatorGapMin,
+FractionDenomDisplayStyleGapMin,
+SkewedFractionHorizontalGap,
+SkewedFractionVerticalGap,
+OverbarVerticalGap,
+OverbarRuleThickness,
+OverbarExtraAscender,
+UnderbarVerticalGap,
+UnderbarRuleThickness,
+UnderbarExtraDescender,
+RadicalVerticalGap,
+RadicalDisplayStyleVerticalGap,
+RadicalRuleThickness,
+RadicalExtraAscender,
+RadicalKernBeforeDegree,
+RadicalKernAfterDegree,
+RadicalDegreeBottomRaisePercent
+};
+// Call TryGetMathTable to try to load the Open Type MATH table. The other
+// functions forward the call to the gfxMathTable class. The GetMath...()
+// functions MUST NOT be called unless TryGetMathTable() has returned true.
+bool     TryGetMathTable(gfxFont* aFont);
+gfxFloat GetMathConstant(MathConstant aConstant);
+bool     GetMathItalicsCorrection(uint32_t aGlyphID,
+gfxFloat* aItalicCorrection);
+uint32_t GetMathVariantsSize(uint32_t aGlyphID, bool aVertical,
+uint16_t aSize);
+bool     GetMathVariantsParts(uint32_t aGlyphID, bool aVertical,
+uint32_t aGlyphs[4]);
+virtual bool MatchesGenericFamily(const nsACString& aGeneric) const {
+return true;
+}
+virtual bool SupportsLangGroup(nsIAtom *aLangGroup) const {
+return true;
+}
+// Access to raw font table data (needed for Harfbuzz):
+// returns a pointer to data owned by the fontEntry or the OS,
+// which will remain valid until the blob is destroyed.
+// The data MUST be treated as read-only; we may be getting a
+// reference to a shared system font cache.
+//
+// The default implementation uses CopyFontTable to get the data
+// into a byte array, and maintains a cache of loaded tables.
+//
+// Subclasses should override this if they can provide more efficient
+// access than copying table data into our own buffers.
+//
+// Get blob that encapsulates a specific font table, or nullptr if
+// the table doesn't exist in the font.
+//
+// Caller is responsible to call hb_blob_destroy() on the returned blob
+// (if non-nullptr) when no longer required. For transient access to a
+// table, use of AutoTable (below) is generally preferred.
+virtual hb_blob_t *GetFontTable(uint32_t aTag);
+// Stack-based utility to return a specified table, automatically releasing
+// the blob when the AutoTable goes out of scope.
+class AutoTable {
+public:
+AutoTable(gfxFontEntry* aFontEntry, uint32_t aTag)
+{
+mBlob = aFontEntry->GetFontTable(aTag);
+}
+~AutoTable() {
+if (mBlob) {
+hb_blob_destroy(mBlob);
+}
+}
+operator hb_blob_t*() const { return mBlob; }
+private:
+hb_blob_t* mBlob;
+// not implemented:
+AutoTable(const AutoTable&) MOZ_DELETE;
+AutoTable& operator=(const AutoTable&) MOZ_DELETE;
+};
+already_AddRefed<gfxFont> FindOrMakeFont(const gfxFontStyle *aStyle,
+bool aNeedsBold);
+// Get an existing font table cache entry in aBlob if it has been
+// registered, or return false if not.  Callers must call
+// hb_blob_destroy on aBlob if true is returned.
+//
+// Note that some gfxFont implementations may not call this at all,
+// if it is more efficient to get the table from the OS at that level.
+bool GetExistingFontTable(uint32_t aTag, hb_blob_t** aBlob);
+// Elements of aTable are transferred (not copied) to and returned in a
+// new hb_blob_t which is registered on the gfxFontEntry, but the initial
+// reference is owned by the caller.  Removing the last reference
+// unregisters the table from the font entry.
+//
+// Pass nullptr for aBuffer to indicate that the table is not present and
+// nullptr will be returned.  Also returns nullptr on OOM.
+hb_blob_t *ShareFontTableAndGetBlob(uint32_t aTag,
+FallibleTArray<uint8_t>* aTable);
+// Get the font's unitsPerEm from the 'head' table, in the case of an
+// sfnt resource. Will return kInvalidUPEM for non-sfnt fonts,
+// if present on the platform.
+uint16_t UnitsPerEm();
+enum {
+kMinUPEM = 16,    // Limits on valid unitsPerEm range, from the
+kMaxUPEM = 16384, // OpenType spec
+kInvalidUPEM = uint16_t(-1)
+};
+// Shaper face accessors:
+// NOTE that harfbuzz and graphite handle ownership/lifetime of the face
+// object in completely different ways.
+// Get HarfBuzz face corresponding to this font file.
+// Caller must release with hb_face_destroy() when finished with it,
+// and the font entry will be notified via ForgetHBFace.
+hb_face_t* GetHBFace();
+virtual void ForgetHBFace();
+// Get Graphite face corresponding to this font file.
+// Caller must call gfxFontEntry::ReleaseGrFace when finished with it.
+gr_face* GetGrFace();
+virtual void ReleaseGrFace(gr_face* aFace);
+// Release any SVG-glyphs document this font may have loaded.
+void DisconnectSVG();
+// Called to notify that aFont is being destroyed. Needed when we're tracking
+// the fonts belonging to this font entry.
+void NotifyFontDestroyed(gfxFont* aFont);
+// For memory reporting
+virtual void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+FontListSizes* aSizes) const;
+virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+FontListSizes* aSizes) const;
+// Used when checking for complex script support, to mask off cmap ranges
+struct ScriptRange {
+uint32_t         rangeStart;
+uint32_t         rangeEnd;
+hb_tag_t         tags[3]; // one or two OpenType script tags to check,
+// plus a NULL terminator
+};
+bool SupportsScriptInGSUB(const hb_tag_t* aScriptTags);
+nsString         mName;
+nsString         mFamilyName;
+bool             mItalic      : 1;
+bool             mFixedPitch  : 1;
+bool             mIsProxy     : 1;
+bool             mIsValid     : 1;
+bool             mIsBadUnderlineFont : 1;
+bool             mIsUserFont  : 1;
+bool             mIsLocalUserFont  : 1;
+bool             mStandardFace : 1;
+bool             mSymbolFont  : 1;
+bool             mIgnoreGDEF  : 1;
+bool             mIgnoreGSUB  : 1;
+bool             mSVGInitialized : 1;
+bool             mMathInitialized : 1;
+bool             mHasSpaceFeaturesInitialized : 1;
+bool             mHasSpaceFeatures : 1;
+bool             mHasSpaceFeaturesKerning : 1;
+bool             mHasSpaceFeaturesNonKerning : 1;
+bool             mSkipDefaultFeatureSpaceCheck : 1;
+bool             mHasGraphiteTables : 1;
+bool             mCheckedForGraphiteTables : 1;
+bool             mHasCmapTable : 1;
+bool             mGrFaceInitialized : 1;
+// bitvector of substitution space features per script, one each
+// for default and non-default features
+uint32_t         mDefaultSubSpaceFeatures[(MOZ_NUM_SCRIPT_CODES + 31) / 32];
+uint32_t         mNonDefaultSubSpaceFeatures[(MOZ_NUM_SCRIPT_CODES + 31) / 32];
+uint16_t         mWeight;
+int16_t          mStretch;
+nsRefPtr<gfxCharacterMap> mCharacterMap;
+uint32_t         mUVSOffset;
+nsAutoArrayPtr<uint8_t> mUVSData;
+nsAutoPtr<gfxUserFontData> mUserFontData;
+nsAutoPtr<gfxSVGGlyphs> mSVGGlyphs;
+// list of gfxFonts that are using SVG glyphs
+nsTArray<gfxFont*> mFontsUsingSVGGlyphs;
+nsAutoPtr<gfxMathTable> mMathTable;
+nsTArray<gfxFontFeature> mFeatureSettings;
+uint32_t         mLanguageOverride;
+protected:
+friend class gfxPlatformFontList;
+friend class gfxMacPlatformFontList;
+friend class gfxUserFcFontEntry;
+friend class gfxFontFamily;
+friend class gfxSingleFaceMacFontFamily;
+gfxFontEntry();
+// Protected destructor, to discourage deletion outside of Release():
+virtual ~gfxFontEntry();
+virtual gfxFont *CreateFontInstance(const gfxFontStyle *aFontStyle, bool aNeedsBold) {
+NS_NOTREACHED("oops, somebody didn't override CreateFontInstance");
+return nullptr;
+}
+virtual void CheckForGraphiteTables();
+// Copy a font table into aBuffer.
+// The caller will be responsible for ownership of the data.
+virtual nsresult CopyFontTable(uint32_t aTableTag,
+FallibleTArray<uint8_t>& aBuffer) {
+NS_NOTREACHED("forgot to override either GetFontTable or CopyFontTable?");
+return NS_ERROR_FAILURE;
+}
+// Return a blob that wraps a table found within a buffer of font data.
+// The blob does NOT own its data; caller guarantees that the buffer
+// will remain valid at least as long as the blob.
+// Returns null if the specified table is not found.
+// This method assumes aFontData is valid 'sfnt' data; before using this,
+// caller is responsible to do any sanitization/validation necessary.
+hb_blob_t* GetTableFromFontData(const void* aFontData, uint32_t aTableTag);
+// lookup the cmap in cached font data
+virtual already_AddRefed<gfxCharacterMap>
+GetCMAPFromFontInfo(FontInfoData *aFontInfoData,
+uint32_t& aUVSOffset,
+bool& aSymbolFont);
+// Font's unitsPerEm from the 'head' table, if available (will be set to
+// kInvalidUPEM for non-sfnt font formats)
+uint16_t mUnitsPerEm;
+// Shaper-specific face objects, shared by all instantiations of the same
+// physical font, regardless of size.
+// Usually, only one of these will actually be created for any given font
+// entry, depending on the font tables that are present.
+// hb_face_t is refcounted internally, so each shaper that's using it will
+// bump the ref count when it acquires the face, and "destroy" (release) it
+// in its destructor. The font entry has only this non-owning reference to
+// the face; when the face is deleted, it will tell the font entry to forget
+// it, so that a new face will be created next time it is needed.
+hb_face_t* mHBFace;
+static hb_blob_t* HBGetTable(hb_face_t *face, uint32_t aTag, void *aUserData);
+// Callback that the hb_face will use to tell us when it is being deleted.
+static void HBFaceDeletedCallback(void *aUserData);
+// gr_face is -not- refcounted, so it will be owned directly by the font
+// entry, and we'll keep a count of how many references we've handed out;
+// each shaper is responsible to call ReleaseGrFace on its entry when
+// finished with it, so that we know when it can be deleted.
+gr_face*   mGrFace;
+// hashtable to map raw table data ptr back to its owning blob, for use by
+// graphite table-release callback
+nsDataHashtable<nsPtrHashKey<const void>,void*>* mGrTableMap;
+// number of current users of this entry's mGrFace
+nsrefcnt mGrFaceRefCnt;
+static const void* GrGetTable(const void *aAppFaceHandle,
+unsigned int aName,
+size_t *aLen);
+static void GrReleaseTable(const void *aAppFaceHandle,
+const void *aTableBuffer);
+private:
+/**
+* Font table hashtable, to support GetFontTable for harfbuzz.
+*
+* The harfbuzz shaper (and potentially other clients) needs access to raw
+* font table data. This needs to be cached so that it can be used
+* repeatedly (each time we construct a text run; in some cases, for
+* each character/glyph within the run) without re-fetching large tables
+* every time.
+*
+* Because we may instantiate many gfxFonts for the same physical font
+* file (at different sizes), we should ensure that they can share a
+* single cached copy of the font tables. To do this, we implement table
+* access and sharing on the fontEntry rather than the font itself.
+*
+* The default implementation uses GetFontTable() to read font table
+* data into byte arrays, and wraps them in blobs which are registered in
+* a hashtable.  The hashtable can then return pre-existing blobs to
+* harfbuzz.
+*
+* Harfbuzz will "destroy" the blobs when it is finished with them.  When
+* the last blob reference is removed, the FontTableBlobData user data
+* will remove the blob from the hashtable if still registered.
+*/
+class FontTableBlobData;
+/**
+* FontTableHashEntry manages the entries of hb_blob_t's containing font
+* table data.
+*
+* This is used to share font tables across fonts with the same
+* font entry (but different sizes) for use by HarfBuzz.  The hashtable
+* does not own a strong reference to the blob, but keeps a weak pointer,
+* managed by FontTableBlobData.  Similarly FontTableBlobData keeps only a
+* weak pointer to the hashtable, managed by FontTableHashEntry.
+*/
+class FontTableHashEntry : public nsUint32HashKey
+{
+public:
+// Declarations for nsTHashtable
+typedef nsUint32HashKey KeyClass;
+typedef KeyClass::KeyType KeyType;
+typedef KeyClass::KeyTypePointer KeyTypePointer;
+FontTableHashEntry(KeyTypePointer aTag)
+: KeyClass(aTag)
+, mSharedBlobData(nullptr)
+, mBlob(nullptr)
+{ }
+// NOTE: This assumes the new entry belongs to the same hashtable as
+// the old, because the mHashtable pointer in mSharedBlobData (if
+// present) will not be updated.
+FontTableHashEntry(FontTableHashEntry&& toMove)
+: KeyClass(mozilla::Move(toMove))
+, mSharedBlobData(mozilla::Move(toMove.mSharedBlobData))
+, mBlob(mozilla::Move(toMove.mBlob))
+{
+toMove.mSharedBlobData = nullptr;
+toMove.mBlob = nullptr;
+}
+~FontTableHashEntry() { Clear(); }
+// FontTable/Blob API
+// Transfer (not copy) elements of aTable to a new hb_blob_t and
+// return ownership to the caller.  A weak reference to the blob is
+// recorded in the hashtable entry so that others may use the same
+// table.
+hb_blob_t *
+ShareTableAndGetBlob(FallibleTArray<uint8_t>& aTable,
+nsTHashtable<FontTableHashEntry> *aHashtable);
+// Return a strong reference to the blob.
+// Callers must hb_blob_destroy the returned blob.
+hb_blob_t *GetBlob() const;
+void Clear();
+static size_t
+SizeOfEntryExcludingThis(FontTableHashEntry *aEntry,
+mozilla::MallocSizeOf aMallocSizeOf,
+void* aUserArg);
+private:
+static void DeleteFontTableBlobData(void *aBlobData);
+// not implemented
+FontTableHashEntry& operator=(FontTableHashEntry& toCopy);
+FontTableBlobData *mSharedBlobData;
+hb_blob_t *mBlob;
+};
+nsAutoPtr<nsTHashtable<FontTableHashEntry> > mFontTableCache;
+gfxFontEntry(const gfxFontEntry&);
+gfxFontEntry& operator=(const gfxFontEntry&);
+};
+// used when iterating over all fonts looking for a match for a given character
+struct GlobalFontMatch {
+GlobalFontMatch(const uint32_t aCharacter,
+int32_t aRunScript,
+const gfxFontStyle *aStyle) :
+mCh(aCharacter), mRunScript(aRunScript), mStyle(aStyle),
+mMatchRank(0), mCount(0), mCmapsTested(0)
+{
+}
+const uint32_t         mCh;          // codepoint to be matched
+int32_t                mRunScript;   // Unicode script for the codepoint
+const gfxFontStyle*    mStyle;       // style to match
+int32_t                mMatchRank;   // metric indicating closest match
+nsRefPtr<gfxFontEntry> mBestMatch;   // current best match
+nsRefPtr<gfxFontFamily> mMatchedFamily; // the family it belongs to
+uint32_t               mCount;       // number of fonts matched
+uint32_t               mCmapsTested; // number of cmaps tested
+};
+class gfxFontFamily {
+public:
+NS_INLINE_DECL_REFCOUNTING(gfxFontFamily)
+gfxFontFamily(const nsAString& aName) :
+mName(aName),
+mOtherFamilyNamesInitialized(false),
+mHasOtherFamilyNames(false),
+mFaceNamesInitialized(false),
+mHasStyles(false),
+mIsSimpleFamily(false),
+mIsBadUnderlineFamily(false),
+mFamilyCharacterMapInitialized(false),
+mSkipDefaultFeatureSpaceCheck(false)
+{ }
+const nsString& Name() { return mName; }
+virtual void LocalizedName(nsAString& aLocalizedName);
+virtual bool HasOtherFamilyNames();
+nsTArray<nsRefPtr<gfxFontEntry> >& GetFontList() { return mAvailableFonts; }
+void AddFontEntry(nsRefPtr<gfxFontEntry> aFontEntry) {
+// bug 589682 - set the IgnoreGDEF flag on entries for Italic faces
+// of Times New Roman, because of buggy table in those fonts
+if (aFontEntry->IsItalic() && !aFontEntry->IsUserFont() &&
+Name().EqualsLiteral("Times New Roman"))
+{
+aFontEntry->mIgnoreGDEF = true;
+}
+aFontEntry->mFamilyName = Name();
+aFontEntry->mSkipDefaultFeatureSpaceCheck = mSkipDefaultFeatureSpaceCheck;
+mAvailableFonts.AppendElement(aFontEntry);
+}
+// note that the styles for this family have been added
+bool HasStyles() { return mHasStyles; }
+void SetHasStyles(bool aHasStyles) { mHasStyles = aHasStyles; }
+// choose a specific face to match a style using CSS font matching
+// rules (weight matching occurs here).  may return a face that doesn't
+// precisely match (e.g. normal face when no italic face exists).
+// aNeedsSyntheticBold is set to true when synthetic bolding is
+// needed, false otherwise
+gfxFontEntry *FindFontForStyle(const gfxFontStyle& aFontStyle,
+bool& aNeedsSyntheticBold);
+// checks for a matching font within the family
+// used as part of the font fallback process
+void FindFontForChar(GlobalFontMatch *aMatchData);
+// checks all fonts for a matching font within the family
+void SearchAllFontsForChar(GlobalFontMatch *aMatchData);
+// read in other family names, if any, and use functor to add each into cache
+virtual void ReadOtherFamilyNames(gfxPlatformFontList *aPlatformFontList);
+// helper method for reading localized family names from the name table
+// of a single face
+static void ReadOtherFamilyNamesForFace(const nsAString& aFamilyName,
+const char *aNameData,
+uint32_t aDataLength,
+nsTArray<nsString>& aOtherFamilyNames,
+bool useFullName);
+// set when other family names have been read in
+void SetOtherFamilyNamesInitialized() {
+mOtherFamilyNamesInitialized = true;
+}
+// read in other localized family names, fullnames and Postscript names
+// for all faces and append to lookup tables
+virtual void ReadFaceNames(gfxPlatformFontList *aPlatformFontList,
+bool aNeedFullnamePostscriptNames,
+FontInfoData *aFontInfoData = nullptr);
+// find faces belonging to this family (platform implementations override this;
+// should be made pure virtual once all subclasses have been updated)
+virtual void FindStyleVariations(FontInfoData *aFontInfoData = nullptr) { }
+// search for a specific face using the Postscript name
+gfxFontEntry* FindFont(const nsAString& aPostscriptName);
+// read in cmaps for all the faces
+void ReadAllCMAPs(FontInfoData *aFontInfoData = nullptr);
+bool TestCharacterMap(uint32_t aCh) {
+if (!mFamilyCharacterMapInitialized) {
+ReadAllCMAPs();
+}
+return mFamilyCharacterMap.test(aCh);
+}
+void ResetCharacterMap() {
+mFamilyCharacterMap.reset();
+mFamilyCharacterMapInitialized = false;
+}
+// mark this family as being in the "bad" underline offset blacklist
+void SetBadUnderlineFamily() {
+mIsBadUnderlineFamily = true;
+if (mHasStyles) {
+SetBadUnderlineFonts();
+}
+}
+bool IsBadUnderlineFamily() const { return mIsBadUnderlineFamily; }
+// sort available fonts to put preferred (standard) faces towards the end
+void SortAvailableFonts();
+// check whether the family fits into the simple 4-face model,
+// so we can use simplified style-matching;
+// if so set the mIsSimpleFamily flag (defaults to False before we've checked)
+void CheckForSimpleFamily();
+// For memory reporter
+virtual void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+FontListSizes* aSizes) const;
+virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+FontListSizes* aSizes) const;
+// Only used for debugging checks - does a linear search
+bool ContainsFace(gfxFontEntry* aFontEntry) {
+uint32_t i, numFonts = mAvailableFonts.Length();
+for (i = 0; i < numFonts; i++) {
+if (mAvailableFonts[i] == aFontEntry) {
+return true;
+}
+}
+return false;
+}
+void SetSkipSpaceFeatureCheck(bool aSkipCheck) {
+mSkipDefaultFeatureSpaceCheck = aSkipCheck;
+}
+protected:
+// Protected destructor, to discourage deletion outside of Release():
+virtual ~gfxFontFamily()
+{
+}
+// fills in an array with weights of faces that match style,
+// returns whether any matching entries found
+virtual bool FindWeightsForStyle(gfxFontEntry* aFontsForWeights[],
+bool anItalic, int16_t aStretch);
+bool ReadOtherFamilyNamesForFace(gfxPlatformFontList *aPlatformFontList,
+hb_blob_t           *aNameTable,
+bool                 useFullName = false);
+// set whether this font family is in "bad" underline offset blacklist.
+void SetBadUnderlineFonts() {
+uint32_t i, numFonts = mAvailableFonts.Length();
+for (i = 0; i < numFonts; i++) {
+if (mAvailableFonts[i]) {
+mAvailableFonts[i]->mIsBadUnderlineFont = true;
+}
+}
+}
+nsString mName;
+nsTArray<nsRefPtr<gfxFontEntry> >  mAvailableFonts;
+gfxSparseBitSet mFamilyCharacterMap;
+bool mOtherFamilyNamesInitialized : 1;
+bool mHasOtherFamilyNames : 1;
+bool mFaceNamesInitialized : 1;
+bool mHasStyles : 1;
+bool mIsSimpleFamily : 1;
+bool mIsBadUnderlineFamily : 1;
+bool mFamilyCharacterMapInitialized : 1;
+bool mSkipDefaultFeatureSpaceCheck : 1;
+enum {
+// for "simple" families, the faces are stored in mAvailableFonts
+// with fixed positions:
+kRegularFaceIndex    = 0,
+kBoldFaceIndex       = 1,
+kItalicFaceIndex     = 2,
+kBoldItalicFaceIndex = 3,
+// mask values for selecting face with bold and/or italic attributes
+kBoldMask   = 0x01,
+kItalicMask = 0x02
+};
+};
+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)
+: start(aStart),
+end(aEnd),
+font(aFont),
+matchType(aMatchType)
+{ }
+uint32_t Length() const { return end - start; }
+uint32_t start, end;
+nsRefPtr<gfxFont> font;
+uint8_t matchType;
+};
+/**
+* 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 MOZ_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);
+// 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);
+// 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() {
+mFonts.EnumerateEntries(ClearCachedWordsForFont, nullptr);
+}
+void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+FontCacheSizes* aSizes) const;
+void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+FontCacheSizes* aSizes) const;
+protected:
+class MemoryReporter MOZ_FINAL : public nsIMemoryReporter
+{
+public:
+NS_DECL_ISUPPORTS
+NS_DECL_NSIMEMORYREPORTER
+};
+// Observer for notifications that the font cache cares about
+class Observer MOZ_FINAL
+: public nsIObserver
+{
+public:
+NS_DECL_ISUPPORTS
+NS_DECL_NSIOBSERVER
+};
+void DestroyFont(gfxFont *aFont);
+static gfxFontCache *gGlobalCache;
+struct Key {
+const gfxFontEntry* mFontEntry;
+const gfxFontStyle* mStyle;
+Key(const gfxFontEntry* aFontEntry, const gfxFontStyle* aStyle)
+: mFontEntry(aFontEntry), mStyle(aStyle) {}
+};
+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.
+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);
+}
+enum { ALLOW_MEMMOVE = true };
+gfxFont* mFont;
+};
+static size_t AddSizeOfFontEntryExcludingThis(HashEntry* aHashEntry,
+mozilla::MallocSizeOf aMallocSizeOf,
+void* aUserArg);
+nsTHashtable<HashEntry> mFonts;
+static PLDHashOperator ClearCachedWordsForFont(HashEntry* aHashEntry, void*);
+static PLDHashOperator AgeCachedWordsForFont(HashEntry* aHashEntry, void*);
+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 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;
+memset(&current, 0, sizeof(current));
+}
+};
+class gfxTextRunFactory {
+NS_INLINE_DECL_REFCOUNTING(gfxTextRunFactory)
+public:
+// 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,
+PLATFORM_TEXT_FLAGS = 0x0000F000,
+TEXTRUN_TEXT_FLAGS  = 0x00000FFF,
+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,
+/**
+* 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,
+TEXT_UNUSED_FLAGS = 0x10000000
+};
+/**
+* This record contains all the parameters needed to initialize a textrun.
+*/
+struct Parameters {
+// A reference context suggesting where the textrun will be rendered
+gfxContext   *mContext;
+// 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() {}
+};
+/**
+* This stores glyph bounds information for a particular gfxFont, at
+* a particular appunits-per-dev-pixel ratio (because the compressed glyph
+* width array is stored in appunits).
+*
+* We store a hashtable from glyph IDs to float bounding rects. For the
+* common case where the glyph has no horizontal left bearing, and no
+* y overflow above the font ascent or below the font descent, and tight
+* bounding boxes are not required, we avoid storing the glyph ID in the hashtable
+* and instead consult an array of 16-bit glyph XMost values (in appunits).
+* This array always has an entry for the font's space glyph --- the width is
+* assumed to be zero.
+*/
+class gfxGlyphExtents {
+public:
+gfxGlyphExtents(int32_t aAppUnitsPerDevUnit) :
+mAppUnitsPerDevUnit(aAppUnitsPerDevUnit) {
+MOZ_COUNT_CTOR(gfxGlyphExtents);
+}
+~gfxGlyphExtents();
+enum { INVALID_WIDTH = 0xFFFF };
+void NotifyGlyphsChanged() {
+mTightGlyphExtents.Clear();
+}
+// returns INVALID_WIDTH => not a contained glyph
+// Otherwise the glyph has no before-bearing or vertical bearings,
+// and the result is its width measured from the baseline origin, in
+// appunits.
+uint16_t GetContainedGlyphWidthAppUnits(uint32_t aGlyphID) const {
+return mContainedGlyphWidths.Get(aGlyphID);
+}
+bool IsGlyphKnown(uint32_t aGlyphID) const {
+return mContainedGlyphWidths.Get(aGlyphID) != INVALID_WIDTH ||
+mTightGlyphExtents.GetEntry(aGlyphID) != nullptr;
+}
+bool IsGlyphKnownWithTightExtents(uint32_t aGlyphID) const {
+return mTightGlyphExtents.GetEntry(aGlyphID) != nullptr;
+}
+// Get glyph extents; a rectangle relative to the left baseline origin
+// Returns true on success. Can fail on OOM or when aContext is null
+// and extents were not (successfully) prefetched.
+bool GetTightGlyphExtentsAppUnits(gfxFont *aFont, gfxContext *aContext,
+uint32_t aGlyphID, gfxRect *aExtents);
+void SetContainedGlyphWidthAppUnits(uint32_t aGlyphID, uint16_t aWidth) {
+mContainedGlyphWidths.Set(aGlyphID, aWidth);
+}
+void SetTightGlyphExtents(uint32_t aGlyphID, const gfxRect& aExtentsAppUnits);
+int32_t GetAppUnitsPerDevUnit() { return mAppUnitsPerDevUnit; }
+size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+private:
+class HashEntry : public nsUint32HashKey {
+public:
+// When constructing a new entry in the hashtable, we'll leave this
+// blank. The caller of Put() will fill this in.
+HashEntry(KeyTypePointer aPtr) : nsUint32HashKey(aPtr) {}
+HashEntry(const HashEntry& toCopy) : nsUint32HashKey(toCopy) {
+x = toCopy.x; y = toCopy.y; width = toCopy.width; height = toCopy.height;
+}
+float x, y, width, height;
+};
+enum { BLOCK_SIZE_BITS = 7, BLOCK_SIZE = 1 << BLOCK_SIZE_BITS }; // 128-glyph blocks
+class GlyphWidths {
+public:
+void Set(uint32_t aIndex, uint16_t aValue);
+uint16_t Get(uint32_t aIndex) const {
+uint32_t block = aIndex >> BLOCK_SIZE_BITS;
+if (block >= mBlocks.Length())
+return INVALID_WIDTH;
+uintptr_t bits = mBlocks[block];
+if (!bits)
+return INVALID_WIDTH;
+uint32_t indexInBlock = aIndex & (BLOCK_SIZE - 1);
+if (bits & 0x1) {
+if (GetGlyphOffset(bits) != indexInBlock)
+return INVALID_WIDTH;
+return GetWidth(bits);
+}
+uint16_t *widths = reinterpret_cast<uint16_t *>(bits);
+return widths[indexInBlock];
+}
+uint32_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+~GlyphWidths();
+private:
+static uint32_t GetGlyphOffset(uintptr_t aBits) {
+NS_ASSERTION(aBits & 0x1, "This is really a pointer...");
+return (aBits >> 1) & ((1 << BLOCK_SIZE_BITS) - 1);
+}
+static uint32_t GetWidth(uintptr_t aBits) {
+NS_ASSERTION(aBits & 0x1, "This is really a pointer...");
+return aBits >> (1 + BLOCK_SIZE_BITS);
+}
+static uintptr_t MakeSingle(uint32_t aGlyphOffset, uint16_t aWidth) {
+return (aWidth << (1 + BLOCK_SIZE_BITS)) + (aGlyphOffset << 1) + 1;
+}
+nsTArray<uintptr_t> mBlocks;
+};
+GlyphWidths             mContainedGlyphWidths;
+nsTHashtable<HashEntry> mTightGlyphExtents;
+int32_t                 mAppUnitsPerDevUnit;
+private:
+// not implemented:
+gfxGlyphExtents(const gfxGlyphExtents& aOther) MOZ_DELETE;
+gfxGlyphExtents& operator=(const gfxGlyphExtents& aOther) MOZ_DELETE;
+};
+/**
+* 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:
+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(gfxContext      *aContext,
+const char16_t *aText,
+uint32_t         aOffset,
+uint32_t         aLength,
+int32_t          aScript,
+gfxShapedText   *aShapedText) = 0;
+gfxFont *GetFont() const { return mFont; }
+// returns true if features exist in output, false otherwise
+static bool
+MergeFontFeatures(const gfxFontStyle *aStyle,
+const nsTArray<gfxFontFeature>& aFontFeatures,
+bool aDisableLigatures,
+const nsAString& aFamilyName,
+nsDataHashtable<nsUint32HashKey,uint32_t>& aMergedFeatures);
+protected:
+// the font this shaper is working with
+gfxFont * mFont;
+};
+/* a SPECIFIC single font family */
+class gfxFont {
+friend class gfxHarfBuzzShaper;
+friend class gfxGraphiteShaper;
+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;
+}
+virtual gfxFloat GetAdjustedSize() {
+return mAdjustedSize > 0.0 ? mAdjustedSize : 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();
+}
+// 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(gfxContext *aCtx, uint16_t aGID);
+// Return Azure GlyphRenderingOptions for drawing this font.
+virtual mozilla::TemporaryRef<mozilla::gfx::GlyphRenderingOptions>
+GetGlyphRenderingOptions() { return nullptr; }
+gfxFloat SynthesizeSpaceWidth(uint32_t aCh);
+// Font metrics
+struct Metrics {
+gfxFloat xHeight;
+gfxFloat superscriptOffset;
+gfxFloat subscriptOffset;
+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
+};
+virtual const gfxFont::Metrics& GetMetrics() = 0;
+/**
+* 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 aBaselineOrigin the baseline origin; the left end of the baseline
+* for LTR textruns, the right end of the baseline for RTL textruns. On return,
+* this should be updated to the other end of the baseline. In application
+* units, really!
+* @param aSpacing 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.
+* @param aDrawMode specifies whether the fill or stroke of the glyph should be
+* drawn, or if it should be drawn into the current path
+* @param aContextPaint 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 aContext should be used for filling
+*
+* Callers guarantee:
+* -- aStart and aEnd are aligned to cluster and ligature boundaries
+* -- all glyphs use this font
+*
+* The default implementation builds a cairo glyph array and
+* calls cairo_show_glyphs or cairo_glyph_path.
+*/
+virtual void Draw(gfxTextRun *aTextRun, uint32_t aStart, uint32_t aEnd,
+gfxContext *aContext, DrawMode aDrawMode, gfxPoint *aBaselineOrigin,
+Spacing *aSpacing, gfxTextContextPaint *aContextPaint,
+gfxTextRunDrawCallbacks *aCallbacks);
+/**
+* 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 aContextForTightBoundingBox 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(gfxTextRun *aTextRun,
+uint32_t aStart, uint32_t aEnd,
+BoundingBoxType aBoundingBoxType,
+gfxContext *aContextForTightBoundingBox,
+Spacing *aSpacing);
+/**
+* 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 the aCR just before calling this
+virtual void SetupGlyphExtents(gfxContext *aContext, uint32_t aGlyphID,
+bool aNeedTight, gfxGlyphExtents *aExtents);
+// This is called by the default Draw() implementation above.
+virtual bool SetupCairoFont(gfxContext *aContext) = 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() { return mFontEntry.get(); }
+bool HasCharacter(uint32_t ch) {
+if (!mIsValid)
+return false;
+return mFontEntry->HasCharacter(ch);
+}
+uint16_t GetUVSGlyph(uint32_t aCh, uint32_t aVS) {
+if (!mIsValid) {
+return 0;
+}
+return mFontEntry->GetUVSGlyph(aCh, aVS);
+}
+// 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(gfxContext *aContext,
+gfxTextRun *aTextRun,
+const T *aString,
+uint32_t aRunStart,
+uint32_t aRunLength,
+int32_t aRunScript);
+// Get a ShapedWord representing the given text (either 8- or 16-bit)
+// for use in setting up a gfxTextRun.
+template<typename T>
+gfxShapedWord* GetShapedWord(gfxContext *aContext,
+const T *aText,
+uint32_t aLength,
+uint32_t aHash,
+int32_t aRunScript,
+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 = new 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() {
+if (mWordCache) {
+(void)mWordCache->EnumerateEntries(AgeCacheEntry, this);
+}
+}
+// 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
+} FontType;
+virtual FontType GetType() const = 0;
+virtual mozilla::TemporaryRef<mozilla::gfx::ScaledFont> GetScaledFont(mozilla::gfx::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:
+GlyphChangeObserver(gfxFont *aFont) : mFont(aFont)
+{
+mFont->AddGlyphChangeObserver(this);
+}
+gfxFont* 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;
+}
+protected:
+// 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() {
+return false;
+}
+// The return value is interpreted as a horizontal advance in 16.16 fixed
+// point format.
+virtual int32_t GetGlyphWidth(gfxContext *aCtx, uint16_t aGID) {
+return -1;
+}
+void AddGlyphChangeObserver(GlyphChangeObserver *aObserver);
+void RemoveGlyphChangeObserver(GlyphChangeObserver *aObserver);
+// whether font contains substitution lookups containing spaces
+bool HasSubstitutionRulesWithSpaceLookups(int32_t aRunScript);
+// do spaces participate in shaping rules? if so, can't used word cache
+bool SpaceMayParticipateInShaping(int32_t aRunScript);
+// For 8-bit text, expand to 16-bit and then call the following method.
+bool ShapeText(gfxContext    *aContext,
+const uint8_t *aText,
+uint32_t       aOffset, // dest offset in gfxShapedText
+uint32_t       aLength,
+int32_t        aScript,
+gfxShapedText *aShapedText, // where to store the result
+bool           aPreferPlatformShaping = false);
+// Call the appropriate shaper to generate glyphs for aText and store
+// them into aShapedText.
+virtual bool ShapeText(gfxContext      *aContext,
+const char16_t *aText,
+uint32_t         aOffset,
+uint32_t         aLength,
+int32_t          aScript,
+gfxShapedText   *aShapedText,
+bool             aPreferPlatformShaping = false);
+// 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(gfxContext      *aContext,
+const char16_t *aText,
+uint32_t         aOffset, // position within aShapedText
+uint32_t         aLength,
+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(gfxContext *aContext,
+const T    *aText,
+uint32_t    aOffset,
+uint32_t    aLength,
+int32_t     aScript,
+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(gfxContext *aContext,
+const T    *aText,
+uint32_t    aOffset,
+uint32_t    aLength,
+int32_t     aScript,
+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, int32_t> *sScriptTagToCode;
+static nsTHashtable<nsUint32HashKey>             *sDefaultFeatures;
+nsRefPtr<gfxFontEntry> mFontEntry;
+struct CacheHashKey {
+union {
+const uint8_t   *mSingle;
+const char16_t *mDouble;
+}                mText;
+uint32_t         mLength;
+uint32_t         mFlags;
+int32_t          mScript;
+int32_t          mAppUnitsPerDevUnit;
+PLDHashNumber    mHashKey;
+bool             mTextIs8Bit;
+CacheHashKey(const uint8_t *aText, uint32_t aLength,
+uint32_t aStringHash,
+int32_t aScriptCode, int32_t aAppUnitsPerDevUnit,
+uint32_t aFlags)
+: mLength(aLength),
+mFlags(aFlags),
+mScript(aScriptCode),
+mAppUnitsPerDevUnit(aAppUnitsPerDevUnit),
+mHashKey(aStringHash + 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,
+int32_t aScriptCode, int32_t aAppUnitsPerDevUnit,
+uint32_t aFlags)
+: mLength(aLength),
+mFlags(aFlags),
+mScript(aScriptCode),
+mAppUnitsPerDevUnit(aAppUnitsPerDevUnit),
+mHashKey(aStringHash + 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.
+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;
+}
+enum { ALLOW_MEMMOVE = true };
+nsAutoPtr<gfxShapedWord> mShapedWord;
+};
+static size_t
+WordCacheEntrySizeOfExcludingThis(CacheHashEntry*   aHashEntry,
+mozilla::MallocSizeOf aMallocSizeOf,
+void*             aUserArg);
+nsAutoPtr<nsTHashtable<CacheHashEntry> > mWordCache;
+static PLDHashOperator AgeCacheEntry(CacheHashEntry *aEntry, void *aUserData);
+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?
+nsExpirationState          mExpirationState;
+gfxFontStyle               mStyle;
+nsAutoTArray<gfxGlyphExtents*,1> mGlyphExtentsArray;
+nsAutoPtr<nsTHashtable<nsPtrHashKey<GlyphChangeObserver> > > mGlyphChangeObservers;
+gfxFloat                   mAdjustedSize;
+float                      mFUnitsConvFactor; // conversion factor from font units to dev units
+// 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
+nsAutoPtr<gfxFont>         mNonAAFont;
+// we may switch between these shapers on the fly, based on the script
+// of the text run being shaped
+nsAutoPtr<gfxFontShaper>   mPlatformShaper;
+nsAutoPtr<gfxFontShaper>   mHarfBuzzShaper;
+nsAutoPtr<gfxFontShaper>   mGraphiteShaper;
+mozilla::RefPtr<mozilla::gfx::ScaledFont> mAzureScaledFont;
+// Create a default platform text shaper for this font.
+// (TODO: This should become pure virtual once all font backends have
+// been updated.)
+virtual void CreatePlatformShaper() { }
+// 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(gfxFont::Metrics *aMetrics, bool aIsBadUnderlineFont);
+bool RenderSVGGlyph(gfxContext *aContext, gfxPoint aPoint, DrawMode aDrawMode,
+uint32_t aGlyphId, gfxTextContextPaint *aContextPaint);
+bool RenderSVGGlyph(gfxContext *aContext, gfxPoint aPoint, DrawMode aDrawMode,
+uint32_t aGlyphId, gfxTextContextPaint *aContextPaint,
+gfxTextRunDrawCallbacks *aCallbacks,
+bool& aEmittedGlyphs);
+// 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(gfxContext *aContext);
+};
+// proportion of ascent used for x-height, if unable to read value from font
+#define DEFAULT_XHEIGHT_FACTOR 0.56f
+/*
+* 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:
+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,
+FLAG_CHAR_IS_LOW_SURROGATE    = 0x20,
+CHAR_IDENTITY_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 CharIsLowSurrogate() const {
+return !IsSimpleGlyph() && (mValue & FLAG_CHAR_IS_LOW_SURROGATE) != 0;
+}
+uint32_t CharIdentityFlags() const {
+return IsSimpleGlyph() ? 0 : (mValue & CHAR_IDENTITY_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(!CharIdentityFlags(), "Char identity 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 |
+CharIdentityFlags() |
+(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)) |
+CharIdentityFlags() |
+(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 SetIsLowSurrogate() {
+NS_ASSERTION(!IsSimpleGlyph(), "Expected non-simple-glyph");
+mValue |= FLAG_CHAR_IS_LOW_SURROGATE;
+}
+private:
+uint32_t mValue;
+};
+// Accessor for the array of CompressedGlyph records, which will be in
+// a different place in gfxShapedWord vs gfxTextRun
+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();
+}
+void SetIsLowSurrogate(uint32_t aIndex) {
+SetGlyphs(aIndex, CompressedGlyph().SetComplex(false, false, 0), nullptr);
+GetCharacterGlyphs()[aIndex].SetIsLowSurrogate();
+}
+bool HasDetailedGlyphs() const {
+return mDetailedGlyphs != nullptr;
+}
+bool IsClusterStart(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return GetCharacterGlyphs()[aPos].IsClusterStart();
+}
+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) {
+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 Flags() const {
+return mFlags;
+}
+bool IsRightToLeft() const {
+return (Flags() & gfxTextRunFactory::TEXT_IS_RTL) != 0;
+}
+float GetDirection() const {
+return IsRightToLeft() ? -1.0f : 1.0f;
+}
+bool DisableLigatures() const {
+return (Flags() & gfxTextRunFactory::TEXT_DISABLE_OPTIONAL_LIGATURES) != 0;
+}
+bool TextIs8Bit() const {
+return (Flags() & 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);
+// 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);
+if (!details) {
+return nullptr;
+}
+// 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) {
+if (!mOffsetToIndex.AppendElement(DGRec(aOffset, detailIndex))) {
+return nullptr;
+}
+} else {
+if (!mOffsetToIndex.InsertElementSorted(DGRec(aOffset, detailIndex),
+CompareRecordOffsets())) {
+return nullptr;
+}
+}
+return details;
+}
+size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
+return aMallocSizeOf(this) +
+mDetails.SizeOfExcludingThis(aMallocSizeOf) +
+mOffsetToIndex.SizeOfExcludingThis(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;
+};
+nsAutoPtr<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 : public gfxShapedText
+{
+public:
+// 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,
+int32_t 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 = moz_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,
+int32_t 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 = moz_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 moz_malloc.
+void operator delete(void* p) {
+moz_free(p);
+}
+CompressedGlyph *GetCharacterGlyphs() {
+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];
+}
+int32_t Script() const {
+return mScript;
+}
+void ResetAge() {
+mAgeCounter = 0;
+}
+uint32_t IncrementAge() {
+return ++mAgeCounter;
+}
+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,
+int32_t 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,
+int32_t 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);
+}
+int32_t          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];
+};
+/**
+* Callback for Draw() to use when drawing text with mode
+* DrawMode::GLYPH_PATH.
+*/
+struct gfxTextRunDrawCallbacks {
+/**
+* Constructs a new DrawCallbacks object.
+*
+* @param aShouldPaintSVGGlyphs If true, SVG glyphs will be
+*   painted and the NotifyBeforeSVGGlyphPainted/NotifyAfterSVGGlyphPainted
+*   callbacks will be invoked for each SVG glyph.  If false, SVG glyphs
+*   will not be painted; fallback plain glyphs are not emitted either.
+*/
+gfxTextRunDrawCallbacks(bool aShouldPaintSVGGlyphs = false)
+: mShouldPaintSVGGlyphs(aShouldPaintSVGGlyphs)
+{
+}
+/**
+* Called when a path has been emitted to the gfxContext when
+* painting a text run.  This can be called any number of times,
+* due to partial ligatures and intervening SVG glyphs.
+*/
+virtual void NotifyGlyphPathEmitted() = 0;
+/**
+* Called just before an SVG glyph has been painted to the gfxContext.
+*/
+virtual void NotifyBeforeSVGGlyphPainted() { }
+/**
+* Called just after an SVG glyph has been painted to the gfxContext.
+*/
+virtual void NotifyAfterSVGGlyphPainted() { }
+bool mShouldPaintSVGGlyphs;
+};
+/**
+* gfxTextRun is an abstraction for drawing and measuring substrings of a run
+* of text. It stores runs of positioned glyph data, each run having a single
+* gfxFont. The glyphs are associated with a string of source text, and the
+* gfxTextRun APIs take parameters that are offsets into that source text.
+*
+* gfxTextRuns are not refcounted. They should be deleted when no longer required.
+*
+* gfxTextRuns are mostly immutable. The only things that can change are
+* inter-cluster spacing and line break placement. Spacing is always obtained
+* lazily by methods that need it, it is not cached. Line breaks are stored
+* persistently (insofar as they affect the shaping of glyphs; gfxTextRun does
+* not actually do anything to explicitly account for line breaks). Initially
+* there are no line breaks. The textrun can record line breaks before or after
+* any given cluster. (Line breaks specified inside clusters are ignored.)
+*
+* It is important that zero-length substrings are handled correctly. This will
+* be on the test!
+*/
+class gfxTextRun : public gfxShapedText {
+public:
+// Override operator delete to properly free the object that was
+// allocated via moz_malloc.
+void operator delete(void* p) {
+moz_free(p);
+}
+virtual ~gfxTextRun();
+typedef gfxFont::RunMetrics Metrics;
+// Public textrun API for general use
+bool IsClusterStart(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].IsClusterStart();
+}
+bool IsLigatureGroupStart(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].IsLigatureGroupStart();
+}
+bool CanBreakLineBefore(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].CanBreakBefore() ==
+CompressedGlyph::FLAG_BREAK_TYPE_NORMAL;
+}
+bool CanHyphenateBefore(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].CanBreakBefore() ==
+CompressedGlyph::FLAG_BREAK_TYPE_HYPHEN;
+}
+bool CharIsSpace(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].CharIsSpace();
+}
+bool CharIsTab(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].CharIsTab();
+}
+bool CharIsNewline(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].CharIsNewline();
+}
+bool CharIsLowSurrogate(uint32_t aPos) {
+NS_ASSERTION(aPos < GetLength(), "aPos out of range");
+return mCharacterGlyphs[aPos].CharIsLowSurrogate();
+}
+uint32_t GetLength() { return mLength; }
+// All uint32_t aStart, uint32_t aLength ranges below are restricted to
+// grapheme cluster boundaries! All offsets are in terms of the string
+// passed into MakeTextRun.
+// All coordinates are in layout/app units
+/**
+* Set the potential linebreaks for a substring of the textrun. These are
+* the "allow break before" points. Initially, there are no potential
+* linebreaks.
+*
+* This can change glyphs and/or geometry! Some textruns' shapes
+* depend on potential line breaks (e.g., title-case-converting textruns).
+* This function is virtual so that those textruns can reshape themselves.
+*
+* @return true if this changed the linebreaks, false if the new line
+* breaks are the same as the old
+*/
+virtual bool SetPotentialLineBreaks(uint32_t aStart, uint32_t aLength,
+uint8_t *aBreakBefore,
+gfxContext *aRefContext);
+/**
+* Layout provides PropertyProvider objects. These allow detection of
+* potential line break points and computation of spacing. We pass the data
+* this way to allow lazy data acquisition; for example BreakAndMeasureText
+* will want to only ask for properties of text it's actually looking at.
+*
+* NOTE that requested spacing may not actually be applied, if the textrun
+* is unable to apply it in some context. Exception: spacing around a
+* whitespace character MUST always be applied.
+*/
+class PropertyProvider {
+public:
+// Detect hyphenation break opportunities in the given range; breaks
+// not at cluster boundaries will be ignored.
+virtual void GetHyphenationBreaks(uint32_t aStart, uint32_t aLength,
+bool *aBreakBefore) = 0;
+// Returns the provider's hyphenation setting, so callers can decide
+// whether it is necessary to call GetHyphenationBreaks.
+// Result is an NS_STYLE_HYPHENS_* value.
+virtual int8_t GetHyphensOption() = 0;
+// Returns the extra width that will be consumed by a hyphen. This should
+// be constant for a given textrun.
+virtual gfxFloat GetHyphenWidth() = 0;
+typedef gfxFont::Spacing Spacing;
+/**
+* Get the spacing around the indicated characters. Spacing must be zero
+* inside clusters. In other words, if character i is not
+* CLUSTER_START, then character i-1 must have zero after-spacing and
+* character i must have zero before-spacing.
+*/
+virtual void GetSpacing(uint32_t aStart, uint32_t aLength,
+Spacing *aSpacing) = 0;
+// Returns a gfxContext that can be used to measure the hyphen glyph.
+// Only called if the hyphen width is requested.
+virtual already_AddRefed<gfxContext> GetContext() = 0;
+// Return the appUnitsPerDevUnit value to be used when measuring.
+// Only called if the hyphen width is requested.
+virtual uint32_t GetAppUnitsPerDevUnit() = 0;
+};
+class ClusterIterator {
+public:
+ClusterIterator(gfxTextRun *aTextRun);
+void Reset();
+bool NextCluster();
+uint32_t Position() const {
+return mCurrentChar;
+}
+uint32_t ClusterLength() const;
+gfxFloat ClusterAdvance(PropertyProvider *aProvider) const;
+private:
+gfxTextRun *mTextRun;
+uint32_t    mCurrentChar;
+};
+/**
+* Draws a substring. Uses only GetSpacing from aBreakProvider.
+* The provided point is the baseline origin on the left of the string
+* for LTR, on the right of the string for RTL.
+* @param aAdvanceWidth if non-null, the advance width of the substring
+* is returned here.
+*
+* Drawing should respect advance widths in the sense that for LTR runs,
+* Draw(ctx, pt, offset1, length1, dirty, &provider, &advance) followed by
+* Draw(ctx, gfxPoint(pt.x + advance, pt.y), offset1 + length1, length2,
+*      dirty, &provider, nullptr) should have the same effect as
+* Draw(ctx, pt, offset1, length1+length2, dirty, &provider, nullptr).
+* For RTL runs the rule is:
+* Draw(ctx, pt, offset1 + length1, length2, dirty, &provider, &advance) followed by
+* Draw(ctx, gfxPoint(pt.x + advance, pt.y), offset1, length1,
+*      dirty, &provider, nullptr) should have the same effect as
+* Draw(ctx, pt, offset1, length1+length2, dirty, &provider, nullptr).
+*
+* Glyphs should be drawn in logical content order, which can be significant
+* if they overlap (perhaps due to negative spacing).
+*/
+void Draw(gfxContext *aContext, gfxPoint aPt,
+DrawMode aDrawMode,
+uint32_t aStart, uint32_t aLength,
+PropertyProvider *aProvider,
+gfxFloat *aAdvanceWidth, gfxTextContextPaint *aContextPaint,
+gfxTextRunDrawCallbacks *aCallbacks = nullptr);
+/**
+* Computes the ReflowMetrics for a substring.
+* Uses GetSpacing from aBreakProvider.
+* @param aBoundingBoxType which kind of bounding box (loose/tight)
+*/
+Metrics MeasureText(uint32_t aStart, uint32_t aLength,
+gfxFont::BoundingBoxType aBoundingBoxType,
+gfxContext *aRefContextForTightBoundingBox,
+PropertyProvider *aProvider);
+/**
+* Computes just the advance width for a substring.
+* Uses GetSpacing from aBreakProvider.
+*/
+gfxFloat GetAdvanceWidth(uint32_t aStart, uint32_t aLength,
+PropertyProvider *aProvider);
+/**
+* Clear all stored line breaks for the given range (both before and after),
+* and then set the line-break state before aStart to aBreakBefore and
+* after the last cluster to aBreakAfter.
+*
+* We require that before and after line breaks be consistent. For clusters
+* i and i+1, we require that if there is a break after cluster i, a break
+* will be specified before cluster i+1. This may be temporarily violated
+* (e.g. after reflowing line L and before reflowing line L+1); to handle
+* these temporary violations, we say that there is a break betwen i and i+1
+* if a break is specified after i OR a break is specified before i+1.
+*
+* This can change textrun geometry! The existence of a linebreak can affect
+* the advance width of the cluster before the break (when kerning) or the
+* geometry of one cluster before the break or any number of clusters
+* after the break. (The one-cluster-before-the-break limit is somewhat
+* arbitrary; if some scripts require breaking it, then we need to
+* alter nsTextFrame::TrimTrailingWhitespace, perhaps drastically becase
+* it could affect the layout of frames before it...)
+*
+* We return true if glyphs or geometry changed, false otherwise. This
+* function is virtual so that gfxTextRun subclasses can reshape
+* properly.
+*
+* @param aAdvanceWidthDelta if non-null, returns the change in advance
+* width of the given range.
+*/
+virtual bool SetLineBreaks(uint32_t aStart, uint32_t aLength,
+bool aLineBreakBefore, bool aLineBreakAfter,
+gfxFloat *aAdvanceWidthDelta,
+gfxContext *aRefContext);
+/**
+* Finds the longest substring that will fit into the given width.
+* Uses GetHyphenationBreaks and GetSpacing from aBreakProvider.
+* Guarantees the following:
+* -- 0 <= result <= aMaxLength
+* -- result is the maximal value of N such that either
+*       N < aMaxLength && line break at N && GetAdvanceWidth(aStart, N) <= aWidth
+*   OR  N < aMaxLength && hyphen break at N && GetAdvanceWidth(aStart, N) + GetHyphenWidth() <= aWidth
+*   OR  N == aMaxLength && GetAdvanceWidth(aStart, N) <= aWidth
+* where GetAdvanceWidth assumes the effect of
+* SetLineBreaks(aStart, N, aLineBreakBefore, N < aMaxLength, aProvider)
+* -- if no such N exists, then result is the smallest N such that
+*       N < aMaxLength && line break at N
+*   OR  N < aMaxLength && hyphen break at N
+*   OR  N == aMaxLength
+*
+* The call has the effect of
+* SetLineBreaks(aStart, result, aLineBreakBefore, result < aMaxLength, aProvider)
+* and the returned metrics and the invariants above reflect this.
+*
+* @param aMaxLength this can be UINT32_MAX, in which case the length used
+* is up to the end of the string
+* @param aLineBreakBefore set to true if and only if there is an actual
+* line break at the start of this string.
+* @param aSuppressInitialBreak if true, then we assume there is no possible
+* linebreak before aStart. If false, then we will check the internal
+* line break opportunity state before deciding whether to return 0 as the
+* character to break before.
+* @param aTrimWhitespace if non-null, then we allow a trailing run of
+* spaces to be trimmed; the width of the space(s) will not be included in
+* the measured string width for comparison with the limit aWidth, and
+* trimmed spaces will not be included in returned metrics. The width
+* of the trimmed spaces will be returned in aTrimWhitespace.
+* Trimmed spaces are still counted in the "characters fit" result.
+* @param aMetrics if non-null, we fill this in for the returned substring.
+* If a hyphenation break was used, the hyphen is NOT included in the returned metrics.
+* @param aBoundingBoxType whether to make the bounding box in aMetrics tight
+* @param aRefContextForTightBoundingBox a reference context to get the
+* tight bounding box, if requested
+* @param aUsedHyphenation if non-null, records if we selected a hyphenation break
+* @param aLastBreak if non-null and result is aMaxLength, we set this to
+* the maximal N such that
+*       N < aMaxLength && line break at N && GetAdvanceWidth(aStart, N) <= aWidth
+*   OR  N < aMaxLength && hyphen break at N && GetAdvanceWidth(aStart, N) + GetHyphenWidth() <= aWidth
+* or UINT32_MAX if no such N exists, where GetAdvanceWidth assumes
+* the effect of
+* SetLineBreaks(aStart, N, aLineBreakBefore, N < aMaxLength, aProvider)
+*
+* @param aCanWordWrap true if we can break between any two grapheme
+* clusters. This is set by word-wrap: break-word
+*
+* @param aBreakPriority in/out the priority of the break opportunity
+* saved in the line. If we are prioritizing break opportunities, we will
+* not set a break with a lower priority. @see gfxBreakPriority.
+*
+* Note that negative advance widths are possible especially if negative
+* spacing is provided.
+*/
+uint32_t BreakAndMeasureText(uint32_t aStart, uint32_t aMaxLength,
+bool aLineBreakBefore, gfxFloat aWidth,
+PropertyProvider *aProvider,
+bool aSuppressInitialBreak,
+gfxFloat *aTrimWhitespace,
+Metrics *aMetrics,
+gfxFont::BoundingBoxType aBoundingBoxType,
+gfxContext *aRefContextForTightBoundingBox,
+bool *aUsedHyphenation,
+uint32_t *aLastBreak,
+bool aCanWordWrap,
+gfxBreakPriority *aBreakPriority);
+/**
+* Update the reference context.
+* XXX this is a hack. New text frame does not call this. Use only
+* temporarily for old text frame.
+*/
+void SetContext(gfxContext *aContext) {}
+// Utility getters
+gfxFloat GetDirection() const { return (mFlags & gfxTextRunFactory::TEXT_IS_RTL) ? -1.0 : 1.0; }
+void *GetUserData() const { return mUserData; }
+void SetUserData(void *aUserData) { mUserData = aUserData; }
+uint32_t GetFlags() const { return mFlags; }
+void SetFlagBits(uint32_t aFlags) {
+NS_ASSERTION(!(aFlags & ~gfxTextRunFactory::SETTABLE_FLAGS),
+"Only user flags should be mutable");
+mFlags |= aFlags;
+}
+void ClearFlagBits(uint32_t aFlags) {
+NS_ASSERTION(!(aFlags & ~gfxTextRunFactory::SETTABLE_FLAGS),
+"Only user flags should be mutable");
+mFlags &= ~aFlags;
+}
+const gfxSkipChars& GetSkipChars() const { return mSkipChars; }
+gfxFontGroup *GetFontGroup() const { return mFontGroup; }
+// Call this, don't call "new gfxTextRun" directly. This does custom
+// allocation and initialization
+static gfxTextRun *Create(const gfxTextRunFactory::Parameters *aParams,
+uint32_t aLength, gfxFontGroup *aFontGroup,
+uint32_t aFlags);
+// The text is divided into GlyphRuns as necessary
+struct GlyphRun {
+nsRefPtr<gfxFont> mFont;   // never null
+uint32_t          mCharacterOffset; // into original UTF16 string
+uint8_t           mMatchType;
+};
+class GlyphRunIterator {
+public:
+GlyphRunIterator(gfxTextRun *aTextRun, uint32_t aStart, uint32_t aLength)
+: mTextRun(aTextRun), mStartOffset(aStart), mEndOffset(aStart + aLength) {
+mNextIndex = mTextRun->FindFirstGlyphRunContaining(aStart);
+}
+bool NextRun();
+GlyphRun *GetGlyphRun() { return mGlyphRun; }
+uint32_t GetStringStart() { return mStringStart; }
+uint32_t GetStringEnd() { return mStringEnd; }
+private:
+gfxTextRun *mTextRun;
+GlyphRun   *mGlyphRun;
+uint32_t    mStringStart;
+uint32_t    mStringEnd;
+uint32_t    mNextIndex;
+uint32_t    mStartOffset;
+uint32_t    mEndOffset;
+};
+class GlyphRunOffsetComparator {
+public:
+bool Equals(const GlyphRun& a,
+const GlyphRun& b) const
+{
+return a.mCharacterOffset == b.mCharacterOffset;
+}
+bool LessThan(const GlyphRun& a,
+const GlyphRun& b) const
+{
+return a.mCharacterOffset < b.mCharacterOffset;
+}
+};
+friend class GlyphRunIterator;
+friend class FontSelector;
+// API for setting up the textrun glyphs. Should only be called by
+// things that construct textruns.
+/**
+* We've found a run of text that should use a particular font. Call this
+* only during initialization when font substitution has been computed.
+* Call it before setting up the glyphs for the characters in this run;
+* SetMissingGlyph requires that the correct glyphrun be installed.
+*
+* If aForceNewRun, a new glyph run will be added, even if the
+* previously added run uses the same font.  If glyph runs are
+* added out of strictly increasing aStartCharIndex order (via
+* force), then SortGlyphRuns must be called after all glyph runs
+* are added before any further operations are performed with this
+* TextRun.
+*/
+nsresult AddGlyphRun(gfxFont *aFont, uint8_t aMatchType,
+uint32_t aStartCharIndex, bool aForceNewRun);
+void ResetGlyphRuns() { mGlyphRuns.Clear(); }
+void SortGlyphRuns();
+void SanitizeGlyphRuns();
+CompressedGlyph* GetCharacterGlyphs() {
+NS_ASSERTION(mCharacterGlyphs, "failed to initialize mCharacterGlyphs");
+return mCharacterGlyphs;
+}
+void SetSpaceGlyph(gfxFont *aFont, gfxContext *aContext, uint32_t aCharIndex);
+// Set the glyph data for the given character index to the font's
+// space glyph, IF this can be done as a "simple" glyph record
+// (not requiring a DetailedGlyph entry). This avoids the need to call
+// the font shaper and go through the shaped-word cache for most spaces.
+//
+// The parameter aSpaceChar is the original character code for which
+// this space glyph is being used; if this is U+0020, we need to record
+// that it could be trimmed at a run edge, whereas other kinds of space
+// (currently just U+00A0) would not be trimmable/breakable.
+//
+// Returns true if it was able to set simple glyph data for the space;
+// if it returns false, the caller needs to fall back to some other
+// means to create the necessary (detailed) glyph data.
+bool SetSpaceGlyphIfSimple(gfxFont *aFont, gfxContext *aContext,
+uint32_t aCharIndex, char16_t aSpaceChar);
+// Record the positions of specific characters that layout may need to
+// detect in the textrun, even though it doesn't have an explicit copy
+// of the original text. These are recorded using flag bits in the
+// CompressedGlyph record; if necessary, we convert "simple" glyph records
+// to "complex" ones as the Tab and Newline flags are not present in
+// simple CompressedGlyph records.
+void SetIsTab(uint32_t aIndex) {
+CompressedGlyph *g = &mCharacterGlyphs[aIndex];
+if (g->IsSimpleGlyph()) {
+DetailedGlyph *details = AllocateDetailedGlyphs(aIndex, 1);
+details->mGlyphID = g->GetSimpleGlyph();
+details->mAdvance = g->GetSimpleAdvance();
+details->mXOffset = details->mYOffset = 0;
+SetGlyphs(aIndex, CompressedGlyph().SetComplex(true, true, 1), details);
+}
+g->SetIsTab();
+}
+void SetIsNewline(uint32_t aIndex) {
+CompressedGlyph *g = &mCharacterGlyphs[aIndex];
+if (g->IsSimpleGlyph()) {
+DetailedGlyph *details = AllocateDetailedGlyphs(aIndex, 1);
+details->mGlyphID = g->GetSimpleGlyph();
+details->mAdvance = g->GetSimpleAdvance();
+details->mXOffset = details->mYOffset = 0;
+SetGlyphs(aIndex, CompressedGlyph().SetComplex(true, true, 1), details);
+}
+g->SetIsNewline();
+}
+void SetIsLowSurrogate(uint32_t aIndex) {
+SetGlyphs(aIndex, CompressedGlyph().SetComplex(false, false, 0), nullptr);
+mCharacterGlyphs[aIndex].SetIsLowSurrogate();
+}
+/**
+* Prefetch all the glyph extents needed to ensure that Measure calls
+* on this textrun not requesting tight boundingBoxes will succeed. Note
+* that some glyph extents might not be fetched due to OOM or other
+* errors.
+*/
+void FetchGlyphExtents(gfxContext *aRefContext);
+uint32_t CountMissingGlyphs();
+const GlyphRun *GetGlyphRuns(uint32_t *aNumGlyphRuns) {
+*aNumGlyphRuns = mGlyphRuns.Length();
+return mGlyphRuns.Elements();
+}
+// Returns the index of the GlyphRun containing the given offset.
+// Returns mGlyphRuns.Length() when aOffset is mCharacterCount.
+uint32_t FindFirstGlyphRunContaining(uint32_t aOffset);
+// Copy glyph data from a ShapedWord into this textrun.
+void CopyGlyphDataFrom(gfxShapedWord *aSource, uint32_t aStart);
+// Copy glyph data for a range of characters from aSource to this
+// textrun.
+void CopyGlyphDataFrom(gfxTextRun *aSource, uint32_t aStart,
+uint32_t aLength, uint32_t aDest);
+nsExpirationState *GetExpirationState() { return &mExpirationState; }
+// Tell the textrun to release its reference to its creating gfxFontGroup
+// immediately, rather than on destruction. This is used for textruns
+// that are actually owned by a gfxFontGroup, so that they don't keep it
+// permanently alive due to a circular reference. (The caller of this is
+// taking responsibility for ensuring the textrun will not outlive its
+// mFontGroup.)
+void ReleaseFontGroup();
+struct LigatureData {
+// textrun offsets of the start and end of the containing ligature
+uint32_t mLigatureStart;
+uint32_t mLigatureEnd;
+// appunits advance to the start of the ligature part within the ligature;
+// never includes any spacing
+gfxFloat mPartAdvance;
+// appunits width of the ligature part; includes before-spacing
+// when the part is at the start of the ligature, and after-spacing
+// when the part is as the end of the ligature
+gfxFloat mPartWidth;
+bool mClipBeforePart;
+bool mClipAfterPart;
+};
+// return storage used by this run, for memory reporter;
+// nsTransformedTextRun needs to override this as it holds additional data
+virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf)
+MOZ_MUST_OVERRIDE;
+virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
+MOZ_MUST_OVERRIDE;
+// Get the size, if it hasn't already been gotten, marking as it goes.
+size_t MaybeSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)  {
+if (mFlags & gfxTextRunFactory::TEXT_RUN_SIZE_ACCOUNTED) {
+return 0;
+}
+mFlags |= gfxTextRunFactory::TEXT_RUN_SIZE_ACCOUNTED;
+return SizeOfIncludingThis(aMallocSizeOf);
+}
+void ResetSizeOfAccountingFlags() {
+mFlags &= ~gfxTextRunFactory::TEXT_RUN_SIZE_ACCOUNTED;
+}
+#ifdef DEBUG
+void Dump(FILE* aOutput);
+#endif
+protected:
+/**
+* Create a textrun, and set its mCharacterGlyphs to point immediately
+* after the base object; this is ONLY used in conjunction with placement
+* new, after allocating a block large enough for the glyph records to
+* follow the base textrun object.
+*/
+gfxTextRun(const gfxTextRunFactory::Parameters *aParams,
+uint32_t aLength, gfxFontGroup *aFontGroup, uint32_t aFlags);
+/**
+* Helper for the Create() factory method to allocate the required
+* glyph storage for a textrun object with the basic size aSize,
+* plus room for aLength glyph records.
+*/
+static void* AllocateStorageForTextRun(size_t aSize, uint32_t aLength);
+// Pointer to the array of CompressedGlyph records; must be initialized
+// when the object is constructed.
+CompressedGlyph *mCharacterGlyphs;
+private:
+// **** general helpers ****
+// Allocate aCount DetailedGlyphs for the given index
+DetailedGlyph *AllocateDetailedGlyphs(uint32_t aCharIndex, uint32_t aCount);
+// Get the total advance for a range of glyphs.
+int32_t GetAdvanceForGlyphs(uint32_t aStart, uint32_t aEnd);
+// Spacing for characters outside the range aSpacingStart/aSpacingEnd
+// is assumed to be zero; such characters are not passed to aProvider.
+// This is useful to protect aProvider from being passed character indices
+// it is not currently able to handle.
+bool GetAdjustedSpacingArray(uint32_t aStart, uint32_t aEnd,
+PropertyProvider *aProvider,
+uint32_t aSpacingStart, uint32_t aSpacingEnd,
+nsTArray<PropertyProvider::Spacing> *aSpacing);
+//  **** ligature helpers ****
+// (Platforms do the actual ligaturization, but we need to do a bunch of stuff
+// to handle requests that begin or end inside a ligature)
+// if aProvider is null then mBeforeSpacing and mAfterSpacing are set to zero
+LigatureData ComputeLigatureData(uint32_t aPartStart, uint32_t aPartEnd,
+PropertyProvider *aProvider);
+gfxFloat ComputePartialLigatureWidth(uint32_t aPartStart, uint32_t aPartEnd,
+PropertyProvider *aProvider);
+void DrawPartialLigature(gfxFont *aFont, gfxContext *aCtx,
+uint32_t aStart, uint32_t aEnd, gfxPoint *aPt,
+PropertyProvider *aProvider,
+gfxTextRunDrawCallbacks *aCallbacks);
+// Advance aStart to the start of the nearest ligature; back up aEnd
+// to the nearest ligature end; may result in *aStart == *aEnd
+void ShrinkToLigatureBoundaries(uint32_t *aStart, uint32_t *aEnd);
+// result in appunits
+gfxFloat GetPartialLigatureWidth(uint32_t aStart, uint32_t aEnd, PropertyProvider *aProvider);
+void AccumulatePartialLigatureMetrics(gfxFont *aFont,
+uint32_t aStart, uint32_t aEnd,
+gfxFont::BoundingBoxType aBoundingBoxType,
+gfxContext *aRefContext,
+PropertyProvider *aProvider,
+Metrics *aMetrics);
+// **** measurement helper ****
+void AccumulateMetricsForRun(gfxFont *aFont, uint32_t aStart, uint32_t aEnd,
+gfxFont::BoundingBoxType aBoundingBoxType,
+gfxContext *aRefContext,
+PropertyProvider *aProvider,
+uint32_t aSpacingStart, uint32_t aSpacingEnd,
+Metrics *aMetrics);
+// **** drawing helper ****
+void DrawGlyphs(gfxFont *aFont, gfxContext *aContext,
+DrawMode aDrawMode, gfxPoint *aPt,
+gfxTextContextPaint *aContextPaint, uint32_t aStart,
+uint32_t aEnd, PropertyProvider *aProvider,
+uint32_t aSpacingStart, uint32_t aSpacingEnd,
+gfxTextRunDrawCallbacks *aCallbacks);
+// XXX this should be changed to a GlyphRun plus a maybe-null GlyphRun*,
+// for smaller size especially in the super-common one-glyphrun case
+nsAutoTArray<GlyphRun,1>        mGlyphRuns;
+void             *mUserData;
+gfxFontGroup     *mFontGroup; // addrefed on creation, but our reference
+// may be released by ReleaseFontGroup()
+gfxSkipChars      mSkipChars;
+nsExpirationState mExpirationState;
+bool              mSkipDrawing; // true if the font group we used had a user font
+// download that's in progress, so we should hide text
+// until the download completes (or timeout fires)
+bool              mReleasedFontGroup; // we already called NS_RELEASE on
+// mFontGroup, so don't do it again
+};
+class gfxFontGroup : public gfxTextRunFactory {
+public:
+class FamilyFace {
+public:
+FamilyFace() { }
+FamilyFace(gfxFontFamily* aFamily, gfxFont* aFont)
+: mFamily(aFamily), mFont(aFont)
+{
+NS_ASSERTION(aFont, "font pointer must not be null");
+NS_ASSERTION(!aFamily ||
+aFamily->ContainsFace(aFont->GetFontEntry()),
+"font is not a member of the given family");
+}
+gfxFontFamily* Family() const { return mFamily.get(); }
+gfxFont* Font() const { return mFont.get(); }
+private:
+nsRefPtr<gfxFontFamily> mFamily;
+nsRefPtr<gfxFont>       mFont;
+};
+static void Shutdown(); // platform must call this to release the languageAtomService
+gfxFontGroup(const nsAString& aFamilies, const gfxFontStyle *aStyle, gfxUserFontSet *aUserFontSet = nullptr);
+virtual ~gfxFontGroup();
+virtual gfxFont *GetFontAt(int32_t i) {
+// If it turns out to be hard for all clients that cache font
+// groups to call UpdateFontList at appropriate times, we could
+// instead consider just calling UpdateFontList from someplace
+// more central (such as here).
+NS_ASSERTION(!mUserFontSet || mCurrGeneration == GetGeneration(),
+"Whoever was caching this font group should have "
+"called UpdateFontList on it");
+NS_ASSERTION(mFonts.Length() > uint32_t(i) && mFonts[i].Font(),
+"Requesting a font index that doesn't exist");
+return mFonts[i].Font();
+}
+uint32_t FontListLength() const {
+return mFonts.Length();
+}
+bool Equals(const gfxFontGroup& other) const {
+return mFamilies.Equals(other.mFamilies) &&
+mStyle.Equals(other.mStyle);
+}
+const gfxFontStyle *GetStyle() const { return &mStyle; }
+virtual gfxFontGroup *Copy(const gfxFontStyle *aStyle);
+/**
+* The listed characters should be treated as invisible and zero-width
+* when creating textruns.
+*/
+static bool IsInvalidChar(uint8_t ch);
+static bool IsInvalidChar(char16_t ch);
+/**
+* Make a textrun for a given string.
+* If aText is not persistent (aFlags & TEXT_IS_PERSISTENT), the
+* textrun will copy it.
+* This calls FetchGlyphExtents on the textrun.
+*/
+virtual gfxTextRun *MakeTextRun(const char16_t *aString, uint32_t aLength,
+const Parameters *aParams, uint32_t aFlags);
+/**
+* Make a textrun for a given string.
+* If aText is not persistent (aFlags & TEXT_IS_PERSISTENT), the
+* textrun will copy it.
+* This calls FetchGlyphExtents on the textrun.
+*/
+virtual gfxTextRun *MakeTextRun(const uint8_t *aString, uint32_t aLength,
+const Parameters *aParams, uint32_t aFlags);
+/**
+* Textrun creation helper for clients that don't want to pass
+* a full Parameters record.
+*/
+template<typename T>
+gfxTextRun *MakeTextRun(const T *aString, uint32_t aLength,
+gfxContext *aRefContext,
+int32_t aAppUnitsPerDevUnit,
+uint32_t aFlags)
+{
+gfxTextRunFactory::Parameters params = {
+aRefContext, nullptr, nullptr, nullptr, 0, aAppUnitsPerDevUnit
+};
+return MakeTextRun(aString, aLength, &params, aFlags);
+}
+/**
+* Get the (possibly-cached) width of the hyphen character.
+* The aCtx and aAppUnitsPerDevUnit parameters will be used only if
+* needed to initialize the cached hyphen width; otherwise they are
+* ignored.
+*/
+gfxFloat GetHyphenWidth(gfxTextRun::PropertyProvider* aProvider);
+/**
+* Make a text run representing a single hyphen character.
+* This will use U+2010 HYPHEN if available in the first font,
+* otherwise fall back to U+002D HYPHEN-MINUS.
+* The caller is responsible for deleting the returned text run
+* when no longer required.
+*/
+gfxTextRun *MakeHyphenTextRun(gfxContext *aCtx,
+uint32_t aAppUnitsPerDevUnit);
+/* helper function for splitting font families on commas and
+* calling a function for each family to fill the mFonts array
+*/
+typedef bool (*FontCreationCallback) (const nsAString& aName,
+const nsACString& aGenericName,
+bool aUseFontSet,
+void *closure);
+bool ForEachFont(const nsAString& aFamilies,
+nsIAtom *aLanguage,
+FontCreationCallback fc,
+void *closure);
+bool ForEachFont(FontCreationCallback fc, void *closure);
+/**
+* Check whether a given font (specified by its gfxFontEntry)
+* is already in the fontgroup's list of actual fonts
+*/
+bool HasFont(const gfxFontEntry *aFontEntry);
+const nsString& GetFamilies() { return mFamilies; }
+// This returns the preferred underline for this font group.
+// Some CJK fonts have wrong underline offset in its metrics.
+// If this group has such "bad" font, each platform's gfxFontGroup initialized mUnderlineOffset.
+// The value should be lower value of first font's metrics and the bad font's metrics.
+// Otherwise, this returns from first font's metrics.
+enum { UNDERLINE_OFFSET_NOT_SET = INT16_MAX };
+virtual gfxFloat GetUnderlineOffset() {
+if (mUnderlineOffset == UNDERLINE_OFFSET_NOT_SET)
+mUnderlineOffset = GetFontAt(0)->GetMetrics().underlineOffset;
+return mUnderlineOffset;
+}
+virtual already_AddRefed<gfxFont>
+FindFontForChar(uint32_t ch, uint32_t prevCh, int32_t aRunScript,
+gfxFont *aPrevMatchedFont,
+uint8_t *aMatchType);
+// search through pref fonts for a character, return nullptr if no matching pref font
+virtual already_AddRefed<gfxFont> WhichPrefFontSupportsChar(uint32_t aCh);
+virtual already_AddRefed<gfxFont>
+WhichSystemFontSupportsChar(uint32_t aCh, int32_t aRunScript);
+template<typename T>
+void ComputeRanges(nsTArray<gfxTextRange>& mRanges,
+const T *aString, uint32_t aLength,
+int32_t aRunScript);
+gfxUserFontSet* GetUserFontSet();
+// With downloadable fonts, the composition of the font group can change as fonts are downloaded
+// for each change in state of the user font set, the generation value is bumped to avoid picking up
+// previously created text runs in the text run word cache.  For font groups based on stylesheets
+// with no @font-face rule, this always returns 0.
+uint64_t GetGeneration();
+// used when logging text performance
+gfxTextPerfMetrics *GetTextPerfMetrics() { return mTextPerf; }
+void SetTextPerfMetrics(gfxTextPerfMetrics *aTextPerf) { mTextPerf = aTextPerf; }
+// This will call UpdateFontList() if the user font set is changed.
+void SetUserFontSet(gfxUserFontSet *aUserFontSet);
+// If there is a user font set, check to see whether the font list or any
+// caches need updating.
+virtual void UpdateFontList();
+bool ShouldSkipDrawing() const {
+return mSkipDrawing;
+}
+class LazyReferenceContextGetter {
+public:
+virtual already_AddRefed<gfxContext> GetRefContext() = 0;
+};
+// The gfxFontGroup keeps ownership of this textrun.
+// It is only guaranteed to exist until the next call to GetEllipsisTextRun
+// (which might use a different appUnitsPerDev value) for the font group,
+// or until UpdateFontList is called, or the fontgroup is destroyed.
+// Get it/use it/forget it :) - don't keep a reference that might go stale.
+gfxTextRun* GetEllipsisTextRun(int32_t aAppUnitsPerDevPixel,
+LazyReferenceContextGetter& aRefContextGetter);
+protected:
+nsString mFamilies;
+gfxFontStyle mStyle;
+nsTArray<FamilyFace> mFonts;
+gfxFloat mUnderlineOffset;
+gfxFloat mHyphenWidth;
+nsRefPtr<gfxUserFontSet> mUserFontSet;
+uint64_t mCurrGeneration;  // track the current user font set generation, rebuild font list if needed
+gfxTextPerfMetrics *mTextPerf;
+// Cache a textrun representing an ellipsis (useful for CSS text-overflow)
+// at a specific appUnitsPerDevPixel size
+nsAutoPtr<gfxTextRun>   mCachedEllipsisTextRun;
+// cache the most recent pref font to avoid general pref font lookup
+nsRefPtr<gfxFontFamily> mLastPrefFamily;
+nsRefPtr<gfxFont>       mLastPrefFont;
+eFontPrefLang           mLastPrefLang;       // lang group for last pref font
+eFontPrefLang           mPageLang;
+bool                    mLastPrefFirstFont;  // is this the first font in the list of pref fonts for this lang group?
+bool                    mSkipDrawing; // hide text while waiting for a font
+// download to complete (or fallback
+// timer to fire)
+/**
+* Textrun creation short-cuts for special cases where we don't need to
+* call a font shaper to generate glyphs.
+*/
+gfxTextRun *MakeEmptyTextRun(const Parameters *aParams, uint32_t aFlags);
+gfxTextRun *MakeSpaceTextRun(const Parameters *aParams, uint32_t aFlags);
+gfxTextRun *MakeBlankTextRun(uint32_t aLength,
+const Parameters *aParams, uint32_t aFlags);
+// Initialize the list of fonts
+void BuildFontList();
+// Init this font group's font metrics. If there no bad fonts, you don't need to call this.
+// But if there are one or more bad fonts which have bad underline offset,
+// you should call this with the *first* bad font.
+void InitMetricsForBadFont(gfxFont* aBadFont);
+// Set up the textrun glyphs for an entire text run:
+// find script runs, and then call InitScriptRun for each
+template<typename T>
+void InitTextRun(gfxContext *aContext,
+gfxTextRun *aTextRun,
+const T *aString,
+uint32_t aLength);
+// InitTextRun helper to handle a single script run, by finding font ranges
+// and calling each font's InitTextRun() as appropriate
+template<typename T>
+void InitScriptRun(gfxContext *aContext,
+gfxTextRun *aTextRun,
+const T *aString,
+uint32_t aScriptRunStart,
+uint32_t aScriptRunEnd,
+int32_t aRunScript);
+/* If aResolveGeneric is true, then CSS/Gecko generic family names are
+* replaced with preferred fonts.
+*
+* If aResolveFontName is true then fc() is called only for existing fonts
+* and with actual font names.  If false then fc() is called with each
+* family name in aFamilies (after resolving CSS/Gecko generic family names
+* if aResolveGeneric).
+* If aUseFontSet is true, the fontgroup's user font set is checked;
+* if false then it is skipped.
+*/
+bool ForEachFontInternal(const nsAString& aFamilies,
+nsIAtom *aLanguage,
+bool aResolveGeneric,
+bool aResolveFontName,
+bool aUseFontSet,
+FontCreationCallback fc,
+void *closure);
+// Helper for font-matching:
+// see if aCh is supported in any of the faces from aFamily;
+// if so return the best style match, else return null.
+already_AddRefed<gfxFont> TryAllFamilyMembers(gfxFontFamily* aFamily,
+uint32_t aCh);
+static bool FontResolverProc(const nsAString& aName, void *aClosure);
+static bool FindPlatformFont(const nsAString& aName,
+const nsACString& aGenericName,
+bool aUseFontSet,
+void *closure);
+static NS_HIDDEN_(nsILanguageAtomService*) gLangService;
+};
+#endif

The Tor Browser / file comparison

comparison: gfx/thebes/gfxFont.h

gfx/thebes/gfxFont.h