mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-23 18:26:15 +00:00
e7b3b3140d
Everything that goes in a PLDHashtable (and its derivatives, like nsTHashtable) needs to inherit from PLDHashEntryHdr. But through a lack of enforcement, copy constructors for these derived classes didn't explicitly invoke the copy constructor for PLDHashEntryHdr (and the compiler didn't invoke the copy constructor for us). Instead, PLDHashTable explicitly copied around the bits that the copy constructor would have. The current setup has two problems: 1) Derived classes should be using move construction, not copy construction, since anything that's shuffling hash table keys/entries around will be using move construction. 2) Derived classes should take responsibility for transferring bits of superclass state around, and not rely on something else to handle that. The second point is not a huge problem for PLDHashTable (PLDHashTable only has to copy PLDHashEntryHdr's bits in a single place), but future hash table implementations that might move entries around more aggressively would have to insert compensation code all over the place. Additionally, if moving entries is implemented via memcpy (which is quite common), PLDHashTable copying around bits *again* is inefficient. Let's fix all these problems in one go, by: 1) Explicitly declaring the set of constructors that PLDHashEntryHdr implements (and does not implement). In particular, the copy constructor is deleted, so any derived classes that attempt to make themselves copyable will be detected at compile time: the compiler will complain that the superclass type is not copyable. This change on its own will result in many compiler errors, so... 2) Change any derived classes to implement move constructors instead of copy constructors. Note that some of these move constructors are, strictly speaking, unnecessary, since the relevant classes are moved via memcpy in nsTHashtable and its derivatives.
740 lines
29 KiB
C++
740 lines
29 KiB
C++
/* -*- 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 "gfxFontSrcPrincipal.h"
|
|
#include "gfxFontSrcURI.h"
|
|
#include "nsRefPtrHashtable.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIURI.h"
|
|
#include "nsIPrincipal.h"
|
|
#include "nsIScriptError.h"
|
|
#include "nsURIHashKey.h"
|
|
#include "mozilla/FontPropertyTypes.h"
|
|
#include "mozilla/net/ReferrerPolicy.h"
|
|
#include "gfxFontConstants.h"
|
|
|
|
namespace mozilla {
|
|
class PostTraversalTask;
|
|
} // namespace mozilla
|
|
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;
|
|
|
|
nsCString mLocalName; // full font name if local
|
|
RefPtr<gfxFontSrcURI> mURI; // uri if url
|
|
nsCOMPtr<nsIURI> mReferrer; // referrer url if url
|
|
mozilla::net::ReferrerPolicy mReferrerPolicy;
|
|
RefPtr<gfxFontSrcPrincipal> mOriginPrincipal; // principal if url
|
|
|
|
RefPtr<gfxFontFaceBufferSource> mBuffer;
|
|
|
|
// The principal that should be used for the load. Should only be used for
|
|
// URL sources.
|
|
gfxFontSrcPrincipal* LoadPrincipal(const gfxUserFontSet&) const;
|
|
};
|
|
|
|
inline bool
|
|
operator==(const gfxFontFaceSrc& a, const gfxFontFaceSrc& b)
|
|
{
|
|
// The mReferrer and mOriginPrincipal comparisons aren't safe OMT.
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
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 &&
|
|
(a.mURI == b.mURI || a.mURI->Equals(b.mURI)) &&
|
|
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),
|
|
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
|
|
RefPtr<gfxFontSrcURI> mURI; // URI of the source, if it was url()
|
|
RefPtr<gfxFontSrcPrincipal> mPrincipal; // principal for the download, if url()
|
|
nsCString mLocalName; // font name used for the source, if local()
|
|
nsCString 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
|
|
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 nsACString& 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
|
|
nsCString thisName = Name();
|
|
nsCString 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:
|
|
typedef mozilla::FontStretch FontStretch;
|
|
typedef mozilla::StretchRange StretchRange;
|
|
typedef mozilla::FontSlantStyle FontSlantStyle;
|
|
typedef mozilla::SlantStyleRange SlantStyleRange;
|
|
typedef mozilla::FontWeight FontWeight;
|
|
typedef mozilla::WeightRange WeightRange;
|
|
typedef gfxFontEntry::RangeFlags RangeFlags;
|
|
|
|
NS_INLINE_DECL_THREADSAFE_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,
|
|
|
|
FLAG_FORMAT_OPENTYPE_VARIATIONS = 1 << 8,
|
|
FLAG_FORMAT_TRUETYPE_VARIATIONS = 1 << 9,
|
|
FLAG_FORMAT_WOFF_VARIATIONS = 1 << 10,
|
|
FLAG_FORMAT_WOFF2_VARIATIONS = 1 << 11,
|
|
|
|
// the common formats that we support everywhere
|
|
FLAG_FORMATS_COMMON = FLAG_FORMAT_OPENTYPE |
|
|
FLAG_FORMAT_TRUETYPE |
|
|
FLAG_FORMAT_WOFF |
|
|
FLAG_FORMAT_WOFF2 |
|
|
FLAG_FORMAT_OPENTYPE_VARIATIONS |
|
|
FLAG_FORMAT_TRUETYPE_VARIATIONS |
|
|
FLAG_FORMAT_WOFF_VARIATIONS |
|
|
FLAG_FORMAT_WOFF2_VARIATIONS,
|
|
|
|
// mask of all unused bits, update when adding new formats
|
|
FLAG_FORMAT_NOT_USED = ~((1 << 12)-1)
|
|
};
|
|
|
|
|
|
// creates a font face without adding it to a particular family
|
|
// weight - [100, 900] (multiples of 100)
|
|
// stretch = [FontStretch::UltraCondensed(), FontStretch::UltraExpanded()]
|
|
// italic style = constants in gfxFontConstants.h, e.g. NS_FONT_STYLE_NORMAL
|
|
// language override = result of calling nsLayoutUtils::ParseFontLanguageOverride
|
|
// TODO: support for unicode ranges not yet implemented
|
|
virtual already_AddRefed<gfxUserFontEntry> CreateUserFontEntry(
|
|
const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
|
|
WeightRange aWeight,
|
|
StretchRange aStretch,
|
|
SlantStyleRange aStyle,
|
|
const nsTArray<gfxFontFeature>& aFeatureSettings,
|
|
const nsTArray<gfxFontVariation>& aVariationSettings,
|
|
uint32_t aLanguageOverride,
|
|
gfxCharacterMap* aUnicodeRanges,
|
|
uint8_t aFontDisplay,
|
|
RangeFlags aRangeFlags) = 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 nsACString& aFamilyName,
|
|
const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
|
|
WeightRange aWeight,
|
|
StretchRange aStretch,
|
|
SlantStyleRange aStyle,
|
|
const nsTArray<gfxFontFeature>& aFeatureSettings,
|
|
const nsTArray<gfxFontVariation>& aVariationSettings,
|
|
uint32_t aLanguageOverride,
|
|
gfxCharacterMap* aUnicodeRanges,
|
|
uint8_t aFontDisplay,
|
|
RangeFlags aRangeFlags);
|
|
|
|
// add in a font face for which we have the gfxUserFontEntry already
|
|
void AddUserFontEntry(const nsCString& aFamilyName,
|
|
gfxUserFontEntry* aUserFontEntry);
|
|
|
|
// Whether there is a face with this family name
|
|
bool HasFamily(const nsACString& aFamilyName) const
|
|
{
|
|
return LookupFamily(aFamilyName) != nullptr;
|
|
}
|
|
|
|
// Look up and return the gfxUserFontFamily in mFontFamilies with
|
|
// the given name
|
|
gfxUserFontFamily* LookupFamily(const nsACString& aName) const;
|
|
|
|
// Look up names in a fontlist and return true if any are in the set
|
|
bool ContainsUserFontSetFonts(const mozilla::FontFamilyList& aFontList) const;
|
|
|
|
virtual gfxFontSrcPrincipal* GetStandardFontLoadPrincipal() const = 0;
|
|
|
|
// check whether content policies allow the given URI to load.
|
|
virtual bool IsFontLoadAllowed(const gfxFontFaceSrc&) = 0;
|
|
|
|
// Dispatches all of the specified runnables to the font face set's
|
|
// document's event queue.
|
|
virtual void DispatchFontLoadViolations(
|
|
nsTArray<nsCOMPtr<nsIRunnable>>& aViolations) = 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:
|
|
// 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.
|
|
static void CacheFont(gfxFontEntry* aFontEntry);
|
|
|
|
// 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(const gfxFontFaceSrc&, const gfxUserFontEntry&);
|
|
|
|
// 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 {
|
|
RefPtr<gfxFontSrcURI> mURI;
|
|
RefPtr<gfxFontSrcPrincipal> 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;
|
|
bool mPrivate;
|
|
|
|
Key(gfxFontSrcURI* aURI, gfxFontSrcPrincipal* aPrincipal,
|
|
gfxFontEntry* aFontEntry, bool aPrivate)
|
|
: mURI(aURI),
|
|
mPrincipal(aPrincipal),
|
|
mFontEntry(aFontEntry),
|
|
mPrivate(aPrivate)
|
|
{ }
|
|
};
|
|
|
|
class Entry : public PLDHashEntryHdr {
|
|
public:
|
|
typedef const Key& KeyType;
|
|
typedef const Key* KeyTypePointer;
|
|
|
|
explicit Entry(KeyTypePointer aKey)
|
|
: mURI(aKey->mURI),
|
|
mPrincipal(aKey->mPrincipal),
|
|
mFontEntry(aKey->mFontEntry),
|
|
mPrivate(aKey->mPrivate)
|
|
{ }
|
|
|
|
Entry(Entry&& aOther)
|
|
: PLDHashEntryHdr(std::move(aOther))
|
|
, mURI(std::move(aOther.mURI))
|
|
, mPrincipal(std::move(aOther.mPrincipal))
|
|
, mFontEntry(std::move(aOther.mFontEntry))
|
|
, mPrivate(std::move(aOther.mPrivate))
|
|
{ }
|
|
|
|
~Entry() { }
|
|
|
|
bool KeyEquals(const KeyTypePointer aKey) const;
|
|
|
|
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
|
|
|
|
static PLDHashNumber HashKey(const KeyTypePointer aKey) {
|
|
PLDHashNumber principalHash =
|
|
aKey->mPrincipal ? aKey->mPrincipal->Hash() : 0;
|
|
return mozilla::HashGeneric(principalHash + int(aKey->mPrivate),
|
|
aKey->mURI->Hash(),
|
|
HashFeatures(aKey->mFontEntry->mFeatureSettings),
|
|
HashVariations(aKey->mFontEntry->mVariationSettings),
|
|
mozilla::HashString(aKey->mFontEntry->mFamilyName),
|
|
aKey->mFontEntry->Weight().AsScalar(),
|
|
aKey->mFontEntry->SlantStyle().AsScalar(),
|
|
aKey->mFontEntry->Stretch().AsScalar(),
|
|
aKey->mFontEntry->mLanguageOverride);
|
|
}
|
|
|
|
enum { ALLOW_MEMMOVE = false };
|
|
|
|
gfxFontSrcURI* GetURI() const { return mURI; }
|
|
gfxFontSrcPrincipal* GetPrincipal() const { return mPrincipal; }
|
|
gfxFontEntry* GetFontEntry() const { return mFontEntry; }
|
|
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));
|
|
}
|
|
|
|
static uint32_t
|
|
HashVariations(const nsTArray<gfxFontVariation>& aVariations) {
|
|
return mozilla::HashBytes(aVariations.Elements(),
|
|
aVariations.Length() * sizeof(gfxFontVariation));
|
|
}
|
|
|
|
RefPtr<gfxFontSrcURI> mURI;
|
|
RefPtr<gfxFontSrcPrincipal> mPrincipal; // or nullptr for data: URLs
|
|
|
|
// 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;
|
|
};
|
|
|
|
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;
|
|
|
|
// Return whether the font set is associated with a document that was
|
|
// shift-reloaded, for example, and thus should bypass the font cache.
|
|
virtual bool BypassCache() = 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,
|
|
WeightRange aWeight,
|
|
StretchRange aStretch,
|
|
SlantStyleRange aStyle,
|
|
const nsTArray<gfxFontFeature>& aFeatureSettings,
|
|
const nsTArray<gfxFontVariation>& aVariationSettings,
|
|
uint32_t aLanguageOverride,
|
|
gfxCharacterMap* aUnicodeRanges,
|
|
uint8_t aFontDisplay,
|
|
RangeFlags aRangeFlags);
|
|
|
|
// creates a new gfxUserFontFamily in mFontFamilies, or returns an existing
|
|
// family if there is one
|
|
gfxUserFontFamily* GetFamily(const nsACString& aFamilyName);
|
|
|
|
// font families defined by @font-face rules
|
|
nsRefPtrHashtable<nsCStringHashKey, 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 mozilla::PostTraversalTask;
|
|
friend class gfxUserFontSet;
|
|
friend class nsUserFontSet;
|
|
friend class nsFontFaceLoader;
|
|
friend class gfxOTSContext;
|
|
|
|
public:
|
|
enum UserFontLoadState {
|
|
STATUS_NOT_LOADED = 0,
|
|
STATUS_LOAD_PENDING,
|
|
STATUS_LOADING,
|
|
STATUS_LOADED,
|
|
STATUS_FAILED
|
|
};
|
|
|
|
gfxUserFontEntry(gfxUserFontSet* aFontSet,
|
|
const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
|
|
WeightRange aWeight,
|
|
StretchRange aStretch,
|
|
SlantStyleRange aStyle,
|
|
const nsTArray<gfxFontFeature>& aFeatureSettings,
|
|
const nsTArray<gfxFontVariation>& aVariationSettings,
|
|
uint32_t aLanguageOverride,
|
|
gfxCharacterMap* aUnicodeRanges,
|
|
uint8_t aFontDisplay,
|
|
RangeFlags aRangeFlags);
|
|
|
|
virtual ~gfxUserFontEntry();
|
|
|
|
// Return whether the entry matches the given list of attributes
|
|
bool Matches(const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
|
|
WeightRange aWeight,
|
|
StretchRange aStretch,
|
|
SlantStyleRange aStyle,
|
|
const nsTArray<gfxFontFeature>& aFeatureSettings,
|
|
const nsTArray<gfxFontVariation>& aVariationSettings,
|
|
uint32_t aLanguageOverride,
|
|
gfxCharacterMap* aUnicodeRanges,
|
|
uint8_t aFontDisplay,
|
|
RangeFlags aRangeFlags);
|
|
|
|
gfxFont* CreateFontInstance(const gfxFontStyle* aFontStyle) override;
|
|
|
|
gfxFontEntry* GetPlatformFontEntry() const { return mPlatformFontEntry; }
|
|
|
|
// is the font loading or loaded, or did it fail?
|
|
UserFontLoadState LoadState() const { return mUserFontLoadState; }
|
|
|
|
void LoadCanceled()
|
|
{
|
|
mUserFontLoadState = STATUS_NOT_LOADED;
|
|
mFontDataLoadingState = NOT_LOADING;
|
|
mLoader = nullptr;
|
|
}
|
|
|
|
// whether to wait before using fallback font or not
|
|
bool WaitForUserFont() const {
|
|
return (mUserFontLoadState == STATUS_LOAD_PENDING ||
|
|
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; }
|
|
gfxFontSrcPrincipal* GetPrincipal() { return mPrincipal; }
|
|
uint32_t GetSrcIndex() { return mSrcIndex; }
|
|
void GetFamilyNameAndURIForLogging(nsACString& aFamilyName,
|
|
nsACString& aURI);
|
|
|
|
gfxFontEntry* Clone() const override {
|
|
MOZ_ASSERT_UNREACHABLE("cannot Clone user fonts");
|
|
return nullptr;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
gfxUserFontSet* GetUserFontSet() const { return mFontSet; }
|
|
#endif
|
|
|
|
const nsTArray<gfxFontFaceSrc>& SourceList() const
|
|
{
|
|
return mSrcList;
|
|
}
|
|
|
|
// The variation-query APIs should not be called on placeholders.
|
|
bool HasVariations() override {
|
|
MOZ_ASSERT_UNREACHABLE("not meaningful for a userfont placeholder");
|
|
return false;
|
|
}
|
|
void GetVariationAxes(nsTArray<gfxFontVariationAxis>&) override {
|
|
MOZ_ASSERT_UNREACHABLE("not meaningful for a userfont placeholder");
|
|
}
|
|
void GetVariationInstances(nsTArray<gfxFontVariationInstance>&) override {
|
|
MOZ_ASSERT_UNREACHABLE("not meaningful for a userfont placeholder");
|
|
}
|
|
|
|
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();
|
|
void ContinueLoad();
|
|
void DoLoadNextSrc(bool aForceAsync);
|
|
|
|
// 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 nsACString& 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* MOZ_NON_OWNING_REF mFontSet; // font-set which owns this userfont entry
|
|
RefPtr<gfxFontSrcPrincipal> mPrincipal;
|
|
};
|
|
|
|
|
|
#endif /* GFX_USER_FONT_SET_H */
|