Get rid of NULLs in core/

core/fxge/ge/fx_ge_fontmap.cpp

 // Copyright 2014 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 <algorithm>
 #include <limits>
 #include <utility>
 #include <vector>
@@ skipping 318 matching lines @@
   }
   return buf.MakeString();
 }
 
 int32_t GetStyleType(const CFX_ByteString& bsStyle, FX_BOOL bRevert) {
   int32_t iLen = bsStyle.GetLength();
   if (!iLen) {
     return -1;
   }
   int iSize = sizeof(g_FontStyles) / sizeof(FX_FontStyle);
-  const FX_FontStyle* pStyle = NULL;
+  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) {
         return i;
       }
     } else {
@@ skipping 53 matching lines @@
   if (!!(style & FXFONT_FIXED_PITCH) ==
       !!(pitch_family & FXFONT_FF_FIXEDPITCH)) {
     iSimilarValue += 8;
   }
   return iSimilarValue;
 }
 
 }  // namespace
 
 CFX_SubstFont::CFX_SubstFont() {
-  m_ExtHandle = NULL;
+  m_ExtHandle = nullptr;
   m_Charset = 0;
   m_SubstFlags = 0;
   m_Weight = 0;
   m_ItalicAngle = 0;
   m_bSubstOfCJK = FALSE;
   m_WeightCJK = 0;
   m_bItlicCJK = FALSE;
 }
 CTTFontDesc::~CTTFontDesc() {
   if (m_Type == 1) {
@@ skipping 86 matching lines @@
   return pFontDesc->m_SingleFace.m_pFace;
 }
 FXFT_Face CFX_FontMgr::AddCachedFace(const CFX_ByteString& face_name,
                                      int weight,
                                      FX_BOOL bItalic,
                                      uint8_t* pData,
                                      uint32_t size,
                                      int face_index) {
   CTTFontDesc* pFontDesc = new CTTFontDesc;
   pFontDesc->m_Type = 1;
-  pFontDesc->m_SingleFace.m_pFace = NULL;
+  pFontDesc->m_SingleFace.m_pFace = nullptr;
   pFontDesc->m_SingleFace.m_bBold = weight;
   pFontDesc->m_SingleFace.m_bItalic = bItalic;
   pFontDesc->m_pFontData = pData;
   pFontDesc->m_RefCount = 1;
 
   InitFTLibrary();
   FXFT_Library library = m_FTLibrary;
   int ret = FXFT_New_Memory_Face(library, pData, size, face_index,
                                  &pFontDesc->m_SingleFace.m_pFace);
   if (ret) {
     delete pFontDesc;
-    return NULL;
+    return nullptr;
   }
   ret = FXFT_Set_Pixel_Sizes(pFontDesc->m_SingleFace.m_pFace, 64, 64);
   if (ret) {
     delete pFontDesc;
-    return NULL;
+    return nullptr;
   }
   m_FaceMap[KeyNameFromFace(face_name, weight, bItalic)] = pFontDesc;
   return pFontDesc->m_SingleFace.m_pFace;
 }
 
 int GetTTCIndex(const uint8_t* pFontData,
                 uint32_t ttc_size,
                 uint32_t font_offset) {
   int face_index = 0;
   const uint8_t* p = pFontData + 8;
@@ skipping 32 matching lines @@
 }
 FXFT_Face CFX_FontMgr::AddCachedTTCFace(int ttc_size,
                                         uint32_t checksum,
                                         uint8_t* pData,
                                         uint32_t size,
                                         int font_offset) {
   CTTFontDesc* pFontDesc = new CTTFontDesc;
   pFontDesc->m_Type = 2;
   pFontDesc->m_pFontData = pData;
   for (int i = 0; i < 16; i++) {
-    pFontDesc->m_TTCFace.m_pFaces[i] = NULL;
+    pFontDesc->m_TTCFace.m_pFaces[i] = nullptr;
   }
   pFontDesc->m_RefCount++;
   m_FaceMap[KeyNameFromSize(ttc_size, checksum)] = pFontDesc;
   int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
   pFontDesc->m_TTCFace.m_pFaces[face_index] =
       GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
   return pFontDesc->m_TTCFace.m_pFaces[face_index];
 }
 
 FXFT_Face CFX_FontMgr::GetFixedFace(const uint8_t* pData,
@@ skipping 207 matching lines @@
 
 FXFT_Face CFX_FontMapper::UseInternalSubst(CFX_SubstFont* pSubstFont,
                                            int iBaseFont,
                                            int italic_angle,
                                            int weight,
                                            int picthfamily) {
   if (iBaseFont < 12) {
     if (m_FoxitFaces[iBaseFont]) {
       return m_FoxitFaces[iBaseFont];
     }
-    const uint8_t* pFontData = NULL;
+    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 = NULL;
+    const uint8_t* pFontData = nullptr;
     uint32_t size = 0;
     m_pFontMgr->GetBuiltinFont(14, &pFontData, &size);
     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 = NULL;
+  const uint8_t* pFontData = nullptr;
   uint32_t size = 0;
   m_pFontMgr->GetBuiltinFont(15, &pFontData, &size);
   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,
@@ skipping 12 matching lines @@
     }
   }
   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]) {
       return m_FoxitFaces[12];
     }
-    const uint8_t* pFontData = NULL;
+    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]) {
       return m_FoxitFaces[13];
     }
-    const uint8_t* pFontData = NULL;
+    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;
   int find = SubstName.Find(",", 0);
@@ skipping 196 matching lines @@
   }
   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 NULL;
+      return nullptr;
     }
 #endif  // PDF_ENABLE_XFA
     if (bCJK) {
       if (italic_angle != 0) {
         bItalic = TRUE;
       } else {
         bItalic = FALSE;
       }
       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]) {
             return m_FoxitFaces[12];
           }
-          const uint8_t* pFontData = NULL;
+          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,
                              weight, italic_angle, 0, pSubstFont);
       }
@@ skipping 52 matching lines @@
     if (!face) {
       pFontData = FX_Alloc(uint8_t, font_size);
       m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
       face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData,
                                        font_size,
                                        m_pFontInfo->GetFaceIndex(hFont));
     }
   }
   if (!face) {
     m_pFontInfo->DeleteFont(hFont);
-    return NULL;
+    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;
     }
@@ skipping 35 matching lines @@
     PitchFamily |= FXFONT_FF_SCRIPT;
   }
   if (flags & FXFONT_FIXED_PITCH) {
     PitchFamily |= FXFONT_FF_FIXEDPITCH;
   }
   void* hFont =
       m_pFontInfo->MapFontByUnicode(dwUnicode, weight, bItalic, PitchFamily);
   if (!hFont)
     return nullptr;
 
-  uint32_t ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, NULL, 0);
-  uint32_t font_size = m_pFontInfo->GetFontData(hFont, 0, NULL, 0);
+  uint32_t ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, nullptr, 0);
+  uint32_t font_size = m_pFontInfo->GetFontData(hFont, 0, nullptr, 0);
   if (font_size == 0 && ttc_size == 0) {
     m_pFontInfo->DeleteFont(hFont);
-    return NULL;
+    return nullptr;
   }
-  FXFT_Face face = NULL;
+  FXFT_Face face = nullptr;
   if (ttc_size) {
     uint8_t temp[1024];
     m_pFontInfo->GetFontData(hFont, 0x74746366, temp, 1024);
     uint32_t checksum = 0;
     for (int i = 0; i < 256; i++) {
       checksum += ((uint32_t*)temp)[i];
     }
     uint8_t* pFontData;
     face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum,
                                         ttc_size - font_size, pFontData);
@@ skipping 32 matching lines @@
                                            int pitch_family) {
   return nullptr;
 }
 #endif  // PDF_ENABLE_XFA
 
 int IFX_SystemFontInfo::GetFaceIndex(void* hFont) {
   return 0;
 }
 
 void* IFX_SystemFontInfo::RetainFont(void* hFont) {
-  return NULL;
+  return nullptr;
 }
 
 int CFX_FontMapper::GetFaceSize() const {
   return pdfium::CollectionSize<int>(m_FaceArray);
 }
 
 FX_BOOL CFX_FontMapper::IsBuiltinFace(const FXFT_Face face) const {
   for (size_t i = 0; i < MM_FACE_COUNT; ++i) {
     if (m_MMFaces[i] == face) {
       return TRUE;
@@ skipping 223 matching lines @@
     }
   }
   return pFind;
 }
 void* CFX_FolderFontInfo::MapFont(int weight,
                                   FX_BOOL bItalic,
                                   int charset,
                                   int pitch_family,
                                   const FX_CHAR* family,
                                   int& iExact) {
-  return NULL;
+  return nullptr;
 }
 
 #ifdef PDF_ENABLE_XFA
 void* CFX_FolderFontInfo::MapFontByUnicode(uint32_t dwUnicode,
                                            int weight,
                                            FX_BOOL bItalic,
                                            int pitch_family) {
-  return NULL;
+  return nullptr;
 }
 #endif  // PDF_ENABLE_XFA
 
 void* CFX_FolderFontInfo::GetFont(const FX_CHAR* face) {
   auto it = m_FontList.find(face);
   return it != m_FontList.end() ? it->second : nullptr;
 }
 
 uint32_t CFX_FolderFontInfo::GetFontData(void* hFont,
                                          uint32_t table,
@@ skipping 51 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;
 }