Add m-esr52 at 52.6.0

1 files changed, 716 insertions, 0 deletions

diff --git a/gfx/thebes/gfxUserFontSet.h b/gfx/thebes/gfxUserFontSet.h
new file mode 100644
index 000000000..896c6951e
--- /dev/null
+++ b/gfx/thebes/gfxUserFontSet.h
@@ -0,0 +1,716 @@
+/* -*- 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_USER_FONT_SET_H
+#define GFX_USER_FONT_SET_H
+
+#include "gfxFont.h"
+#include "gfxFontFamilyList.h"
+#include "nsRefPtrHashtable.h"
+#include "nsCOMPtr.h"
+#include "nsIURI.h"
+#include "nsIPrincipal.h"
+#include "nsIScriptError.h"
+#include "nsURIHashKey.h"
+#include "mozilla/net/ReferrerPolicy.h"
+#include "gfxFontConstants.h"
+
+class nsFontFaceLoader;
+
+//#define DEBUG_USERFONT_CACHE
+
+class gfxFontFaceBufferSource
+{
+  NS_INLINE_DECL_REFCOUNTING(gfxFontFaceBufferSource)
+public:
+  virtual void TakeBuffer(uint8_t*& aBuffer, uint32_t& aLength) = 0;
+
+protected:
+  virtual ~gfxFontFaceBufferSource() {}
+};
+
+// parsed CSS @font-face rule information
+// lifetime: from when @font-face rule processed until font is loaded
+struct gfxFontFaceSrc {
+
+    enum SourceType {
+        eSourceType_Local,
+        eSourceType_URL,
+        eSourceType_Buffer
+    };
+
+    SourceType             mSourceType;
+
+    // if url, whether to use the origin principal or not
+    bool                   mUseOriginPrincipal;
+
+    // format hint flags, union of all possible formats
+    // (e.g. TrueType, EOT, SVG, etc.)
+    // see FLAG_FORMAT_* enum values below
+    uint32_t               mFormatFlags;
+
+    nsString               mLocalName;     // full font name if local
+    nsCOMPtr<nsIURI>       mURI;           // uri if url
+    nsCOMPtr<nsIURI>       mReferrer;      // referrer url if url
+    mozilla::net::ReferrerPolicy mReferrerPolicy;
+    nsCOMPtr<nsIPrincipal> mOriginPrincipal; // principal if url
+
+    RefPtr<gfxFontFaceBufferSource> mBuffer;
+};
+
+inline bool
+operator==(const gfxFontFaceSrc& a, const gfxFontFaceSrc& b)
+{
+    if (a.mSourceType != b.mSourceType) {
+        return false;
+    }
+    switch (a.mSourceType) {
+        case gfxFontFaceSrc::eSourceType_Local:
+            return a.mLocalName == b.mLocalName;
+        case gfxFontFaceSrc::eSourceType_URL: {
+            bool equals;
+            return a.mUseOriginPrincipal == b.mUseOriginPrincipal &&
+                   a.mFormatFlags == b.mFormatFlags &&
+                   NS_SUCCEEDED(a.mURI->Equals(b.mURI, &equals)) && equals &&
+                   NS_SUCCEEDED(a.mReferrer->Equals(b.mReferrer, &equals)) &&
+                     equals &&
+                   a.mReferrerPolicy == b.mReferrerPolicy &&
+                   a.mOriginPrincipal->Equals(b.mOriginPrincipal);
+        }
+        case gfxFontFaceSrc::eSourceType_Buffer:
+            return a.mBuffer == b.mBuffer;
+    }
+    NS_WARNING("unexpected mSourceType");
+    return false;
+}
+
+// Subclassed to store platform-specific code cleaned out when font entry is
+// deleted.
+// Lifetime: from when platform font is created until it is deactivated.
+// If the platform does not need to add any platform-specific code/data here,
+// then the gfxUserFontSet will allocate a base gfxUserFontData and attach
+// to the entry to track the basic user font info fields here.
+class gfxUserFontData {
+public:
+    gfxUserFontData()
+        : mSrcIndex(0), mFormat(0), mMetaOrigLen(0),
+          mCRC32(0), mLength(0), mCompression(kUnknownCompression),
+          mPrivate(false), mIsBuffer(false)
+    { }
+    virtual ~gfxUserFontData() { }
+
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+    nsTArray<uint8_t> mMetadata;  // woff metadata block (compressed), if any
+    nsCOMPtr<nsIURI>  mURI;       // URI of the source, if it was url()
+    nsCOMPtr<nsIPrincipal> mPrincipal; // principal for the download, if url()
+    nsString          mLocalName; // font name used for the source, if local()
+    nsString          mRealName;  // original fullname from the font resource
+    uint32_t          mSrcIndex;  // index in the rule's source list
+    uint32_t          mFormat;    // format hint for the source used, if any
+    uint32_t          mMetaOrigLen; // length needed to decompress metadata
+    uint32_t          mCRC32;     // Checksum
+    uint32_t          mLength;    // Font length
+    uint8_t           mCompression; // compression type
+    bool              mPrivate;   // whether font belongs to a private window
+    bool              mIsBuffer;  // whether the font source was a buffer
+
+    enum {
+        kUnknownCompression = 0,
+        kZlibCompression = 1,
+        kBrotliCompression = 2
+    };
+};
+
+// initially contains a set of userfont font entry objects, replaced with
+// platform/user fonts as downloaded
+
+class gfxUserFontFamily : public gfxFontFamily {
+public:
+    friend class gfxUserFontSet;
+
+    explicit gfxUserFontFamily(const nsAString& aName)
+        : gfxFontFamily(aName) { }
+
+    virtual ~gfxUserFontFamily() { }
+
+    // add the given font entry to the end of the family's list
+    void AddFontEntry(gfxFontEntry* aFontEntry) {
+        // keep ref while removing existing entry
+        RefPtr<gfxFontEntry> fe = aFontEntry;
+        // remove existing entry, if already present
+        mAvailableFonts.RemoveElement(aFontEntry);
+        // insert at the beginning so that the last-defined font is the first
+        // one in the fontlist used for matching, as per CSS Fonts spec
+        mAvailableFonts.InsertElementAt(0, aFontEntry);
+
+        if (aFontEntry->mFamilyName.IsEmpty()) {
+            aFontEntry->mFamilyName = Name();
+        } else {
+#ifdef DEBUG
+            nsString thisName = Name();
+            nsString entryName = aFontEntry->mFamilyName;
+            ToLowerCase(thisName);
+            ToLowerCase(entryName);
+            MOZ_ASSERT(thisName.Equals(entryName));
+#endif
+        }
+        ResetCharacterMap();
+    }
+
+    // Remove all font entries from the family
+    void DetachFontEntries() {
+        mAvailableFonts.Clear();
+    }
+};
+
+class gfxUserFontEntry;
+class gfxOTSContext;
+
+class gfxUserFontSet {
+    friend class gfxUserFontEntry;
+    friend class gfxOTSContext;
+
+public:
+
+    NS_INLINE_DECL_REFCOUNTING(gfxUserFontSet)
+
+    gfxUserFontSet();
+
+    enum {
+        // no flags ==> no hint set
+        // unknown ==> unknown format hint set
+        FLAG_FORMAT_UNKNOWN        = 1,
+        FLAG_FORMAT_OPENTYPE       = 1 << 1,
+        FLAG_FORMAT_TRUETYPE       = 1 << 2,
+        FLAG_FORMAT_TRUETYPE_AAT   = 1 << 3,
+        FLAG_FORMAT_EOT            = 1 << 4,
+        FLAG_FORMAT_SVG            = 1 << 5,
+        FLAG_FORMAT_WOFF           = 1 << 6,
+        FLAG_FORMAT_WOFF2          = 1 << 7,
+
+        // the common formats that we support everywhere
+        FLAG_FORMATS_COMMON        = FLAG_FORMAT_OPENTYPE |
+                                     FLAG_FORMAT_TRUETYPE |
+                                     FLAG_FORMAT_WOFF     |
+                                     FLAG_FORMAT_WOFF2,
+
+        // mask of all unused bits, update when adding new formats
+        FLAG_FORMAT_NOT_USED       = ~((1 << 8)-1)
+    };
+
+
+    // creates a font face without adding it to a particular family
+    // weight - [100, 900] (multiples of 100)
+    // stretch = [NS_FONT_STRETCH_ULTRA_CONDENSED, NS_FONT_STRETCH_ULTRA_EXPANDED]
+    // italic style = constants in gfxFontConstants.h, e.g. NS_FONT_STYLE_NORMAL
+    // language override = result of calling gfxFontStyle::ParseFontLanguageOverride
+    // TODO: support for unicode ranges not yet implemented
+    virtual already_AddRefed<gfxUserFontEntry> CreateUserFontEntry(
+                              const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
+                              uint32_t aWeight,
+                              int32_t aStretch,
+                              uint8_t aStyle,
+                              const nsTArray<gfxFontFeature>& aFeatureSettings,
+                              uint32_t aLanguageOverride,
+                              gfxSparseBitSet* aUnicodeRanges,
+                              uint8_t aFontDisplay) = 0;
+
+    // creates a font face for the specified family, or returns an existing
+    // matching entry on the family if there is one
+    already_AddRefed<gfxUserFontEntry> FindOrCreateUserFontEntry(
+                               const nsAString& aFamilyName,
+                               const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
+                               uint32_t aWeight,
+                               int32_t aStretch,
+                               uint8_t aStyle,
+                               const nsTArray<gfxFontFeature>& aFeatureSettings,
+                               uint32_t aLanguageOverride,
+                               gfxSparseBitSet* aUnicodeRanges,
+                               uint8_t aFontDisplay);
+
+    // add in a font face for which we have the gfxUserFontEntry already
+    void AddUserFontEntry(const nsAString& aFamilyName,
+                          gfxUserFontEntry* aUserFontEntry);
+
+    // Whether there is a face with this family name
+    bool HasFamily(const nsAString& aFamilyName) const
+    {
+        return LookupFamily(aFamilyName) != nullptr;
+    }
+
+    // Look up and return the gfxUserFontFamily in mFontFamilies with
+    // the given name
+    gfxUserFontFamily* LookupFamily(const nsAString& aName) const;
+
+    // Look up names in a fontlist and return true if any are in the set
+    bool ContainsUserFontSetFonts(const mozilla::FontFamilyList& aFontList) const;
+
+    // Lookup a font entry for a given style, returns null if not loaded.
+    // aFamily must be a family returned by our LookupFamily method.
+    // (only used by gfxPangoFontGroup for now)
+    gfxUserFontEntry* FindUserFontEntryAndLoad(gfxFontFamily* aFamily,
+                                               const gfxFontStyle& aFontStyle,
+                                               bool& aNeedsBold,
+                                               bool& aWaitForUserFont);
+
+    // check whether the given source is allowed to be loaded;
+    // returns the Principal (for use in the key when caching the loaded font),
+    // and whether the load should bypass the cache (force-reload).
+    virtual nsresult CheckFontLoad(const gfxFontFaceSrc* aFontFaceSrc,
+                                   nsIPrincipal** aPrincipal,
+                                   bool* aBypassCache) = 0;
+
+    // check whether content policies allow the given URI to load.
+    virtual bool IsFontLoadAllowed(nsIURI* aFontLocation,
+                                   nsIPrincipal* aPrincipal) = 0;
+
+    // initialize the process that loads external font data, which upon
+    // completion will call FontDataDownloadComplete method
+    virtual nsresult StartLoad(gfxUserFontEntry* aUserFontEntry,
+                               const gfxFontFaceSrc* aFontFaceSrc) = 0;
+
+    // generation - each time a face is loaded, generation is
+    // incremented so that the change can be recognized
+    uint64_t GetGeneration() { return mGeneration; }
+
+    // increment the generation on font load
+    void IncrementGeneration(bool aIsRebuild = false);
+
+    // Generation is bumped on font loads but that doesn't affect name-style
+    // mappings. Rebuilds do however affect name-style mappings so need to
+    // lookup fontlists again when that happens.
+    uint64_t GetRebuildGeneration() { return mRebuildGeneration; }
+
+    // rebuild if local rules have been used
+    void RebuildLocalRules();
+
+    class UserFontCache {
+    public:
+        // Flag passed when caching a font entry, to specify whether the entry
+        // should persist in the cache or be discardable.
+        typedef enum {
+            kDiscardable,
+            kPersistent
+        } EntryPersistence;
+
+        // Record a loaded user-font in the cache. This requires that the
+        // font-entry's userFontData has been set up already, as it relies
+        // on the URI and Principal recorded there.
+        // If aPersistence is Persistent, the entry will remain in the cache
+        // across cacheservice:empty-cache notifications. This is used for
+        // "preloaded hidden fonts" on FxOS.
+        static void CacheFont(gfxFontEntry* aFontEntry,
+                              EntryPersistence aPersistence = kDiscardable);
+
+        // The given gfxFontEntry is being destroyed, so remove any record that
+        // refers to it.
+        static void ForgetFont(gfxFontEntry* aFontEntry);
+
+        // Return the gfxFontEntry corresponding to a given URI and principal,
+        // and the features of the given userfont entry, or nullptr if none is available.
+        // The aPrivate flag is set for requests coming from private windows,
+        // so we can avoid leaking fonts cached in private windows mode out to
+        // normal windows.
+        static gfxFontEntry* GetFont(nsIURI* aSrcURI,
+                                     nsIPrincipal* aPrincipal,
+                                     gfxUserFontEntry* aUserFontEntry,
+                                     bool              aPrivate);
+
+        // Clear everything so that we don't leak URIs and Principals.
+        static void Shutdown();
+
+        // Memory-reporting support.
+        class MemoryReporter final : public nsIMemoryReporter
+        {
+        private:
+            ~MemoryReporter() { }
+
+        public:
+            NS_DECL_ISUPPORTS
+            NS_DECL_NSIMEMORYREPORTER
+        };
+
+#ifdef DEBUG_USERFONT_CACHE
+        // dump contents
+        static void Dump();
+#endif
+
+    private:
+        // Helper that we use to observe the empty-cache notification
+        // from nsICacheService.
+        class Flusher : public nsIObserver
+        {
+            virtual ~Flusher() {}
+        public:
+            NS_DECL_ISUPPORTS
+            NS_DECL_NSIOBSERVER
+            Flusher() {}
+        };
+
+        // Key used to look up entries in the user-font cache.
+        // Note that key comparison does *not* use the mFontEntry field
+        // as a whole; it only compares specific fields within the entry
+        // (weight/width/style/features) that could affect font selection
+        // or rendering, and that must match between a font-set's userfont
+        // entry and the corresponding "real" font entry.
+        struct Key {
+            nsCOMPtr<nsIURI>        mURI;
+            nsCOMPtr<nsIPrincipal>  mPrincipal; // use nullptr with data: URLs
+            // The font entry MUST notify the cache when it is destroyed
+            // (by calling ForgetFont()).
+            gfxFontEntry* MOZ_NON_OWNING_REF mFontEntry;
+            uint32_t                mCRC32;
+            uint32_t                mLength;
+            bool                    mPrivate;
+            EntryPersistence        mPersistence;
+
+            Key(nsIURI* aURI, nsIPrincipal* aPrincipal,
+                gfxFontEntry* aFontEntry, bool aPrivate,
+                EntryPersistence aPersistence = kDiscardable)
+                : mURI(aURI),
+                  mPrincipal(aPrincipal),
+                  mFontEntry(aFontEntry),
+                  mCRC32(0),
+                  mLength(0),
+                  mPrivate(aPrivate),
+                  mPersistence(aPersistence)
+            { }
+
+            Key(uint32_t aCRC32, uint32_t aLength,
+                gfxFontEntry* aFontEntry, bool aPrivate,
+                EntryPersistence aPersistence = kDiscardable)
+                : mURI(nullptr),
+                  mPrincipal(nullptr),
+                  mFontEntry(aFontEntry),
+                  mCRC32(aCRC32),
+                  mLength(aLength),
+                  mPrivate(aPrivate),
+                  mPersistence(aPersistence)
+            { }
+        };
+
+        class Entry : public PLDHashEntryHdr {
+        public:
+            typedef const Key& KeyType;
+            typedef const Key* KeyTypePointer;
+
+            explicit Entry(KeyTypePointer aKey)
+                : mURI(aKey->mURI),
+                  mPrincipal(aKey->mPrincipal),
+                  mCRC32(aKey->mCRC32),
+                  mLength(aKey->mLength),
+                  mFontEntry(aKey->mFontEntry),
+                  mPrivate(aKey->mPrivate),
+                  mPersistence(aKey->mPersistence)
+            { }
+
+            Entry(const Entry& aOther)
+                : mURI(aOther.mURI),
+                  mPrincipal(aOther.mPrincipal),
+                  mCRC32(aOther.mCRC32),
+                  mLength(aOther.mLength),
+                  mFontEntry(aOther.mFontEntry),
+                  mPrivate(aOther.mPrivate),
+                  mPersistence(aOther.mPersistence)
+            { }
+
+            ~Entry() { }
+
+            bool KeyEquals(const KeyTypePointer aKey) const;
+
+            static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
+
+            static PLDHashNumber HashKey(const KeyTypePointer aKey) {
+                if (aKey->mLength) {
+                    return aKey->mCRC32;
+                }
+                uint32_t principalHash = 0;
+                if (aKey->mPrincipal) {
+                    aKey->mPrincipal->GetHashValue(&principalHash);
+                }
+                return mozilla::HashGeneric(principalHash + int(aKey->mPrivate),
+                                            nsURIHashKey::HashKey(aKey->mURI),
+                                            HashFeatures(aKey->mFontEntry->mFeatureSettings),
+                                            mozilla::HashString(aKey->mFontEntry->mFamilyName),
+                                            (aKey->mFontEntry->mStyle |
+                                             (aKey->mFontEntry->mWeight << 2) |
+                                             (aKey->mFontEntry->mStretch << 11) ) ^
+                                             aKey->mFontEntry->mLanguageOverride);
+            }
+
+            enum { ALLOW_MEMMOVE = false };
+
+            gfxFontEntry* GetFontEntry() const { return mFontEntry; }
+
+            bool IsPersistent() const { return mPersistence == kPersistent; }
+            bool IsPrivate() const { return mPrivate; }
+
+            void ReportMemory(nsIHandleReportCallback* aHandleReport,
+                              nsISupports* aData, bool aAnonymize);
+
+#ifdef DEBUG_USERFONT_CACHE
+            void Dump();
+#endif
+
+        private:
+            static uint32_t
+            HashFeatures(const nsTArray<gfxFontFeature>& aFeatures) {
+                return mozilla::HashBytes(aFeatures.Elements(),
+                                          aFeatures.Length() * sizeof(gfxFontFeature));
+            }
+
+            nsCOMPtr<nsIURI>       mURI;
+            nsCOMPtr<nsIPrincipal> mPrincipal; // or nullptr for data: URLs
+
+            uint32_t               mCRC32;
+            uint32_t               mLength;
+
+            // The "real" font entry corresponding to this downloaded font.
+            // The font entry MUST notify the cache when it is destroyed
+            // (by calling ForgetFont()).
+            gfxFontEntry* MOZ_NON_OWNING_REF mFontEntry;
+
+            // Whether this font was loaded from a private window.
+            bool                   mPrivate;
+
+            // Whether this entry should survive cache-flushing.
+            EntryPersistence       mPersistence;
+        };
+
+        static nsTHashtable<Entry>* sUserFonts;
+    };
+
+    void SetLocalRulesUsed() {
+        mLocalRulesUsed = true;
+    }
+
+    static mozilla::LogModule* GetUserFontsLog();
+
+    // record statistics about font completion
+    virtual void RecordFontLoadDone(uint32_t aFontSize,
+                                    mozilla::TimeStamp aDoneTime) {}
+
+    void GetLoadStatistics(uint32_t& aLoadCount, uint64_t& aLoadSize) const {
+        aLoadCount = mDownloadCount;
+        aLoadSize = mDownloadSize;
+    }
+
+protected:
+    // Protected destructor, to discourage deletion outside of Release():
+    virtual ~gfxUserFontSet();
+
+    // Return whether the font set is associated with a private-browsing tab.
+    virtual bool GetPrivateBrowsing() = 0;
+
+    // parse data for a data URL
+    virtual nsresult SyncLoadFontData(gfxUserFontEntry* aFontToLoad,
+                                      const gfxFontFaceSrc* aFontFaceSrc,
+                                      uint8_t* &aBuffer,
+                                      uint32_t &aBufferLength) = 0;
+
+    // report a problem of some kind (implemented in nsUserFontSet)
+    virtual nsresult LogMessage(gfxUserFontEntry* aUserFontEntry,
+                                const char* aMessage,
+                                uint32_t aFlags = nsIScriptError::errorFlag,
+                                nsresult aStatus = NS_OK) = 0;
+
+    // helper method for performing the actual userfont set rebuild
+    virtual void DoRebuildUserFontSet() = 0;
+
+    // helper method for FindOrCreateUserFontEntry
+    gfxUserFontEntry* FindExistingUserFontEntry(
+                                   gfxUserFontFamily* aFamily,
+                                   const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
+                                   uint32_t aWeight,
+                                   int32_t aStretch,
+                                   uint8_t aStyle,
+                                   const nsTArray<gfxFontFeature>& aFeatureSettings,
+                                   uint32_t aLanguageOverride,
+                                   gfxSparseBitSet* aUnicodeRanges,
+                                   uint8_t aFontDisplay);
+
+    // creates a new gfxUserFontFamily in mFontFamilies, or returns an existing
+    // family if there is one
+    gfxUserFontFamily* GetFamily(const nsAString& aFamilyName);
+
+    // font families defined by @font-face rules
+    nsRefPtrHashtable<nsStringHashKey, gfxUserFontFamily> mFontFamilies;
+
+    uint64_t        mGeneration;        // bumped on any font load change
+    uint64_t        mRebuildGeneration; // only bumped on rebuilds
+
+    // true when local names have been looked up, false otherwise
+    bool mLocalRulesUsed;
+
+    // true when rules using local names need to be redone
+    bool mRebuildLocalRules;
+
+    // performance stats
+    uint32_t mDownloadCount;
+    uint64_t mDownloadSize;
+};
+
+// acts a placeholder until the real font is downloaded
+
+class gfxUserFontEntry : public gfxFontEntry {
+    friend class gfxUserFontSet;
+    friend class nsUserFontSet;
+    friend class nsFontFaceLoader;
+    friend class gfxOTSContext;
+
+public:
+    enum UserFontLoadState {
+        STATUS_NOT_LOADED = 0,
+        STATUS_LOADING,
+        STATUS_LOADED,
+        STATUS_FAILED
+    };
+
+    gfxUserFontEntry(gfxUserFontSet* aFontSet,
+                     const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
+                     uint32_t aWeight,
+                     int32_t aStretch,
+                     uint8_t aStyle,
+                     const nsTArray<gfxFontFeature>& aFeatureSettings,
+                     uint32_t aLanguageOverride,
+                     gfxSparseBitSet* aUnicodeRanges,
+                     uint8_t aFontDisplay);
+
+    virtual ~gfxUserFontEntry();
+
+    // Return whether the entry matches the given list of attributes
+    bool Matches(const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
+                 uint32_t aWeight,
+                 int32_t aStretch,
+                 uint8_t aStyle,
+                 const nsTArray<gfxFontFeature>& aFeatureSettings,
+                 uint32_t aLanguageOverride,
+                 gfxSparseBitSet* aUnicodeRanges,
+                 uint8_t aFontDisplay);
+
+    virtual gfxFont* CreateFontInstance(const gfxFontStyle* aFontStyle,
+                                        bool aNeedsBold);
+
+    gfxFontEntry* GetPlatformFontEntry() const { return mPlatformFontEntry; }
+
+    // is the font loading or loaded, or did it fail?
+    UserFontLoadState LoadState() const { return mUserFontLoadState; }
+
+    // whether to wait before using fallback font or not
+    bool WaitForUserFont() const {
+        return mUserFontLoadState == STATUS_LOADING &&
+               mFontDataLoadingState < LOADING_SLOWLY;
+    }
+
+    // for userfonts, cmap is used to store the unicode range data
+    // no cmap ==> all codepoints permitted
+    bool CharacterInUnicodeRange(uint32_t ch) const {
+        if (mCharacterMap) {
+            return mCharacterMap->test(ch);
+        }
+        return true;
+    }
+
+    gfxCharacterMap* GetUnicodeRangeMap() const {
+        return mCharacterMap.get();
+    }
+
+    uint8_t GetFontDisplay() const { return mFontDisplay; }
+
+    // load the font - starts the loading of sources which continues until
+    // a valid font resource is found or all sources fail
+    void Load();
+
+    // methods to expose some information to FontFaceSet::UserFontSet
+    // since we can't make that class a friend
+    void SetLoader(nsFontFaceLoader* aLoader) { mLoader = aLoader; }
+    nsFontFaceLoader* GetLoader() { return mLoader; }
+    nsIPrincipal* GetPrincipal() { return mPrincipal; }
+    uint32_t GetSrcIndex() { return mSrcIndex; }
+    void GetFamilyNameAndURIForLogging(nsACString& aFamilyName,
+                                       nsACString& aURI);
+
+#ifdef DEBUG
+    gfxUserFontSet* GetUserFontSet() const { return mFontSet; }
+#endif
+
+protected:
+    const uint8_t* SanitizeOpenTypeData(const uint8_t* aData,
+                                        uint32_t aLength,
+                                        uint32_t& aSaneLength,
+                                        gfxUserFontType aFontType);
+
+    // attempt to load the next resource in the src list.
+    void LoadNextSrc();
+
+    // change the load state
+    virtual void SetLoadState(UserFontLoadState aLoadState);
+
+    // when download has been completed, pass back data here
+    // aDownloadStatus == NS_OK ==> download succeeded, error otherwise
+    // returns true if platform font creation sucessful (or local()
+    // reference was next in line)
+    // Ownership of aFontData is passed in here; the font set must
+    // ensure that it is eventually deleted with free().
+    bool FontDataDownloadComplete(const uint8_t* aFontData, uint32_t aLength,
+                                  nsresult aDownloadStatus);
+
+    // helper method for creating a platform font
+    // returns true if platform font creation successful
+    // Ownership of aFontData is passed in here; the font must
+    // ensure that it is eventually deleted with free().
+    bool LoadPlatformFont(const uint8_t* aFontData, uint32_t& aLength);
+
+    // store metadata and src details for current src into aFontEntry
+    void StoreUserFontData(gfxFontEntry*      aFontEntry,
+                           bool               aPrivate,
+                           const nsAString&   aOriginalName,
+                           FallibleTArray<uint8_t>* aMetadata,
+                           uint32_t           aMetaOrigLen,
+                           uint8_t            aCompression);
+
+    // Clears and then adds to aResult all of the user font sets that this user
+    // font entry has been added to.  This will at least include mFontSet, the
+    // owner of this user font entry.
+    virtual void GetUserFontSets(nsTArray<gfxUserFontSet*>& aResult);
+
+    // Calls IncrementGeneration() on all user font sets that contain this
+    // user font entry.
+    void IncrementGeneration();
+
+    // general load state
+    UserFontLoadState        mUserFontLoadState;
+
+    // detailed load state while font data is loading
+    // used to determine whether to use fallback font or not
+    // note that code depends on the ordering of these values!
+    enum FontDataLoadingState {
+        NOT_LOADING = 0,     // not started to load any font resources yet
+        LOADING_STARTED,     // loading has started; hide fallback font
+        LOADING_ALMOST_DONE, // timeout happened but we're nearly done,
+                             // so keep hiding fallback font
+        LOADING_SLOWLY,      // timeout happened and we're not nearly done,
+                             // so use the fallback font
+        LOADING_TIMED_OUT,   // font load took too long
+        LOADING_FAILED       // failed to load any source: use fallback
+    };
+    FontDataLoadingState     mFontDataLoadingState;
+
+    bool                     mUnsupportedFormat;
+    uint8_t                  mFontDisplay; // timing of userfont fallback
+
+    RefPtr<gfxFontEntry>   mPlatformFontEntry;
+    nsTArray<gfxFontFaceSrc> mSrcList;
+    uint32_t                 mSrcIndex; // index of loading src item
+    // This field is managed by the nsFontFaceLoader. In the destructor and Cancel()
+    // methods of nsFontFaceLoader this reference is nulled out.
+    nsFontFaceLoader* MOZ_NON_OWNING_REF mLoader; // current loader for this entry, if any
+    gfxUserFontSet*          mFontSet; // font-set which owns this userfont entry
+    nsCOMPtr<nsIPrincipal>   mPrincipal;
+};
+
+
+#endif /* GFX_USER_FONT_SET_H */