Add m-esr52 at 52.6.0

1 files changed, 2262 insertions, 0 deletions

diff --git a/gfx/thebes/gfxFontconfigFonts.cpp b/gfx/thebes/gfxFontconfigFonts.cpp
new file mode 100644
index 000000000..bbcbbabf9
--- /dev/null
+++ b/gfx/thebes/gfxFontconfigFonts.cpp
@@ -0,0 +1,2262 @@
+/* -*- 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/. */
+
+#include "prlink.h"
+#include "gfxTypes.h"
+
+#include "nsTArray.h"
+
+#include "gfxContext.h"
+#ifdef MOZ_WIDGET_GTK
+#include "gfxPlatformGtk.h"
+#endif
+#include "gfxFontconfigFonts.h"
+#include "gfxFT2FontBase.h"
+#include "gfxFT2Utils.h"
+#include "harfbuzz/hb.h"
+#include "harfbuzz/hb-glib.h"
+#include "harfbuzz/hb-ot.h"
+#include "nsUnicodeProperties.h"
+#include "nsUnicodeScriptCodes.h"
+#include "gfxFontconfigUtils.h"
+#include "gfxUserFontSet.h"
+#include "gfxFontConstants.h"
+#include "nsGkAtoms.h"
+#include "nsILanguageAtomService.h"
+#include "nsServiceManagerUtils.h"
+
+#include <cairo.h>
+#include <cairo-ft.h>
+#include "mozilla/gfx/HelpersCairo.h"
+
+#include <fontconfig/fcfreetype.h>
+#include <pango/pango.h>
+
+#include FT_TRUETYPE_TABLES_H
+
+#ifdef MOZ_WIDGET_GTK
+#include <gdk/gdk.h>
+#endif
+
+#include <math.h>
+
+using namespace mozilla;
+using namespace mozilla::unicode;
+
+#define PRINTING_FC_PROPERTY "gfx.printing"
+
+static PangoLanguage *GuessPangoLanguage(nsIAtom *aLanguage);
+
+static cairo_scaled_font_t *
+CreateScaledFont(FcPattern *aPattern, cairo_font_face_t *aFace);
+
+static FT_Library gFTLibrary;
+
+// FC_FAMILYLANG and FC_FULLNAME were introduced in fontconfig-2.2.97
+// and so fontconfig-2.3.0 (2005).
+#ifndef FC_FAMILYLANG
+#define FC_FAMILYLANG "familylang"
+#endif
+#ifndef FC_FULLNAME
+#define FC_FULLNAME "fullname"
+#endif
+
+static PRFuncPtr
+FindFunctionSymbol(const char *name)
+{
+    PRLibrary *lib = nullptr;
+    PRFuncPtr result = PR_FindFunctionSymbolAndLibrary(name, &lib);
+    if (lib) {
+        PR_UnloadLibrary(lib);
+    }
+
+    return result;
+}
+
+static bool HasChar(FcPattern *aFont, FcChar32 wc)
+{
+    FcCharSet *charset = nullptr;
+    FcPatternGetCharSet(aFont, FC_CHARSET, 0, &charset);
+
+    return charset && FcCharSetHasChar(charset, wc);
+}
+
+/**
+ * gfxFcFontEntry:
+ *
+ * An abstract base class of for gfxFontEntry implementations used by
+ * gfxFcFont and gfxUserFontSet.
+ */
+
+class gfxFcFontEntry : public gfxFontEntry {
+public:
+    // For all FontEntrys attached to gfxFcFonts, there will be only one
+    // pattern in this array.  This is always a font pattern, not a fully
+    // resolved pattern.  gfxFcFont only uses this to construct a PangoFont.
+    //
+    // FontEntrys for src:local() fonts in gfxUserFontSet may return more than
+    // one pattern.  (See comment in gfxUserFcFontEntry.)
+    const nsTArray< nsCountedRef<FcPattern> >& GetPatterns()
+    {
+        return mPatterns;
+    }
+
+    static gfxFcFontEntry *LookupFontEntry(cairo_font_face_t *aFace)
+    {
+        return static_cast<gfxFcFontEntry*>
+            (cairo_font_face_get_user_data(aFace, &sFontEntryKey));
+    }
+
+    // override the gfxFontEntry impl to read the name from fontconfig
+    // instead of trying to get the 'name' table, as we don't implement
+    // GetFontTable() here
+    virtual nsString RealFaceName();
+
+    // This is needed to make gfxFontEntry::HasCharacter(aCh) work.
+    virtual bool TestCharacterMap(uint32_t aCh)
+    {
+        for (uint32_t i = 0; i < mPatterns.Length(); ++i) {
+            if (HasChar(mPatterns[i], aCh)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+protected:
+    explicit gfxFcFontEntry(const nsAString& aName)
+        : gfxFontEntry(aName)
+    {
+    }
+
+    // One pattern is the common case and some subclasses rely on successful
+    // addition of the first element to the array.
+    AutoTArray<nsCountedRef<FcPattern>,1> mPatterns;
+
+    static cairo_user_data_key_t sFontEntryKey;
+};
+
+cairo_user_data_key_t gfxFcFontEntry::sFontEntryKey;
+
+nsString
+gfxFcFontEntry::RealFaceName()
+{
+    FcChar8 *name;
+    if (!mPatterns.IsEmpty()) {
+        if (FcPatternGetString(mPatterns[0],
+                               FC_FULLNAME, 0, &name) == FcResultMatch) {
+            return NS_ConvertUTF8toUTF16((const char*)name);
+        }
+        if (FcPatternGetString(mPatterns[0],
+                               FC_FAMILY, 0, &name) == FcResultMatch) {
+            NS_ConvertUTF8toUTF16 result((const char*)name);
+            if (FcPatternGetString(mPatterns[0],
+                                   FC_STYLE, 0, &name) == FcResultMatch) {
+                result.Append(' ');
+                AppendUTF8toUTF16((const char*)name, result);
+            }
+            return result;
+        }
+    }
+    // fall back to gfxFontEntry implementation (only works for sfnt fonts)
+    return gfxFontEntry::RealFaceName();
+}
+
+/**
+ * gfxSystemFcFontEntry:
+ *
+ * An implementation of gfxFcFontEntry used by gfxFcFonts for system fonts,
+ * including those from regular family-name based font selection as well as
+ * those from src:local().
+ *
+ * All gfxFcFonts using the same cairo_font_face_t share the same FontEntry. 
+ */
+
+class gfxSystemFcFontEntry : public gfxFcFontEntry {
+public:
+    // For memory efficiency, aFontPattern should be a font pattern,
+    // not a fully resolved pattern.
+    gfxSystemFcFontEntry(cairo_font_face_t *aFontFace,
+                         FcPattern *aFontPattern,
+                         const nsAString& aName)
+        : gfxFcFontEntry(aName), mFontFace(aFontFace),
+          mFTFace(nullptr), mFTFaceInitialized(false)
+    {
+        cairo_font_face_reference(mFontFace);
+        cairo_font_face_set_user_data(mFontFace, &sFontEntryKey, this, nullptr);
+
+        // mPatterns is an AutoTArray with 1 space always available, so the
+        // AppendElement always succeeds.
+        // FIXME: Make this infallible after bug 968520 is done.
+        MOZ_ALWAYS_TRUE(mPatterns.AppendElement(fallible));
+        mPatterns[0] = aFontPattern;
+
+        FcChar8 *name;
+        if (FcPatternGetString(aFontPattern,
+                               FC_FAMILY, 0, &name) == FcResultMatch) {
+            mFamilyName = NS_ConvertUTF8toUTF16((const char*)name);
+        }
+    }
+
+    ~gfxSystemFcFontEntry()
+    {
+        cairo_font_face_set_user_data(mFontFace,
+                                      &sFontEntryKey,
+                                      nullptr,
+                                      nullptr);
+        cairo_font_face_destroy(mFontFace);
+    }
+
+    virtual void ForgetHBFace() override;
+    virtual void ReleaseGrFace(gr_face* aFace) override;
+
+protected:
+    virtual nsresult
+    CopyFontTable(uint32_t aTableTag, nsTArray<uint8_t>& aBuffer) override;
+
+    void MaybeReleaseFTFace();
+
+private:
+    cairo_font_face_t *mFontFace;
+    FT_Face            mFTFace;
+    bool               mFTFaceInitialized;
+};
+
+nsresult
+gfxSystemFcFontEntry::CopyFontTable(uint32_t aTableTag,
+                                    nsTArray<uint8_t>& aBuffer)
+{
+    if (!mFTFaceInitialized) {
+        mFTFaceInitialized = true;
+        FcChar8 *filename;
+        if (FcPatternGetString(mPatterns[0], FC_FILE, 0, &filename) != FcResultMatch) {
+            return NS_ERROR_FAILURE;
+        }
+        int index;
+        if (FcPatternGetInteger(mPatterns[0], FC_INDEX, 0, &index) != FcResultMatch) {
+            index = 0; // default to 0 if not found in pattern
+        }
+        if (FT_New_Face(gfxPangoFontGroup::GetFTLibrary(),
+                        (const char*)filename, index, &mFTFace) != 0) {
+            return NS_ERROR_FAILURE;
+        }
+    }
+
+    if (!mFTFace) {
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    FT_ULong length = 0;
+    if (FT_Load_Sfnt_Table(mFTFace, aTableTag, 0, nullptr, &length) != 0) {
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+    if (!aBuffer.SetLength(length, fallible)) {
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+    if (FT_Load_Sfnt_Table(mFTFace, aTableTag, 0, aBuffer.Elements(), &length) != 0) {
+        aBuffer.Clear();
+        return NS_ERROR_FAILURE;
+    }
+
+    return NS_OK;
+}
+
+void
+gfxSystemFcFontEntry::MaybeReleaseFTFace()
+{
+    // don't release if either HB or Gr face still exists
+    if (mHBFace || mGrFace) {
+        return;
+    }
+    if (mFTFace) {
+        FT_Done_Face(mFTFace);
+        mFTFace = nullptr;
+    }
+    mFTFaceInitialized = false;
+}
+
+void
+gfxSystemFcFontEntry::ForgetHBFace()
+{
+    gfxFontEntry::ForgetHBFace();
+    MaybeReleaseFTFace();
+}
+
+void
+gfxSystemFcFontEntry::ReleaseGrFace(gr_face* aFace)
+{
+    gfxFontEntry::ReleaseGrFace(aFace);
+    MaybeReleaseFTFace();
+}
+
+// A namespace for @font-face family names in FcPatterns so that fontconfig
+// aliases do not pick up families from @font-face rules and so that
+// fontconfig rules can distinguish between web fonts and platform fonts.
+// http://lists.freedesktop.org/archives/fontconfig/2008-November/003037.html
+#define FONT_FACE_FAMILY_PREFIX "@font-face:"
+
+/**
+ * gfxUserFcFontEntry:
+ *
+ * An abstract class for objects in a gfxUserFontSet that can provide
+ * FcPattern* handles to fonts.
+ *
+ * Separate implementations of this class support local fonts from src:local()
+ * and web fonts from src:url().
+ */
+
+// There is a one-to-one correspondence between gfxUserFcFontEntry objects and
+// @font-face rules, but sometimes a one-to-many correspondence between font
+// entries and font patterns.
+//
+// http://www.w3.org/TR/2002/WD-css3-webfonts-20020802#font-descriptions
+// provided a font-size descriptor to specify the sizes supported by the face,
+// but the "Editor's Draft 27 June 2008"
+// http://dev.w3.org/csswg/css3-fonts/#font-resources does not provide such a
+// descriptor, and Mozilla does not recognize such a descriptor.
+//
+// Font face names used in src:local() also do not usually specify a size.
+//
+// PCF format fonts have each size in a different file, and each of these
+// files is referenced by its own pattern, but really these are each
+// different sizes of one face with one name.
+//
+// Multiple patterns in an entry also effectively deals with a set of
+// PostScript Type 1 font files that all have the same face name but are in
+// several files because of the limit on the number of glyphs in a Type 1 font
+// file.  (e.g. Computer Modern.)
+
+class gfxUserFcFontEntry : public gfxFcFontEntry {
+protected:
+    explicit gfxUserFcFontEntry(const nsAString& aFontName,
+                       uint16_t aWeight,
+                       int16_t aStretch,
+                       uint8_t aStyle)
+        : gfxFcFontEntry(aFontName)
+    {
+        mStyle = aStyle;
+        mWeight = aWeight;
+        mStretch = aStretch;
+    }
+
+    // Helper function to change a pattern so that it matches the CSS style
+    // descriptors and so gets properly sorted in font selection.  This also
+    // avoids synthetic style effects being added by the renderer when the
+    // style of the font itself does not match the descriptor provided by the
+    // author.
+    void AdjustPatternToCSS(FcPattern *aPattern);
+};
+
+void
+gfxUserFcFontEntry::AdjustPatternToCSS(FcPattern *aPattern)
+{
+    int fontWeight = -1;
+    FcPatternGetInteger(aPattern, FC_WEIGHT, 0, &fontWeight);
+    int cssWeight = gfxFontconfigUtils::FcWeightForBaseWeight(mWeight / 100);
+    if (cssWeight != fontWeight) {
+        FcPatternDel(aPattern, FC_WEIGHT);
+        FcPatternAddInteger(aPattern, FC_WEIGHT, cssWeight);
+    }
+
+    int fontSlant;
+    FcResult res = FcPatternGetInteger(aPattern, FC_SLANT, 0, &fontSlant);
+    // gfxFontEntry doesn't understand the difference between oblique
+    // and italic.
+    if (res != FcResultMatch ||
+        IsItalic() != (fontSlant != FC_SLANT_ROMAN)) {
+        FcPatternDel(aPattern, FC_SLANT);
+        FcPatternAddInteger(aPattern, FC_SLANT,
+                            IsItalic() ? FC_SLANT_OBLIQUE : FC_SLANT_ROMAN);
+    }
+
+    int fontWidth = -1;
+    FcPatternGetInteger(aPattern, FC_WIDTH, 0, &fontWidth);
+    int cssWidth = gfxFontconfigUtils::FcWidthForThebesStretch(mStretch);
+    if (cssWidth != fontWidth) {
+        FcPatternDel(aPattern, FC_WIDTH);
+        FcPatternAddInteger(aPattern, FC_WIDTH, cssWidth);
+    }
+
+    // Ensure that there is a fullname property (if there is a family
+    // property) so that fontconfig rules can identify the real name of the
+    // font, because the family property will be replaced.
+    FcChar8 *unused;
+    if (FcPatternGetString(aPattern,
+                           FC_FULLNAME, 0, &unused) == FcResultNoMatch) {
+        nsAutoCString fullname;
+        if (gfxFontconfigUtils::GetFullnameFromFamilyAndStyle(aPattern,
+                                                              &fullname)) {
+            FcPatternAddString(aPattern, FC_FULLNAME,
+                               gfxFontconfigUtils::ToFcChar8(fullname));
+        }
+    }
+
+    nsAutoCString family;
+    family.Append(FONT_FACE_FAMILY_PREFIX);
+    AppendUTF16toUTF8(Name(), family);
+
+    FcPatternDel(aPattern, FC_FAMILY);
+    FcPatternDel(aPattern, FC_FAMILYLANG);
+    FcPatternAddString(aPattern, FC_FAMILY,
+                       gfxFontconfigUtils::ToFcChar8(family));
+}
+
+/**
+ * gfxLocalFcFontEntry:
+ *
+ * An implementation of gfxUserFcFontEntry for local fonts from src:local().
+ *
+ * This class is used only in gfxUserFontSet and for providing FcPattern*
+ * handles to system fonts for font selection.  gfxFcFonts created from these
+ * patterns will use gfxSystemFcFontEntrys, which may be shared with
+ * gfxFcFonts from regular family-name based font selection.
+ */
+
+class gfxLocalFcFontEntry : public gfxUserFcFontEntry {
+public:
+    gfxLocalFcFontEntry(const nsAString& aFontName,
+                        uint16_t aWeight,
+                        int16_t aStretch,
+                        uint8_t aStyle,
+                        const nsTArray< nsCountedRef<FcPattern> >& aPatterns)
+        : gfxUserFcFontEntry(aFontName, aWeight, aStretch, aStyle)
+    {
+        if (!mPatterns.SetCapacity(aPatterns.Length(), fallible))
+            return; // OOM
+
+        for (uint32_t i = 0; i < aPatterns.Length(); ++i) {
+            FcPattern *pattern = FcPatternDuplicate(aPatterns.ElementAt(i));
+            if (!pattern)
+                return; // OOM
+
+            AdjustPatternToCSS(pattern);
+
+            // FIXME: Make this infallible after bug 968520 is done.
+            MOZ_ALWAYS_TRUE(mPatterns.AppendElement(fallible));
+            mPatterns[i].own(pattern);
+        }
+        mIsLocalUserFont = true;
+    }
+};
+
+/**
+ * gfxDownloadedFcFontEntry:
+ *
+ * An implementation of gfxFcFontEntry for web fonts from src:url().
+ * 
+ * When a cairo_font_face_t is created for these fonts, the cairo_font_face_t
+ * keeps a reference to the FontEntry to keep the font data alive.
+ */
+
+class gfxDownloadedFcFontEntry : public gfxUserFcFontEntry {
+public:
+    // This takes ownership of the face and its underlying data
+    gfxDownloadedFcFontEntry(const nsAString& aFontName,
+                             uint16_t aWeight,
+                             int16_t aStretch,
+                             uint8_t aStyle,
+                             const uint8_t *aData, FT_Face aFace)
+        : gfxUserFcFontEntry(aFontName, aWeight, aStretch, aStyle),
+          mFontData(aData), mFace(aFace)
+    {
+        NS_PRECONDITION(aFace != nullptr, "aFace is NULL!");
+        mIsDataUserFont = true;
+        InitPattern();
+    }
+
+    virtual ~gfxDownloadedFcFontEntry();
+
+    // Returns true on success
+    bool SetCairoFace(cairo_font_face_t *aFace);
+
+    virtual hb_blob_t* GetFontTable(uint32_t aTableTag) override;
+
+protected:
+    void InitPattern();
+
+    // mFontData holds the data used to instantiate the FT_Face;
+    // this has to persist until we are finished with the face,
+    // then be released with free().
+    const uint8_t* mFontData;
+
+    FT_Face mFace;
+};
+
+// A property for recording gfxDownloadedFcFontEntrys on FcPatterns.
+static const char *kFontEntryFcProp = "-moz-font-entry";
+
+static FcBool AddDownloadedFontEntry(FcPattern *aPattern,
+                                     gfxDownloadedFcFontEntry *aFontEntry)
+{
+    FcValue value;
+    value.type = FcTypeFTFace; // void* field of union
+    value.u.f = aFontEntry;
+
+    return FcPatternAdd(aPattern, kFontEntryFcProp, value, FcFalse);
+}
+
+static FcBool DelDownloadedFontEntry(FcPattern *aPattern)
+{
+    return FcPatternDel(aPattern, kFontEntryFcProp);
+}
+
+static gfxDownloadedFcFontEntry *GetDownloadedFontEntry(FcPattern *aPattern)
+{
+    FcValue value;
+    if (FcPatternGet(aPattern, kFontEntryFcProp, 0, &value) != FcResultMatch)
+        return nullptr;
+
+    if (value.type != FcTypeFTFace) {
+        NS_NOTREACHED("Wrong type for -moz-font-entry font property");
+        return nullptr;
+    }
+
+    return static_cast<gfxDownloadedFcFontEntry*>(value.u.f);
+}
+
+gfxDownloadedFcFontEntry::~gfxDownloadedFcFontEntry()
+{
+    if (mPatterns.Length() != 0) {
+        // Remove back reference to this font entry and the face in case
+        // anyone holds a reference to the pattern.
+        NS_ASSERTION(mPatterns.Length() == 1,
+                     "More than one pattern in gfxDownloadedFcFontEntry!");
+        DelDownloadedFontEntry(mPatterns[0]);
+        FcPatternDel(mPatterns[0], FC_FT_FACE);
+    }
+    FT_Done_Face(mFace);
+    free((void*)mFontData);
+}
+
+typedef FcPattern* (*QueryFaceFunction)(const FT_Face face,
+                                        const FcChar8 *file, int id,
+                                        FcBlanks *blanks);
+
+void
+gfxDownloadedFcFontEntry::InitPattern()
+{
+    static QueryFaceFunction sQueryFacePtr =
+        reinterpret_cast<QueryFaceFunction>
+        (FindFunctionSymbol("FcFreeTypeQueryFace"));
+    FcPattern *pattern;
+
+    // FcFreeTypeQueryFace is the same function used to construct patterns for
+    // system fonts and so is the preferred function to use for this purpose.
+    // This will set up the langset property, which helps with sorting, and
+    // the foundry, fullname, and fontversion properties, which properly
+    // identify the font to fontconfig rules.  However, FcFreeTypeQueryFace is
+    // available only from fontconfig-2.4.2 (December 2006).  (CentOS 5.0 has
+    // fontconfig-2.4.1.)
+    if (sQueryFacePtr) {
+        // The "file" argument cannot be nullptr (in fontconfig-2.6.0 at
+        // least). The dummy file passed here is removed below.
+        //
+        // When fontconfig scans the system fonts, FcConfigGetBlanks(nullptr)
+        // is passed as the "blanks" argument, which provides that unexpectedly
+        // blank glyphs are elided.  Here, however, we pass nullptr for
+        // "blanks", effectively assuming that, if the font has a blank glyph,
+        // then the author intends any associated character to be rendered
+        // blank.
+        pattern =
+            (*sQueryFacePtr)(mFace,
+                             gfxFontconfigUtils::ToFcChar8(""),
+                             0,
+                             nullptr);
+        if (!pattern)
+            // Either OOM, or fontconfig chose to skip this font because it
+            // has "no encoded characters", which I think means "BDF and PCF
+            // fonts which are not in Unicode (or the effectively equivalent
+            // ISO Latin-1) encoding".
+            return;
+
+        // These properties don't make sense for this face without a file.
+        FcPatternDel(pattern, FC_FILE);
+        FcPatternDel(pattern, FC_INDEX);
+
+    } else {
+        // Do the minimum necessary to construct a pattern for sorting.
+
+        // FC_CHARSET is vital to determine which characters are supported.
+        nsAutoRef<FcCharSet> charset(FcFreeTypeCharSet(mFace, nullptr));
+        // If there are no characters then assume we don't know how to read
+        // this font.
+        if (!charset || FcCharSetCount(charset) == 0)
+            return;
+
+        pattern = FcPatternCreate();
+        FcPatternAddCharSet(pattern, FC_CHARSET, charset);
+
+        // FC_PIXEL_SIZE can be important for font selection of fixed-size
+        // fonts.
+        if (!(mFace->face_flags & FT_FACE_FLAG_SCALABLE)) {
+            for (FT_Int i = 0; i < mFace->num_fixed_sizes; ++i) {
+#if HAVE_FT_BITMAP_SIZE_Y_PPEM
+                double size = FLOAT_FROM_26_6(mFace->available_sizes[i].y_ppem);
+#else
+                double size = mFace->available_sizes[i].height;
+#endif
+                FcPatternAddDouble (pattern, FC_PIXEL_SIZE, size);
+            }
+
+            // Not sure whether this is important;
+            // imitating FcFreeTypeQueryFace:
+            FcPatternAddBool (pattern, FC_ANTIALIAS, FcFalse);
+        }
+
+        // Setting up the FC_LANGSET property is very difficult with the APIs
+        // available prior to FcFreeTypeQueryFace.  Having no FC_LANGSET
+        // property seems better than having a property with an empty LangSet.
+        // With no FC_LANGSET property, fontconfig sort functions will
+        // consider this face to have the same priority as (otherwise equal)
+        // faces that have support for the primary requested language, but
+        // will not consider any language to have been satisfied (and so will
+        // continue to look for a face with language support in fallback
+        // fonts).
+    }
+
+    AdjustPatternToCSS(pattern);
+
+    FcPatternAddFTFace(pattern, FC_FT_FACE, mFace);
+    AddDownloadedFontEntry(pattern, this);
+
+    // There is never more than one pattern
+    // FIXME: Make this infallible after bug 968520 is done.
+    MOZ_ALWAYS_TRUE(mPatterns.AppendElement(fallible));
+    mPatterns[0].own(pattern);
+}
+
+static void ReleaseDownloadedFontEntry(void *data)
+{
+    gfxDownloadedFcFontEntry *downloadedFontEntry =
+        static_cast<gfxDownloadedFcFontEntry*>(data);
+    NS_RELEASE(downloadedFontEntry);
+}
+
+bool gfxDownloadedFcFontEntry::SetCairoFace(cairo_font_face_t *aFace)
+{
+    if (CAIRO_STATUS_SUCCESS !=
+        cairo_font_face_set_user_data(aFace, &sFontEntryKey, this,
+                                      ReleaseDownloadedFontEntry))
+        return false;
+
+    // Hold a reference to this font entry to keep the font face data.
+    NS_ADDREF(this);
+    return true;
+}
+
+hb_blob_t *
+gfxDownloadedFcFontEntry::GetFontTable(uint32_t aTableTag)
+{
+    // The entry already owns the (sanitized) sfnt data in mFontData,
+    // so we can just return a blob that "wraps" the appropriate chunk of it.
+    // The blob should not attempt to free its data, as the entire sfnt data
+    // will be freed when the font entry is deleted.
+    return gfxFontUtils::GetTableFromFontData(mFontData, aTableTag);
+}
+
+/*
+ * gfxFcFont
+ *
+ * This is a gfxFont implementation using a CAIRO_FONT_TYPE_FT
+ * cairo_scaled_font created from an FcPattern.
+ */
+
+class gfxFcFont : public gfxFontconfigFontBase {
+public:
+    virtual ~gfxFcFont();
+    static already_AddRefed<gfxFcFont>
+    GetOrMakeFont(FcPattern *aRequestedPattern, FcPattern *aFontPattern,
+                  const gfxFontStyle *aFontStyle);
+
+    // return a cloned font resized and offset to simulate sub/superscript glyphs
+    virtual already_AddRefed<gfxFont>
+    GetSubSuperscriptFont(int32_t aAppUnitsPerDevPixel) override;
+
+protected:
+    virtual already_AddRefed<gfxFont> MakeScaledFont(gfxFontStyle *aFontStyle,
+                                                     gfxFloat aFontScale);
+    virtual already_AddRefed<gfxFont> GetSmallCapsFont() override;
+
+private:
+    gfxFcFont(cairo_scaled_font_t *aCairoFont,
+              FcPattern *aPattern,
+              gfxFcFontEntry *aFontEntry,
+              const gfxFontStyle *aFontStyle);
+
+    // key for locating a gfxFcFont corresponding to a cairo_scaled_font
+    static cairo_user_data_key_t sGfxFontKey;
+};
+
+/**
+ * gfxFcFontSet:
+ *
+ * Translation from a desired FcPattern to a sorted set of font references
+ * (fontconfig cache data) and (when needed) fonts.
+ */
+
+class gfxFcFontSet final {
+public:
+    NS_INLINE_DECL_REFCOUNTING(gfxFcFontSet)
+    
+    explicit gfxFcFontSet(FcPattern *aPattern,
+                               gfxUserFontSet *aUserFontSet)
+        : mSortPattern(aPattern), mUserFontSet(aUserFontSet),
+          mFcFontsTrimmed(0),
+          mHaveFallbackFonts(false)
+    {
+        bool waitForUserFont;
+        mFcFontSet = SortPreferredFonts(waitForUserFont);
+        mWaitingForUserFont = waitForUserFont;
+    }
+
+    // A reference is held by the FontSet.
+    // The caller may add a ref to keep the font alive longer than the FontSet.
+    gfxFcFont *GetFontAt(uint32_t i, const gfxFontStyle *aFontStyle)
+    {
+        if (i >= mFonts.Length() || !mFonts[i].mFont) { 
+            // GetFontPatternAt sets up mFonts
+            FcPattern *fontPattern = GetFontPatternAt(i);
+            if (!fontPattern)
+                return nullptr;
+
+            mFonts[i].mFont =
+                gfxFcFont::GetOrMakeFont(mSortPattern, fontPattern,
+                                         aFontStyle);
+        }
+        return mFonts[i].mFont;
+    }
+
+    FcPattern *GetFontPatternAt(uint32_t i);
+
+    bool WaitingForUserFont() const {
+        return mWaitingForUserFont;
+    }
+
+private:
+    // Private destructor, to discourage deletion outside of Release():
+    ~gfxFcFontSet()
+    {
+    }
+
+    nsReturnRef<FcFontSet> SortPreferredFonts(bool& aWaitForUserFont);
+    nsReturnRef<FcFontSet> SortFallbackFonts();
+
+    struct FontEntry {
+        explicit FontEntry(FcPattern *aPattern) : mPattern(aPattern) {}
+        nsCountedRef<FcPattern> mPattern;
+        RefPtr<gfxFcFont> mFont;
+    };
+
+    struct LangSupportEntry {
+        LangSupportEntry(FcChar8 *aLang, FcLangResult aSupport) :
+            mLang(aLang), mBestSupport(aSupport) {}
+        FcChar8 *mLang;
+        FcLangResult mBestSupport;
+    };
+
+public:
+    // public for nsTArray
+    class LangComparator {
+    public:
+        bool Equals(const LangSupportEntry& a, const FcChar8 *b) const
+        {
+            return FcStrCmpIgnoreCase(a.mLang, b) == 0;
+        }
+    };
+
+private:
+    // The requested pattern
+    nsCountedRef<FcPattern> mSortPattern;
+    // Fonts from @font-face rules
+    RefPtr<gfxUserFontSet> mUserFontSet;
+    // A (trimmed) list of font patterns and fonts that is built up as
+    // required.
+    nsTArray<FontEntry> mFonts;
+    // Holds a list of font patterns that will be trimmed.  This is first set
+    // to a list of preferred fonts.  Then, if/when all the preferred fonts
+    // have been trimmed and added to mFonts, this is set to a list of
+    // fallback fonts.
+    nsAutoRef<FcFontSet> mFcFontSet;
+    // The set of characters supported by the fonts in mFonts.
+    nsAutoRef<FcCharSet> mCharSet;
+    // The index of the next font in mFcFontSet that has not yet been
+    // considered for mFonts.
+    int mFcFontsTrimmed;
+    // True iff fallback fonts are either stored in mFcFontSet or have been
+    // trimmed and added to mFonts (so that mFcFontSet is nullptr).
+    bool mHaveFallbackFonts;
+    // True iff there was a user font set with pending downloads,
+    // so the set may be updated when downloads complete
+    bool mWaitingForUserFont;
+};
+
+// Find the FcPattern for an @font-face font suitable for CSS family |aFamily|
+// and style |aStyle| properties.
+static const nsTArray< nsCountedRef<FcPattern> >*
+FindFontPatterns(gfxUserFontSet *mUserFontSet,
+                 const nsACString &aFamily, uint8_t aStyle,
+                 uint16_t aWeight, int16_t aStretch,
+                 bool& aWaitForUserFont)
+{
+    // Convert to UTF16
+    NS_ConvertUTF8toUTF16 utf16Family(aFamily);
+
+    // needsBold is not used here.  Instead synthetic bold is enabled through
+    // FcFontRenderPrepare when the weight in the requested pattern is
+    // compared against the weight in the font pattern.
+    bool needsBold;
+
+    gfxFontStyle style;
+    style.style = aStyle;
+    style.weight = aWeight;
+    style.stretch = aStretch;
+
+    gfxUserFcFontEntry *fontEntry = nullptr;
+    gfxFontFamily *family = mUserFontSet->LookupFamily(utf16Family);
+    if (family) {
+        gfxUserFontEntry* userFontEntry =
+            mUserFontSet->FindUserFontEntryAndLoad(family, style, needsBold,
+                                                   aWaitForUserFont);
+        if (userFontEntry) {
+            fontEntry = static_cast<gfxUserFcFontEntry*>
+                (userFontEntry->GetPlatformFontEntry());
+        }
+
+        // Accept synthetic oblique for italic and oblique.
+        // xxx - this isn't really ideal behavior, for docs that only use a
+        //       single italic face it will also pull down the normal face
+        //       and probably never use it
+        if (!fontEntry && aStyle != NS_FONT_STYLE_NORMAL) {
+            style.style = NS_FONT_STYLE_NORMAL;
+            userFontEntry =
+                mUserFontSet->FindUserFontEntryAndLoad(family, style,
+                                                       needsBold,
+                                                       aWaitForUserFont);
+            if (userFontEntry) {
+                fontEntry = static_cast<gfxUserFcFontEntry*>
+                    (userFontEntry->GetPlatformFontEntry());
+            }
+        }
+    }
+
+    if (!fontEntry) {
+        return nullptr;
+    }
+
+    return &fontEntry->GetPatterns();
+}
+
+typedef FcBool (*FcPatternRemoveFunction)(FcPattern *p, const char *object,
+                                          int id);
+
+// FcPatternRemove is available in fontconfig-2.3.0 (2005)
+static FcBool
+moz_FcPatternRemove(FcPattern *p, const char *object, int id)
+{
+    static FcPatternRemoveFunction sFcPatternRemovePtr =
+        reinterpret_cast<FcPatternRemoveFunction>
+        (FindFunctionSymbol("FcPatternRemove"));
+
+    if (!sFcPatternRemovePtr)
+        return FcFalse;
+
+    return (*sFcPatternRemovePtr)(p, object, id);
+}
+
+// fontconfig prefers a matching family or lang to pixelsize of bitmap
+// fonts.  CSS suggests a tolerance of 20% on pixelsize.
+static bool
+SizeIsAcceptable(FcPattern *aFont, double aRequestedSize)
+{
+    double size;
+    int v = 0;
+    while (FcPatternGetDouble(aFont,
+                              FC_PIXEL_SIZE, v, &size) == FcResultMatch) {
+        ++v;
+        if (5.0 * fabs(size - aRequestedSize) < aRequestedSize)
+            return true;
+    }
+
+    // No size means scalable
+    return v == 0;
+}
+
+// Sorting only the preferred fonts first usually saves having to sort through
+// every font on the system.
+nsReturnRef<FcFontSet>
+gfxFcFontSet::SortPreferredFonts(bool &aWaitForUserFont)
+{
+    aWaitForUserFont = false;
+
+    gfxFontconfigUtils *utils = gfxFontconfigUtils::GetFontconfigUtils();
+    if (!utils)
+        return nsReturnRef<FcFontSet>();
+
+    // The list of families in mSortPattern has values with both weak and
+    // strong bindings.  Values with strong bindings should be preferred.
+    // Values with weak bindings are default fonts that should be considered
+    // only when the font provides the best support for a requested language
+    // or after other fonts have satisfied all the requested languages.
+    //
+    // There are no direct fontconfig APIs to get the binding type.  The
+    // binding only takes effect in the sort and match functions.
+
+    // |requiredLangs| is a list of requested languages that have not yet been
+    // satisfied.  gfxFontconfigUtils only sets one FC_LANG property value,
+    // but FcConfigSubstitute may add more values (e.g. prepending "en" to
+    // "ja" will use western fonts to render Latin/Arabic numerals in Japanese
+    // text.)
+    AutoTArray<LangSupportEntry,10> requiredLangs;
+    for (int v = 0; ; ++v) {
+        FcChar8 *lang;
+        FcResult result = FcPatternGetString(mSortPattern, FC_LANG, v, &lang);
+        if (result != FcResultMatch) {
+            // No need to check FcPatternGetLangSet() because
+            // gfxFontconfigUtils sets only a string value for FC_LANG and
+            // FcConfigSubstitute cannot add LangSets.
+            NS_ASSERTION(result != FcResultTypeMismatch,
+                         "Expected a string for FC_LANG");
+            break;
+        }
+
+        if (!requiredLangs.Contains(lang, LangComparator())) {
+            FcLangResult bestLangSupport = utils->GetBestLangSupport(lang);
+            if (bestLangSupport != FcLangDifferentLang) {
+                requiredLangs.
+                    AppendElement(LangSupportEntry(lang, bestLangSupport));
+            }
+        }
+    }
+
+    nsAutoRef<FcFontSet> fontSet(FcFontSetCreate());
+    if (!fontSet)
+        return fontSet.out();
+
+    // FcDefaultSubstitute() ensures a slant on mSortPattern, but, if that ever
+    // doesn't happen, Roman will be used.
+    int requestedSlant = FC_SLANT_ROMAN;
+    FcPatternGetInteger(mSortPattern, FC_SLANT, 0, &requestedSlant);
+    double requestedSize = -1.0;
+    FcPatternGetDouble(mSortPattern, FC_PIXEL_SIZE, 0, &requestedSize);
+
+    nsTHashtable<gfxFontconfigUtils::DepFcStrEntry> existingFamilies(32);
+    FcChar8 *family;
+    for (int v = 0;
+         FcPatternGetString(mSortPattern,
+                            FC_FAMILY, v, &family) == FcResultMatch; ++v) {
+        const nsTArray< nsCountedRef<FcPattern> > *familyFonts = nullptr;
+
+        // Is this an @font-face family?
+        bool isUserFont = false;
+        if (mUserFontSet) {
+            // Have some @font-face definitions
+
+            nsDependentCString cFamily(gfxFontconfigUtils::ToCString(family));
+            NS_NAMED_LITERAL_CSTRING(userPrefix, FONT_FACE_FAMILY_PREFIX);
+
+            if (StringBeginsWith(cFamily, userPrefix)) {
+                isUserFont = true;
+
+                // Trim off the prefix
+                nsDependentCSubstring cssFamily(cFamily, userPrefix.Length());
+
+                uint8_t thebesStyle =
+                    gfxFontconfigUtils::FcSlantToThebesStyle(requestedSlant);
+                uint16_t thebesWeight =
+                    gfxFontconfigUtils::GetThebesWeight(mSortPattern);
+                int16_t thebesStretch =
+                    gfxFontconfigUtils::GetThebesStretch(mSortPattern);
+
+                bool waitForUserFont;
+                familyFonts = FindFontPatterns(mUserFontSet, cssFamily,
+                                               thebesStyle,
+                                               thebesWeight, thebesStretch,
+                                               waitForUserFont);
+                if (waitForUserFont) {
+                    aWaitForUserFont = true;
+                }
+            }
+        }
+
+        if (!isUserFont) {
+            familyFonts = &utils->GetFontsForFamily(family);
+        }
+
+        if (!familyFonts || familyFonts->Length() == 0) {
+            // There are no fonts matching this family, so there is no point
+            // in searching for this family in the FontSort.
+            //
+            // Perhaps the original pattern should be retained for
+            // FcFontRenderPrepare.  However, the only a useful config
+            // substitution test against missing families that i can imagine
+            // would only be interested in the preferred family
+            // (qual="first"), so always keep the first family and use the
+            // same pattern for Sort and RenderPrepare.
+            if (v != 0 && moz_FcPatternRemove(mSortPattern, FC_FAMILY, v)) {
+                --v;
+            }
+            continue;
+        }
+
+        // Aliases seem to often end up occurring more than once, but
+        // duplicate families can't be removed from the sort pattern without
+        // knowing whether duplicates have the same binding.
+        gfxFontconfigUtils::DepFcStrEntry *familyEntry =
+            existingFamilies.PutEntry(family);
+        if (familyEntry) {
+            if (familyEntry->mKey) // old entry
+                continue;
+
+            familyEntry->mKey = family; // initialize new entry
+        }
+
+        for (uint32_t f = 0; f < familyFonts->Length(); ++f) {
+            FcPattern *font = familyFonts->ElementAt(f);
+
+            // Fix up the family name of user-font patterns, as the same
+            // font entry may be used (via the UserFontCache) for multiple
+            // CSS family names
+            if (isUserFont) {
+                font = FcPatternDuplicate(font);
+                FcPatternDel(font, FC_FAMILY);
+                FcPatternAddString(font, FC_FAMILY, family);
+            }
+
+            // User fonts are already filtered by slant (but not size) in
+            // mUserFontSet->FindUserFontEntry().
+            if (requestedSize != -1.0 && !SizeIsAcceptable(font, requestedSize))
+                continue;
+
+            for (uint32_t r = 0; r < requiredLangs.Length(); ++r) {
+                const LangSupportEntry& langEntry = requiredLangs[r];
+                FcLangResult support =
+                    gfxFontconfigUtils::GetLangSupport(font, langEntry.mLang);
+                if (support <= langEntry.mBestSupport) { // lower is better
+                    requiredLangs.RemoveElementAt(r);
+                    --r;
+                }
+            }
+
+            // FcFontSetDestroy will remove a reference but FcFontSetAdd
+            // does _not_ take a reference!
+            if (FcFontSetAdd(fontSet, font)) {
+                // We don't add a reference here for user fonts, because we're
+                // using a local clone of the pattern (see above) in order to
+                // override the family name
+                if (!isUserFont) {
+                    FcPatternReference(font);
+                }
+            }
+        }
+    }
+
+    FcPattern *truncateMarker = nullptr;
+    for (uint32_t r = 0; r < requiredLangs.Length(); ++r) {
+        const nsTArray< nsCountedRef<FcPattern> >& langFonts =
+            utils->GetFontsForLang(requiredLangs[r].mLang);
+
+        bool haveLangFont = false;
+        for (uint32_t f = 0; f < langFonts.Length(); ++f) {
+            FcPattern *font = langFonts[f];
+            if (requestedSize != -1.0 && !SizeIsAcceptable(font, requestedSize))
+                continue;
+
+            haveLangFont = true;
+            if (FcFontSetAdd(fontSet, font)) {
+                FcPatternReference(font);
+            }
+        }
+
+        if (!haveLangFont && langFonts.Length() > 0) {
+            // There is a font that supports this language but it didn't pass
+            // the slant and size criteria.  Weak default font families should
+            // not be considered until the language has been satisfied.
+            //
+            // Insert a font that supports the language so that it will mark
+            // the position of fonts from weak families in the sorted set and
+            // they can be removed.  The language and weak families will be
+            // considered in the fallback fonts, which use fontconfig's
+            // algorithm.
+            //
+            // Of the fonts that don't meet slant and size criteria, strong
+            // default font families should be considered before (other) fonts
+            // for this language, so this marker font will be removed (as well
+            // as the fonts from weak families), and strong families will be
+            // reconsidered in the fallback fonts.
+            FcPattern *font = langFonts[0];
+            if (FcFontSetAdd(fontSet, font)) {
+                FcPatternReference(font);
+                truncateMarker = font;
+            }
+            break;
+        }
+    }
+
+    FcFontSet *sets[1] = { fontSet };
+    FcResult result;
+#ifdef SOLARIS
+    // Get around a crash of FcFontSetSort when FcConfig is nullptr
+    // Solaris's FcFontSetSort needs an FcConfig (bug 474758)
+    fontSet.own(FcFontSetSort(FcConfigGetCurrent(), sets, 1, mSortPattern,
+                              FcFalse, nullptr, &result));
+#else
+    fontSet.own(FcFontSetSort(nullptr, sets, 1, mSortPattern,
+                              FcFalse, nullptr, &result));
+#endif
+
+    if (truncateMarker != nullptr && fontSet) {
+        nsAutoRef<FcFontSet> truncatedSet(FcFontSetCreate());
+
+        for (int f = 0; f < fontSet->nfont; ++f) {
+            FcPattern *font = fontSet->fonts[f];
+            if (font == truncateMarker)
+                break;
+
+            if (FcFontSetAdd(truncatedSet, font)) {
+                FcPatternReference(font);
+            }
+        }
+
+        fontSet.steal(truncatedSet);
+    }
+
+    return fontSet.out();
+}
+
+nsReturnRef<FcFontSet>
+gfxFcFontSet::SortFallbackFonts()
+{
+    // Setting trim to FcTrue would provide a much smaller (~ 1/10) FcFontSet,
+    // but would take much longer due to comparing all the character sets.
+    //
+    // The references to fonts in this FcFontSet are almost free
+    // as they are pointers into mmaped cache files.
+    //
+    // GetFontPatternAt() will trim lazily if and as needed, which will also
+    // remove duplicates of preferred fonts.
+    FcResult result;
+    return nsReturnRef<FcFontSet>(FcFontSort(nullptr, mSortPattern,
+                                             FcFalse, nullptr, &result));
+}
+
+// GetFontAt relies on this setting up all patterns up to |i|.
+FcPattern *
+gfxFcFontSet::GetFontPatternAt(uint32_t i)
+{
+    while (i >= mFonts.Length()) {
+        while (!mFcFontSet) {
+            if (mHaveFallbackFonts)
+                return nullptr;
+
+            mFcFontSet = SortFallbackFonts();
+            mHaveFallbackFonts = true;
+            mFcFontsTrimmed = 0;
+            // Loop to test that mFcFontSet is non-nullptr.
+        }
+
+        while (mFcFontsTrimmed < mFcFontSet->nfont) {
+            FcPattern *font = mFcFontSet->fonts[mFcFontsTrimmed];
+            ++mFcFontsTrimmed;
+
+            if (mFonts.Length() != 0) {
+                // See if the next font provides support for any extra
+                // characters.  Most often the next font is not going to
+                // support more characters so check for a SubSet first before
+                // allocating a new CharSet with Union.
+                FcCharSet *supportedChars = mCharSet;
+                if (!supportedChars) {
+                    FcPatternGetCharSet(mFonts[mFonts.Length() - 1].mPattern,
+                                        FC_CHARSET, 0, &supportedChars);
+                }
+
+                if (supportedChars) {
+                    FcCharSet *newChars = nullptr;
+                    FcPatternGetCharSet(font, FC_CHARSET, 0, &newChars);
+                    if (newChars) {
+                        if (FcCharSetIsSubset(newChars, supportedChars))
+                            continue;
+
+                        mCharSet.own(FcCharSetUnion(supportedChars, newChars));
+                    } else if (!mCharSet) {
+                        mCharSet.own(FcCharSetCopy(supportedChars));
+                    }
+                }
+            }
+
+            mFonts.AppendElement(font);
+            if (mFonts.Length() >= i)
+                break;
+        }
+
+        if (mFcFontsTrimmed == mFcFontSet->nfont) {
+            // finished with this font set
+            mFcFontSet.reset();
+        }
+    }
+
+    return mFonts[i].mPattern;
+}
+
+#ifdef MOZ_WIDGET_GTK
+static void ApplyGdkScreenFontOptions(FcPattern *aPattern);
+#endif
+
+// Apply user settings and defaults to pattern in preparation for matching.
+static void
+PrepareSortPattern(FcPattern *aPattern, double aFallbackSize,
+                   double aSizeAdjustFactor, bool aIsPrinterFont)
+{
+    FcConfigSubstitute(nullptr, aPattern, FcMatchPattern);
+
+    // This gets cairo_font_options_t for the Screen.  We should have
+    // different font options for printing (no hinting) but we are not told
+    // what we are measuring for.
+    //
+    // If cairo adds support for lcd_filter, gdk will not provide the default
+    // setting for that option.  We could get the default setting by creating
+    // an xlib surface once, recording its font_options, and then merging the
+    // gdk options.
+    //
+    // Using an xlib surface would also be an option to get Screen font
+    // options for non-GTK X11 toolkits, but less efficient than using GDK to
+    // pick up dynamic changes.
+    if(aIsPrinterFont) {
+       cairo_font_options_t *options = cairo_font_options_create();
+       cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE);
+       cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_GRAY);
+       cairo_ft_font_options_substitute(options, aPattern);
+       cairo_font_options_destroy(options);
+       FcPatternAddBool(aPattern, PRINTING_FC_PROPERTY, FcTrue);
+    } else {
+#ifdef MOZ_WIDGET_GTK
+       ApplyGdkScreenFontOptions(aPattern);
+#endif
+    }
+
+    // Protect against any fontconfig settings that may have incorrectly
+    // modified the pixelsize, and consider aSizeAdjustFactor.
+    double size = aFallbackSize;
+    if (FcPatternGetDouble(aPattern, FC_PIXEL_SIZE, 0, &size) != FcResultMatch
+        || aSizeAdjustFactor != 1.0) {
+        FcPatternDel(aPattern, FC_PIXEL_SIZE);
+        FcPatternAddDouble(aPattern, FC_PIXEL_SIZE, size * aSizeAdjustFactor);
+    }
+
+    FcDefaultSubstitute(aPattern);
+}
+
+/**
+ ** gfxPangoFontGroup
+ **/
+
+gfxPangoFontGroup::gfxPangoFontGroup(const FontFamilyList& aFontFamilyList,
+                                     const gfxFontStyle *aStyle,
+                                     gfxUserFontSet *aUserFontSet,
+                                     gfxFloat aDevToCssSize)
+    : gfxFontGroup(aFontFamilyList, aStyle, nullptr, aUserFontSet, aDevToCssSize),
+      mPangoLanguage(GuessPangoLanguage(aStyle->language))
+{
+    // This language is passed to the font for shaping.
+    // Shaping doesn't know about lang groups so make it a real language.
+    if (mPangoLanguage) {
+        mStyle.language = NS_Atomize(pango_language_to_string(mPangoLanguage));
+    }
+
+    // dummy entry, will be replaced when actually needed
+    mFonts.AppendElement(FamilyFace());
+    mSkipUpdateUserFonts = true;
+}
+
+gfxPangoFontGroup::~gfxPangoFontGroup()
+{
+}
+
+gfxFontGroup *
+gfxPangoFontGroup::Copy(const gfxFontStyle *aStyle)
+{
+    return new gfxPangoFontGroup(mFamilyList, aStyle, mUserFontSet, mDevToCssSize);
+}
+
+void
+gfxPangoFontGroup::FindGenericFontsPFG(FontFamilyType aGenericType,
+                                       nsIAtom *aLanguage,
+                                       void *aClosure)
+{
+    AutoTArray<nsString, 5> resolvedGenerics;
+    ResolveGenericFontNamesPFG(aGenericType, aLanguage, resolvedGenerics);
+    uint32_t g = 0, numGenerics = resolvedGenerics.Length();
+    for (g = 0; g < numGenerics; g++) {
+        FindPlatformFontPFG(resolvedGenerics[g], false, aClosure);
+    }
+}
+
+/* static */ void
+gfxPangoFontGroup::ResolveGenericFontNamesPFG(FontFamilyType aGenericType,
+                                              nsIAtom *aLanguage,
+                                              nsTArray<nsString>& aGenericFamilies)
+{
+    static const char kGeneric_serif[] = "serif";
+    static const char kGeneric_sans_serif[] = "sans-serif";
+    static const char kGeneric_monospace[] = "monospace";
+    static const char kGeneric_cursive[] = "cursive";
+    static const char kGeneric_fantasy[] = "fantasy";
+
+    // treat -moz-fixed as monospace
+    if (aGenericType == eFamily_moz_fixed) {
+        aGenericType = eFamily_monospace;
+    }
+
+    // type should be standard generic type at this point
+    NS_ASSERTION(aGenericType >= eFamily_serif &&
+                 aGenericType <= eFamily_fantasy,
+                 "standard generic font family type required");
+
+    // create the lang string
+    nsIAtom *langGroupAtom = nullptr;
+    nsAutoCString langGroupString;
+    if (aLanguage) {
+        if (!gLangService) {
+            CallGetService(NS_LANGUAGEATOMSERVICE_CONTRACTID, &gLangService);
+        }
+        if (gLangService) {
+            nsresult rv;
+            langGroupAtom = gLangService->GetLanguageGroup(aLanguage, &rv);
+        }
+    }
+    if (!langGroupAtom) {
+        langGroupAtom = nsGkAtoms::Unicode;
+    }
+    langGroupAtom->ToUTF8String(langGroupString);
+
+    // map generic type to string
+    const char *generic = nullptr;
+    switch (aGenericType) {
+        case eFamily_serif:
+            generic = kGeneric_serif;
+            break;
+        case eFamily_sans_serif:
+            generic = kGeneric_sans_serif;
+            break;
+        case eFamily_monospace:
+            generic = kGeneric_monospace;
+            break;
+        case eFamily_cursive:
+            generic = kGeneric_cursive;
+            break;
+        case eFamily_fantasy:
+            generic = kGeneric_fantasy;
+            break;
+        default:
+            break;
+    }
+
+    if (!generic) {
+        return;
+    }
+
+    aGenericFamilies.Clear();
+
+    // load family for "font.name.generic.lang"
+    nsAutoCString prefFontName("font.name.");
+    prefFontName.Append(generic);
+    prefFontName.Append('.');
+    prefFontName.Append(langGroupString);
+    gfxFontUtils::AppendPrefsFontList(prefFontName.get(),
+                                      aGenericFamilies);
+
+    // if lang has pref fonts, also load fonts for "font.name-list.generic.lang"
+    if (!aGenericFamilies.IsEmpty()) {
+        nsAutoCString prefFontListName("font.name-list.");
+        prefFontListName.Append(generic);
+        prefFontListName.Append('.');
+        prefFontListName.Append(langGroupString);
+        gfxFontUtils::AppendPrefsFontList(prefFontListName.get(),
+                                          aGenericFamilies);
+    }
+
+#if 0  // dump out generic mappings
+    printf("%s ===> ", prefFontName.get());
+    for (uint32_t k = 0; k < aGenericFamilies.Length(); k++) {
+        if (k > 0) printf(", ");
+        printf("%s", NS_ConvertUTF16toUTF8(aGenericFamilies[k]).get());
+    }
+    printf("\n");
+#endif
+}
+
+void gfxPangoFontGroup::EnumerateFontListPFG(nsIAtom *aLanguage, void *aClosure)
+{
+    // initialize fonts in the font family list
+    const nsTArray<FontFamilyName>& fontlist = mFamilyList.GetFontlist();
+
+    // lookup fonts in the fontlist
+    uint32_t i, numFonts = fontlist.Length();
+    for (i = 0; i < numFonts; i++) {
+        const FontFamilyName& name = fontlist[i];
+        if (name.IsNamed()) {
+            FindPlatformFontPFG(name.mName, true, aClosure);
+        } else {
+            FindGenericFontsPFG(name.mType, aLanguage, aClosure);
+        }
+    }
+
+    // if necessary, append default generic onto the end
+    if (mFamilyList.GetDefaultFontType() != eFamily_none &&
+        !mFamilyList.HasDefaultGeneric()) {
+        FindGenericFontsPFG(mFamilyList.GetDefaultFontType(),
+                            aLanguage, aClosure);
+    }
+}
+
+void
+gfxPangoFontGroup::FindPlatformFontPFG(const nsAString& fontName,
+                                       bool aUseFontSet,
+                                       void *aClosure)
+{
+    nsTArray<nsString> *list = static_cast<nsTArray<nsString>*>(aClosure);
+
+    if (!list->Contains(fontName)) {
+        // names present in the user fontset are not matched against system fonts
+        if (aUseFontSet && mUserFontSet && mUserFontSet->HasFamily(fontName)) {
+            nsAutoString userFontName =
+                NS_LITERAL_STRING(FONT_FACE_FAMILY_PREFIX) + fontName;
+            list->AppendElement(userFontName);
+        } else {
+            list->AppendElement(fontName);
+        }
+    }
+}
+
+gfxFcFont *
+gfxPangoFontGroup::GetBaseFont()
+{
+    if (mFonts[0].Font() == nullptr) {
+        gfxFont* font = GetBaseFontSet()->GetFontAt(0, GetStyle());
+        mFonts[0] = FamilyFace(nullptr, font);
+    }
+
+    return static_cast<gfxFcFont*>(mFonts[0].Font());
+}
+
+gfxFont*
+gfxPangoFontGroup::GetFirstValidFont(uint32_t aCh)
+{
+    return GetFontAt(0);
+}
+
+gfxFont *
+gfxPangoFontGroup::GetFontAt(int32_t i, uint32_t aCh)
+{
+    // If it turns out to be hard for all clients that cache font
+    // groups to call UpdateUserFonts at appropriate times, we could
+    // instead consider just calling UpdateUserFonts from someplace
+    // more central (such as here).
+    NS_ASSERTION(!mUserFontSet || mCurrGeneration == GetGeneration(),
+                 "Whoever was caching this font group should have "
+                 "called UpdateUserFonts on it");
+
+    NS_PRECONDITION(i == 0, "Only have one font");
+
+    return GetBaseFont();
+}
+
+void
+gfxPangoFontGroup::UpdateUserFonts()
+{
+    uint64_t newGeneration = GetGeneration();
+    if (newGeneration == mCurrGeneration)
+        return;
+
+    mFonts[0] = FamilyFace();
+    mFontSets.Clear();
+    ClearCachedData();
+    mCurrGeneration = newGeneration;
+}
+
+already_AddRefed<gfxFcFontSet>
+gfxPangoFontGroup::MakeFontSet(PangoLanguage *aLang, gfxFloat aSizeAdjustFactor,
+                               nsAutoRef<FcPattern> *aMatchPattern)
+{
+    const char *lang = pango_language_to_string(aLang);
+
+    RefPtr<nsIAtom> langGroup;
+    if (aLang != mPangoLanguage) {
+        // Set up langGroup for Mozilla's font prefs.
+        langGroup = NS_Atomize(lang);
+    }
+
+    AutoTArray<nsString, 20> fcFamilyList;
+    EnumerateFontListPFG(langGroup ? langGroup.get() : mStyle.language.get(),
+                         &fcFamilyList);
+
+    // To consider: A fontset cache here could be helpful.
+
+    // Get a pattern suitable for matching.
+    nsAutoRef<FcPattern> pattern
+        (gfxFontconfigUtils::NewPattern(fcFamilyList, mStyle, lang));
+
+    PrepareSortPattern(pattern, mStyle.size, aSizeAdjustFactor, mStyle.printerFont);
+
+    RefPtr<gfxFcFontSet> fontset =
+        new gfxFcFontSet(pattern, mUserFontSet);
+
+    mSkipDrawing = fontset->WaitingForUserFont();
+
+    if (aMatchPattern)
+        aMatchPattern->steal(pattern);
+
+    return fontset.forget();
+}
+
+gfxPangoFontGroup::
+FontSetByLangEntry::FontSetByLangEntry(PangoLanguage *aLang,
+                                       gfxFcFontSet *aFontSet)
+    : mLang(aLang), mFontSet(aFontSet)
+{
+}
+
+gfxFcFontSet *
+gfxPangoFontGroup::GetFontSet(PangoLanguage *aLang)
+{
+    GetBaseFontSet(); // sets mSizeAdjustFactor and mFontSets[0]
+
+    if (!aLang)
+        return mFontSets[0].mFontSet;
+
+    for (uint32_t i = 0; i < mFontSets.Length(); ++i) {
+        if (mFontSets[i].mLang == aLang)
+            return mFontSets[i].mFontSet;
+    }
+
+    RefPtr<gfxFcFontSet> fontSet =
+        MakeFontSet(aLang, mSizeAdjustFactor);
+    mFontSets.AppendElement(FontSetByLangEntry(aLang, fontSet));
+
+    return fontSet;
+}
+
+already_AddRefed<gfxFont>
+gfxPangoFontGroup::FindFontForChar(uint32_t aCh, uint32_t aPrevCh,
+                                   uint32_t aNextCh, Script aRunScript,
+                                   gfxFont *aPrevMatchedFont,
+                                   uint8_t *aMatchType)
+{
+    if (aPrevMatchedFont) {
+        // Don't switch fonts for control characters, regardless of
+        // whether they are present in the current font, as they won't
+        // actually be rendered (see bug 716229)
+        uint8_t category = GetGeneralCategory(aCh);
+        if (category == HB_UNICODE_GENERAL_CATEGORY_CONTROL) {
+            return RefPtr<gfxFont>(aPrevMatchedFont).forget();
+        }
+
+        // if this character is a join-control or the previous is a join-causer,
+        // use the same font as the previous range if we can
+        if (gfxFontUtils::IsJoinControl(aCh) ||
+            gfxFontUtils::IsJoinCauser(aPrevCh)) {
+            if (aPrevMatchedFont->HasCharacter(aCh)) {
+                return RefPtr<gfxFont>(aPrevMatchedFont).forget();
+            }
+        }
+    }
+
+    // if this character is a variation selector,
+    // use the previous font regardless of whether it supports VS or not.
+    // otherwise the text run will be divided.
+    if (gfxFontUtils::IsVarSelector(aCh)) {
+        if (aPrevMatchedFont) {
+            return RefPtr<gfxFont>(aPrevMatchedFont).forget();
+        }
+        // VS alone. it's meaningless to search different fonts
+        return nullptr;
+    }
+
+    // The real fonts that fontconfig provides for generic/fallback families
+    // depend on the language used, so a different FontSet is used for each
+    // language (except for the variation below).
+    //
+    //   With most fontconfig configurations any real family names prior to a
+    //   fontconfig generic with corresponding fonts installed will still lead
+    //   to the same leading fonts in each FontSet.
+    //
+    //   There is an inefficiency here therefore because the same base FontSet
+    //   could often be used if these real families support the character.
+    //   However, with fontconfig aliases, it is difficult to distinguish
+    //   where exactly alias fonts end and generic/fallback fonts begin.
+    //
+    // The variation from pure language-based matching used here is that the
+    // same primary/base font is always used irrespective of the language.
+    // This provides that SCRIPT_COMMON characters are consistently rendered
+    // with the same font (bug 339513 and bug 416725).  This is particularly
+    // important with the word cache as script can't be reliably determined
+    // from surrounding words.  It also often avoids the unnecessary extra
+    // FontSet efficiency mentioned above.
+    //
+    // However, in two situations, the base font is not checked before the
+    // language-specific FontSet.
+    //
+    //   1. When we don't have a language to make a good choice for
+    //      the base font.
+    //
+    //   2. For system fonts, use the default Pango behavior to give
+    //      consistency with other apps.  This is relevant when un-localized
+    //      builds are run in non-Latin locales.  This special-case probably
+    //      wouldn't be necessary but for bug 91190.
+
+    gfxFcFontSet *fontSet = GetBaseFontSet();
+    uint32_t nextFont = 0;
+    FcPattern *basePattern = nullptr;
+    if (!mStyle.systemFont && mPangoLanguage) {
+        basePattern = fontSet->GetFontPatternAt(0);
+        if (HasChar(basePattern, aCh)) {
+            *aMatchType = gfxTextRange::kFontGroup;
+            return RefPtr<gfxFont>(GetBaseFont()).forget();
+        }
+
+        nextFont = 1;
+    }
+
+    // Our MOZ_SCRIPT_* codes may not match the PangoScript enumeration values
+    // (if we're using ICU's codes), so convert by mapping through ISO 15924 tag.
+    // Note that PangoScript is defined to be compatible with GUnicodeScript:
+    // https://developer.gnome.org/pango/stable/pango-Scripts-and-Languages.html#PangoScript
+    const hb_tag_t scriptTag = GetScriptTagForCode(aRunScript);
+    const PangoScript script =
+      (const PangoScript)hb_glib_script_from_script(hb_script_from_iso15924_tag(scriptTag));
+
+    // Might be nice to call pango_language_includes_script only once for the
+    // run rather than for each character.
+    PangoLanguage *scriptLang;
+    if ((!basePattern ||
+         !pango_language_includes_script(mPangoLanguage, script)) &&
+        (scriptLang = pango_script_get_sample_language(script))) {
+        fontSet = GetFontSet(scriptLang);
+        nextFont = 0;
+    }
+
+    for (uint32_t i = nextFont;
+         FcPattern *pattern = fontSet->GetFontPatternAt(i);
+         ++i) {
+        if (pattern == basePattern) {
+            continue; // already checked basePattern
+        }
+
+        if (HasChar(pattern, aCh)) {
+            *aMatchType = gfxTextRange::kFontGroup;
+            return RefPtr<gfxFont>(fontSet->GetFontAt(i, GetStyle())).forget();
+        }
+    }
+
+    return nullptr;
+}
+
+/**
+ ** gfxFcFont
+ **/
+
+cairo_user_data_key_t gfxFcFont::sGfxFontKey;
+
+gfxFcFont::gfxFcFont(cairo_scaled_font_t *aCairoFont,
+                     FcPattern *aPattern,
+                     gfxFcFontEntry *aFontEntry,
+                     const gfxFontStyle *aFontStyle)
+    : gfxFontconfigFontBase(aCairoFont, aPattern, aFontEntry, aFontStyle)
+{
+    cairo_scaled_font_set_user_data(mScaledFont, &sGfxFontKey, this, nullptr);
+}
+
+gfxFcFont::~gfxFcFont()
+{
+    cairo_scaled_font_set_user_data(mScaledFont,
+                                    &sGfxFontKey,
+                                    nullptr,
+                                    nullptr);
+}
+
+already_AddRefed<gfxFont>
+gfxFcFont::GetSubSuperscriptFont(int32_t aAppUnitsPerDevPixel)
+{
+    gfxFontStyle style(*GetStyle());
+    style.AdjustForSubSuperscript(aAppUnitsPerDevPixel);
+    return MakeScaledFont(&style, style.size / GetStyle()->size);
+}
+
+already_AddRefed<gfxFont>
+gfxFcFont::MakeScaledFont(gfxFontStyle *aFontStyle, gfxFloat aScaleFactor)
+{
+    gfxFcFontEntry* fe = static_cast<gfxFcFontEntry*>(GetFontEntry());
+    RefPtr<gfxFont> font =
+        gfxFontCache::GetCache()->Lookup(fe, aFontStyle, nullptr);
+    if (font) {
+        return font.forget();
+    }
+
+    cairo_matrix_t fontMatrix;
+    cairo_scaled_font_get_font_matrix(mScaledFont, &fontMatrix);
+    cairo_matrix_scale(&fontMatrix, aScaleFactor, aScaleFactor);
+
+    cairo_matrix_t ctm;
+    cairo_scaled_font_get_ctm(mScaledFont, &ctm);
+
+    cairo_font_options_t *options = cairo_font_options_create();
+    cairo_scaled_font_get_font_options(mScaledFont, options);
+
+    cairo_scaled_font_t *newFont =
+        cairo_scaled_font_create(cairo_scaled_font_get_font_face(mScaledFont),
+                                 &fontMatrix, &ctm, options);
+    cairo_font_options_destroy(options);
+
+    font = new gfxFcFont(newFont, GetPattern(), fe, aFontStyle);
+    gfxFontCache::GetCache()->AddNew(font);
+    cairo_scaled_font_destroy(newFont);
+
+    return font.forget();
+}
+
+already_AddRefed<gfxFont>
+gfxFcFont::GetSmallCapsFont()
+{
+    gfxFontStyle style(*GetStyle());
+    style.size *= SMALL_CAPS_SCALE_FACTOR;
+    style.variantCaps = NS_FONT_VARIANT_CAPS_NORMAL;
+    return MakeScaledFont(&style, SMALL_CAPS_SCALE_FACTOR);
+}
+
+/* static */ void
+gfxPangoFontGroup::Shutdown()
+{
+    // Resetting gFTLibrary in case this is wanted again after a
+    // cairo_debug_reset_static_data.
+    gFTLibrary = nullptr;
+}
+
+/* static */ gfxFontEntry *
+gfxPangoFontGroup::NewFontEntry(const nsAString& aFontName,
+                                uint16_t aWeight,
+                                int16_t aStretch,
+                                uint8_t aStyle)
+{
+    gfxFontconfigUtils *utils = gfxFontconfigUtils::GetFontconfigUtils();
+    if (!utils)
+        return nullptr;
+
+    // The font face name from @font-face { src: local() } is not well
+    // defined.
+    //
+    // On MS Windows, this name gets compared with
+    // ENUMLOGFONTEXW::elfFullName, which for OpenType fonts seems to be the
+    // full font name from the name table.  For CFF OpenType fonts this is the
+    // same as the PostScript name, but for TrueType fonts it is usually
+    // different.
+    //
+    // On Mac, the font face name is compared with the PostScript name, even
+    // for TrueType fonts.
+    //
+    // Fontconfig only records the full font names, so the behavior here
+    // follows that on MS Windows.  However, to provide the possibility
+    // of aliases to compensate for variations, the font face name is passed
+    // through FcConfigSubstitute.
+
+    nsAutoRef<FcPattern> pattern(FcPatternCreate());
+    if (!pattern)
+        return nullptr;
+
+    NS_ConvertUTF16toUTF8 fullname(aFontName);
+    FcPatternAddString(pattern, FC_FULLNAME,
+                       gfxFontconfigUtils::ToFcChar8(fullname));
+    FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
+
+    FcChar8 *name;
+    for (int v = 0;
+         FcPatternGetString(pattern, FC_FULLNAME, v, &name) == FcResultMatch;
+         ++v) {
+        const nsTArray< nsCountedRef<FcPattern> >& fonts =
+            utils->GetFontsForFullname(name);
+
+        if (fonts.Length() != 0)
+            return new gfxLocalFcFontEntry(aFontName,
+                                           aWeight,
+                                           aStretch,
+                                           aStyle,
+                                           fonts);
+    }
+
+    return nullptr;
+}
+
+/* static */ FT_Library
+gfxPangoFontGroup::GetFTLibrary()
+{
+    if (!gFTLibrary) {
+        // Use cairo's FT_Library so that cairo takes care of shutdown of the
+        // FT_Library after it has destroyed its font_faces, and FT_Done_Face
+        // has been called on each FT_Face, at least until this bug is fixed:
+        // https://bugs.freedesktop.org/show_bug.cgi?id=18857
+        //
+        // Cairo's FT_Library can be obtained from any cairo_scaled_font.  The
+        // font properties requested here are chosen to get an FT_Face that is
+        // likely to be also used elsewhere.
+        gfxFontStyle style;
+        RefPtr<gfxPangoFontGroup> fontGroup =
+            new gfxPangoFontGroup(FontFamilyList(eFamily_sans_serif),
+                                  &style, nullptr, 1.0);
+
+        gfxFcFont *font = fontGroup->GetBaseFont();
+        if (!font)
+            return nullptr;
+
+        gfxFT2LockedFace face(font);
+        if (!face.get())
+            return nullptr;
+
+        gFTLibrary = face.get()->glyph->library;
+    }
+
+    return gFTLibrary;
+}
+
+/* static */ gfxFontEntry *
+gfxPangoFontGroup::NewFontEntry(const nsAString& aFontName,
+                                uint16_t aWeight,
+                                int16_t aStretch,
+                                uint8_t aStyle,
+                                const uint8_t* aFontData,
+                                uint32_t aLength)
+{
+    // Ownership of aFontData is passed in here, and transferred to the
+    // new fontEntry, which will release it when no longer needed.
+
+    // Using face_index = 0 for the first face in the font, as we have no
+    // other information.  FT_New_Memory_Face checks for a nullptr FT_Library.
+    FT_Face face;
+    FT_Error error =
+        FT_New_Memory_Face(GetFTLibrary(), aFontData, aLength, 0, &face);
+    if (error != 0) {
+        free((void*)aFontData);
+        return nullptr;
+    }
+
+    return new gfxDownloadedFcFontEntry(aFontName, aWeight,
+                                        aStretch, aStyle,
+                                        aFontData, face);
+}
+
+
+static double
+GetPixelSize(FcPattern *aPattern)
+{
+    double size;
+    if (FcPatternGetDouble(aPattern,
+                           FC_PIXEL_SIZE, 0, &size) == FcResultMatch)
+        return size;
+
+    NS_NOTREACHED("No size on pattern");
+    return 0.0;
+}
+
+/**
+ * The following gfxFcFonts are accessed from the cairo_scaled_font or created
+ * from the FcPattern, not from the gfxFontCache hash table.  The gfxFontCache
+ * hash table is keyed by desired family and style, whereas here we only know
+ * actual family and style.  There may be more than one of these fonts with
+ * the same family and style, but different PangoFont and actual font face.
+ * 
+ * The point of this is to record the exact font face for gfxTextRun glyph
+ * indices.  The style of this font does not necessarily represent the exact
+ * gfxFontStyle used to build the text run.  Notably, the language is not
+ * recorded.
+ */
+
+/* static */
+already_AddRefed<gfxFcFont>
+gfxFcFont::GetOrMakeFont(FcPattern *aRequestedPattern, FcPattern *aFontPattern,
+                         const gfxFontStyle *aFontStyle)
+{
+    nsAutoRef<FcPattern> renderPattern
+        (FcFontRenderPrepare(nullptr, aRequestedPattern, aFontPattern));
+
+    // If synthetic bold/italic is not allowed by the style, adjust the
+    // resulting pattern to match the actual properties of the font.
+    if (!aFontStyle->allowSyntheticWeight) {
+        int weight;
+        if (FcPatternGetInteger(aFontPattern, FC_WEIGHT, 0,
+                                &weight) == FcResultMatch) {
+            FcPatternDel(renderPattern, FC_WEIGHT);
+            FcPatternAddInteger(renderPattern, FC_WEIGHT, weight);
+        }
+    }
+    if (!aFontStyle->allowSyntheticStyle) {
+        int slant;
+        if (FcPatternGetInteger(aFontPattern, FC_SLANT, 0,
+                                &slant) == FcResultMatch) {
+            FcPatternDel(renderPattern, FC_SLANT);
+            FcPatternAddInteger(renderPattern, FC_SLANT, slant);
+        }
+    }
+
+    cairo_font_face_t *face =
+        cairo_ft_font_face_create_for_pattern(renderPattern);
+
+    // Reuse an existing font entry if available.
+    RefPtr<gfxFcFontEntry> fe = gfxFcFontEntry::LookupFontEntry(face);
+    if (!fe) {
+        gfxDownloadedFcFontEntry *downloadedFontEntry =
+            GetDownloadedFontEntry(aFontPattern);
+        if (downloadedFontEntry) {
+            // Web font
+            fe = downloadedFontEntry;
+            if (cairo_font_face_status(face) == CAIRO_STATUS_SUCCESS) {
+                // cairo_font_face_t is using the web font data.
+                // Hold a reference to the font entry to keep the font face
+                // data.
+                if (!downloadedFontEntry->SetCairoFace(face)) {
+                    // OOM.  Let cairo pick a fallback font
+                    cairo_font_face_destroy(face);
+                    face = cairo_ft_font_face_create_for_pattern(aRequestedPattern);
+                    fe = gfxFcFontEntry::LookupFontEntry(face);
+                }
+            }
+        }
+        if (!fe) {
+            // Get a unique name for the font face from the file and id.
+            nsAutoString name;
+            FcChar8 *fc_file;
+            if (FcPatternGetString(renderPattern,
+                                   FC_FILE, 0, &fc_file) == FcResultMatch) {
+                int index;
+                if (FcPatternGetInteger(renderPattern,
+                                        FC_INDEX, 0, &index) != FcResultMatch) {
+                    // cairo defaults to 0.
+                    index = 0;
+                }
+
+                AppendUTF8toUTF16(gfxFontconfigUtils::ToCString(fc_file), name);
+                if (index != 0) {
+                    name.Append('/');
+                    name.AppendInt(index);
+                }
+            }
+
+            fe = new gfxSystemFcFontEntry(face, aFontPattern, name);
+        }
+    }
+
+    gfxFontStyle style(*aFontStyle);
+    style.size = GetPixelSize(renderPattern);
+    style.style = gfxFontconfigUtils::GetThebesStyle(renderPattern);
+    style.weight = gfxFontconfigUtils::GetThebesWeight(renderPattern);
+
+    RefPtr<gfxFont> font =
+        gfxFontCache::GetCache()->Lookup(fe, &style, nullptr);
+    if (!font) {
+        // Note that a file/index pair (or FT_Face) and the gfxFontStyle are
+        // not necessarily enough to provide a key that will describe a unique
+        // font.  cairoFont contains information from renderPattern, which is a
+        // fully resolved pattern from FcFontRenderPrepare.
+        // FcFontRenderPrepare takes the requested pattern and the face
+        // pattern as input and can modify elements of the resulting pattern
+        // that affect rendering but are not included in the gfxFontStyle.
+        cairo_scaled_font_t *cairoFont = CreateScaledFont(renderPattern, face);
+        font = new gfxFcFont(cairoFont, renderPattern, fe, &style);
+        gfxFontCache::GetCache()->AddNew(font);
+        cairo_scaled_font_destroy(cairoFont);
+    }
+
+    cairo_font_face_destroy(face);
+
+    RefPtr<gfxFcFont> retval(static_cast<gfxFcFont*>(font.get()));
+    return retval.forget();
+}
+
+gfxFcFontSet *
+gfxPangoFontGroup::GetBaseFontSet()
+{
+    if (mFontSets.Length() > 0)
+        return mFontSets[0].mFontSet;
+
+    mSizeAdjustFactor = 1.0; // will be adjusted below if necessary
+    nsAutoRef<FcPattern> pattern;
+    RefPtr<gfxFcFontSet> fontSet =
+        MakeFontSet(mPangoLanguage, mSizeAdjustFactor, &pattern);
+
+    double size = GetPixelSize(pattern);
+    if (size != 0.0 && mStyle.sizeAdjust > 0.0) {
+        gfxFcFont *font = fontSet->GetFontAt(0, GetStyle());
+        if (font) {
+            const gfxFont::Metrics& metrics =
+                font->GetMetrics(gfxFont::eHorizontal); // XXX vertical?
+
+            // The factor of 0.1 ensures that xHeight is sane so fonts don't
+            // become huge.  Strictly ">" ensures that xHeight and emHeight are
+            // not both zero.
+            if (metrics.xHeight > 0.1 * metrics.emHeight) {
+                mSizeAdjustFactor =
+                    mStyle.sizeAdjust * metrics.emHeight / metrics.xHeight;
+
+                size *= mSizeAdjustFactor;
+                FcPatternDel(pattern, FC_PIXEL_SIZE);
+                FcPatternAddDouble(pattern, FC_PIXEL_SIZE, size);
+
+                fontSet = new gfxFcFontSet(pattern, mUserFontSet);
+            }
+        }
+    }
+
+    PangoLanguage *pangoLang = mPangoLanguage;
+    FcChar8 *fcLang;
+    if (!pangoLang &&
+        FcPatternGetString(pattern, FC_LANG, 0, &fcLang) == FcResultMatch) {
+        pangoLang =
+            pango_language_from_string(gfxFontconfigUtils::ToCString(fcLang));
+    }
+
+    mFontSets.AppendElement(FontSetByLangEntry(pangoLang, fontSet));
+
+    return fontSet;
+}
+
+/**
+ ** gfxTextRun
+ * 
+ * A serious problem:
+ *
+ * -- We draw with a font that's hinted for the CTM, but we measure with a font
+ * hinted to the identity matrix, so our "bounding metrics" may not be accurate.
+ * 
+ **/
+
+// This will fetch an existing scaled_font if one exists.
+static cairo_scaled_font_t *
+CreateScaledFont(FcPattern *aPattern, cairo_font_face_t *aFace)
+{
+    double size = GetPixelSize(aPattern);
+        
+    cairo_matrix_t fontMatrix;
+    FcMatrix *fcMatrix;
+    if (FcPatternGetMatrix(aPattern, FC_MATRIX, 0, &fcMatrix) == FcResultMatch)
+        cairo_matrix_init(&fontMatrix, fcMatrix->xx, -fcMatrix->yx, -fcMatrix->xy, fcMatrix->yy, 0, 0);
+    else
+        cairo_matrix_init_identity(&fontMatrix);
+    cairo_matrix_scale(&fontMatrix, size, size);
+
+    FcBool printing;
+    if (FcPatternGetBool(aPattern, PRINTING_FC_PROPERTY, 0, &printing) != FcResultMatch) {
+        printing = FcFalse;
+    }
+
+    // The cairo_scaled_font is created with a unit ctm so that metrics and
+    // positions are in user space, but this means that hinting effects will
+    // not be estimated accurately for non-unit transformations.
+    cairo_matrix_t identityMatrix;
+    cairo_matrix_init_identity(&identityMatrix);
+
+    // Font options are set explicitly here to improve cairo's caching
+    // behavior and to record the relevant parts of the pattern for
+    // SetupCairoFont (so that the pattern can be released).
+    //
+    // Most font_options have already been set as defaults on the FcPattern
+    // with cairo_ft_font_options_substitute(), then user and system
+    // fontconfig configurations were applied.  The resulting font_options
+    // have been recorded on the face during
+    // cairo_ft_font_face_create_for_pattern().
+    //
+    // None of the settings here cause this scaled_font to behave any
+    // differently from how it would behave if it were created from the same
+    // face with default font_options.
+    //
+    // We set options explicitly so that the same scaled_font will be found in
+    // the cairo_scaled_font_map when cairo loads glyphs from a context with
+    // the same font_face, font_matrix, ctm, and surface font_options.
+    //
+    // Unfortunately, _cairo_scaled_font_keys_equal doesn't know about the
+    // font_options on the cairo_ft_font_face, and doesn't consider default
+    // option values to not match any explicit values.
+    //
+    // Even after cairo_set_scaled_font is used to set font_options for the
+    // cairo context, when cairo looks for a scaled_font for the context, it
+    // will look for a font with some option values from the target surface if
+    // any values are left default on the context font_options.  If this
+    // scaled_font is created with default font_options, cairo will not find
+    // it.
+    cairo_font_options_t *fontOptions = cairo_font_options_create();
+
+    // The one option not recorded in the pattern is hint_metrics, which will
+    // affect glyph metrics.  The default behaves as CAIRO_HINT_METRICS_ON.
+    // We should be considering the font_options of the surface on which this
+    // font will be used, but currently we don't have different gfxFonts for
+    // different surface font_options, so we'll create a font suitable for the
+    // Screen. Image and xlib surfaces default to CAIRO_HINT_METRICS_ON.
+    if (printing) {
+        cairo_font_options_set_hint_metrics(fontOptions, CAIRO_HINT_METRICS_OFF);
+    } else {
+        cairo_font_options_set_hint_metrics(fontOptions, CAIRO_HINT_METRICS_ON);
+    }
+
+    // The remaining options have been recorded on the pattern and the face.
+    // _cairo_ft_options_merge has some logic to decide which options from the
+    // scaled_font or from the cairo_ft_font_face take priority in the way the
+    // font behaves.
+    //
+    // In the majority of cases, _cairo_ft_options_merge uses the options from
+    // the cairo_ft_font_face, so sometimes it is not so important which
+    // values are set here so long as they are not defaults, but we'll set
+    // them to the exact values that we expect from the font, to be consistent
+    // and to protect against changes in cairo.
+    //
+    // In some cases, _cairo_ft_options_merge uses some options from the
+    // scaled_font's font_options rather than options on the
+    // cairo_ft_font_face (from fontconfig).
+    // https://bugs.freedesktop.org/show_bug.cgi?id=11838
+    //
+    // Surface font options were set on the pattern in
+    // cairo_ft_font_options_substitute.  If fontconfig has changed the
+    // hint_style then that is what the user (or distribution) wants, so we
+    // use the setting from the FcPattern.
+    //
+    // Fallback values here mirror treatment of defaults in cairo-ft-font.c.
+    FcBool hinting = FcFalse;
+    if (FcPatternGetBool(aPattern, FC_HINTING, 0, &hinting) != FcResultMatch) {
+        hinting = FcTrue;
+    }
+
+    cairo_hint_style_t hint_style;
+    if (printing || !hinting) {
+        hint_style = CAIRO_HINT_STYLE_NONE;
+    } else {
+#ifdef FC_HINT_STYLE  // FC_HINT_STYLE is available from fontconfig 2.2.91.
+        int fc_hintstyle;
+        if (FcPatternGetInteger(aPattern, FC_HINT_STYLE,
+                                0, &fc_hintstyle        ) != FcResultMatch) {
+            fc_hintstyle = FC_HINT_FULL;
+        }
+        switch (fc_hintstyle) {
+            case FC_HINT_NONE:
+                hint_style = CAIRO_HINT_STYLE_NONE;
+                break;
+            case FC_HINT_SLIGHT:
+                hint_style = CAIRO_HINT_STYLE_SLIGHT;
+                break;
+            case FC_HINT_MEDIUM:
+            default: // This fallback mirrors _get_pattern_ft_options in cairo.
+                hint_style = CAIRO_HINT_STYLE_MEDIUM;
+                break;
+            case FC_HINT_FULL:
+                hint_style = CAIRO_HINT_STYLE_FULL;
+                break;
+        }
+#else // no FC_HINT_STYLE
+        hint_style = CAIRO_HINT_STYLE_FULL;
+#endif
+    }
+    cairo_font_options_set_hint_style(fontOptions, hint_style);
+
+    int rgba;
+    if (FcPatternGetInteger(aPattern,
+                            FC_RGBA, 0, &rgba) != FcResultMatch) {
+        rgba = FC_RGBA_UNKNOWN;
+    }
+    cairo_subpixel_order_t subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
+    switch (rgba) {
+        case FC_RGBA_UNKNOWN:
+        case FC_RGBA_NONE:
+        default:
+            // There is no CAIRO_SUBPIXEL_ORDER_NONE.  Subpixel antialiasing
+            // is disabled through cairo_antialias_t.
+            rgba = FC_RGBA_NONE;
+            // subpixel_order won't be used by the font as we won't use
+            // CAIRO_ANTIALIAS_SUBPIXEL, but don't leave it at default for
+            // caching reasons described above.  Fall through:
+            MOZ_FALLTHROUGH;
+        case FC_RGBA_RGB:
+            subpixel_order = CAIRO_SUBPIXEL_ORDER_RGB;
+            break;
+        case FC_RGBA_BGR:
+            subpixel_order = CAIRO_SUBPIXEL_ORDER_BGR;
+            break;
+        case FC_RGBA_VRGB:
+            subpixel_order = CAIRO_SUBPIXEL_ORDER_VRGB;
+            break;
+        case FC_RGBA_VBGR:
+            subpixel_order = CAIRO_SUBPIXEL_ORDER_VBGR;
+            break;
+    }
+    cairo_font_options_set_subpixel_order(fontOptions, subpixel_order);
+
+    FcBool fc_antialias;
+    if (FcPatternGetBool(aPattern,
+                         FC_ANTIALIAS, 0, &fc_antialias) != FcResultMatch) {
+        fc_antialias = FcTrue;
+    }
+    cairo_antialias_t antialias;
+    if (!fc_antialias) {
+        antialias = CAIRO_ANTIALIAS_NONE;
+    } else if (rgba == FC_RGBA_NONE) {
+        antialias = CAIRO_ANTIALIAS_GRAY;
+    } else {
+        antialias = CAIRO_ANTIALIAS_SUBPIXEL;
+    }
+    cairo_font_options_set_antialias(fontOptions, antialias);
+
+    cairo_scaled_font_t *scaledFont =
+        cairo_scaled_font_create(aFace, &fontMatrix, &identityMatrix,
+                                 fontOptions);
+
+    cairo_font_options_destroy(fontOptions);
+
+    NS_ASSERTION(cairo_scaled_font_status(scaledFont) == CAIRO_STATUS_SUCCESS,
+                 "Failed to create scaled font");
+    return scaledFont;
+}
+
+/* static */
+PangoLanguage *
+GuessPangoLanguage(nsIAtom *aLanguage)
+{
+    if (!aLanguage)
+        return nullptr;
+
+    // Pango and fontconfig won't understand mozilla's internal langGroups, so
+    // find a real language.
+    nsAutoCString lang;
+    gfxFontconfigUtils::GetSampleLangForGroup(aLanguage, &lang);
+    if (lang.IsEmpty())
+        return nullptr;
+
+    return pango_language_from_string(lang.get());
+}
+
+#ifdef MOZ_WIDGET_GTK
+/***************************************************************************
+ *
+ * This function must be last in the file because it uses the system cairo
+ * library.  Above this point the cairo library used is the tree cairo if
+ * MOZ_TREE_CAIRO.
+ */
+
+#if MOZ_TREE_CAIRO
+// Tree cairo symbols have different names.  Disable their activation through
+// preprocessor macros.
+#undef cairo_ft_font_options_substitute
+
+// The system cairo functions are not declared because the include paths cause
+// the gdk headers to pick up the tree cairo.h.
+extern "C" {
+NS_VISIBILITY_DEFAULT void
+cairo_ft_font_options_substitute (const cairo_font_options_t *options,
+                                  FcPattern                  *pattern);
+}
+#endif
+
+static void
+ApplyGdkScreenFontOptions(FcPattern *aPattern)
+{
+    const cairo_font_options_t *options =
+        gdk_screen_get_font_options(gdk_screen_get_default());
+
+    cairo_ft_font_options_substitute(options, aPattern);
+}
+
+#endif // MOZ_WIDGET_GTK
+