Remove implicit cast from CFX_ByteString to (const char*).

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 <vector>
 
@@ skipping 740 matching lines @@
   const uint8_t* ptr = name.raw_str();
   FX_BOOL bLocalized = FALSE;
   for (int i = 0; i < name.GetLength(); i++) {
     if (ptr[i] > 0x80) {
       bLocalized = TRUE;
       break;
     }
   }
 
   if (bLocalized) {
-    void* hFont = m_pFontInfo->GetFont(name);
+    void* hFont = m_pFontInfo->GetFont(name.c_str());
     if (!hFont) {
       int iExact;
-      hFont =
-          m_pFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0, name, iExact);
+      hFont = m_pFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0,
+                                   name.c_str(), iExact);
       if (!hFont)
         return;
     }
 
     CFX_ByteString new_name = GetPSNameFromTT(hFont);
     if (!new_name.IsEmpty()) {
       new_name.Insert(0, ' ');
       m_InstalledTTFonts.push_back(new_name);
     }
     m_pFontInfo->DeleteFont(hFont);
@@ skipping 13 matching lines @@
     return;
   }
   m_pFontInfo->EnumFontList(this);
   m_bListLoaded = TRUE;
 }
 CFX_ByteString CFX_FontMapper::MatchInstalledFonts(
     const CFX_ByteString& norm_name) {
   LoadInstalledFonts();
   int i;
   for (i = pdfium::CollectionSize<int>(m_InstalledTTFonts) - 1; i >= 0; i--) {
-    CFX_ByteString norm1 = TT_NormalizeName(m_InstalledTTFonts[i]);
+    CFX_ByteString norm1 = TT_NormalizeName(m_InstalledTTFonts[i].c_str());
     if (norm1 == norm_name) {
       break;
     }
   }
   if (i < 0) {
     return CFX_ByteString();
   }
   CFX_ByteString match = m_InstalledTTFonts[i];
   if (match[0] == ' ') {
     match = m_InstalledTTFonts[i + 1];
@@ skipping 155 matching lines @@
     }
     if (flags & FXFONT_SCRIPT) {
       PitchFamily |= FXFONT_FF_SCRIPT;
     }
     if (flags & FXFONT_FIXED_PITCH) {
       PitchFamily |= FXFONT_FF_FIXEDPITCH;
     }
   }
   if (!style.IsEmpty()) {
     int nLen = style.GetLength();
-    const FX_CHAR* pStyle = style;
+    const FX_CHAR* pStyle = style.c_str();
     int i = 0;
     FX_BOOL bFirstItem = TRUE;
     CFX_ByteString buf;
     while (i < nLen) {
       buf = ParseStyle(pStyle, nLen, i);
       int32_t nRet = GetStyleType(buf, FALSE);
       if ((i && !bStyleAvail) || (!i && nRet < 0)) {
         family = SubstName;
         iBaseFont = 12;
         break;
@@ skipping 52 matching lines @@
       Charset == FXFONT_HANGEUL_CHARSET ||
       Charset == FXFONT_CHINESEBIG5_CHARSET) {
     bCJK = TRUE;
   }
   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));
+  CFX_ByteString match = MatchInstalledFonts(TT_NormalizeName(family.c_str()));
   if (match.IsEmpty() && family != SubstName &&
       (!bHasComma && (!bHasHypen || (bHasHypen && !bStyleAvail)))) {
-    match = MatchInstalledFonts(TT_NormalizeName(SubstName));
+    match = MatchInstalledFonts(TT_NormalizeName(SubstName.c_str()));
   }
   if (match.IsEmpty() && iBaseFont >= 12) {
     if (!bCJK) {
       if (!CheckSupportThirdPartFont(family, PitchFamily)) {
         if (italic_angle != 0) {
           bItalic = TRUE;
         } else {
           bItalic = FALSE;
         }
         weight = old_weight;
@@ skipping 35 matching lines @@
       family = g_Base14FontNames[iBaseFont];
       pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
     }
   } else {
     if (flags & FXFONT_ITALIC) {
       bItalic = TRUE;
     }
   }
   iExact = !match.IsEmpty();
   void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily,
-                                     family, iExact);
+                                     family.c_str(), iExact);
   if (iExact) {
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
   }
   if (!hFont) {
 #ifdef PDF_ENABLE_XFA
     if (flags & FXFONT_EXACTMATCH) {
       return NULL;
     }
 #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);
+      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";
@@ skipping 21 matching lines @@
 
       auto it =
           std::find_if(m_FaceArray.begin(), m_FaceArray.end(),
                        [Charset](const FaceData& face) {
                          return face.charset == static_cast<uint32_t>(Charset);
                        });
       if (it == m_FaceArray.end()) {
         return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight,
                                 PitchFamily);
       }
-      hFont = m_pFontInfo->GetFont(it->name);
+      hFont = m_pFontInfo->GetFont(it->name.c_str());
     }
   }
   pSubstFont->m_ExtHandle = m_pFontInfo->RetainFont(hFont);
   if (!hFont)
     return nullptr;
 
   m_pFontInfo->GetFaceName(hFont, SubstName);
   if (Charset == FXFONT_DEFAULT_CHARSET) {
     m_pFontInfo->GetFontCharset(hFont, Charset);
   }
@@ skipping 195 matching lines @@
 void CFX_FolderFontInfo::Release() {
   delete this;
 }
 FX_BOOL CFX_FolderFontInfo::EnumFontList(CFX_FontMapper* pMapper) {
   m_pMapper = pMapper;
   for (const auto& path : m_PathList)
     ScanPath(path);
   return TRUE;
 }
 void CFX_FolderFontInfo::ScanPath(const CFX_ByteString& path) {
-  void* handle = FX_OpenFolder(path);
+  void* handle = FX_OpenFolder(path.c_str());
   if (!handle)
     return;
 
   CFX_ByteString filename;
   FX_BOOL bFolder;
   while (FX_GetNextFile(handle, filename, bFolder)) {
     if (bFolder) {
       if (filename == "." || filename == "..")
         continue;
     } else {
@@ skipping 10 matching lines @@
     fullpath += "/";
 #endif
 
     fullpath += filename;
     bFolder ? ScanPath(fullpath) : ScanFile(fullpath);
   }
   FX_CloseFolder(handle);
 }
 
 void CFX_FolderFontInfo::ScanFile(const CFX_ByteString& path) {
-  FXSYS_FILE* pFile = FXSYS_fopen(path, "rb");
+  FXSYS_FILE* pFile = FXSYS_fopen(path.c_str(), "rb");
   if (!pFile)
     return;
 
   FXSYS_fseek(pFile, 0, FXSYS_SEEK_END);
 
   uint32_t filesize = FXSYS_ftell(pFile);
   uint8_t buffer[16];
   FXSYS_fseek(pFile, 0, FXSYS_SEEK_SET);
 
   size_t readCnt = FXSYS_fread(buffer, 12, 1, pFile);
@@ skipping 183 matching lines @@
       if (GET_TT_LONG(p) == table) {
         offset = GET_TT_LONG(p + 8);
         datasize = GET_TT_LONG(p + 12);
       }
     }
   }
 
   if (!datasize || size < datasize)
     return datasize;
 
-  FXSYS_FILE* pFile = FXSYS_fopen(pFont->m_FilePath, "rb");
+  FXSYS_FILE* pFile = FXSYS_fopen(pFont->m_FilePath.c_str(), "rb");
   if (!pFile)
     return 0;
 
   if (FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET) < 0 ||
       FXSYS_fread(buffer, datasize, 1, pFile) != 1) {
     datasize = 0;
   }
   FXSYS_fclose(pFile);
   return datasize;
 }
@@ skipping 14 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;
 }