Simplify some code in CFX_FontMapper.

core/fxge/ge/cfx_fontmapper.cpp

 // Copyright 2016 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fxge/include/cfx_fontmapper.h"
 
+#include <memory>
+#include <utility>
+#include <vector>
+
 #include "core/fxge/include/ifx_systemfontinfo.h"
 #include "core/fxge/include/fx_font.h"
 
 #include "third_party/base/stl_util.h"
 
 #define FX_FONT_STYLE_None 0x00
 #define FX_FONT_STYLE_Bold 0x01
 #define FX_FONT_STYLE_Italic 0x02
 #define FX_FONT_STYLE_BoldBold 0x04
 
@@ skipping 135 matching lines @@
     {932, 128},  {936, 134},  {949, 129},  {950, 136},  {1250, 238},
     {1251, 204}, {1252, 0},   {1253, 161}, {1254, 162}, {1255, 177},
     {1256, 178}, {1257, 186}, {1258, 163}, {1361, 130}, {10000, 77},
     {10001, 78}, {10002, 81}, {10003, 79}, {10004, 84}, {10005, 83},
     {10006, 85}, {10007, 89}, {10008, 80}, {10021, 87}, {10029, 88},
     {10081, 86},
 };
 
 int CompareFontFamilyString(const void* key, const void* element) {
   CFX_ByteString str_key((const FX_CHAR*)key);
-  if (str_key.Find(((AltFontFamily*)element)->m_pFontName) != -1)
+  const AltFontFamily* family = reinterpret_cast<const AltFontFamily*>(element);
+  if (str_key.Find(family->m_pFontName) != -1)
     return 0;
-  return FXSYS_stricmp((const FX_CHAR*)key,
-                       ((AltFontFamily*)element)->m_pFontName);
+  return FXSYS_stricmp(reinterpret_cast<const FX_CHAR*>(key),
+                       family->m_pFontName);
 }
 
 int CompareString(const void* key, const void* element) {
-  return FXSYS_stricmp((const FX_CHAR*)key, ((AltFontName*)element)->m_pName);
+  return FXSYS_stricmp(reinterpret_cast<const FX_CHAR*>(key),
+                       reinterpret_cast<const AltFontName*>(element)->m_pName);
 }
 
 CFX_ByteString TT_NormalizeName(const FX_CHAR* family) {
   CFX_ByteString norm(family);
   norm.Remove(' ');
   norm.Remove('-');
   norm.Remove(',');
   int pos = norm.Find('+');
   if (pos > 0)
     norm = norm.Left(pos);
@@ skipping 19 matching lines @@
     if ((nStyle & FX_FONT_STYLE_Bold) == FX_FONT_STYLE_Bold)
       fontName = "ScriptMTBold";
     else if (fontName.Find("Palace") >= 0)
       fontName = "PalaceScriptMT";
     else if (fontName.Find("French") >= 0)
       fontName = "FrenchScriptMT";
     else if (fontName.Find("FreeStyle") >= 0)
       fontName = "FreeStyleScript";
     return fontName;
   }
-  AltFontFamily* found = (AltFontFamily*)FXSYS_bsearch(
-      fontName.c_str(), g_AltFontFamilies,
-      sizeof g_AltFontFamilies / sizeof(AltFontFamily), sizeof(AltFontFamily),
-      CompareFontFamilyString);
+  AltFontFamily* found = reinterpret_cast<AltFontFamily*>(FXSYS_bsearch(
+      fontName.c_str(), g_AltFontFamilies, FX_ArraySize(g_AltFontFamilies),
+      sizeof(AltFontFamily), CompareFontFamilyString));
   return found ? CFX_ByteString(found->m_pFontFamily) : fontName;
 }
 
 CFX_ByteString ParseStyle(const FX_CHAR* pStyle, int iLen, int iIndex) {
   CFX_ByteTextBuf buf;
   if (!iLen || iLen <= iIndex)
     return buf.MakeString();
   while (iIndex < iLen) {
     if (pStyle[iIndex] == ',')
       break;
     buf.AppendChar(pStyle[iIndex]);
     ++iIndex;
   }
   return buf.MakeString();
 }
 
-int32_t GetStyleType(const CFX_ByteString& bsStyle, FX_BOOL bRevert) {
+int32_t GetStyleType(const CFX_ByteString& bsStyle, bool bReverse) {
   int32_t iLen = bsStyle.GetLength();
   if (!iLen)
     return -1;
-  int iSize = sizeof(g_FontStyles) / sizeof(FX_FontStyle);
+  int iSize = FX_ArraySize(g_FontStyles);
   const FX_FontStyle* pStyle = nullptr;
   for (int i = iSize - 1; i >= 0; --i) {
     pStyle = g_FontStyles + i;
     if (!pStyle || pStyle->len > iLen)
       continue;
-    if (!bRevert) {
-      if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0)
+
+    if (bReverse) {
+      if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0)
         return i;
     } else {
-      if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0)
+      if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0)
         return i;
     }
   }
   return -1;
 }
 
 FX_BOOL CheckSupportThirdPartFont(CFX_ByteString name, int& PitchFamily) {
   if (name == "MyriadPro") {
     PitchFamily &= ~FXFONT_FF_ROMAN;
     return TRUE;
   }
   return FALSE;
 }
 
 void UpdatePitchFamily(uint32_t flags, int& PitchFamily) {
   if (flags & FXFONT_SERIF)
     PitchFamily |= FXFONT_FF_ROMAN;
   if (flags & FXFONT_SCRIPT)
     PitchFamily |= FXFONT_FF_SCRIPT;
   if (flags & FXFONT_FIXED_PITCH)
     PitchFamily |= FXFONT_FF_FIXEDPITCH;
 }
 
+const int kExternalFontIndex = 12;

[npm, 2016/08/25 17:43:30]

Do we have any conventions on the placement of variables on namespace?

[Lei Zhang, 2016/08/25 18:41:37]

Oh, I can move it to the top if that's what you mean.

[npm, 2016/08/25 19:01:50]

My understanding is there's 14 base fonts: first 12 + Symbol + Zapf Dingbats
(last 2 handled separately in the code). And we also have Chrome Sans/Serif to
be used as last resort substitute fonts.

+
 }  // namespace
 
 CFX_FontMapper::CFX_FontMapper(CFX_FontMgr* mgr)
     : m_bListLoaded(FALSE), m_pFontMgr(mgr) {
   m_MMFaces[0] = nullptr;
   m_MMFaces[1] = nullptr;
   FXSYS_memset(m_FoxitFaces, 0, sizeof(m_FoxitFaces));
 }
 
 CFX_FontMapper::~CFX_FontMapper() {
@@ skipping 92 matching lines @@
   if (match[0] == ' ')
     match = m_InstalledTTFonts[i + 1];
   return match;
 }
 
 FXFT_Face CFX_FontMapper::UseInternalSubst(CFX_SubstFont* pSubstFont,
                                            int iBaseFont,
                                            int italic_angle,
                                            int weight,
                                            int picthfamily) {
-  if (iBaseFont < 12) {
+  if (iBaseFont < kExternalFontIndex) {
     if (m_FoxitFaces[iBaseFont])
       return m_FoxitFaces[iBaseFont];
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     if (m_pFontMgr->GetBuiltinFont(iBaseFont, &pFontData, &size)) {
       m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
       return m_FoxitFaces[iBaseFont];
     }
   }
   pSubstFont->m_SubstFlags |= FXFONT_SUBST_MM;
   pSubstFont->m_ItalicAngle = italic_angle;
   if (weight)
     pSubstFont->m_Weight = weight;
   if (picthfamily & FXFONT_FF_ROMAN) {
     pSubstFont->m_Weight = pSubstFont->m_Weight * 4 / 5;
     pSubstFont->m_Family = "Chrome Serif";
     if (m_MMFaces[1])
       return m_MMFaces[1];
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(14, &pFontData, &size);

[npm, 2016/08/25 17:43:30]

Replace 14 with kExternalFontIndex + 2

[Lei Zhang, 2016/08/25 18:41:37]

I haven't looked, so I don't know if the index passed to CFX_FontMgr has the
same meaning. Let's punt this to later? Same below.

     m_MMFaces[1] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_MMFaces[1];
   }
   pSubstFont->m_Family = "Chrome Sans";
   if (m_MMFaces[0])
     return m_MMFaces[0];
   const uint8_t* pFontData = nullptr;
   uint32_t size = 0;
   m_pFontMgr->GetBuiltinFont(15, &pFontData, &size);

[npm, 2016/08/25 17:43:30]

kExternalFontIndex + 3

   m_MMFaces[0] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
   return m_MMFaces[0];
 }
 
 FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name,
                                         FX_BOOL bTrueType,
                                         uint32_t flags,
                                         int weight,
                                         int italic_angle,
                                         int WindowCP,
                                         CFX_SubstFont* pSubstFont) {
   if (!(flags & FXFONT_USEEXTERNATTR)) {
     weight = FXFONT_FW_NORMAL;
     italic_angle = 0;
   }
   CFX_ByteString SubstName = name;
-  SubstName.Remove(0x20);
+  SubstName.Remove(' ');
   if (bTrueType && name[0] == '@')
     SubstName = name.Mid(1);
   PDF_GetStandardFontName(&SubstName);
   if (SubstName == "Symbol" && !bTrueType) {
     pSubstFont->m_Family = "Chrome Symbol";
     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     if (m_FoxitFaces[12])

[npm, 2016/08/25 17:43:30]

kExternalFontIndex for this and the 12's just below

       return m_FoxitFaces[12];
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(12, &pFontData, &size);
     m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_FoxitFaces[12];
   }
   if (SubstName == "ZapfDingbats") {
     pSubstFont->m_Family = "Chrome Dingbats";
     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     if (m_FoxitFaces[13])

[npm, 2016/08/25 17:43:30]

Similarly, kExternalFontIndex+1 here

       return m_FoxitFaces[13];
     const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(13, &pFontData, &size);
     m_FoxitFaces[13] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_FoxitFaces[13];
   }
   int iBaseFont = 0;
-  CFX_ByteString family, style;
-  FX_BOOL bHasComma = FALSE;
-  FX_BOOL bHasHypen = FALSE;
+  CFX_ByteString family;
+  CFX_ByteString style;
+  bool bHasComma = false;
+  bool bHasHyphen = false;
   int find = SubstName.Find(",", 0);
   if (find >= 0) {
     family = SubstName.Left(find);
     PDF_GetStandardFontName(&family);
     style = SubstName.Mid(find + 1);
-    bHasComma = TRUE;
+    bHasComma = true;
   } else {
     family = SubstName;
   }
-  for (; iBaseFont < 12; iBaseFont++) {
+  for (; iBaseFont < kExternalFontIndex; iBaseFont++) {
     if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont]))
       break;
   }
   int PitchFamily = 0;
-  FX_BOOL bItalic = FALSE;
+  bool bItalic = false;
   uint32_t nStyle = 0;
-  FX_BOOL bStyleAvail = FALSE;
-  if (iBaseFont < 12) {
+  bool bStyleAvail = false;
+  if (iBaseFont < kExternalFontIndex) {
     if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2)
       nStyle |= FX_FONT_STYLE_Bold;
     if ((iBaseFont % 4) / 2)
       nStyle |= FX_FONT_STYLE_Italic;
     if (iBaseFont < 4)
       PitchFamily |= FXFONT_FF_FIXEDPITCH;
     if (iBaseFont >= 8)
       PitchFamily |= FXFONT_FF_ROMAN;
   } else {
     if (!bHasComma) {
       find = family.ReverseFind('-');
       if (find >= 0) {
         style = family.Mid(find + 1);
         family = family.Left(find);
-        bHasHypen = TRUE;
+        bHasHyphen = true;
       }
     }
-    if (!bHasHypen) {
+    if (!bHasHyphen) {
       int nLen = family.GetLength();
-      int32_t nRet = GetStyleType(family, TRUE);
+      int32_t nRet = GetStyleType(family, true);
       if (nRet > -1) {
         family = family.Left(nLen - g_FontStyles[nRet].len);
         if (nRet == 0)
           nStyle |= FX_FONT_STYLE_Bold;
-        if (nRet == 1)
+        else if (nRet == 1)
           nStyle |= FX_FONT_STYLE_Italic;
-        if (nRet == 2)
+        else if (nRet == 2)
           nStyle |= (FX_FONT_STYLE_Bold | FX_FONT_STYLE_Italic);
       }
     }
     UpdatePitchFamily(flags, PitchFamily);
   }
   if (!style.IsEmpty()) {
     int nLen = style.GetLength();
     const FX_CHAR* pStyle = style.c_str();
     int i = 0;
-    FX_BOOL bFirstItem = TRUE;
+    bool bFirstItem = true;
     CFX_ByteString buf;
     while (i < nLen) {
       buf = ParseStyle(pStyle, nLen, i);
-      int32_t nRet = GetStyleType(buf, FALSE);
+      int32_t nRet = GetStyleType(buf, false);
       if ((i && !bStyleAvail) || (!i && nRet < 0)) {
         family = SubstName;
-        iBaseFont = 12;
+        iBaseFont = kExternalFontIndex;
         break;
-      } else if (nRet >= 0) {
-        bStyleAvail = TRUE;
+      }
+      if (nRet >= 0) {
+        bStyleAvail = true;
+      }
+      if (nRet == 1) {
+        if (bFirstItem) {
+          nStyle |= FX_FONT_STYLE_Italic;
+        } else {
+          family = SubstName;
+          iBaseFont = kExternalFontIndex;
+        }
+        break;
       }
       if (nRet == 0) {
         if (nStyle & FX_FONT_STYLE_Bold)
           nStyle |= FX_FONT_STYLE_BoldBold;
         else
           nStyle |= FX_FONT_STYLE_Bold;
-        bFirstItem = FALSE;
-      }
-      if (nRet == 1) {
-        if (bFirstItem) {
-          nStyle |= FX_FONT_STYLE_Italic;
-        } else {
-          family = SubstName;
-          iBaseFont = 12;
-        }
-        break;
-      }
-      if (nRet == 2) {
+        bFirstItem = false;
+      } else if (nRet == 2) {
         nStyle |= FX_FONT_STYLE_Italic;
         if (nStyle & FX_FONT_STYLE_Bold)
           nStyle |= FX_FONT_STYLE_BoldBold;
         else
           nStyle |= FX_FONT_STYLE_Bold;
-        bFirstItem = FALSE;
+        bFirstItem = false;
       }
       i += buf.GetLength() + 1;
     }
   }
   weight = weight ? weight : FXFONT_FW_NORMAL;
   int old_weight = weight;
   if (nStyle) {
     weight =
         nStyle & FX_FONT_STYLE_BoldBold
             ? 900
             : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
   }
   if (nStyle & FX_FONT_STYLE_Italic)
-    bItalic = TRUE;
-  FX_BOOL bCJK = FALSE;
+    bItalic = true;
   int iExact = 0;
   int Charset = FXFONT_ANSI_CHARSET;
   if (WindowCP)
     Charset = GetCharsetFromCodePage(WindowCP);
-  else if (iBaseFont == 12 && (flags & FXFONT_SYMBOLIC))
+  else if (iBaseFont == kExternalFontIndex && (flags & FXFONT_SYMBOLIC))
     Charset = FXFONT_SYMBOL_CHARSET;
-  if (Charset == FXFONT_SHIFTJIS_CHARSET || Charset == FXFONT_GB2312_CHARSET ||
-      Charset == FXFONT_HANGEUL_CHARSET ||
-      Charset == FXFONT_CHINESEBIG5_CHARSET) {
-    bCJK = TRUE;
-  }
+  bool bCJK =
+      (Charset == FXFONT_SHIFTJIS_CHARSET || Charset == FXFONT_GB2312_CHARSET ||
+       Charset == FXFONT_HANGEUL_CHARSET ||
+       Charset == FXFONT_CHINESEBIG5_CHARSET);
   if (!m_pFontInfo) {
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
                             PitchFamily);
   }
   family = GetFontFamily(family, nStyle);
   CFX_ByteString match = MatchInstalledFonts(TT_NormalizeName(family.c_str()));
   if (match.IsEmpty() && family != SubstName &&
-      (!bHasComma && (!bHasHypen || (bHasHypen && !bStyleAvail)))) {
+      (!bHasComma && (!bHasHyphen || (bHasHyphen && !bStyleAvail)))) {
     match = MatchInstalledFonts(TT_NormalizeName(SubstName.c_str()));
   }
-  if (match.IsEmpty() && iBaseFont >= 12) {
+  if (match.IsEmpty() && iBaseFont >= kExternalFontIndex) {
     if (!bCJK) {
       if (!CheckSupportThirdPartFont(family, PitchFamily)) {
-        if (italic_angle != 0)
-          bItalic = TRUE;
-        else
-          bItalic = FALSE;
+        bItalic = italic_angle != 0;
         weight = old_weight;
       }
     } else {
       pSubstFont->m_bSubstCJK = true;
       if (nStyle)
-        pSubstFont->m_WeightCJK = weight;
-      else
-        pSubstFont->m_WeightCJK = FXFONT_FW_NORMAL;
+        pSubstFont->m_WeightCJK = nStyle ? weight : FXFONT_FW_NORMAL;
       if (nStyle & FX_FONT_STYLE_Italic)
         pSubstFont->m_bItalicCJK = true;
     }
   } else {
     italic_angle = 0;
     weight =
         nStyle & FX_FONT_STYLE_BoldBold
             ? 900
             : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
   }
-  if (!match.IsEmpty() || iBaseFont < 12) {
+  if (!match.IsEmpty() || iBaseFont < kExternalFontIndex) {
     if (!match.IsEmpty())
       family = match;
-    if (iBaseFont < 12) {
+    if (iBaseFont < kExternalFontIndex) {
       if (nStyle && !(iBaseFont % 4)) {
         if ((nStyle & 0x3) == 1)
           iBaseFont += 1;
         if ((nStyle & 0x3) == 2)
           iBaseFont += 3;
         if ((nStyle & 0x3) == 3)
           iBaseFont += 2;
       }
       family = g_Base14FontNames[iBaseFont];
       pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     }
   } else {
     if (flags & FXFONT_ITALIC)
-      bItalic = TRUE;
+      bItalic = true;
   }
   iExact = !match.IsEmpty();
   void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily,
                                      family.c_str(), iExact);
   if (iExact)
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
   if (!hFont) {
 #ifdef PDF_ENABLE_XFA
     if (flags & FXFONT_EXACTMATCH)
       return nullptr;
 #endif  // PDF_ENABLE_XFA
     if (bCJK) {
-      if (italic_angle != 0)
-        bItalic = TRUE;
-      else
-        bItalic = FALSE;
+      bItalic = italic_angle != 0;
       weight = old_weight;
     }
     if (!match.IsEmpty()) {
       hFont = m_pFontInfo->GetFont(match.c_str());
       if (!hFont) {
         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
                                 PitchFamily);
       }
     } else {
       if (Charset == FXFONT_SYMBOL_CHARSET) {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_
         if (SubstName == "Symbol") {
           pSubstFont->m_Family = "Chrome Symbol";
           pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
           pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
           if (m_FoxitFaces[12])

[npm, 2016/08/25 17:43:30]

kExternalFontIndex here and below

             return m_FoxitFaces[12];
           const uint8_t* pFontData = nullptr;
           uint32_t size = 0;
           m_pFontMgr->GetBuiltinFont(12, &pFontData, &size);
           m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
           return m_FoxitFaces[12];
         }
 #endif
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
         return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC,
@@ skipping 33 matching lines @@
   if (ttc_size)
     face = GetCachedTTCFace(hFont, kTableTTCF, ttc_size, font_size);
   else
     face = GetCachedFace(hFont, SubstName, weight, bItalic, font_size);
   if (!face) {
     m_pFontInfo->DeleteFont(hFont);
     return nullptr;
   }
   pSubstFont->m_Family = SubstName;
   pSubstFont->m_Charset = Charset;
-  FX_BOOL bNeedUpdateWeight = FALSE;
-  if (FXFT_Is_Face_Bold(face)) {
-    if (weight == FXFONT_FW_BOLD)
-      bNeedUpdateWeight = FALSE;
-    else
-      bNeedUpdateWeight = TRUE;
-  } else {
-    if (weight == FXFONT_FW_NORMAL)
-      bNeedUpdateWeight = FALSE;
-    else
-      bNeedUpdateWeight = TRUE;
-  }
+  bool bNeedUpdateWeight = false;
+  if (FXFT_Is_Face_Bold(face))
+    bNeedUpdateWeight = weight != FXFONT_FW_BOLD;
+  else
+    bNeedUpdateWeight = weight != FXFONT_FW_NORMAL;
   if (bNeedUpdateWeight)
     pSubstFont->m_Weight = weight;
   if (bItalic && !FXFT_Is_Face_Italic(face)) {
     if (italic_angle == 0)
       italic_angle = -12;
     else if (FXSYS_abs(italic_angle) < 5)
       italic_angle = 0;
     pSubstFont->m_ItalicAngle = italic_angle;
   }
   m_pFontInfo->DeleteFont(hFont);
@@ skipping 49 matching lines @@
       return TRUE;
   }
   return FALSE;
 }
 
 FXFT_Face CFX_FontMapper::GetCachedTTCFace(void* hFont,
                                            const uint32_t tableTTCF,
                                            uint32_t ttc_size,
                                            uint32_t font_size) {
   FXFT_Face face;
-  uint8_t temp[1024];
-  m_pFontInfo->GetFontData(hFont, tableTTCF, temp, 1024);
+  uint8_t buffer[1024];
+  m_pFontInfo->GetFontData(hFont, tableTTCF, buffer, FX_ArraySize(buffer));
+  uint32_t* pBuffer = reinterpret_cast<uint32_t*>(&buffer);

[npm, 2016/08/25 17:43:30]

Is this the same as
uint32_t* pBuffer = reinterpret_cast<uint32_t*>(buffer);

[Lei Zhang, 2016/08/25 18:41:37]

Done.

   uint32_t checksum = 0;
   for (int i = 0; i < 256; i++)
-    checksum += ((uint32_t*)temp)[i];
+    checksum += pBuffer[i];
   uint8_t* pFontData;
   face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum, ttc_size - font_size,
                                       pFontData);
   if (!face) {
     pFontData = FX_Alloc(uint8_t, ttc_size);
     m_pFontInfo->GetFontData(hFont, tableTTCF, pFontData, ttc_size);
     face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData, ttc_size,
                                         ttc_size - font_size);
   }
   return face;
@@ skipping 20 matching lines @@
 int PDF_GetStandardFontName(CFX_ByteString* name) {
   AltFontName* found = static_cast<AltFontName*>(
       FXSYS_bsearch(name->c_str(), g_AltFontNames, FX_ArraySize(g_AltFontNames),
                     sizeof(AltFontName), CompareString));
   if (!found)
     return -1;
 
   *name = g_Base14FontNames[found->m_Index];
   return found->m_Index;
 }