Bug 1492908 [wpt PR 13122] - Update wpt metadata, a=testonly

[gecko.git] / gfx / thebes / gfxFontEntry.h

/* -*- 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_FONTENTRY_H
#define GFX_FONTENTRY_H

#include "gfxTypes.h"
#include "nsString.h"
#include "gfxFontConstants.h"
#include "gfxFontFeatures.h"
#include "gfxFontUtils.h"
#include "gfxFontVariations.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/HashFunctions.h"
#include "mozilla/MemoryReporting.h"
#include "MainThreadUtils.h"
#include "nsUnicodeScriptCodes.h"
#include "nsDataHashtable.h"
#include "harfbuzz/hb.h"
#include "mozilla/FontPropertyTypes.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/WeakPtr.h"
#include <math.h>

typedef struct gr_face gr_face;
typedef struct FT_MM_Var_ FT_MM_Var;

#ifdef DEBUG
#include <stdio.h>
#endif

struct gfxFontStyle;
class gfxContext;
class gfxFont;
class gfxFontFamily;
class gfxUserFontData;
class gfxSVGGlyphs;
class FontInfoData;
struct FontListSizes;
class nsAtom;

namespace mozilla {
class SVGContextPaint;
};

#define NO_FONT_LANGUAGE_OVERRIDE      0

class gfxCharacterMap : public gfxSparseBitSet {
public:
    nsrefcnt AddRef() {
        MOZ_ASSERT(int32_t(mRefCnt) >= 0, "illegal refcnt");
        ++mRefCnt;
        NS_LOG_ADDREF(this, mRefCnt, "gfxCharacterMap", sizeof(*this));
        return mRefCnt;
    }

    nsrefcnt Release() {
        MOZ_ASSERT(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)
    { }

    explicit gfxCharacterMap(const gfxSparseBitSet& aOther) :
        gfxSparseBitSet(aOther),
        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&);
};

// Info on an individual font feature, for reporting available features
// to DevTools via the GetFeatureInfo method.
struct gfxFontFeatureInfo {
    uint32_t mTag;
    uint32_t mScript;
    uint32_t mLangSys;
};

class gfxFontEntry {
public:
    typedef mozilla::gfx::DrawTarget DrawTarget;
    typedef mozilla::unicode::Script Script;
    typedef mozilla::FontWeight FontWeight;
    typedef mozilla::FontSlantStyle FontSlantStyle;
    typedef mozilla::FontStretch FontStretch;
    typedef mozilla::WeightRange WeightRange;
    typedef mozilla::SlantStyleRange SlantStyleRange;
    typedef mozilla::StretchRange StretchRange;

    // Used by stylo
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(gfxFontEntry)

    explicit gfxFontEntry(const nsACString& aName, bool aIsStandardFace = false);

    // Create a new entry that refers to the same font as this, but without
    // additional state that may have been set up (such as family name).
    // (This is only to be used for system fonts in the platform font list,
    // not user fonts.)
    virtual gfxFontEntry* Clone() const = 0;

    // unique name for the face, *not* the family; not necessarily the
    // "real" or user-friendly name, may be an internal identifier
    const nsCString& Name() const { return mName; }

    // family name
    const nsCString& 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 nsCString RealFaceName();

    WeightRange Weight() const { return mWeightRange; }
    StretchRange Stretch() const { return mStretchRange; }
    SlantStyleRange SlantStyle() const { return mStyleRange; }

    bool IsUserFont() const { return mIsDataUserFont || mIsLocalUserFont; }
    bool IsLocalUserFont() const { return mIsLocalUserFont; }
    bool IsFixedPitch() const { return mFixedPitch; }
    bool IsItalic() const { return SlantStyle().Min().IsItalic(); }
    bool IsOblique() const { return SlantStyle().Min().IsOblique(); }
    bool IsUpright() const { return SlantStyle().Min().IsNormal(); }
    inline bool SupportsItalic();
    inline bool SupportsBold(); // defined below, because of RangeFlags use
    bool IgnoreGDEF() const { return mIgnoreGDEF; }
    bool IgnoreGSUB() const { return mIgnoreGSUB; }

    // Return whether the face corresponds to "normal" CSS style properties:
    //    font-style: normal;
    //    font-weight: normal;
    //    font-stretch: normal;
    // If this is false, we might want to fall back to a different face and
    // possibly apply synthetic styling.
    bool IsNormalStyle() const
    {
        return IsUpright() &&
               Weight().Min() <= FontWeight::Normal() &&
               Weight().Max() >= FontWeight::Normal() &&
               Stretch().Min() <= FontStretch::Normal() &&
               Stretch().Max() >= FontStretch::Normal();
    }

    // whether a feature is supported by the font (limited to a small set
    // of features for which some form of fallback needs to be implemented)
    virtual bool SupportsOpenTypeFeature(Script aScript, uint32_t aFeatureTag);
    bool SupportsGraphiteFeature(uint32_t aFeatureTag);

    // returns a set containing all input glyph ids for a given feature
    const hb_set_t*
    InputsForOpenTypeFeature(Script aScript, uint32_t aFeatureTag);

    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; }
    nsresult InitializeUVSMap();
    uint16_t GetUVSGlyph(uint32_t aCh, uint32_t aVS);

    // All concrete gfxFontEntry subclasses (except gfxUserFontEntry) 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(DrawTarget* aDrawTarget, uint32_t aGlyphId,
                            gfxFloat aSize, gfxRect* aResult);
    void RenderSVGGlyph(gfxContext *aContext, uint32_t aGlyphId,
                        mozilla::SVGContextPaint* aContextPaint);
    // Call this when glyph geometry or rendering has changed
    // (e.g. animated SVG glyphs)
    void NotifyGlyphsChanged();

    bool     TryGetColorGlyphs();
    bool     GetColorLayersInfo(uint32_t aGlyphId,
                                const mozilla::gfx::Color& aDefaultColor,
                                nsTArray<uint16_t>& layerGlyphs,
                                nsTArray<mozilla::gfx::Color>& layerColors);

    // 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&) = delete;
        AutoTable& operator=(const AutoTable&) = delete;
    };

    // Return a font instance for a particular style. This may be a newly-
    // created instance, or a font already in the global cache.
    // We can't return a UniquePtr here, because we may be returning a shared
    // cached instance; but we also don't return already_AddRefed, because
    // the caller may only need to use the font temporarily and doesn't need
    // a strong reference.
    gfxFont* FindOrMakeFont(const gfxFontStyle *aStyle,
                            gfxCharacterMap* aUnicodeRangeMap = nullptr);

    // 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,
                                        nsTArray<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);

    // Does the font have graphite contextuals that involve the space glyph
    // (and therefore we should bypass the word cache)?
    bool HasGraphiteSpaceContextuals();

    // 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 of the platform font list.
    virtual void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
                                        FontListSizes* aSizes) const;
    virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
                                        FontListSizes* aSizes) const;

    // Used for reporting on individual font entries in the user font cache,
    // which are not present in the platform font list.
    size_t
    ComputedSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) 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);

    /**
     * Font-variation query methods.
     *
     * Font backends that don't support variations should provide empty
     * implementations.
     */
    virtual bool HasVariations() = 0;

    virtual void
    GetVariationAxes(nsTArray<gfxFontVariationAxis>& aVariationAxes) = 0;

    virtual void
    GetVariationInstances(nsTArray<gfxFontVariationInstance>& aInstances) = 0;

    bool HasBoldVariableWeight();
    bool HasItalicVariation();
    void CheckForVariationAxes();

    // Set up the entry's weight/stretch/style ranges according to axes found
    // by GetVariationAxes (for installed fonts; do NOT call this for user
    // fonts, where the ranges are provided by @font-face descriptors).
    void SetupVariationRanges();

    // Get variation axis settings that should be used to implement a particular
    // font style using this resource.
    void GetVariationsForStyle(nsTArray<gfxFontVariation>& aResult,
                               const gfxFontStyle& aStyle);

    // Get the font's list of features (if any) for DevTools support.
    void GetFeatureInfo(nsTArray<gfxFontFeatureInfo>& aFeatureInfo);

    // This is only called on platforms where we use FreeType.
    virtual FT_MM_Var* GetMMVar() { return nullptr; }

    nsCString         mName;
    nsCString         mFamilyName;

    RefPtr<gfxCharacterMap> mCharacterMap;

    mozilla::UniquePtr<uint8_t[]> mUVSData;
    mozilla::UniquePtr<gfxUserFontData> mUserFontData;
    mozilla::UniquePtr<gfxSVGGlyphs> mSVGGlyphs;
    // list of gfxFonts that are using SVG glyphs
    nsTArray<gfxFont*> mFontsUsingSVGGlyphs;
    nsTArray<gfxFontFeature> mFeatureSettings;
    nsTArray<gfxFontVariation> mVariationSettings;
    mozilla::UniquePtr<nsDataHashtable<nsUint32HashKey,bool>> mSupportedFeatures;
    mozilla::UniquePtr<nsDataHashtable<nsUint32HashKey,hb_set_t*>> mFeatureInputs;

    // Color Layer font support
    hb_blob_t*       mCOLR = nullptr;
    hb_blob_t*       mCPAL = nullptr;

    // bitvector of substitution space features per script, one each
    // for default and non-default features
    uint32_t         mDefaultSubSpaceFeatures[(int(Script::NUM_SCRIPT_CODES) + 31) / 32];
    uint32_t         mNonDefaultSubSpaceFeatures[(int(Script::NUM_SCRIPT_CODES) + 31) / 32];

    uint32_t         mUVSOffset = 0;

    uint32_t         mLanguageOverride = NO_FONT_LANGUAGE_OVERRIDE;

    WeightRange      mWeightRange = WeightRange(FontWeight(500));
    StretchRange     mStretchRange = StretchRange(FontStretch::Normal());
    SlantStyleRange  mStyleRange = SlantStyleRange(FontSlantStyle::Normal());

    // For user fonts (only), we need to record whether or not weight/stretch/
    // slant variations should be clamped to the range specified in the entry
    // properties. When the @font-face rule omitted one or more of these
    // descriptors, it is treated as the initial value for font-matching (and
    // so that is what we record in the font entry), but when rendering the
    // range is NOT clamped.
    enum class RangeFlags : uint8_t {
        eNoFlags        = 0,
        eAutoWeight     = (1 << 0),
        eAutoStretch    = (1 << 1),
        eAutoSlantStyle = (1 << 2),

        // Flag to record whether the face has a variable "wght" axis
        // that supports "bold" values, used to disable the application
        // of synthetic-bold effects.
        eBoldVariableWeight = (1 << 3),
        // Whether the face has an 'ital' axis.
        eItalicVariation    = (1 << 4),

        // Flags to record if the face uses a non-CSS-compatible scale
        // for weight and/or stretch, in which case we won't map the
        // properties to the variation axes (though they can still be
        // explicitly set using font-variation-settings).
        eNonCSSWeight   = (1 << 5),
        eNonCSSStretch  = (1 << 6)
    };
    RangeFlags       mRangeFlags = RangeFlags::eNoFlags;

    // NOTE that there are currently exactly 24 one-bit flags defined here,
    // so together with the 8-bit RangeFlags above, this packs neatly to a
    // 32-bit boundary. Worth considering if further flags are wanted.
    bool             mFixedPitch  : 1;
    bool             mIsBadUnderlineFont : 1;
    bool             mIsUserFontContainer : 1; // userfont entry
    bool             mIsDataUserFont : 1;      // platform font entry (data)
    bool             mIsLocalUserFont : 1;     // platform font entry (local)
    bool             mStandardFace : 1;
    bool             mIgnoreGDEF  : 1;
    bool             mIgnoreGSUB  : 1;
    bool             mSVGInitialized : 1;
    bool             mHasSpaceFeaturesInitialized : 1;
    bool             mHasSpaceFeatures : 1;
    bool             mHasSpaceFeaturesKerning : 1;
    bool             mHasSpaceFeaturesNonKerning : 1;
    bool             mSkipDefaultFeatureSpaceCheck : 1;
    bool             mGraphiteSpaceContextualsInitialized : 1;
    bool             mHasGraphiteSpaceContextuals : 1;
    bool             mSpaceGlyphIsInvisible : 1;
    bool             mSpaceGlyphIsInvisibleInitialized : 1;
    bool             mHasGraphiteTables : 1;
    bool             mCheckedForGraphiteTables : 1;
    bool             mHasCmapTable : 1;
    bool             mGrFaceInitialized : 1;
    bool             mCheckedForColorGlyph : 1;
    bool             mCheckedForVariationAxes : 1;

protected:
    friend class gfxPlatformFontList;
    friend class gfxMacPlatformFontList;
    friend class gfxUserFcFontEntry;
    friend class gfxFontFamily;
    friend class gfxSingleFaceMacFontFamily;
    friend class gfxUserFontEntry;

    gfxFontEntry();

    // Protected destructor, to discourage deletion outside of Release():
    virtual ~gfxFontEntry();

    virtual gfxFont *CreateFontInstance(const gfxFontStyle *aFontStyle) = 0;

    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,
                                   nsTArray<uint8_t>& aBuffer) {
        MOZ_ASSERT_UNREACHABLE("forgot to override either GetFontTable or "
                               "CopyFontTable?");
        return NS_ERROR_FAILURE;
    }

    // lookup the cmap in cached font data
    virtual already_AddRefed<gfxCharacterMap>
    GetCMAPFromFontInfo(FontInfoData *aFontInfoData,
                        uint32_t& aUVSOffset);

    // helper for HasCharacter(), which is what client code should call
    virtual bool TestCharacterMap(uint32_t aCh);

    // 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 = nullptr;

    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 = nullptr;

    // 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 = nullptr;

    // number of current users of this entry's mGrFace
    nsrefcnt mGrFaceRefCnt = 0;

    static const void* GrGetTable(const void *aAppFaceHandle,
                                  unsigned int aName,
                                  size_t *aLen);
    static void GrReleaseTable(const void *aAppFaceHandle,
                               const void *aTableBuffer);

    // For memory reporting: size of user-font data belonging to this entry.
    // We record this in the font entry because the actual data block may be
    // handed over to platform APIs, so that it would become difficult (and
    // platform-specific) to measure it directly at report-gathering time.
    uint32_t mComputedSizeOfUserFont = 0;

    // Font's unitsPerEm from the 'head' table, if available (will be set to
    // kInvalidUPEM for non-sfnt font formats)
    uint16_t mUnitsPerEm = 0;

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;

        explicit 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(std::move(toMove))
            , mSharedBlobData(std::move(toMove.mSharedBlobData))
            , mBlob(std::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(nsTArray<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();

        size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;

    private:
        static void DeleteFontTableBlobData(void *aBlobData);
        // not implemented
        FontTableHashEntry& operator=(FontTableHashEntry& toCopy);

        FontTableBlobData *mSharedBlobData;
        hb_blob_t *mBlob;
    };

    mozilla::UniquePtr<nsTHashtable<FontTableHashEntry> > mFontTableCache;

    gfxFontEntry(const gfxFontEntry&);
    gfxFontEntry& operator=(const gfxFontEntry&);
};

MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(gfxFontEntry::RangeFlags)

inline bool
gfxFontEntry::SupportsItalic()
{
    return SlantStyle().Max().IsItalic() ||
           ((mRangeFlags & RangeFlags::eAutoSlantStyle) ==
               RangeFlags::eAutoSlantStyle &&
            HasItalicVariation());
}

inline bool
gfxFontEntry::SupportsBold()
{
    // bold == weights 600 and above
    // We return true if the face has a max weight descriptor >= 600,
    // OR if it's a user font with auto-weight (no descriptor) and has
    // a weight axis that supports values >= 600
    return Weight().Max().IsBold() ||
           ((mRangeFlags & RangeFlags::eAutoWeight) ==
               RangeFlags::eAutoWeight &&
            HasBoldVariableWeight());
}

// used when iterating over all fonts looking for a match for a given character
struct GlobalFontMatch {
    GlobalFontMatch(const uint32_t aCharacter,
                    const gfxFontStyle& aStyle) :
        mStyle(aStyle), mCh(aCharacter),
        mCount(0), mCmapsTested(0), mMatchDistance(INFINITY)
        {
        }

    RefPtr<gfxFontEntry>   mBestMatch;   // current best match
    RefPtr<gfxFontFamily>  mMatchedFamily; // the family it belongs to
    const gfxFontStyle&    mStyle;       // style to match
    const uint32_t         mCh;          // codepoint to be matched
    uint32_t               mCount;       // number of fonts matched
    uint32_t               mCmapsTested; // number of cmaps tested
    float                  mMatchDistance; // metric indicating closest match
};

class gfxFontFamily {
public:
    // Used by stylo
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(gfxFontFamily)

    explicit gfxFontFamily(const nsACString& aName) :
        mName(aName),
        mOtherFamilyNamesInitialized(false),
        mHasOtherFamilyNames(false),
        mFaceNamesInitialized(false),
        mHasStyles(false),
        mIsSimpleFamily(false),
        mIsBadUnderlineFamily(false),
        mFamilyCharacterMapInitialized(false),
        mSkipDefaultFeatureSpaceCheck(false),
        mCheckForFallbackFaces(false),
        mCheckedForLegacyFamilyNames(false)
        { }

    const nsCString& Name() { return mName; }

    virtual void LocalizedName(nsACString& aLocalizedName);
    virtual bool HasOtherFamilyNames();

    // See https://bugzilla.mozilla.org/show_bug.cgi?id=835204:
    // check the font's 'name' table to see if it has a legacy family name
    // that would have been used by GDI (e.g. to split extra-bold or light
    // faces in a large family into separate "styled families" because of
    // GDI's 4-faces-per-family limitation). If found, the styled family
    // name will be added to the font list's "other family names" table.
    bool CheckForLegacyFamilyNames(gfxPlatformFontList* aFontList);

    nsTArray<RefPtr<gfxFontEntry> >& GetFontList() { return mAvailableFonts; }
    
    void AddFontEntry(RefPtr<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;
        }
        if (aFontEntry->mFamilyName.IsEmpty()) {
            aFontEntry->mFamilyName = Name();
        } else {
            MOZ_ASSERT(aFontEntry->mFamilyName.Equals(Name()));
        }
        aFontEntry->mSkipDefaultFeatureSpaceCheck = mSkipDefaultFeatureSpaceCheck;
        mAvailableFonts.AppendElement(aFontEntry);

        // If we're adding a face to a family that has been marked as "simple",
        // we need to ensure any null entries are removed, as well as clearing
        // the flag (which may be set again later).
        if (mIsSimpleFamily) {
            for (size_t i = mAvailableFonts.Length() - 1; i-- > 0; ) {
                if (!mAvailableFonts[i]) {
                    mAvailableFonts.RemoveElementAt(i);
                }
            }
            mIsSimpleFamily = false;
        }
    }

    // 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).
    gfxFontEntry *FindFontForStyle(const gfxFontStyle& aFontStyle, 
                                   bool aIgnoreSizeTolerance = false);

    virtual void
    FindAllFontsForStyle(const gfxFontStyle& aFontStyle,
                         nsTArray<gfxFontEntry*>& aFontEntryList,
                         bool aIgnoreSizeTolerance = false);

    // 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 nsACString& aFamilyName,
                                            const char *aNameData,
                                            uint32_t aDataLength,
                                            nsTArray<nsCString>& 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 nsACString& 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; }
    bool CheckForFallbackFaces() const { return mCheckForFallbackFaces; }

    // 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;

#ifdef DEBUG
    // Only used for debugging checks - does a linear search
    bool ContainsFace(gfxFontEntry* aFontEntry);
#endif

    void SetSkipSpaceFeatureCheck(bool aSkipCheck) {
        mSkipDefaultFeatureSpaceCheck = aSkipCheck;
    }

    // Check whether this family is appropriate to include in the Preferences
    // font list for the given langGroup and CSS generic, if the platform lets
    // us determine this.
    // Return true if the family should be included in the list, false to omit.
    // Default implementation returns true for everything, so no filtering
    // will occur; individual platforms may override.
    virtual bool FilterForFontList(nsAtom* aLangGroup,
                                   const nsACString& aGeneric) const {
        return true;
    }

protected:
    // Protected destructor, to discourage deletion outside of Release():
    virtual ~gfxFontFamily();

    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;
            }
        }
    }

    nsCString mName;
    nsTArray<RefPtr<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;
    bool mCheckForFallbackFaces : 1;  // check other faces for character
    bool mCheckedForLegacyFamilyNames : 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 used in the gfxFontGroup font list to keep track of a font family
// together with the CSS generic (if any) that was mapped to it in this
// particular case (so it can be reported to the DevTools font inspector).
struct FamilyAndGeneric final {
    FamilyAndGeneric()
        : mFamily(nullptr)
        , mGeneric(mozilla::FontFamilyType::eFamily_none)
    {
    }
    FamilyAndGeneric(const FamilyAndGeneric& aOther)
        : mFamily(aOther.mFamily)
        , mGeneric(aOther.mGeneric)
    {
    }
    explicit FamilyAndGeneric(gfxFontFamily* aFamily,
                              mozilla::FontFamilyType aGeneric =
                                  mozilla::FontFamilyType::eFamily_none)
        : mFamily(aFamily)
        , mGeneric(aGeneric)
    {
    }
    gfxFontFamily* mFamily;
    mozilla::FontFamilyType mGeneric;
};

#endif