The Tor Browser: gfx/thebes/gfxPangoFonts.cpp@97036ab72558 (annotated)

gfx/thebes/gfxPangoFonts.cpp@97036ab72558 (annotated)

gfx/thebes/gfxPangoFonts.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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
 #ifdef MOZ_WIDGET_QT
 #include "gfxQtPlatform.h"
 #endif
 #include "gfxPangoFonts.h"
 #include "gfxFT2FontBase.h"
 #include "gfxFT2Utils.h"
 #include "harfbuzz/hb.h"
 #include "harfbuzz/hb-ot.h"
 #include "gfxHarfBuzzShaper.h"
 #include "gfxGraphiteShaper.h"
 #include "nsUnicodeProperties.h"
 #include "nsUnicodeScriptCodes.h"
 #include "gfxFontconfigUtils.h"
 #include "gfxUserFontSet.h"
 #include "gfxFontConstants.h"
 #include <cairo.h>
 #include <cairo-ft.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:
     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.
     AutoFallibleTArray<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.AppendLiteral(" ");
                 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.AppendElement();
         // mPatterns is an nsAutoTArray with 1 space always available, so the
         // AppendElement always succeeds.
         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();
     virtual void ReleaseGrFace(gr_face* aFace);
 protected:
     virtual nsresult
     CopyFontTable(uint32_t aTableTag, FallibleTArray<uint8_t>& aBuffer) MOZ_OVERRIDE;
     void MaybeReleaseFTFace();
 private:
     cairo_font_face_t *mFontFace;
     FT_Face            mFTFace;
     bool               mFTFaceInitialized;
 };
 nsresult
 gfxSystemFcFontEntry::CopyFontTable(uint32_t aTableTag,
                                     FallibleTArray<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)) {
         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:
     gfxUserFcFontEntry(const gfxProxyFontEntry &aProxyEntry)
         : gfxFcFontEntry(aProxyEntry.Name())
     {
         mItalic = aProxyEntry.mItalic;
         mWeight = aProxyEntry.mWeight;
         mStretch = aProxyEntry.mStretch;
         mIsUserFont = true;
     }
     // 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 gfxProxyFontEntry &aProxyEntry,
                         const nsTArray< nsCountedRef<FcPattern> >& aPatterns)
         : gfxUserFcFontEntry(aProxyEntry)
     {
         if (!mPatterns.SetCapacity(aPatterns.Length()))
             return; // OOM
         for (uint32_t i = 0; i < aPatterns.Length(); ++i) {
             FcPattern *pattern = FcPatternDuplicate(aPatterns.ElementAt(i));
             if (!pattern)
                 return; // OOM
             AdjustPatternToCSS(pattern);
             mPatterns.AppendElement();
             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 gfxProxyFontEntry &aProxyEntry,
                              const uint8_t *aData, FT_Face aFace)
         : gfxUserFcFontEntry(aProxyEntry), mFontData(aData), mFace(aFace)
     {
         NS_PRECONDITION(aFace != nullptr, "aFace is NULL!");
         InitPattern();
     }
     virtual ~gfxDownloadedFcFontEntry();
     // Returns true on success
     bool SetCairoFace(cairo_font_face_t *aFace);
     virtual hb_blob_t* GetFontTable(uint32_t aTableTag) MOZ_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 NS_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);
     NS_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(""),
 ,
                              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
     mPatterns.AppendElement();
     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 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 gfxFT2FontBase {
 public:
     virtual ~gfxFcFont();
     static already_AddRefed<gfxFcFont>
     GetOrMakeFont(FcPattern *aRequestedPattern, FcPattern *aFontPattern,
                   const gfxFontStyle *aFontStyle);
 #ifdef USE_SKIA
     virtual mozilla::TemporaryRef<mozilla::gfx::GlyphRenderingOptions> GetGlyphRenderingOptions();
 #endif
 protected:
     virtual bool ShapeText(gfxContext      *aContext,
                            const char16_t *aText,
                            uint32_t         aOffset,
                            uint32_t         aLength,
                            int32_t          aScript,
                            gfxShapedText   *aShapedText,
                            bool             aPreferPlatformShaping);
     bool InitGlyphRunWithPango(const char16_t *aString,
                                uint32_t         aOffset,
                                uint32_t         aLength,
                                int32_t          aScript,
                                gfxShapedText   *aShapedText);
 private:
     gfxFcFont(cairo_scaled_font_t *aCairoFont, 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 MOZ_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;
         nsRefPtr<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
     nsRefPtr<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->GetFamily(utf16Family);
     if (family) {
         fontEntry = static_cast<gfxUserFcFontEntry*>
             (mUserFontSet->FindFontEntry(family, style, needsBold,
                                          aWaitForUserFont));
         // Accept synthetic oblique for italic and oblique.
         if (!fontEntry && aStyle != NS_FONT_STYLE_NORMAL) {
             style.style = NS_FONT_STYLE_NORMAL;
             fontEntry = static_cast<gfxUserFcFontEntry*>
                 (mUserFontSet->FindFontEntry(family, style, needsBold,
                                              aWaitForUserFont));
         }
     }
     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.)
     nsAutoTArray<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(50);
     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?
         // XXX: Make use of this + pass to nsFont??
         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 *entry =
             existingFamilies.PutEntry(family);
         if (entry) {
             if (entry->mKey) // old entry
                 continue;
             entry->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->FindFontEntry().
             if (requestedSize != -1.0 && !SizeIsAcceptable(font, requestedSize))
                 continue;
             for (uint32_t r = 0; r < requiredLangs.Length(); ++r) {
                 const LangSupportEntry& entry = requiredLangs[r];
                 FcLangResult support =
                     gfxFontconfigUtils::GetLangSupport(font, entry.mLang);
                 if (support <= entry.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_GFX_OPTIMIZE_MOBILE
        cairo_font_options_t *options = cairo_font_options_create();
        cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE);
        cairo_ft_font_options_substitute(options, aPattern);
        cairo_font_options_destroy(options);
 #endif
 #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
  **/
 struct FamilyCallbackData {
     FamilyCallbackData(nsTArray<nsString> *aFcFamilyList,
                        gfxUserFontSet *aUserFontSet)
         : mFcFamilyList(aFcFamilyList), mUserFontSet(aUserFontSet)
     {
     }
     nsTArray<nsString> *mFcFamilyList;
     const gfxUserFontSet *mUserFontSet;
 };
 static int
 FFRECountHyphens (const nsAString &aFFREName)
 {
     int h = 0;
     int32_t hyphen = 0;
     while ((hyphen = aFFREName.FindChar('-', hyphen)) >= 0) {
         ++h;
         ++hyphen;
     }
     return h;
 }
 static bool
 FamilyCallback (const nsAString& fontName, const nsACString& genericName,
                 bool aUseFontSet, void *closure)
 {
     FamilyCallbackData *data = static_cast<FamilyCallbackData*>(closure);
     nsTArray<nsString> *list = data->mFcFamilyList;
     // We ignore prefs that have three hypens since they are X style prefs.
     if (genericName.Length() && FFRECountHyphens(fontName) >= 3)
         return true;
     if (!list->Contains(fontName)) {
         // The family properties of FcPatterns for @font-face fonts have a
         // namespace to identify them among system fonts.  (see
         // FONT_FACE_FAMILY_PREFIX.)
         //
         // Earlier versions of this code allowed the CSS family name to match
         // either the @font-face family or the system font family, so both
         // were added here. This was in accordance with earlier versions of
         // the W3C specifications regarding @font-face.
         //
         // The current (2011-02-27) draft of CSS3 Fonts says
         //
         // (Section 4.2: Font family: the font-family descriptor):
         // "If the font family name is the same as a font family available in
         // a given user's environment, it effectively hides the underlying
         // font for documents that use the stylesheet."
         //
         // (Section 5: Font matching algorithm)
         // "... the user agent attempts to find the family name among fonts
         // defined via @font-face rules and then among available system fonts,
         // .... If a font family defined via @font-face rules contains only
         // invalid font data, it should be considered as if a font was present
         // but contained an empty character map; matching a platform font with
         // the same name must not occur in this case."
         //
         // Therefore, for names present in the user font set, this code no
         // longer includes the family name for matching against system fonts.
         //
         const gfxUserFontSet *userFontSet = data->mUserFontSet;
         if (aUseFontSet && genericName.Length() == 0 &&
             userFontSet && userFontSet->HasFamily(fontName)) {
             nsAutoString userFontName =
                 NS_LITERAL_STRING(FONT_FACE_FAMILY_PREFIX) + fontName;
             list->AppendElement(userFontName);
         } else {
             list->AppendElement(fontName);
         }
     }
     return true;
 }
 gfxPangoFontGroup::gfxPangoFontGroup (const nsAString& families,
                                       const gfxFontStyle *aStyle,
                                       gfxUserFontSet *aUserFontSet)
     : gfxFontGroup(families, aStyle, aUserFontSet),
       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 = do_GetAtom(pango_language_to_string(mPangoLanguage));
     }
     // dummy entry, will be replaced when actually needed
     mFonts.AppendElement(FamilyFace());
 }
 gfxPangoFontGroup::~gfxPangoFontGroup()
 {
 }
 gfxFontGroup *
 gfxPangoFontGroup::Copy(const gfxFontStyle *aStyle)
 {
     return new gfxPangoFontGroup(mFamilies, aStyle, mUserFontSet);
 }
 // An array of family names suitable for fontconfig
 void
 gfxPangoFontGroup::GetFcFamilies(nsTArray<nsString> *aFcFamilyList,
                                  nsIAtom *aLanguage)
 {
     FamilyCallbackData data(aFcFamilyList, mUserFontSet);
     // Leave non-existing fonts in the list so that fontconfig can get the
     // best match.
     ForEachFontInternal(mFamilies, aLanguage, true, false, true,
                         FamilyCallback, &data);
 }
 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::GetFontAt(int32_t i)
 {
     // If it turns out to be hard for all clients that cache font
     // groups to call UpdateFontList at appropriate times, we could
     // instead consider just calling UpdateFontList from someplace
     // more central (such as here).
     NS_ASSERTION(!mUserFontSet || mCurrGeneration == GetGeneration(),
                  "Whoever was caching this font group should have "
                  "called UpdateFontList on it");
     NS_PRECONDITION(i == 0, "Only have one font");
     return GetBaseFont();
 }
 void
 gfxPangoFontGroup::UpdateFontList()
 {
     uint64_t newGeneration = GetGeneration();
     if (newGeneration == mCurrGeneration)
         return;
     mFonts[0] = FamilyFace();
     mFontSets.Clear();
     mCachedEllipsisTextRun = nullptr;
     mUnderlineOffset = UNDERLINE_OFFSET_NOT_SET;
     mCurrGeneration = newGeneration;
     mSkipDrawing = false;
 }
 already_AddRefed<gfxFcFontSet>
 gfxPangoFontGroup::MakeFontSet(PangoLanguage *aLang, gfxFloat aSizeAdjustFactor,
                                nsAutoRef<FcPattern> *aMatchPattern)
 {
     const char *lang = pango_language_to_string(aLang);
     nsRefPtr <nsIAtom> langGroup;
     if (aLang != mPangoLanguage) {
         // Set up langGroup for Mozilla's font prefs.
         langGroup = do_GetAtom(lang);
     }
     nsAutoTArray<nsString, 20> fcFamilyList;
     GetFcFamilies(&fcFamilyList,
                   langGroup ? langGroup.get() : mStyle.language.get());
     // 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);
     nsRefPtr<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;
     }
     nsRefPtr<gfxFcFontSet> fontSet =
         MakeFontSet(aLang, mSizeAdjustFactor);
     mFontSets.AppendElement(FontSetByLangEntry(aLang, fontSet));
     return fontSet;
 }
 already_AddRefed<gfxFont>
 gfxPangoFontGroup::FindFontForChar(uint32_t aCh, uint32_t aPrevCh,
                                    int32_t 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 nsRefPtr<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 nsRefPtr<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 nsRefPtr<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 nsRefPtr<gfxFont>(GetBaseFont()).forget();
         }
         nextFont = 1;
     }
     // Pango, GLib, and Thebes (but not harfbuzz!) all happen to use the same
     // script codes, so we can just cast the value here.
     const PangoScript script = static_cast<PangoScript>(aRunScript);
     // 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 nsRefPtr<gfxFont>(fontSet->GetFontAt(i, GetStyle())).forget();
         }
     }
     return nullptr;
 }
 // Sanity-check: spot-check a few constants to confirm that Thebes and
 // Pango script codes really do match
 #define CHECK_SCRIPT_CODE(script) \
     PR_STATIC_ASSERT(int32_t(MOZ_SCRIPT_##script) == \
                      int32_t(PANGO_SCRIPT_##script))
 CHECK_SCRIPT_CODE(COMMON);
 CHECK_SCRIPT_CODE(INHERITED);
 CHECK_SCRIPT_CODE(ARABIC);
 CHECK_SCRIPT_CODE(LATIN);
 CHECK_SCRIPT_CODE(UNKNOWN);
 CHECK_SCRIPT_CODE(NKO);
 /**
  ** gfxFcFont
  **/
 cairo_user_data_key_t gfxFcFont::sGfxFontKey;
 gfxFcFont::gfxFcFont(cairo_scaled_font_t *aCairoFont,
                      gfxFcFontEntry *aFontEntry,
                      const gfxFontStyle *aFontStyle)
     : gfxFT2FontBase(aCairoFont, aFontEntry, aFontStyle)
 {
     cairo_scaled_font_set_user_data(mScaledFont, &sGfxFontKey, this, nullptr);
 }
 gfxFcFont::~gfxFcFont()
 {
     cairo_scaled_font_set_user_data(mScaledFont,
                                     &sGfxFontKey,
                                     nullptr,
                                     nullptr);
 }
 bool
 gfxFcFont::ShapeText(gfxContext      *aContext,
                      const char16_t *aText,
                      uint32_t         aOffset,
                      uint32_t         aLength,
                      int32_t          aScript,
                      gfxShapedText   *aShapedText,
                      bool             aPreferPlatformShaping)
 {
     bool ok = false;
     if (FontCanSupportGraphite()) {
         if (gfxPlatform::GetPlatform()->UseGraphiteShaping()) {
             if (!mGraphiteShaper) {
                 mGraphiteShaper = new gfxGraphiteShaper(this);
             }
             ok = mGraphiteShaper->ShapeText(aContext, aText, aOffset, aLength,
                                             aScript, aShapedText);
         }
     }
     if (!ok) {
         if (!mHarfBuzzShaper) {
             mHarfBuzzShaper = new gfxHarfBuzzShaper(this);
         }
         ok = mHarfBuzzShaper->ShapeText(aContext, aText, aOffset, aLength,
                                         aScript, aShapedText);
     }
     NS_WARN_IF_FALSE(ok, "shaper failed, expect scrambled or missing text");
     PostShapingFixup(aContext, aText, aOffset, aLength, aShapedText);
     return ok;
 }
 /* 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 gfxProxyFontEntry &aProxyEntry,
                                 const nsAString& aFullname)
 {
     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(aFullname);
     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(aProxyEntry, 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;
         nsRefPtr<gfxPangoFontGroup> fontGroup =
             new gfxPangoFontGroup(NS_LITERAL_STRING("sans-serif"),
                                   &style, nullptr);
         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 gfxProxyFontEntry &aProxyEntry,
                                 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) {
         NS_Free((void*)aFontData);
         return nullptr;
     }
     return new gfxDownloadedFcFontEntry(aProxyEntry, 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));
     cairo_font_face_t *face =
         cairo_ft_font_face_create_for_pattern(renderPattern);
     // Reuse an existing font entry if available.
     nsRefPtr<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.AppendLiteral("/");
                     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);
     nsRefPtr<gfxFont> font = gfxFontCache::GetCache()->Lookup(fe, &style);
     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, fe, &style);
         gfxFontCache::GetCache()->AddNew(font);
         cairo_scaled_font_destroy(cairoFont);
     }
     cairo_font_face_destroy(face);
     nsRefPtr<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;
     nsRefPtr<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();
             // 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.
 #ifdef MOZ_GFX_OPTIMIZE_MOBILE
     cairo_font_options_set_hint_metrics(fontOptions, CAIRO_HINT_METRICS_OFF);
 #else
     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);
     }
 #endif
     // 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;
 #ifndef MOZ_GFX_OPTIMIZE_MOBILE
     if (FcPatternGetBool(aPattern, FC_HINTING, 0, &hinting) != FcResultMatch) {
         hinting = FcTrue;
     }
 #endif
     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,
 , &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:
         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_GTK2
 #ifdef USE_SKIA
 mozilla::TemporaryRef<mozilla::gfx::GlyphRenderingOptions>
 gfxFcFont::GetGlyphRenderingOptions()
 {
   cairo_scaled_font_t *scaled_font = CairoScaledFont();
   cairo_font_options_t *options = cairo_font_options_create();
   cairo_scaled_font_get_font_options(scaled_font, options);
   cairo_hint_style_t hint_style = cairo_font_options_get_hint_style(options);
   cairo_font_options_destroy(options);
   mozilla::gfx::FontHinting hinting;
   switch (hint_style) {
     case CAIRO_HINT_STYLE_NONE:
       hinting = mozilla::gfx::FontHinting::NONE;
       break;
     case CAIRO_HINT_STYLE_SLIGHT:
       hinting = mozilla::gfx::FontHinting::LIGHT;
       break;
     case CAIRO_HINT_STYLE_FULL:
       hinting = mozilla::gfx::FontHinting::FULL;
       break;
     default:
       hinting = mozilla::gfx::FontHinting::NORMAL;
       break;
   }
   // We don't want to force the use of the autohinter over the font's built in hints
   return mozilla::gfx::Factory::CreateCairoGlyphRenderingOptions(hinting, false);
 }
 #endif

The Tor Browser / annotate

gfx/thebes/gfxPangoFonts.cpp@97036ab72558 (annotated)

gfx/thebes/gfxPangoFonts.cpp