Merge remote-tracking branch 'origin/tracking' into custom

accessible/base/TextAttrs.cpp

@@ -18,10 +18,6 @@
 #include "mozilla/AppUnits.h"
 #include "mozilla/gfx/2D.h"
 
-#if defined(MOZ_WIDGET_GTK)
-#include "gfxPlatformGtk.h" // xxx - for UseFcFontList
-#endif
-
 using namespace mozilla;
 using namespace mozilla::a11y;
 
@@ -653,28 +649,14 @@ TextAttrsMgr::FontWeightTextAttr::
   if (font->IsSyntheticBold())
     return 700;
 
-  bool useFontEntryWeight = true;
+  // On Windows, font->GetStyle()->weight will give the same weight as
-
+  // fontEntry->Weight(), the weight of the first font in the font group,
-  // Under Linux, when gfxPangoFontGroup code is used,
+  // which may not be the weight of the font face used to render the
-  // font->GetStyle()->weight will give the absolute weight requested of the
+  // characters. On Mac, font->GetStyle()->weight will just give the same
-  // font face. The gfxPangoFontGroup code uses the gfxFontEntry constructor
+  // number as getComputedStyle(). fontEntry->Weight() will give the weight
-  // which doesn't initialize the weight field.
+  // of the font face used.
-#if defined(MOZ_WIDGET_GTK)
+  gfxFontEntry *fontEntry = font->GetFontEntry();
-  useFontEntryWeight = gfxPlatformGtk::UseFcFontList();
+  return fontEntry->Weight();
-#endif
-
-  if (useFontEntryWeight) {
-    // On Windows, font->GetStyle()->weight will give the same weight as
-    // fontEntry->Weight(), the weight of the first font in the font group,
-    // which may not be the weight of the font face used to render the
-    // characters. On Mac, font->GetStyle()->weight will just give the same
-    // number as getComputedStyle(). fontEntry->Weight() will give the weight
-    // of the font face used.
-    gfxFontEntry *fontEntry = font->GetFontEntry();
-    return fontEntry->Weight();
-  } else {
-    return font->GetStyle()->weight;
-  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////

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

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

gfx/2d/2D.h

@@ -718,6 +718,9 @@ public:
     return mUserData.Get(key);
   }
 
+  virtual cairo_scaled_font_t* GetCairoScaledFont() { return nullptr; }
+  virtual void SetCairoScaledFont(cairo_scaled_font_t* font) {}
+
 protected:
   ScaledFont() {}
 

gfx/2d/ScaledFontBase.h

@@ -48,8 +48,8 @@ public:
 
 #ifdef USE_CAIRO_SCALED_FONT
   bool PopulateCairoScaledFont();
-  cairo_scaled_font_t* GetCairoScaledFont() { return mScaledFont; }
+  virtual cairo_scaled_font_t* GetCairoScaledFont() { return mScaledFont; }
-  void SetCairoScaledFont(cairo_scaled_font_t* font);
+  virtual void SetCairoScaledFont(cairo_scaled_font_t* font);
 #endif
 
 protected:

gfx/thebes/gfxDWriteFonts.cpp

@@ -458,7 +458,7 @@ gfxDWriteFont::GetSpaceGlyph()
 bool
 gfxDWriteFont::SetupCairoFont(DrawTarget* aDrawTarget)
 {
-    cairo_scaled_font_t *scaledFont = GetCairoScaledFont();
+    cairo_scaled_font_t *scaledFont = InitCairoScaledFont();
     if (cairo_scaled_font_status(scaledFont) != CAIRO_STATUS_SUCCESS) {
         // Don't cairo_set_scaled_font as that would propagate the error to
         // the cairo_t, precluding any further drawing.
@@ -495,7 +495,7 @@ gfxDWriteFont::CairoFontFace()
 
 
 cairo_scaled_font_t *
-gfxDWriteFont::GetCairoScaledFont()
+gfxDWriteFont::InitCairoScaledFont()
 {
     if (!mScaledFont) {
         cairo_matrix_t sizeMatrix;
@@ -672,38 +672,35 @@ gfxDWriteFont::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
 already_AddRefed<ScaledFont>
 gfxDWriteFont::GetScaledFont(mozilla::gfx::DrawTarget *aTarget)
 {
-  bool wantCairo = aTarget->GetBackendType() == BackendType::CAIRO;
+    if (!mAzureScaledFont) {
-  if (mAzureScaledFont && mAzureScaledFontIsCairo == wantCairo) {
+        gfxDWriteFontEntry *fe =
-    RefPtr<ScaledFont> scaledFont(mAzureScaledFont);
+            static_cast<gfxDWriteFontEntry*>(mFontEntry.get());
-    return scaledFont.forget();
+        bool useEmbeddedBitmap =
-  }
+            fe->IsCJKFont() &&
+            HasBitmapStrikeForSize(NS_lround(mAdjustedSize));
 
-  NativeFont nativeFont;
+        const gfxFontStyle* fontStyle = GetStyle();
-  nativeFont.mType = NativeFontType::DWRITE_FONT_FACE;
+        mAzureScaledFont =
-  nativeFont.mFont = GetFontFace();
-
-  if (wantCairo) {
-    mAzureScaledFont = Factory::CreateScaledFontWithCairo(nativeFont,
-                                                        GetAdjustedSize(),
-                                                        GetCairoScaledFont());
-  } else if (aTarget->GetBackendType() == BackendType::SKIA) {
-    gfxDWriteFontEntry *fe =
-        static_cast<gfxDWriteFontEntry*>(mFontEntry.get());
-    bool useEmbeddedBitmap = (fe->IsCJKFont() && HasBitmapStrikeForSize(NS_lround(mAdjustedSize)));
-
-    const gfxFontStyle* fontStyle = GetStyle();
-    mAzureScaledFont =
             Factory::CreateScaledFontForDWriteFont(mFontFace, fontStyle,
                                                    GetAdjustedSize(),
                                                    useEmbeddedBitmap,
                                                    GetForceGDIClassic());
-  } else {
-    mAzureScaledFont = Factory::CreateScaledFontForNativeFont(nativeFont,
-                                                            GetAdjustedSize());
-  }
 
-  mAzureScaledFontIsCairo = wantCairo;
+        if (!mAzureScaledFont) {
+            return nullptr;
+        }
+    }
 
-  RefPtr<ScaledFont> scaledFont(mAzureScaledFont);
+    if (aTarget->GetBackendType() == BackendType::CAIRO) {
-  return scaledFont.forget();
+        if (!mAzureScaledFont->GetCairoScaledFont()) {
+            cairo_scaled_font_t* cairoScaledFont = InitCairoScaledFont();
+            if (!cairoScaledFont) {
+                return nullptr;
+            }
+            mAzureScaledFont->SetCairoScaledFont(cairoScaledFont);
+        }
+    }
+
+    RefPtr<ScaledFont> scaledFont(mAzureScaledFont);
+    return scaledFont.forget();
 }

gfx/thebes/gfxDWriteFonts.h

@@ -69,9 +69,9 @@ public:
     virtual already_AddRefed<mozilla::gfx::ScaledFont>
     GetScaledFont(mozilla::gfx::DrawTarget *aTarget) override;
 
-    virtual cairo_scaled_font_t *GetCairoScaledFont() override;
-
 protected:
+    cairo_scaled_font_t *InitCairoScaledFont();
+
     virtual const Metrics& GetHorizontalMetrics() override;
 
     bool GetFakeMetricsForArialBlack(DWRITE_FONT_METRICS *aFontMetrics);
@@ -101,7 +101,6 @@ protected:
     bool mNeedsBold;
     bool mUseSubpixelPositions;
     bool mAllowManualShowGlyphs;
-    bool mAzureScaledFontIsCairo;
 };
 
 #endif

gfx/thebes/gfxFT2FontBase.cpp

@@ -37,7 +37,7 @@ gfxFT2FontBase::GetGlyph(uint32_t aCharCode)
     // lightweight cache, which is stored on the cairo_font_face_t.
 
     cairo_font_face_t *face =
-        cairo_scaled_font_get_font_face(CairoScaledFont());
+        cairo_scaled_font_get_font_face(GetCairoScaledFont());
 
     if (cairo_font_face_status(face) != CAIRO_STATUS_SUCCESS)
         return 0;
@@ -105,7 +105,7 @@ gfxFT2FontBase::GetGlyphExtents(uint32_t aGlyph, cairo_text_extents_t* aExtents)
     // so caching only the advance could allow many requests to be cached with
     // little memory use.  Ideally this cache would be merged with
     // gfxGlyphExtents.
-    cairo_scaled_font_glyph_extents(CairoScaledFont(), glyphs, 1, aExtents);
+    cairo_scaled_font_glyph_extents(GetCairoScaledFont(), glyphs, 1, aExtents);
 }
 
 const gfxFont::Metrics&
@@ -186,7 +186,7 @@ gfxFT2FontBase::SetupCairoFont(DrawTarget* aDrawTarget)
     // for the target can be different from the scaled_font passed to
     // cairo_set_scaled_font.  (Unfortunately we have measured only for an
     // identity ctm.)
-    cairo_scaled_font_t *cairoFont = CairoScaledFont();
+    cairo_scaled_font_t *cairoFont = GetCairoScaledFont();
 
     if (cairo_scaled_font_status(cairoFont) != CAIRO_STATUS_SUCCESS) {
         // Don't cairo_set_scaled_font as that would propagate the error to

gfx/thebes/gfxFT2FontBase.h

@@ -29,7 +29,6 @@ public:
     virtual int32_t GetGlyphWidth(DrawTarget& aDrawTarget,
                                   uint16_t aGID) override;
 
-    cairo_scaled_font_t *CairoScaledFont() { return mScaledFont; };
     virtual bool SetupCairoFont(DrawTarget* aDrawTarget) override;
 
     virtual FontType GetType() const override { return FONT_TYPE_FT2; }

gfx/thebes/gfxFT2Fonts.cpp

@@ -34,6 +34,9 @@
 #include "mozilla/Preferences.h"
 #include "mozilla/gfx/2D.h"
 
+using namespace mozilla;
+using namespace mozilla::gfx;
+
 /**
  * gfxFT2Font
  */
@@ -174,6 +177,21 @@ gfxFT2Font::~gfxFT2Font()
 {
 }
 
+already_AddRefed<ScaledFont>
+gfxFT2Font::GetScaledFont(DrawTarget *aTarget)
+{
+    if (!mAzureScaledFont) {
+        NativeFont nativeFont;
+        nativeFont.mType = NativeFontType::CAIRO_FONT_FACE;
+        nativeFont.mFont = GetCairoScaledFont();
+        mAzureScaledFont =
+            Factory::CreateScaledFontForNativeFont(nativeFont, GetAdjustedSize());
+    }
+
+    RefPtr<ScaledFont> scaledFont(mAzureScaledFont);
+    return scaledFont.forget();
+}
+
 void
 gfxFT2Font::FillGlyphDataForChar(uint32_t ch, CachedGlyphData *gd)
 {
@@ -212,7 +230,7 @@ gfxFT2Font::FillGlyphDataForChar(uint32_t ch, CachedGlyphData *gd)
 }
 
 void
-gfxFT2Font::AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+gfxFT2Font::AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
                                    FontCacheSizes* aSizes) const
 {
     gfxFont::AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
@@ -221,7 +239,7 @@ gfxFT2Font::AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
 }
 
 void
-gfxFT2Font::AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+gfxFT2Font::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
                                    FontCacheSizes* aSizes) const
 {
     aSizes->mFontInstances += aMallocSizeOf(this);

gfx/thebes/gfxFT2Fonts.h

@@ -27,6 +27,9 @@ public: // new functions
 
     FT2FontEntry *GetFontEntry();
 
+    virtual already_AddRefed<mozilla::gfx::ScaledFont>
+    GetScaledFont(DrawTarget *aTarget) override;
+
     struct CachedGlyphData {
         CachedGlyphData()
             : glyphIndex(0xffffffffU) { }

gfx/thebes/gfxFT2Utils.h

@@ -24,12 +24,12 @@ class gfxFT2LockedFace {
 public:
     explicit gfxFT2LockedFace(gfxFT2FontBase *aFont) :
         mGfxFont(aFont),
-        mFace(cairo_ft_scaled_font_lock_face(aFont->CairoScaledFont()))
+        mFace(cairo_ft_scaled_font_lock_face(aFont->GetCairoScaledFont()))
     { }
     ~gfxFT2LockedFace()
     {
         if (mFace) {
-            cairo_ft_scaled_font_unlock_face(mGfxFont->CairoScaledFont());
+            cairo_ft_scaled_font_unlock_face(mGfxFont->GetCairoScaledFont());
         }
     }
 

gfx/thebes/gfxFcPlatformFontList.cpp

@@ -38,6 +38,7 @@
 #endif
 
 using namespace mozilla;
+using namespace mozilla::gfx;
 using namespace mozilla::unicode;
 
 #ifndef FC_POSTSCRIPT_NAME
@@ -55,6 +56,20 @@ using namespace mozilla::unicode;
                                    gfxPlatform::GetLog(eGfxLog_cmapdata), \
                                    LogLevel::Debug)
 
+template <>
+class nsAutoRefTraits<FcFontSet> : public nsPointerRefTraits<FcFontSet>
+{
+public:
+    static void Release(FcFontSet *ptr) { FcFontSetDestroy(ptr); }
+};
+
+template <>
+class nsAutoRefTraits<FcObjectSet> : public nsPointerRefTraits<FcObjectSet>
+{
+public:
+    static void Release(FcObjectSet *ptr) { FcObjectSetDestroy(ptr); }
+};
+
 static const FcChar8*
 ToFcChar8Ptr(const char* aStr)
 {
@@ -1078,8 +1093,9 @@ gfxFontconfigFont::gfxFontconfigFont(cairo_scaled_font_t *aScaledFont,
                                      gfxFloat aAdjustedSize,
                                      gfxFontEntry *aFontEntry,
                                      const gfxFontStyle *aFontStyle,
-                                     bool aNeedsBold) :
+                                     bool aNeedsBold)
-    gfxFontconfigFontBase(aScaledFont, aPattern, aFontEntry, aFontStyle)
+    : gfxFT2FontBase(aScaledFont, aFontEntry, aFontStyle)
+    , mPattern(aPattern)
 {
     mAdjustedSize = aAdjustedSize;
 }
@@ -1088,6 +1104,20 @@ gfxFontconfigFont::~gfxFontconfigFont()
 {
 }
 
+already_AddRefed<ScaledFont>
+gfxFontconfigFont::GetScaledFont(DrawTarget *aTarget)
+{
+    if (!mAzureScaledFont) {
+        mAzureScaledFont =
+            Factory::CreateScaledFontForFontconfigFont(GetCairoScaledFont(),
+                                                       GetPattern(),
+                                                       GetAdjustedSize());
+    }
+
+    RefPtr<ScaledFont> scaledFont(mAzureScaledFont);
+    return scaledFont.forget();
+}
+
 gfxFcPlatformFontList::gfxFcPlatformFontList()
     : mLocalNames(64)
     , mGenericMappings(32)

gfx/thebes/gfxFcPlatformFontList.h

@@ -11,6 +11,7 @@
 #include "gfxFT2FontBase.h"
 #include "gfxPlatformFontList.h"
 #include "mozilla/mozalloc.h"
+#include "nsAutoRef.h"
 #include "nsClassHashtable.h"
 
 #include <fontconfig/fontconfig.h>
@@ -20,13 +21,12 @@
 #include <cairo.h>
 #include <cairo-ft.h>
 
-#include "gfxFontconfigUtils.h" // xxx - only for nsAutoRefTraits<FcPattern>, etc.
-
 template <>
-class nsAutoRefTraits<FcObjectSet> : public nsPointerRefTraits<FcObjectSet>
+class nsAutoRefTraits<FcPattern> : public nsPointerRefTraits<FcPattern>
 {
 public:
-    static void Release(FcObjectSet *ptr) { FcObjectSetDestroy(ptr); }
+    static void Release(FcPattern *ptr) { FcPatternDestroy(ptr); }
+    static void AddRef(FcPattern *ptr) { FcPatternReference(ptr); }
 };
 
 template <>
@@ -205,7 +205,7 @@ protected:
     bool      mForceScalable;
 };
 
-class gfxFontconfigFont : public gfxFontconfigFontBase {
+class gfxFontconfigFont : public gfxFT2FontBase {
 public:
     gfxFontconfigFont(cairo_scaled_font_t *aScaledFont,
                       FcPattern *aPattern,
@@ -214,8 +214,16 @@ public:
                       const gfxFontStyle *aFontStyle,
                       bool aNeedsBold);
 
-protected:
+    virtual FontType GetType() const override { return FONT_TYPE_FONTCONFIG; }
+    virtual FcPattern *GetPattern() const { return mPattern; }
+
+    virtual already_AddRefed<mozilla::gfx::ScaledFont>
+    GetScaledFont(DrawTarget *aTarget) override;
+
+private:
     virtual ~gfxFontconfigFont();
+
+    nsCountedRef<FcPattern> mPattern;
 };
 
 class nsILanguageAtomService;

gfx/thebes/gfxFont.h

@@ -1452,7 +1452,7 @@ public:
     const nsString& GetName() const { return mFontEntry->Name(); }
     const gfxFontStyle *GetStyle() const { return &mStyle; }
 
-    virtual cairo_scaled_font_t* GetCairoScaledFont() { return mScaledFont; }
+    cairo_scaled_font_t* GetCairoScaledFont() { return mScaledFont; }
 
     virtual gfxFont* CopyWithAntialiasOption(AntialiasOption anAAOption) {
         // platforms where this actually matters should override
@@ -1826,8 +1826,7 @@ public:
 
     virtual FontType GetType() const = 0;
 
-    virtual already_AddRefed<mozilla::gfx::ScaledFont> GetScaledFont(DrawTarget* aTarget)
+    virtual already_AddRefed<mozilla::gfx::ScaledFont> GetScaledFont(DrawTarget* aTarget) = 0;
-    { return gfxPlatform::GetPlatform()->GetScaledFontForFont(aTarget, this); }
 
     bool KerningDisabled() {
         return mKerningSet && !mKerningEnabled;

gfx/thebes/gfxFontconfigFonts.h

@@ -1,124 +0,0 @@
-/* -*- 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_FONTCONFIG_FONTS_H
-#define GFX_FONTCONFIG_FONTS_H
-
-#include "cairo.h"
-#include "gfxTypes.h"
-#include "gfxTextRun.h"
-
-#include "nsAutoRef.h"
-#include "nsTArray.h"
-
-#include <pango/pango.h>
-
-class gfxFcFontSet;
-class gfxFcFont;
-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);
-
-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);
-
-
-    friend class gfxSystemFcFontEntry;
-    static FT_Library GetFTLibrary();
-};
-
-#endif /* GFX_FONTCONFIG_FONTS_H */

gfx/thebes/gfxFontconfigUtils.h

@@ -1,330 +0,0 @@
-/* -*- 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_FONTCONFIG_UTILS_H
-#define GFX_FONTCONFIG_UTILS_H
-
-#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>
-
-
-template <>
-class nsAutoRefTraits<FcPattern> : public nsPointerRefTraits<FcPattern>
-{
-public:
-    static void Release(FcPattern *ptr) { FcPatternDestroy(ptr); }
-    static void AddRef(FcPattern *ptr) { FcPatternReference(ptr); }
-};
-
-template <>
-class nsAutoRefTraits<FcFontSet> : public nsPointerRefTraits<FcFontSet>
-{
-public:
-    static void Release(FcFontSet *ptr) { FcFontSetDestroy(ptr); }
-};
-
-template <>
-class nsAutoRefTraits<FcCharSet> : public nsPointerRefTraits<FcCharSet>
-{
-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);
-
-    virtual FontType GetType() const override { return FONT_TYPE_FONTCONFIG; }
-    virtual FcPattern *GetPattern() const { return mPattern; }
-
-private:
-    nsCountedRef<FcPattern> mPattern;
-};
-
-#endif /* GFX_FONTCONFIG_UTILS_H */

gfx/thebes/gfxGDIFont.cpp

@@ -22,6 +22,7 @@
 #define ROUND(x) floor((x) + 0.5)
 
 using namespace mozilla;
+using namespace mozilla::gfx;
 using namespace mozilla::unicode;
 
 static inline cairo_antialias_t
@@ -130,6 +131,26 @@ gfxGDIFont::SetupCairoFont(DrawTarget* aDrawTarget)
     return true;
 }
 
+already_AddRefed<ScaledFont>
+gfxGDIFont::GetScaledFont(DrawTarget *aTarget)
+{
+    if (!mAzureScaledFont) {
+        NativeFont nativeFont;
+        nativeFont.mType = NativeFontType::GDI_FONT_FACE;
+        LOGFONT lf;
+        GetObject(GetHFONT(), sizeof(LOGFONT), &lf);
+        nativeFont.mFont = &lf;
+
+        mAzureScaledFont =
+          Factory::CreateScaledFontWithCairo(nativeFont,
+                                             GetAdjustedSize(),
+                                             GetCairoScaledFont());
+    }
+
+    RefPtr<ScaledFont> scaledFont(mAzureScaledFont);
+    return scaledFont.forget();
+}
+
 gfxFont::RunMetrics
 gfxGDIFont::Measure(const gfxTextRun *aTextRun,
                     uint32_t aStart, uint32_t aEnd,

gfx/thebes/gfxGDIFont.h

@@ -28,14 +28,16 @@ public:
 
     HFONT GetHFONT() { return mFont; }
 
-    cairo_font_face_t   *CairoFontFace() { return mFontFace; }
+    cairo_font_face_t* CairoFontFace() { return mFontFace; }
-    cairo_scaled_font_t *CairoScaledFont() { return mScaledFont; }
 
     /* overrides for the pure virtual methods in gfxFont */
     virtual uint32_t GetSpaceGlyph() override;
 
     virtual bool SetupCairoFont(DrawTarget* aDrawTarget) override;
 
+    virtual already_AddRefed<mozilla::gfx::ScaledFont>
+    GetScaledFont(DrawTarget *aTarget) override;
+
     /* override Measure to add padding for antialiasing */
     virtual RunMetrics Measure(const gfxTextRun *aTextRun,
                                uint32_t aStart, uint32_t aEnd,

gfx/thebes/gfxPlatform.cpp

@@ -83,10 +83,6 @@
 #include "GLContextProvider.h"
 #include "mozilla/gfx/Logging.h"
 
-#if defined(MOZ_WIDGET_GTK)
-#include "gfxPlatformGtk.h" // xxx - for UseFcFontList
-#endif
-
 #ifdef USE_SKIA
 # ifdef __GNUC__
 #  pragma GCC diagnostic push
@@ -621,16 +617,9 @@ gfxPlatform::Init()
 
     nsresult rv;
 
-    bool usePlatformFontList = true;
+    rv = gfxPlatformFontList::Init();
-#if defined(MOZ_WIDGET_GTK)
+    if (NS_FAILED(rv)) {
-    usePlatformFontList = gfxPlatformGtk::UseFcFontList();
+        NS_RUNTIMEABORT("Could not initialize gfxPlatformFontList");
-#endif
-
-    if (usePlatformFontList) {
-        rv = gfxPlatformFontList::Init();
-        if (NS_FAILED(rv)) {
-            NS_RUNTIMEABORT("Could not initialize gfxPlatformFontList");
-        }
     }
 
     gPlatform->mScreenReferenceSurface =
@@ -1069,16 +1058,6 @@ gfxPlatform::GetWrappedDataSourceSurface(gfxASurface* aSurface)
   return result.forget();
 }
 
-already_AddRefed<ScaledFont>
-gfxPlatform::GetScaledFontForFont(DrawTarget* aTarget, gfxFont *aFont)
-{
-  NativeFont nativeFont;
-  nativeFont.mType = NativeFontType::CAIRO_FONT_FACE;
-  nativeFont.mFont = aFont->GetCairoScaledFont();
-  return Factory::CreateScaledFontForNativeFont(nativeFont,
-                                                aFont->GetAdjustedSize());
-}
-
 void
 gfxPlatform::ComputeTileSize()
 {
@@ -2183,19 +2162,6 @@ gfxPlatform::DisableBufferRotation()
   sBufferRotationCheckPref = false;
 }
 
-already_AddRefed<ScaledFont>
-gfxPlatform::GetScaledFontForFontWithCairoSkia(DrawTarget* aTarget, gfxFont* aFont)
-{
-    NativeFont nativeFont;
-    if (aTarget->GetBackendType() == BackendType::CAIRO || aTarget->GetBackendType() == BackendType::SKIA) {
-        nativeFont.mType = NativeFontType::CAIRO_FONT_FACE;
-        nativeFont.mFont = aFont->GetCairoScaledFont();
-        return Factory::CreateScaledFontForNativeFont(nativeFont, aFont->GetAdjustedSize());
-    }
-
-    return nullptr;
-}
-
 /* static */ bool
 gfxPlatform::UsesOffMainThreadCompositing()
 {

gfx/thebes/gfxPlatform.h

@@ -223,9 +223,6 @@ public:
     static already_AddRefed<DataSourceSurface>
         GetWrappedDataSourceSurface(gfxASurface *aSurface);
 
-    virtual already_AddRefed<mozilla::gfx::ScaledFont>
-      GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont);
-
     already_AddRefed<DrawTarget>
       CreateOffscreenContentDrawTarget(const mozilla::gfx::IntSize& aSize, mozilla::gfx::SurfaceFormat aFormat);
 
@@ -747,9 +744,6 @@ protected:
      */
     static mozilla::gfx::BackendType BackendTypeForName(const nsCString& aName);
 
-    static already_AddRefed<mozilla::gfx::ScaledFont>
-      GetScaledFontForFontWithCairoSkia(mozilla::gfx::DrawTarget* aTarget, gfxFont* aFont);
-
     virtual bool CanUseHardwareVideoDecoding();
 
     int8_t  mAllowDownloadableFonts;

gfx/thebes/gfxPlatformGtk.cpp

@@ -13,14 +13,13 @@
 #include "nsUnicodeProperties.h"
 #include "gfx2DGlue.h"
 #include "gfxFcPlatformFontList.h"
-#include "gfxFontconfigUtils.h"
-#include "gfxFontconfigFonts.h"
 #include "gfxConfig.h"
 #include "gfxContext.h"
 #include "gfxUserFontSet.h"
 #include "gfxUtils.h"
 #include "gfxFT2FontBase.h"
 #include "gfxPrefs.h"
+#include "gfxTextRun.h"
 #include "VsyncSource.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/Monitor.h"
@@ -67,23 +66,14 @@ using namespace mozilla;
 using namespace mozilla::gfx;
 using namespace mozilla::unicode;
 
-gfxFontconfigUtils *gfxPlatformGtk::sFontconfigUtils = nullptr;
-
 #if (MOZ_WIDGET_GTK == 2)
 static cairo_user_data_key_t cairo_gdk_drawable_key;
 #endif
 
-bool gfxPlatformGtk::sUseFcFontList = false;
-
 gfxPlatformGtk::gfxPlatformGtk()
 {
     gtk_init(nullptr, nullptr);
 
-    sUseFcFontList = mozilla::Preferences::GetBool("gfx.font_rendering.fontconfig.fontlist.enabled");
-    if (!sUseFcFontList && !sFontconfigUtils) {
-        sFontconfigUtils = gfxFontconfigUtils::GetFontconfigUtils();
-    }
-
     mMaxGenericSubstitutions = UNINITIALIZED_VALUE;
 
 #ifdef MOZ_X11
@@ -117,12 +107,6 @@ gfxPlatformGtk::gfxPlatformGtk()
 
 gfxPlatformGtk::~gfxPlatformGtk()
 {
-    if (!sUseFcFontList) {
-        gfxFontconfigUtils::Shutdown();
-        sFontconfigUtils = nullptr;
-        gfxPangoFontGroup::Shutdown();
-    }
-
 #ifdef MOZ_X11
     if (mCompositorDisplay) {
       XCloseDisplay(mCompositorDisplay);
@@ -197,27 +181,17 @@ gfxPlatformGtk::GetFontList(nsIAtom *aLangGroup,
                             const nsACString& aGenericFamily,
                             nsTArray<nsString>& aListOfFonts)
 {
-    if (sUseFcFontList) {
+    gfxPlatformFontList::PlatformFontList()->GetFontList(aLangGroup,
-        gfxPlatformFontList::PlatformFontList()->GetFontList(aLangGroup,
+                                                         aGenericFamily,
-                                                             aGenericFamily,
+                                                         aListOfFonts);
-                                                             aListOfFonts);
+    return NS_OK;
-        return NS_OK;
-    }
-
-    return sFontconfigUtils->GetFontList(aLangGroup,
-                                         aGenericFamily,
-                                         aListOfFonts);
 }
 
 nsresult
 gfxPlatformGtk::UpdateFontList()
 {
-    if (sUseFcFontList) {
+    gfxPlatformFontList::PlatformFontList()->UpdateFontList();
-        gfxPlatformFontList::PlatformFontList()->UpdateFontList();
+    return NS_OK;
-        return NS_OK;
-    }
-
-    return sFontconfigUtils->UpdateFontList();
 }
 
 // xxx - this is ubuntu centric, need to go through other distros and flesh
@@ -280,13 +254,9 @@ gfxPlatformGtk::CreatePlatformFontList()
 nsresult
 gfxPlatformGtk::GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName)
 {
-    if (sUseFcFontList) {
+    gfxPlatformFontList::PlatformFontList()->
-        gfxPlatformFontList::PlatformFontList()->
+        GetStandardFamilyName(aFontName, aFamilyName);
-            GetStandardFamilyName(aFontName, aFamilyName);
+    return NS_OK;
-        return NS_OK;
-    }
-
-    return sFontconfigUtils->GetStandardFamilyName(aFontName, aFamilyName);
 }
 
 gfxFontGroup *
@@ -296,13 +266,8 @@ gfxPlatformGtk::CreateFontGroup(const FontFamilyList& aFontFamilyList,
                                 gfxUserFontSet* aUserFontSet,
                                 gfxFloat aDevToCssSize)
 {
-    if (sUseFcFontList) {
+    return new gfxFontGroup(aFontFamilyList, aStyle, aTextPerf,
-        return new gfxFontGroup(aFontFamilyList, aStyle, aTextPerf,
+                            aUserFontSet, aDevToCssSize);
-                                aUserFontSet, aDevToCssSize);
-    }
-
-    return new gfxPangoFontGroup(aFontFamilyList, aStyle,
-                                 aUserFontSet, aDevToCssSize);
 }
 
 gfxFontEntry*
@@ -311,14 +276,9 @@ gfxPlatformGtk::LookupLocalFont(const nsAString& aFontName,
                                 int16_t aStretch,
                                 uint8_t aStyle)
 {
-    if (sUseFcFontList) {
+    gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
-        gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+    return pfl->LookupLocalFont(aFontName, aWeight, aStretch,
-        return pfl->LookupLocalFont(aFontName, aWeight, aStretch,
+                                aStyle);
-                                    aStyle);
-    }
-
-    return gfxPangoFontGroup::NewFontEntry(aFontName, aWeight,
-                                           aStretch, aStyle);
 }
 
 gfxFontEntry*
@@ -329,16 +289,9 @@ gfxPlatformGtk::MakePlatformFont(const nsAString& aFontName,
                                  const uint8_t* aFontData,
                                  uint32_t aLength)
 {
-    if (sUseFcFontList) {
+    gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
-        gfxPlatformFontList* pfl = gfxPlatformFontList::PlatformFontList();
+    return pfl->MakePlatformFont(aFontName, aWeight, aStretch,
-        return pfl->MakePlatformFont(aFontName, aWeight, aStretch,
+                                 aStyle, aFontData, aLength);
-                                     aStyle, aFontData, aLength);
-    }
-
-    // passing ownership of the font data to the new font entry
-    return gfxPangoFontGroup::NewFontEntry(aFontName, aWeight,
-                                           aStretch, aStyle,
-                                           aFontData, aLength);
 }
 
 bool
@@ -429,11 +382,9 @@ void gfxPlatformGtk::FontsPrefsChanged(const char *aPref)
     }
 
     mMaxGenericSubstitutions = UNINITIALIZED_VALUE;
-    if (sUseFcFontList) {
+    gfxFcPlatformFontList* pfl = gfxFcPlatformFontList::PlatformFontList();
-        gfxFcPlatformFontList* pfl = gfxFcPlatformFontList::PlatformFontList();
+    pfl->ClearGenericMappings();
-        pfl->ClearGenericMappings();
+    FlushFontAndWordCaches();
-        FlushFontAndWordCaches();
-    }
 }
 
 uint32_t gfxPlatformGtk::MaxGenericSubstitions()
@@ -624,25 +575,6 @@ gfxPlatformGtk::GetGdkDrawable(cairo_surface_t *target)
 }
 #endif
 
-already_AddRefed<ScaledFont>
-gfxPlatformGtk::GetScaledFontForFont(DrawTarget* aTarget, gfxFont *aFont)
-{
-    switch (aTarget->GetBackendType()) {
-    case BackendType::CAIRO:
-    case BackendType::SKIA:
-        if (aFont->GetType() == gfxFont::FONT_TYPE_FONTCONFIG) {
-            gfxFontconfigFontBase* fcFont = static_cast<gfxFontconfigFontBase*>(aFont);
-            return Factory::CreateScaledFontForFontconfigFont(
-                    fcFont->GetCairoScaledFont(),
-                    fcFont->GetPattern(),
-                    fcFont->GetAdjustedSize());
-        }
-        MOZ_FALLTHROUGH;
-    default:
-        return GetScaledFontForFontWithCairoSkia(aTarget, aFont);
-    }
-}
-
 #ifdef GL_PROVIDER_GLX
 
 class GLXVsyncSource final : public VsyncSource

gfx/thebes/gfxPlatformGtk.h

@@ -22,8 +22,6 @@ struct _XDisplay;
 typedef struct _XDisplay Display;
 #endif // MOZ_X11
 
-class gfxFontconfigUtils;
-
 class gfxPlatformGtk : public gfxPlatform {
 public:
     gfxPlatformGtk();
@@ -37,9 +35,6 @@ public:
       CreateOffscreenSurface(const IntSize& aSize,
                              gfxImageFormat aFormat) override;
 
-    virtual already_AddRefed<mozilla::gfx::ScaledFont>
-      GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont) override;
-
     virtual nsresult GetFontList(nsIAtom *aLangGroup,
                                  const nsACString& aGenericFamily,
                                  nsTArray<nsString>& aListOfFonts) override;
@@ -111,8 +106,6 @@ public:
     }
 #endif
 
-    static bool UseFcFontList() { return sUseFcFontList; }
-
     bool UseImageOffscreenSurfaces();
 
     virtual gfxImageFormat GetOffscreenFormat() override;
@@ -143,8 +136,6 @@ public:
 #endif // MOZ_X11
 
 protected:
-    static gfxFontconfigUtils *sFontconfigUtils;
-
     int8_t mMaxGenericSubstitutions;
 
 private:
@@ -154,10 +145,6 @@ private:
 #ifdef MOZ_X11
     Display* mCompositorDisplay;
 #endif
-
-    // xxx - this will be removed once the new fontconfig platform font list
-    // replaces gfxPangoFontGroup
-    static bool sUseFcFontList;
 };
 
 #endif /* GFX_PLATFORM_GTK_H */

gfx/thebes/gfxPlatformMac.cpp

@@ -125,13 +125,6 @@ gfxPlatformMac::CreateOffscreenSurface(const IntSize& aSize,
     return newSurface.forget();
 }
 
-already_AddRefed<ScaledFont>
-gfxPlatformMac::GetScaledFontForFont(DrawTarget* aTarget, gfxFont *aFont)
-{
-    gfxMacFont *font = static_cast<gfxMacFont*>(aFont);
-    return font->GetScaledFont(aTarget);
-}
-
 gfxFontGroup *
 gfxPlatformMac::CreateFontGroup(const FontFamilyList& aFontFamilyList,
                                 const gfxFontStyle *aStyle,

gfx/thebes/gfxPlatformMac.h

@@ -30,9 +30,6 @@ public:
       CreateOffscreenSurface(const IntSize& aSize,
                              gfxImageFormat aFormat) override;
 
-    already_AddRefed<mozilla::gfx::ScaledFont>
-      GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont) override;
-
     gfxFontGroup*
     CreateFontGroup(const mozilla::FontFamilyList& aFontFamilyList,
                     const gfxFontStyle *aStyle,

gfx/thebes/gfxTextRun.cpp

@@ -26,10 +26,6 @@
 #include "mozilla/gfx/Logging.h"        // for gfxCriticalError
 #include "mozilla/UniquePtr.h"
 
-#if defined(MOZ_WIDGET_GTK)
-#include "gfxPlatformGtk.h" // xxx - for UseFcFontList
-#endif
-
 #ifdef XP_WIN
 #include "gfxWindowsPlatform.h"
 #endif
@@ -1599,7 +1595,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.
@@ -1616,14 +1611,6 @@ gfxFontGroup::BuildFontList()
 {
     bool enumerateFonts = true;
 
-#if defined(MOZ_WIDGET_GTK)
-    // xxx - eliminate this once gfxPangoFontGroup is no longer needed
-    enumerateFonts = gfxPlatformGtk::UseFcFontList();
-#endif
-    if (!enumerateFonts) {
-        return;
-    }
-
     // initialize fonts in the font family list
     AutoTArray<gfxFontFamily*,10> fonts;
     gfxPlatformFontList *pfl = gfxPlatformFontList::PlatformFontList();
@@ -2338,7 +2325,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();
     }
@@ -3076,8 +3063,6 @@ gfxFontGroup::GetRebuildGeneration()
     return mUserFontSet->GetRebuildGeneration();
 }
 
-// note: gfxPangoFontGroup overrides UpdateUserFonts, such that
-//       BuildFontList is never used
 void
 gfxFontGroup::UpdateUserFonts()
 {

gfx/thebes/gfxTextRun.h

@@ -1108,9 +1108,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.

gfx/thebes/gfxUserFontSet.cpp

@@ -926,32 +926,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)
 {

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).

gfx/thebes/gfxWindowsPlatform.cpp

@@ -593,44 +593,6 @@ gfxWindowsPlatform::CreateOffscreenSurface(const IntSize& aSize,
     return surf.forget();
 }
 
-already_AddRefed<ScaledFont>
-gfxWindowsPlatform::GetScaledFontForFont(DrawTarget* aTarget, gfxFont *aFont)
-{
-    if (aFont->GetType() == gfxFont::FONT_TYPE_DWRITE) {
-        gfxDWriteFont *font = static_cast<gfxDWriteFont*>(aFont);
-
-        NativeFont nativeFont;
-        nativeFont.mType = NativeFontType::DWRITE_FONT_FACE;
-        nativeFont.mFont = font->GetFontFace();
-
-        if (aTarget->GetBackendType() == BackendType::CAIRO) {
-          return Factory::CreateScaledFontWithCairo(nativeFont,
-                                                    font->GetAdjustedSize(),
-                                                    font->GetCairoScaledFont());
-        }
-
-        return Factory::CreateScaledFontForNativeFont(nativeFont,
-                                                      font->GetAdjustedSize());
-    }
-
-    NS_ASSERTION(aFont->GetType() == gfxFont::FONT_TYPE_GDI,
-        "Fonts on windows should be GDI or DWrite!");
-
-    NativeFont nativeFont;
-    nativeFont.mType = NativeFontType::GDI_FONT_FACE;
-    LOGFONT lf;
-    GetObject(static_cast<gfxGDIFont*>(aFont)->GetHFONT(), sizeof(LOGFONT), &lf);
-    nativeFont.mFont = &lf;
-
-    if (aTarget->GetBackendType() == BackendType::CAIRO) {
-      return Factory::CreateScaledFontWithCairo(nativeFont,
-                                                aFont->GetAdjustedSize(),
-                                                aFont->GetCairoScaledFont());
-    }
-
-    return Factory::CreateScaledFontForNativeFont(nativeFont, aFont->GetAdjustedSize());
-}
-
 static const char kFontAparajita[] = "Aparajita";
 static const char kFontArabicTypesetting[] = "Arabic Typesetting";
 static const char kFontArial[] = "Arial";

gfx/thebes/gfxWindowsPlatform.h

@@ -121,9 +121,6 @@ public:
       CreateOffscreenSurface(const IntSize& aSize,
                              gfxImageFormat aFormat) override;
 
-    virtual already_AddRefed<mozilla::gfx::ScaledFont>
-      GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont) override;
-
     enum RenderMode {
         /* Use GDI and windows surfaces */
         RENDER_GDI = 0,

gfx/thebes/moz.build

@@ -76,7 +76,6 @@ if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
     ]
 elif 'gtk' in CONFIG['MOZ_WIDGET_TOOLKIT']:
     EXPORTS += [
-        'gfxFontconfigFonts.h',
         'gfxFT2FontBase.h',
         'gfxGdkNativeRenderer.h',
         'gfxPlatformGtk.h',
@@ -87,8 +86,6 @@ elif 'gtk' in CONFIG['MOZ_WIDGET_TOOLKIT']:
     ]
     SOURCES += [
         'gfxFcPlatformFontList.cpp',
-        'gfxFontconfigFonts.cpp',
-        'gfxFontconfigUtils.cpp',
         'gfxFT2FontBase.cpp',
         'gfxFT2Utils.cpp',
         'gfxGdkNativeRenderer.cpp',

layout/base/nsPresContext.cpp

@@ -77,10 +77,6 @@
 #include "mozilla/StyleSheet.h"
 #include "mozilla/StyleSheetInlines.h"
 
-#if defined(MOZ_WIDGET_GTK)
-#include "gfxPlatformGtk.h" // xxx - for UseFcFontList
-#endif
-
 
 // Needed for Start/Stop of Image Animation
 #include "imgIContainer.h"
@@ -2068,19 +2064,12 @@ nsPresContext::UserFontSetUpdated(gfxUserFontEntry* aUpdatedFont)
   if (!mShell)
     return;
 
-  bool usePlatformFontList = true;
-#if defined(MOZ_WIDGET_GTK)
-  usePlatformFontList = gfxPlatformGtk::UseFcFontList();
-#endif
-
-  // xxx - until the Linux platform font list is always used, use full
-  // restyle to force updates with gfxPangoFontGroup usage
   // Note: this method is called without a font when rules in the userfont set
   // are updated, which may occur during reflow as a result of the lazy
   // initialization of the userfont set. It would be better to avoid a full
   // restyle but until this method is only called outside of reflow, schedule a
   // full restyle in these cases.
-  if (!usePlatformFontList || !aUpdatedFont) {
+  if (!aUpdatedFont) {
     PostRebuildAllStyleDataEvent(NS_STYLE_HINT_REFLOW, eRestyle_ForceDescendants);
     return;
   }

modules/libpref/init/all.js

@@ -4122,13 +4122,7 @@ pref("intl.ime.use_simple_context_on_password_field", true);
 pref("intl.ime.use_simple_context_on_password_field", false);
 #endif
 
-# enable new platform fontlist for linux on GTK platforms
-# temporary pref to allow flipping back to the existing
-# gfxPangoFontGroup/gfxFontconfigUtils code for handling system fonts
-
 #ifdef MOZ_WIDGET_GTK
-pref("gfx.font_rendering.fontconfig.fontlist.enabled", true);
-
 // maximum number of fonts to substitute for a generic
 pref("gfx.font_rendering.fontconfig.max_generic_substitutions", 3);
 #endif