Bug 1395061 - patch 3 - Clean up vestigial code that existed to support setting the gfxFontEntry::mSymbolFont flag. r=jrmuizel
authorJonathan Kew <jkew@mozilla.com>
Mon, 11 Sep 2017 19:23:30 +0100
changeset 429602 395a64d67308a9451fd7eadaa6cca0f58ae82470
parent 429601 f546b44e4549e7ffbf761bbebe57300b22ea48dc
child 429603 3ef47d9eabf7316d890319587a7fb795c89bff92
push id7761
push userjlund@mozilla.com
push dateFri, 15 Sep 2017 00:19:52 +0000
treeherdermozilla-beta@c38455951db4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjrmuizel
bugs1395061
milestone57.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1395061 - patch 3 - Clean up vestigial code that existed to support setting the gfxFontEntry::mSymbolFont flag. r=jrmuizel
gfx/thebes/gfxDWriteFontList.cpp
gfx/thebes/gfxFT2FontList.cpp
gfx/thebes/gfxFcPlatformFontList.cpp
gfx/thebes/gfxFontEntry.cpp
gfx/thebes/gfxFontEntry.h
gfx/thebes/gfxFontInfoLoader.h
gfx/thebes/gfxFontUtils.cpp
gfx/thebes/gfxFontUtils.h
gfx/thebes/gfxGDIFontList.cpp
gfx/thebes/gfxGDIFontList.h
gfx/thebes/gfxHarfBuzzShaper.cpp
gfx/thebes/gfxMacPlatformFontList.mm
--- a/gfx/thebes/gfxDWriteFontList.cpp
+++ b/gfx/thebes/gfxDWriteFontList.cpp
@@ -530,36 +530,32 @@ gfxDWriteFontEntry::ReadCMAP(FontInfoDat
 
     // attempt this once, if errors occur leave a blank cmap
     if (mCharacterMap) {
         return NS_OK;
     }
 
     RefPtr<gfxCharacterMap> charmap;
     nsresult rv;
-    bool symbolFont;
 
     if (aFontInfoData && (charmap = GetCMAPFromFontInfo(aFontInfoData,
-                                                        mUVSOffset,
-                                                        symbolFont))) {
+                                                        mUVSOffset))) {
         rv = NS_OK;
     } else {
         uint32_t kCMAP = TRUETYPE_TAG('c','m','a','p');
         charmap = new gfxCharacterMap();
         AutoTable cmapTable(this, kCMAP);
 
         if (cmapTable) {
-            bool unicodeFont = false, symbolFont = false; // currently ignored
             uint32_t cmapLen;
             const uint8_t* cmapData =
                 reinterpret_cast<const uint8_t*>(hb_blob_get_data(cmapTable,
                                                                   &cmapLen));
             rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen,
-                                        *charmap, mUVSOffset,
-                                        unicodeFont, symbolFont);
+                                        *charmap, mUVSOffset);
         } else {
             rv = NS_ERROR_NOT_AVAILABLE;
         }
     }
 
     mHasCmapTable = NS_SUCCEEDED(rv);
     if (mHasCmapTable) {
         // Bug 969504: exclude U+25B6 from Segoe UI family, because it's used
@@ -1671,28 +1667,26 @@ DirectWriteFontInfo::LoadFontFamilyData(
             void* ctx;
             uint32_t cmapSize;
 
             hr = dwFontFace->TryGetFontTable(kCMAP,
                      (const void**)&cmapData, &cmapSize, &ctx, &exists);
 
             if (SUCCEEDED(hr)) {
                 bool cmapLoaded = false;
-                bool unicodeFont = false, symbolFont = false;
                 RefPtr<gfxCharacterMap> charmap = new gfxCharacterMap();
                 uint32_t offset;
 
                 if (cmapData &&
                     cmapSize > 0 &&
                     NS_SUCCEEDED(
                         gfxFontUtils::ReadCMAP(cmapData, cmapSize, *charmap,
-                                               offset, unicodeFont, symbolFont))) {
+                                               offset))) {
                     fontData.mCharacterMap = charmap;
                     fontData.mUVSOffset = offset;
-                    fontData.mSymbolFont = symbolFont;
                     cmapLoaded = true;
                     mLoadStats.cmaps++;
                 }
                 dwFontFace->ReleaseFontTable(ctx);
                 haveData = haveData || cmapLoaded;
            }
         }
 
--- a/gfx/thebes/gfxFT2FontList.cpp
+++ b/gfx/thebes/gfxFT2FontList.cpp
@@ -479,21 +479,18 @@ FT2FontEntry::ReadCMAP(FontInfoData *aFo
     }
 
     RefPtr<gfxCharacterMap> charmap = new gfxCharacterMap();
 
     AutoTArray<uint8_t, 16384> buffer;
     nsresult rv = CopyFontTable(TTAG_cmap, buffer);
     
     if (NS_SUCCEEDED(rv)) {
-        bool unicodeFont;
-        bool symbolFont;
         rv = gfxFontUtils::ReadCMAP(buffer.Elements(), buffer.Length(),
-                                    *charmap, mUVSOffset,
-                                    unicodeFont, symbolFont);
+                                    *charmap, mUVSOffset);
     }
 
     if (NS_SUCCEEDED(rv) && !HasGraphiteTables()) {
         // We assume a Graphite font knows what it's doing,
         // and provides whatever shaping is needed for the
         // characters it supports, so only check/clear the
         // complex-script ranges for non-Graphite fonts
 
--- a/gfx/thebes/gfxFcPlatformFontList.cpp
+++ b/gfx/thebes/gfxFcPlatformFontList.cpp
@@ -330,36 +330,32 @@ gfxFontconfigFontEntry::ReadCMAP(FontInf
 {
     // attempt this once, if errors occur leave a blank cmap
     if (mCharacterMap) {
         return NS_OK;
     }
 
     RefPtr<gfxCharacterMap> charmap;
     nsresult rv;
-    bool symbolFont = false; // currently ignored
 
     if (aFontInfoData && (charmap = GetCMAPFromFontInfo(aFontInfoData,
-                                                        mUVSOffset,
-                                                        symbolFont))) {
+                                                        mUVSOffset))) {
         rv = NS_OK;
     } else {
         uint32_t kCMAP = TRUETYPE_TAG('c','m','a','p');
         charmap = new gfxCharacterMap();
         AutoTable cmapTable(this, kCMAP);
 
         if (cmapTable) {
-            bool unicodeFont = false; // currently ignored
             uint32_t cmapLen;
             const uint8_t* cmapData =
                 reinterpret_cast<const uint8_t*>(hb_blob_get_data(cmapTable,
                                                                   &cmapLen));
             rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen,
-                                        *charmap, mUVSOffset,
-                                        unicodeFont, symbolFont);
+                                        *charmap, mUVSOffset);
         } else {
             rv = NS_ERROR_NOT_AVAILABLE;
         }
     }
 
     mHasCmapTable = NS_SUCCEEDED(rv);
     if (mHasCmapTable) {
         gfxPlatformFontList *pfl = gfxPlatformFontList::PlatformFontList();
--- a/gfx/thebes/gfxFontEntry.cpp
+++ b/gfx/thebes/gfxFontEntry.cpp
@@ -590,24 +590,23 @@ gfxFontEntry::ShareFontTableAndGetBlob(u
         return nullptr;
     }
 
     return entry->ShareTableAndGetBlob(Move(*aBuffer), mFontTableCache.get());
 }
 
 already_AddRefed<gfxCharacterMap>
 gfxFontEntry::GetCMAPFromFontInfo(FontInfoData *aFontInfoData,
-                                  uint32_t& aUVSOffset,
-                                  bool& aSymbolFont)
+                                  uint32_t& aUVSOffset)
 {
     if (!aFontInfoData || !aFontInfoData->mLoadCmaps) {
         return nullptr;
     }
 
-    return aFontInfoData->GetCMAP(mName, aUVSOffset, aSymbolFont);
+    return aFontInfoData->GetCMAP(mName, aUVSOffset);
 }
 
 hb_blob_t *
 gfxFontEntry::GetFontTable(uint32_t aTag)
 {
     hb_blob_t *blob;
     if (GetExistingFontTable(aTag, &blob)) {
         return blob;
--- a/gfx/thebes/gfxFontEntry.h
+++ b/gfx/thebes/gfxFontEntry.h
@@ -408,18 +408,17 @@ protected:
                                    nsTArray<uint8_t>& aBuffer) {
         NS_NOTREACHED("forgot to override either GetFontTable or CopyFontTable?");
         return NS_ERROR_FAILURE;
     }
 
     // lookup the cmap in cached font data
     virtual already_AddRefed<gfxCharacterMap>
     GetCMAPFromFontInfo(FontInfoData *aFontInfoData,
-                        uint32_t& aUVSOffset,
-                        bool& aSymbolFont);
+                        uint32_t& aUVSOffset);
 
     // helper for HasCharacter(), which is what client code should call
     virtual bool TestCharacterMap(uint32_t aCh);
 
     // Font's unitsPerEm from the 'head' table, if available (will be set to
     // kInvalidUPEM for non-sfnt font formats)
     uint16_t mUnitsPerEm;
 
--- a/gfx/thebes/gfxFontInfoLoader.h
+++ b/gfx/thebes/gfxFontInfoLoader.h
@@ -16,31 +16,29 @@
 #include "nsIRunnable.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/TimeStamp.h"
 #include "nsISupportsImpl.h"
 
 // data retrieved for a given face
 
 struct FontFaceData {
-    FontFaceData() : mUVSOffset(0), mSymbolFont(false) {}
+    FontFaceData() : mUVSOffset(0) {}
 
     FontFaceData(const FontFaceData& aFontFaceData) {
         mFullName = aFontFaceData.mFullName;
         mPostscriptName = aFontFaceData.mPostscriptName;
         mCharacterMap = aFontFaceData.mCharacterMap;
         mUVSOffset = aFontFaceData.mUVSOffset;
-        mSymbolFont = aFontFaceData.mSymbolFont;
     }
 
     nsString mFullName;
     nsString mPostscriptName;
     RefPtr<gfxCharacterMap> mCharacterMap;
     uint32_t mUVSOffset;
-    bool mSymbolFont;
 };
 
 // base class used to contain cached system-wide font info.
 // methods in this class are called on off-main threads so
 // all methods use only static methods or other thread-safe
 // font data access API's. specifically, no use is made of
 // gfxPlatformFontList, gfxFontFamily, gfxFamily or any
 // harfbuzz API methods within FontInfoData subclasses.
@@ -73,27 +71,25 @@ public:
     // (called on async thread)
     virtual void LoadFontFamilyData(const nsAString& aFamilyName) = 0;
 
     // -- methods overriden by platform-specific versions --
 
     // fetches cmap data for a particular font from cached font data
     virtual already_AddRefed<gfxCharacterMap>
     GetCMAP(const nsAString& aFontName,
-            uint32_t& aUVSOffset,
-            bool& aSymbolFont)
+            uint32_t& aUVSOffset)
     {
         FontFaceData faceData;
         if (!mFontFaceData.Get(aFontName, &faceData) ||
             !faceData.mCharacterMap) {
             return nullptr;
         }
 
         aUVSOffset = faceData.mUVSOffset;
-        aSymbolFont = faceData.mSymbolFont;
         RefPtr<gfxCharacterMap> cmap = faceData.mCharacterMap;
         return cmap.forget();
     }
 
     // fetches fullname/postscript names from cached font data
     virtual void GetFaceNames(const nsAString& aFontName,
                               nsAString& aFullName,
                               nsAString& aPostscriptName)
--- a/gfx/thebes/gfxFontUtils.cpp
+++ b/gfx/thebes/gfxFontUtils.cpp
@@ -408,18 +408,17 @@ gfxFontUtils::ReadCMAPTableFormat14(cons
 
 #define acceptablePlatform(p) ((p) == PLATFORM_ID_UNICODE || (p) == PLATFORM_ID_MICROSOFT)
 #define isSymbol(p,e)         ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDSymbol)
 #define isUVSEncoding(p, e)   ((p) == PLATFORM_ID_UNICODE && (e) == EncodingIDUVSForUnicodePlatform)
 
 uint32_t
 gfxFontUtils::FindPreferredSubtable(const uint8_t *aBuf, uint32_t aBufLength,
                                     uint32_t *aTableOffset,
-                                    uint32_t *aUVSTableOffset,
-                                    bool *aSymbolEncoding)
+                                    uint32_t *aUVSTableOffset)
 {
     enum {
         OffsetVersion = 0,
         OffsetNumTables = 2,
         SizeOfHeader = 4,
 
         TableOffsetPlatformID = 0,
         TableOffsetEncodingID = 2,
@@ -469,27 +468,24 @@ gfxFontUtils::FindPreferredSubtable(cons
         }
 
         const uint8_t *subtable = aBuf + offset;
         const uint16_t format = ReadShortAt(subtable, SubtableOffsetFormat);
 
         if (isSymbol(platformID, encodingID)) {
             keepFormat = format;
             *aTableOffset = offset;
-            *aSymbolEncoding = true;
             break;
         } else if (format == 4 && acceptableFormat4(platformID, encodingID, keepFormat)) {
             keepFormat = format;
             *aTableOffset = offset;
-            *aSymbolEncoding = false;
         } else if ((format == 10 || format == 12 || format == 13) &&
                    acceptableUCS4Encoding(platformID, encodingID, keepFormat)) {
             keepFormat = format;
             *aTableOffset = offset;
-            *aSymbolEncoding = false;
             if (platformID > PLATFORM_ID_UNICODE || !aUVSTableOffset || *aUVSTableOffset) {
                 break; // we don't want to try anything else when this format is available.
             }
         } else if (format == 14 && isUVSEncoding(platformID, encodingID) && aUVSTableOffset) {
             *aUVSTableOffset = offset;
             if (keepFormat == 10 || keepFormat == 12) {
                 break;
             }
@@ -497,46 +493,33 @@ gfxFontUtils::FindPreferredSubtable(cons
     }
 
     return keepFormat;
 }
 
 nsresult
 gfxFontUtils::ReadCMAP(const uint8_t *aBuf, uint32_t aBufLength,
                        gfxSparseBitSet& aCharacterMap,
-                       uint32_t& aUVSOffset,
-                       bool& aUnicodeFont, bool& aSymbolFont)
+                       uint32_t& aUVSOffset)
 {
     uint32_t offset;
-    bool     symbol;
     uint32_t format = FindPreferredSubtable(aBuf, aBufLength,
-                                            &offset, &aUVSOffset, &symbol);
+                                            &offset, &aUVSOffset);
 
     switch (format) {
     case 4:
-        if (symbol) {
-            aUnicodeFont = false;
-            aSymbolFont = true;
-        } else {
-            aUnicodeFont = true;
-            aSymbolFont = false;
-        }
         return ReadCMAPTableFormat4(aBuf + offset, aBufLength - offset,
                                     aCharacterMap);
 
     case 10:
-        aUnicodeFont = true;
-        aSymbolFont = false;
         return ReadCMAPTableFormat10(aBuf + offset, aBufLength - offset,
                                      aCharacterMap);
 
     case 12:
     case 13:
-        aUnicodeFont = true;
-        aSymbolFont = false;
         return ReadCMAPTableFormat12or13(aBuf + offset, aBufLength - offset,
                                          aCharacterMap);
 
     default:
         break;
     }
 
     return NS_ERROR_FAILURE;
@@ -764,19 +747,18 @@ gfxFontUtils::MapUVSToGlyphFormat14(cons
     return 0;
 }
 
 uint32_t
 gfxFontUtils::MapCharToGlyph(const uint8_t *aCmapBuf, uint32_t aBufLength,
                              uint32_t aUnicode, uint32_t aVarSelector)
 {
     uint32_t offset, uvsOffset;
-    bool     symbol;
     uint32_t format = FindPreferredSubtable(aCmapBuf, aBufLength, &offset,
-                                            &uvsOffset, &symbol);
+                                            &uvsOffset);
 
     uint32_t gid;
     switch (format) {
     case 4:
         gid = aUnicode < UNICODE_BMP_LIMIT ?
             MapCharToGlyphFormat4(aCmapBuf + offset, char16_t(aUnicode)) : 0;
         break;
     case 10:
--- a/gfx/thebes/gfxFontUtils.h
+++ b/gfx/thebes/gfxFontUtils.h
@@ -789,24 +789,22 @@ public:
                          gfxSparseBitSet& aCharacterMap);
 
     static nsresult
     ReadCMAPTableFormat14(const uint8_t *aBuf, uint32_t aLength, 
                           mozilla::UniquePtr<uint8_t[]>& aTable);
 
     static uint32_t
     FindPreferredSubtable(const uint8_t *aBuf, uint32_t aBufLength,
-                          uint32_t *aTableOffset, uint32_t *aUVSTableOffset,
-                          bool *aSymbolEncoding);
+                          uint32_t *aTableOffset, uint32_t *aUVSTableOffset);
 
     static nsresult
     ReadCMAP(const uint8_t *aBuf, uint32_t aBufLength,
              gfxSparseBitSet& aCharacterMap,
-             uint32_t& aUVSOffset,
-             bool& aUnicodeFont, bool& aSymbolFont);
+             uint32_t& aUVSOffset);
 
     static uint32_t
     MapCharToGlyphFormat4(const uint8_t *aBuf, char16_t aCh);
 
     static uint32_t
     MapCharToGlyphFormat10(const uint8_t *aBuf, uint32_t aCh);
 
     static uint32_t
--- a/gfx/thebes/gfxGDIFontList.cpp
+++ b/gfx/thebes/gfxGDIFontList.cpp
@@ -161,32 +161,29 @@ GDIFontEntry::ReadCMAP(FontInfoData *aFo
     {
         mCharacterMap = new gfxCharacterMap();
         mCharacterMap->mBuildOnTheFly = true;
         return NS_ERROR_FAILURE;
     }
 
     RefPtr<gfxCharacterMap> charmap;
     nsresult rv;
-    bool unicodeFont = false, symbolFont = false;
 
     if (aFontInfoData && (charmap = GetCMAPFromFontInfo(aFontInfoData,
-                                                        mUVSOffset,
-                                                        symbolFont))) {
+                                                        mUVSOffset))) {
         rv = NS_OK;
     } else {
         uint32_t kCMAP = TRUETYPE_TAG('c','m','a','p');
         charmap = new gfxCharacterMap();
         AutoTArray<uint8_t, 16384> cmap;
         rv = CopyFontTable(kCMAP, cmap);
 
         if (NS_SUCCEEDED(rv)) {
             rv = gfxFontUtils::ReadCMAP(cmap.Elements(), cmap.Length(),
-                                        *charmap, mUVSOffset,
-                                        unicodeFont, symbolFont);
+                                        *charmap, mUVSOffset);
         }
     }
 
     mHasCmapTable = NS_SUCCEEDED(rv);
     if (mHasCmapTable) {
         gfxPlatformFontList *pfl = gfxPlatformFontList::PlatformFontList();
         mCharacterMap = pfl->FindCharMap(charmap);
     } else {
@@ -1105,27 +1102,24 @@ int CALLBACK GDIFontInfo::EnumerateFonts
         AutoTArray<uint8_t, 1024> cmapData;
 
         cmapSize = ::GetFontData(hdc, kCMAP, 0, nullptr, 0);
         if (cmapSize != GDI_ERROR &&
             cmapSize > 0 &&
             cmapData.SetLength(cmapSize, fallible)) {
             ::GetFontData(hdc, kCMAP, 0, cmapData.Elements(), cmapSize);
             bool cmapLoaded = false;
-            bool unicodeFont = false, symbolFont = false;
             RefPtr<gfxCharacterMap> charmap = new gfxCharacterMap();
             uint32_t offset;
 
             if (NS_SUCCEEDED(gfxFontUtils::ReadCMAP(cmapData.Elements(),
                                                     cmapSize, *charmap,
-                                                    offset, unicodeFont,
-                                                    symbolFont))) {
+                                                    offset))) {
                 fontData.mCharacterMap = charmap;
                 fontData.mUVSOffset = offset;
-                fontData.mSymbolFont = symbolFont;
                 cmapLoaded = true;
                 famData->mFontInfo.mLoadStats.cmaps++;
             }
         }
     }
 
     if (cmapLoaded || nameDataLoaded) {
         famData->mFontInfo.mFontFaceData.Put(fontName, fontData);
--- a/gfx/thebes/gfxGDIFontList.h
+++ b/gfx/thebes/gfxGDIFontList.h
@@ -104,17 +104,17 @@ enum gfxWindowsFontType {
 // A single member of a font family (i.e. a single face, such as Times Italic)
 // represented as a LOGFONT that will resolve to the correct face.
 // This replaces FontEntry from gfxWindowsFonts.h/cpp.
 class GDIFontEntry : public gfxFontEntry
 {
 public:
     LPLOGFONTW GetLogFont() { return &mLogFont; }
 
-    nsresult ReadCMAP(FontInfoData *aFontInfoData = nullptr);
+    nsresult ReadCMAP(FontInfoData *aFontInfoData = nullptr) override;
 
     void FillLogFont(LOGFONTW *aLogFont, uint16_t aWeight, gfxFloat aSize);
 
     static gfxWindowsFontType DetermineFontType(const NEWTEXTMETRICW& metrics, 
                                                 DWORD fontType)
     {
         gfxWindowsFontType feType;
         if (metrics.ntmFlags & NTM_TYPE1)
@@ -189,17 +189,18 @@ protected:
     friend class gfxGDIFont;
 
     GDIFontEntry(const nsAString& aFaceName, gfxWindowsFontType aFontType,
                  uint8_t aStyle, uint16_t aWeight, int16_t aStretch,
                  gfxUserFontData *aUserFontData, bool aFamilyHasItalicFace);
 
     void InitLogFont(const nsAString& aName, gfxWindowsFontType aFontType);
 
-    virtual gfxFont *CreateFontInstance(const gfxFontStyle *aFontStyle, bool aNeedsBold);
+    virtual gfxFont* CreateFontInstance(const gfxFontStyle *aFontStyle,
+                                        bool aNeedsBold) override;
 
     virtual nsresult CopyFontTable(uint32_t aTableTag,
                                    nsTArray<uint8_t>& aBuffer) override;
 
     already_AddRefed<mozilla::gfx::UnscaledFontGDI> LookupUnscaledFont(HFONT aFont);
 
     LOGFONTW mLogFont;
 
--- a/gfx/thebes/gfxHarfBuzzShaper.cpp
+++ b/gfx/thebes/gfxHarfBuzzShaper.cpp
@@ -1270,21 +1270,19 @@ gfxHarfBuzzShaper::Initialize()
         // get the cmap table and find offset to our subtable
         mCmapTable = entry->GetFontTable(TRUETYPE_TAG('c','m','a','p'));
         if (!mCmapTable) {
             NS_WARNING("failed to load cmap, glyphs will be missing");
             return false;
         }
         uint32_t len;
         const uint8_t* data = (const uint8_t*)hb_blob_get_data(mCmapTable, &len);
-        bool symbol;
         mCmapFormat = gfxFontUtils::
             FindPreferredSubtable(data, len,
-                                  &mSubtableOffset, &mUVSTableOffset,
-                                  &symbol);
+                                  &mSubtableOffset, &mUVSTableOffset);
         if (mCmapFormat <= 0) {
             return false;
         }
     }
 
     if (!mUseFontGlyphWidths) {
         // If font doesn't implement GetGlyphWidth, we will be reading
         // the metrics table directly, so make sure we can load it.
--- a/gfx/thebes/gfxMacPlatformFontList.mm
+++ b/gfx/thebes/gfxMacPlatformFontList.mm
@@ -147,36 +147,32 @@ MacOSFontEntry::ReadCMAP(FontInfoData *a
 {
     // attempt this once, if errors occur leave a blank cmap
     if (mCharacterMap) {
         return NS_OK;
     }
 
     RefPtr<gfxCharacterMap> charmap;
     nsresult rv;
-    bool symbolFont = false; // currently ignored
 
     if (aFontInfoData && (charmap = GetCMAPFromFontInfo(aFontInfoData,
-                                                        mUVSOffset,
-                                                        symbolFont))) {
+                                                        mUVSOffset))) {
         rv = NS_OK;
     } else {
         uint32_t kCMAP = TRUETYPE_TAG('c','m','a','p');
         charmap = new gfxCharacterMap();
         AutoTable cmapTable(this, kCMAP);
 
         if (cmapTable) {
-            bool unicodeFont = false; // currently ignored
             uint32_t cmapLen;
             const uint8_t* cmapData =
                 reinterpret_cast<const uint8_t*>(hb_blob_get_data(cmapTable,
                                                                   &cmapLen));
             rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen,
-                                        *charmap, mUVSOffset,
-                                        unicodeFont, symbolFont);
+                                        *charmap, mUVSOffset);
         } else {
             rv = NS_ERROR_NOT_AVAILABLE;
         }
     }
 
     if (NS_SUCCEEDED(rv) && !HasGraphiteTables()) {
         // We assume a Graphite font knows what it's doing,
         // and provides whatever shaping is needed for the
@@ -1474,26 +1470,22 @@ MacFontInfo::LoadFontFamilyData(const ns
                                                   kCTFontTableOptionNoOptions);
 
             if (cmapTable) {
                 const uint8_t *cmapData =
                     (const uint8_t*)CFDataGetBytePtr(cmapTable);
                 uint32_t cmapLen = CFDataGetLength(cmapTable);
                 RefPtr<gfxCharacterMap> charmap = new gfxCharacterMap();
                 uint32_t offset;
-                bool unicodeFont = false; // ignored
-                bool symbolFont = false;
                 nsresult rv;
 
-                rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen, *charmap, offset,
-                                            unicodeFont, symbolFont);
+                rv = gfxFontUtils::ReadCMAP(cmapData, cmapLen, *charmap, offset);
                 if (NS_SUCCEEDED(rv)) {
                     fontData.mCharacterMap = charmap;
                     fontData.mUVSOffset = offset;
-                    fontData.mSymbolFont = symbolFont;
                     mLoadStats.cmaps++;
                 }
                 CFRelease(cmapTable);
             }
 
             mFontFaceData.Put(fontName, fontData);
             CFRelease(faceName);
         }