mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1119128. Eliminate gfxPangoFontGroup and gfxFontconfigUtils. r=lsalzman

This commit is contained in:
Jeff Muizelaar 2017-03-22 12:00:02 -04:00
Родитель 49eb5ba0b6
Коммит da3210576b
11 изменённых файлов: 4 добавлений и 3802 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

10
build/valgrind/i386-redhat-linux-gnu.sup
Просмотреть файл

@ -18,16 +18,6 @@
obj:/lib/libdbus-1.so.3.4.0
...
}
{
Bug 793600
Memcheck:Leak
fun:realloc
obj:/usr/lib/libfontconfig.so.1.4.4
...
fun:FcDefaultSubstitute
fun:_ZN17gfxPangoFontGroup11MakeFontSetEP14_PangoLanguagedP9nsAutoRefI10_FcPatternE
...
}
{
Bug 794366
Memcheck:Leak

10
build/valgrind/x86_64-redhat-linux-gnu.sup
Просмотреть файл

@ -18,16 +18,6 @@
obj:/lib64/libdbus-1.so.3.4.0
...
}
{
Bug 793600
Memcheck:Leak
fun:realloc
obj:/usr/lib64/libfontconfig.so.1.4.4
...
fun:FcDefaultSubstitute
fun:_ZN17gfxPangoFontGroup11MakeFontSetEP14_PangoLanguagedP9nsAutoRefI10_FcPatternE
...
}
# Fontconfig is going fancy with its cache structure and that confuses valgrind.
# https://bugs.freedesktop.org/show_bug.cgi?id=8215
# https://bugs.freedesktop.org/show_bug.cgi?id=8428

2262
gfx/thebes/gfxFontconfigFonts.cpp
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

99
gfx/thebes/gfxFontconfigFonts.h
Просмотреть файл

@ -21,103 +21,4 @@ typedef struct _FcPattern FcPattern;
typedef struct FT_FaceRec_* FT_Face;
typedef struct FT_LibraryRec_ *FT_Library;
class gfxPangoFontGroup : public gfxFontGroup {
public:
gfxPangoFontGroup(const mozilla::FontFamilyList& aFontFamilyList,
const gfxFontStyle *aStyle,
gfxUserFontSet *aUserFontSet,
gfxFloat aDevToCssSize);
virtual ~gfxPangoFontGroup();
virtual gfxFontGroup *Copy(const gfxFontStyle *aStyle);
virtual gfxFont* GetFirstValidFont(uint32_t aCh = 0x20);
virtual void UpdateUserFonts();
virtual already_AddRefed<gfxFont>
FindFontForChar(uint32_t aCh, uint32_t aPrevCh, uint32_t aNextCh,
Script aRunScript, gfxFont *aPrevMatchedFont,
uint8_t *aMatchType);
static void Shutdown();
// Used for @font-face { src: local(); }
static gfxFontEntry *NewFontEntry(const nsAString& aFontName,
uint16_t aWeight,
int16_t aStretch,
uint8_t aStyle);
// Used for @font-face { src: url(); }
static gfxFontEntry *NewFontEntry(const nsAString& aFontName,
uint16_t aWeight,
int16_t aStretch,
uint8_t aStyle,
const uint8_t* aFontData,
uint32_t aLength);
static FT_Library GetFTLibrary();
private:
virtual gfxFont *GetFontAt(int32_t i, uint32_t aCh = 0x20);
// @param aLang [in] language to use for pref fonts and system default font
// selection, or nullptr for the language guessed from the
// gfxFontStyle.
// The FontGroup holds a reference to this set.
gfxFcFontSet *GetFontSet(PangoLanguage *aLang = nullptr);
class FontSetByLangEntry {
public:
FontSetByLangEntry(PangoLanguage *aLang, gfxFcFontSet *aFontSet);
PangoLanguage *mLang;
RefPtr<gfxFcFontSet> mFontSet;
};
// There is only one of entry in this array unless characters from scripts
// of other languages are measured.
AutoTArray<FontSetByLangEntry,1> mFontSets;
gfxFloat mSizeAdjustFactor;
PangoLanguage *mPangoLanguage;
// @param aLang [in] language to use for pref fonts and system font
// resolution, or nullptr to guess a language from the gfxFontStyle.
// @param aMatchPattern [out] if non-nullptr, will return the pattern used.
already_AddRefed<gfxFcFontSet>
MakeFontSet(PangoLanguage *aLang, gfxFloat aSizeAdjustFactor,
nsAutoRef<FcPattern> *aMatchPattern = nullptr);
gfxFcFontSet *GetBaseFontSet();
gfxFcFont *GetBaseFont();
gfxFloat GetSizeAdjustFactor()
{
if (mFontSets.Length() == 0)
GetBaseFontSet();
return mSizeAdjustFactor;
}
// old helper methods from gfxFontGroup, moved here so that those methods
// can be revamped without affecting the legacy code here
// iterate over the fontlist, lookup names and expand generics
void EnumerateFontListPFG(nsIAtom *aLanguage, void *aClosure);
// expand a generic to a list of specific names based on prefs
void FindGenericFontsPFG(mozilla::FontFamilyType aGenericType,
nsIAtom *aLanguage,
void *aClosure);
// lookup and add a font with a given name (i.e. *not* a generic!)
void FindPlatformFontPFG(const nsAString& aName,
bool aUseFontSet,
void *aClosure);
static void
ResolveGenericFontNamesPFG(mozilla::FontFamilyType aGenericType,
nsIAtom *aLanguage,
nsTArray<nsString>& aGenericFamilies);
};
#endif /* GFX_FONTCONFIG_FONTS_H */

1100
gfx/thebes/gfxFontconfigUtils.cpp
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

281
gfx/thebes/gfxFontconfigUtils.h
Просмотреть файл

@ -8,11 +8,7 @@
#include "gfxPlatform.h"
#include "mozilla/MathAlgorithms.h"
#include "nsAutoRef.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "nsISupportsImpl.h"
#include "gfxFT2FontBase.h"
#include <fontconfig/fontconfig.h>
@ -40,285 +36,14 @@ public:
static void Release(FcCharSet *ptr) { FcCharSetDestroy(ptr); }
};
class gfxIgnoreCaseCStringComparator
{
public:
bool Equals(const nsACString& a, const nsACString& b) const
{
return nsCString(a).Equals(b, nsCaseInsensitiveCStringComparator());
}
bool LessThan(const nsACString& a, const nsACString& b) const
{
return a < b;
}
};
class gfxFontconfigUtils {
public:
gfxFontconfigUtils();
static gfxFontconfigUtils* GetFontconfigUtils() {
if (!sUtils)
sUtils = new gfxFontconfigUtils();
return sUtils;
}
static void Shutdown();
nsresult GetFontList(nsIAtom *aLangGroup,
const nsACString& aGenericFamily,
nsTArray<nsString>& aListOfFonts);
nsresult UpdateFontList();
nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName);
const nsTArray< nsCountedRef<FcPattern> >&
GetFontsForFamily(const FcChar8 *aFamilyName);
const nsTArray< nsCountedRef<FcPattern> >&
GetFontsForFullname(const FcChar8 *aFullname);
// Returns the best support that any font offers for |aLang|.
FcLangResult GetBestLangSupport(const FcChar8 *aLang);
// Returns the fonts offering this best level of support.
const nsTArray< nsCountedRef<FcPattern> >&
GetFontsForLang(const FcChar8 *aLang);
// Retuns the language support for a fontconfig font pattern
static FcLangResult GetLangSupport(FcPattern *aFont, const FcChar8 *aLang);
// Conversions between FcChar8*, which is unsigned char*,
// and (signed) char*, that check the type of the argument.
static const FcChar8 *ToFcChar8(const char *aCharPtr)
{
return reinterpret_cast<const FcChar8*>(aCharPtr);
}
static const FcChar8 *ToFcChar8(const nsCString& aCString)
{
return ToFcChar8(aCString.get());
}
static const char *ToCString(const FcChar8 *aChar8Ptr)
{
return reinterpret_cast<const char*>(aChar8Ptr);
}
static uint8_t FcSlantToThebesStyle(int aFcSlant);
static uint8_t GetThebesStyle(FcPattern *aPattern); // slant
static uint16_t GetThebesWeight(FcPattern *aPattern);
static int16_t GetThebesStretch(FcPattern *aPattern);
static int GetFcSlant(const gfxFontStyle& aFontStyle);
// Returns a precise FC_WEIGHT from |aBaseWeight|,
// which is a CSS absolute weight / 100.
static int FcWeightForBaseWeight(int8_t aBaseWeight);
static int FcWidthForThebesStretch(int16_t aStretch);
static bool GetFullnameFromFamilyAndStyle(FcPattern *aFont,
nsACString *aFullname);
// This doesn't consider which faces exist, and so initializes the pattern
// using a guessed weight, and doesn't consider sizeAdjust.
static nsReturnRef<FcPattern>
NewPattern(const nsTArray<nsString>& aFamilies,
const gfxFontStyle& aFontStyle, const char *aLang);
/**
* @param aLangGroup [in] a Mozilla langGroup.
* @param aFcLang [out] returns a language suitable for fontconfig
* matching |aLangGroup| or an empty string if no match is found.
*/
static void GetSampleLangForGroup(nsIAtom *aLangGroup,
nsACString *aFcLang);
protected:
// Base class for hash table entries with case-insensitive FcChar8
// string keys.
class FcStrEntryBase : public PLDHashEntryHdr {
public:
typedef const FcChar8 *KeyType;
typedef const FcChar8 *KeyTypePointer;
static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
// Case-insensitive hash.
//
// fontconfig always ignores case of ASCII characters in family
// names and languages, but treatment of whitespace in families is
// not consistent. FcFontSort and FcFontMatch ignore whitespace
// except for whitespace in the first character, while FcFontList
// and config subsitution tests require whitespace to match
// exactly. CSS 2.1 implies that whitespace is important in the
// font-family property. FcStrCmpIgnoreCase considers whitespace
// important.
static PLDHashNumber HashKey(const FcChar8 *aKey) {
uint32_t hash = 0;
for (const FcChar8 *c = aKey; *c != '\0'; ++c) {
hash = mozilla::RotateLeft(hash, 3) ^ FcToLower(*c);
}
return hash;
}
enum { ALLOW_MEMMOVE = true };
};
public:
// Hash entry with a dependent const FcChar8* pointer to an external
// string for a key (and no data). The user must ensure that the string
// associated with the pointer is not destroyed. This entry type is
// useful for family name keys as the family name string is held in the
// font pattern.
class DepFcStrEntry : public FcStrEntryBase {
public:
// When constructing a new entry in the hashtable, the key is left
// nullptr. The caller of PutEntry() must fill in mKey when nullptr.
// This provides a mechanism for the caller of PutEntry() to determine
// whether the entry has been initialized.
explicit DepFcStrEntry(KeyTypePointer aName)
: mKey(nullptr) { }
DepFcStrEntry(const DepFcStrEntry& toCopy)
: mKey(toCopy.mKey) { }
bool KeyEquals(KeyTypePointer aKey) const {
return FcStrCmpIgnoreCase(aKey, mKey) == 0;
}
const FcChar8 *mKey;
};
// Hash entry that uses a copy of an FcChar8 string to store the key.
// This entry type is useful for language keys, as languages are usually
// not stored as strings in font patterns.
class CopiedFcStrEntry : public FcStrEntryBase {
public:
// When constructing a new entry in the hashtable, the key is void.
// The caller of PutEntry() must call InitKey() when IsKeyInitialized()
// returns false. This provides a mechanism for the caller of
// PutEntry() to determine whether the entry has been initialized.
explicit CopiedFcStrEntry(KeyTypePointer aName) {
mKey.SetIsVoid(true);
}
CopiedFcStrEntry(const CopiedFcStrEntry& toCopy)
: mKey(toCopy.mKey) { }
bool KeyEquals(KeyTypePointer aKey) const {
return FcStrCmpIgnoreCase(aKey, ToFcChar8(mKey)) == 0;
}
bool IsKeyInitialized() { return !mKey.IsVoid(); }
void InitKey(const FcChar8* aKey) { mKey.Assign(ToCString(aKey)); }
private:
nsCString mKey;
};
protected:
class FontsByFcStrEntry : public DepFcStrEntry {
public:
explicit FontsByFcStrEntry(KeyTypePointer aName)
: DepFcStrEntry(aName) { }
FontsByFcStrEntry(const FontsByFcStrEntry& toCopy)
: DepFcStrEntry(toCopy), mFonts(toCopy.mFonts) { }
bool AddFont(FcPattern *aFont) {
return mFonts.AppendElement(aFont) != nullptr;
}
const nsTArray< nsCountedRef<FcPattern> >& GetFonts() {
return mFonts;
}
private:
nsTArray< nsCountedRef<FcPattern> > mFonts;
};
// FontsByFullnameEntry is similar to FontsByFcStrEntry (used for
// mFontsByFamily) except for two differences:
//
// * The font does not always contain a single string for the fullname, so
// the key is sometimes a combination of family and style.
//
// * There is usually only one font.
class FontsByFullnameEntry : public DepFcStrEntry {
public:
// When constructing a new entry in the hashtable, the key is left
// nullptr. The caller of PutEntry() is must fill in mKey when adding
// the first font if the key is not derived from the family and style.
// If the key is derived from family and style, a font must be added.
explicit FontsByFullnameEntry(KeyTypePointer aName)
: DepFcStrEntry(aName) { }
FontsByFullnameEntry(const FontsByFullnameEntry& toCopy)
: DepFcStrEntry(toCopy), mFonts(toCopy.mFonts) { }
bool KeyEquals(KeyTypePointer aKey) const;
bool AddFont(FcPattern *aFont) {
return mFonts.AppendElement(aFont) != nullptr;
}
const nsTArray< nsCountedRef<FcPattern> >& GetFonts() {
return mFonts;
}
// Don't memmove the AutoTArray.
enum { ALLOW_MEMMOVE = false };
private:
// There is usually only one font, but sometimes more.
AutoTArray<nsCountedRef<FcPattern>,1> mFonts;
};
class LangSupportEntry : public CopiedFcStrEntry {
public:
explicit LangSupportEntry(KeyTypePointer aName)
: CopiedFcStrEntry(aName) { }
LangSupportEntry(const LangSupportEntry& toCopy)
: CopiedFcStrEntry(toCopy), mSupport(toCopy.mSupport) { }
FcLangResult mSupport;
nsTArray< nsCountedRef<FcPattern> > mFonts;
};
static gfxFontconfigUtils* sUtils;
bool IsExistingFamily(const nsCString& aFamilyName);
nsresult GetFontListInternal(nsTArray<nsCString>& aListOfFonts,
nsIAtom *aLangGroup);
nsresult UpdateFontListInternal(bool aForce = false);
void AddFullnameEntries();
LangSupportEntry *GetLangSupportEntry(const FcChar8 *aLang,
bool aWithFonts);
// mFontsByFamily and mFontsByFullname contain entries only for families
// and fullnames for which there are fonts.
nsTHashtable<FontsByFcStrEntry> mFontsByFamily;
nsTHashtable<FontsByFullnameEntry> mFontsByFullname;
// mLangSupportTable contains an entry for each language that has been
// looked up through GetLangSupportEntry, even when the language is not
// supported.
nsTHashtable<LangSupportEntry> mLangSupportTable;
const nsTArray< nsCountedRef<FcPattern> > mEmptyPatternArray;
FcConfig *mLastConfig;
#ifdef MOZ_BUNDLED_FONTS
void ActivateBundledFonts();
nsCString mBundledFontsPath;
bool mBundledFontsInitialized;
#endif
};
class gfxFontconfigFontBase : public gfxFT2FontBase {
public:
gfxFontconfigFontBase(cairo_scaled_font_t *aScaledFont,
FcPattern *aPattern,
gfxFontEntry *aFontEntry,
const gfxFontStyle *aFontStyle);
const gfxFontStyle *aFontStyle)
: gfxFT2FontBase(aScaledFont, aFontEntry, aFontStyle)
, mPattern(aPattern) { }
virtual FontType GetType() const override { return FONT_TYPE_FONTCONFIG; }
virtual FcPattern *GetPattern() const { return mPattern; }

5
gfx/thebes/gfxTextRun.cpp
Просмотреть файл

@ -1711,7 +1711,6 @@ gfxFontGroup::gfxFontGroup(const FontFamilyList& aFontFamilyList,
, mPageLang(gfxPlatformFontList::GetFontPrefLangFor(aStyle->language))
, mLastPrefFirstFont(false)
, mSkipDrawing(false)
, mSkipUpdateUserFonts(false)
{
// We don't use SetUserFontSet() here, as we want to unconditionally call
// BuildFontList() rather than only do UpdateUserFonts() if it changed.
@ -2440,7 +2439,7 @@ gfxFontGroup::InitScriptRun(DrawTarget* aDrawTarget,
"don't call InitScriptRun with aborted shaping state");
// confirm the load state of userfonts in the list
if (!mSkipUpdateUserFonts && mUserFontSet &&
if (mUserFontSet &&
mCurrGeneration != mUserFontSet->GetGeneration()) {
UpdateUserFonts();
}
@ -3178,8 +3177,6 @@ gfxFontGroup::GetRebuildGeneration()
return mUserFontSet->GetRebuildGeneration();
}
// note: gfxPangoFontGroup overrides UpdateUserFonts, such that
// BuildFontList is never used
void
gfxFontGroup::UpdateUserFonts()
{

3
gfx/thebes/gfxTextRun.h
Просмотреть файл

@ -1115,9 +1115,6 @@ protected:
// download to complete (or fallback
// timer to fire)
// xxx - gfxPangoFontGroup skips UpdateUserFonts
bool mSkipUpdateUserFonts;
/**
* Textrun creation short-cuts for special cases where we don't need to
* call a font shaper to generate glyphs.

26
gfx/thebes/gfxUserFontSet.cpp
Просмотреть файл

@ -978,32 +978,6 @@ gfxUserFontSet::AddUserFontEntry(const nsAString& aFamilyName,
}
}
gfxUserFontEntry*
gfxUserFontSet::FindUserFontEntryAndLoad(gfxFontFamily* aFamily,
const gfxFontStyle& aFontStyle,
bool& aNeedsBold,
bool& aWaitForUserFont)
{
aWaitForUserFont = false;
gfxFontEntry* fe = aFamily->FindFontForStyle(aFontStyle, aNeedsBold);
NS_ASSERTION(!fe || fe->mIsUserFontContainer,
"should only have userfont entries in userfont families");
if (!fe) {
return nullptr;
}
gfxUserFontEntry* userFontEntry = static_cast<gfxUserFontEntry*>(fe);
// start the load if it hasn't been loaded
userFontEntry->Load();
if (userFontEntry->GetPlatformFontEntry()) {
return userFontEntry;
}
aWaitForUserFont = userFontEntry->WaitForUserFont();
return nullptr;
}
void
gfxUserFontSet::IncrementGeneration(bool aIsRebuild)
{

8
gfx/thebes/gfxUserFontSet.h
Просмотреть файл

@ -248,14 +248,6 @@ public:
// 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).

2
gfx/thebes/moz.build
Просмотреть файл

@ -110,8 +110,6 @@ elif 'gtk' in CONFIG['MOZ_WIDGET_TOOLKIT']:
]
SOURCES += [
'gfxFcPlatformFontList.cpp',
'gfxFontconfigFonts.cpp',
'gfxFontconfigUtils.cpp',
'gfxFT2FontBase.cpp',
'gfxFT2Utils.cpp',
'gfxGdkNativeRenderer.cpp',