Use a std::vector in fpdf_font code.

core/fpdfapi/fpdf_font/cpdf_font.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/fpdfapi/fpdf_font/include/cpdf_font.h"
 
 #include <memory>
+#include <vector>
 
 #include "core/fpdfapi/fpdf_font/cpdf_truetypefont.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type1font.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type3font.h"
 #include "core/fpdfapi/fpdf_font/font_int.h"
 #include "core/fpdfapi/fpdf_font/include/cpdf_fontencoding.h"
 #include "core/fpdfapi/fpdf_page/cpdf_pagemodule.h"
 #include "core/fpdfapi/fpdf_page/pageint.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_name.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h"
 #include "core/fpdfapi/include/cpdf_modulemgr.h"
 #include "core/fxge/include/fx_freetype.h"
 
 namespace {
 
 const uint8_t kChineseFontNames[][5] = {{0xCB, 0xCE, 0xCC, 0xE5, 0x00},
                                         {0xBF, 0xAC, 0xCC, 0xE5, 0x00},
                                         {0xBA, 0xDA, 0xCC, 0xE5, 0x00},
                                         {0xB7, 0xC2, 0xCB, 0xCE, 0x00},
                                         {0xD0, 0xC2, 0xCB, 0xCE, 0x00}};
 
-void GetPredefinedEncoding(int& basemap, const CFX_ByteString& value) {
+void GetPredefinedEncoding(const CFX_ByteString& value, int* basemap) {
   if (value == "WinAnsiEncoding")
-    basemap = PDFFONT_ENCODING_WINANSI;
+    *basemap = PDFFONT_ENCODING_WINANSI;
   else if (value == "MacRomanEncoding")
-    basemap = PDFFONT_ENCODING_MACROMAN;
+    *basemap = PDFFONT_ENCODING_MACROMAN;
   else if (value == "MacExpertEncoding")
-    basemap = PDFFONT_ENCODING_MACEXPERT;
+    *basemap = PDFFONT_ENCODING_MACEXPERT;
   else if (value == "PDFDocEncoding")
-    basemap = PDFFONT_ENCODING_PDFDOC;
+    *basemap = PDFFONT_ENCODING_PDFDOC;
 }
 
 }  // namespace
 
 CPDF_Font::CPDF_Font()
     : m_pFontFile(nullptr),
       m_pFontDict(nullptr),
       m_bToUnicodeLoaded(FALSE),
       m_Flags(0),
       m_StemV(0),
@@ skipping 296 matching lines @@
                                 int& offset) const {
   if (offset < 0 || nStrLen < 1) {
     return 0;
   }
   uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen - 1];
   return static_cast<uint32_t>(ch);
 }
 
 void CPDF_Font::LoadPDFEncoding(CPDF_Object* pEncoding,
                                 int& iBaseEncoding,
-                                CFX_ByteString*& pCharNames,
+                                std::vector<CFX_ByteString>* pCharNames,
                                 FX_BOOL bEmbedded,
                                 FX_BOOL bTrueType) {
   if (!pEncoding) {
     if (m_BaseFont == "Symbol") {
       iBaseEncoding = bTrueType ? PDFFONT_ENCODING_MS_SYMBOL
                                 : PDFFONT_ENCODING_ADOBE_SYMBOL;
     } else if (!bEmbedded && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
       iBaseEncoding = PDFFONT_ENCODING_WINANSI;
     }
     return;
   }
   if (pEncoding->IsName()) {
     if (iBaseEncoding == PDFFONT_ENCODING_ADOBE_SYMBOL ||
         iBaseEncoding == PDFFONT_ENCODING_ZAPFDINGBATS) {
       return;
     }
     if ((m_Flags & PDFFONT_SYMBOLIC) && m_BaseFont == "Symbol") {
       if (!bTrueType) {
         iBaseEncoding = PDFFONT_ENCODING_ADOBE_SYMBOL;
       }
       return;
     }
     CFX_ByteString bsEncoding = pEncoding->GetString();
     if (bsEncoding.Compare("MacExpertEncoding") == 0) {
       bsEncoding = "WinAnsiEncoding";
     }
-    GetPredefinedEncoding(iBaseEncoding, bsEncoding);
+    GetPredefinedEncoding(bsEncoding, &iBaseEncoding);
     return;
   }
 
   CPDF_Dictionary* pDict = pEncoding->AsDictionary();
   if (!pDict)
     return;
 
   if (iBaseEncoding != PDFFONT_ENCODING_ADOBE_SYMBOL &&
       iBaseEncoding != PDFFONT_ENCODING_ZAPFDINGBATS) {
     CFX_ByteString bsEncoding = pDict->GetStringBy("BaseEncoding");
     if (bsEncoding.Compare("MacExpertEncoding") == 0 && bTrueType) {
       bsEncoding = "WinAnsiEncoding";
     }
-    GetPredefinedEncoding(iBaseEncoding, bsEncoding);
+    GetPredefinedEncoding(bsEncoding, &iBaseEncoding);
   }
-  if ((!bEmbedded || bTrueType) && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
+  if ((!bEmbedded || bTrueType) && iBaseEncoding == PDFFONT_ENCODING_BUILTIN)
     iBaseEncoding = PDFFONT_ENCODING_STANDARD;
-  }
+
   CPDF_Array* pDiffs = pDict->GetArrayBy("Differences");
-  if (!pDiffs) {
+  if (!pDiffs)
     return;
-  }
-  pCharNames = new CFX_ByteString[256];
+
+  pCharNames->resize(256);
   uint32_t cur_code = 0;
   for (uint32_t i = 0; i < pDiffs->GetCount(); i++) {
     CPDF_Object* pElement = pDiffs->GetDirectObjectAt(i);
     if (!pElement)
       continue;
 
     if (CPDF_Name* pName = pElement->AsName()) {
       if (cur_code < 256)
-        pCharNames[cur_code] = pName->GetString();
+        (*pCharNames)[cur_code] = pName->GetString();
       cur_code++;
     } else {
       cur_code = pElement->GetInteger();
     }
   }
 }
 
 FX_BOOL CPDF_Font::IsStandardFont() const {
   if (!IsType1Font())
     return FALSE;
   if (m_pFontFile)
     return FALSE;
   if (AsType1Font()->GetBase14Font() < 0)
     return FALSE;
   return TRUE;
 }
 
-const FX_CHAR* CPDF_Font::GetAdobeCharName(int iBaseEncoding,
-                                           const CFX_ByteString* pCharNames,
-                                           int charcode) {
+const FX_CHAR* CPDF_Font::GetAdobeCharName(
+    int iBaseEncoding,
+    const std::vector<CFX_ByteString>& charnames,
+    int charcode) {
   if (charcode < 0 || charcode >= 256) {
     ASSERT(false);
     return nullptr;
   }
 
-  if (pCharNames && !pCharNames[charcode].IsEmpty())
-    return pCharNames[charcode].c_str();
+  if (!charnames.empty() && !charnames[charcode].IsEmpty())
+    return charnames[charcode].c_str();
 
   const FX_CHAR* name = nullptr;
   if (iBaseEncoding)
     name = PDF_CharNameFromPredefinedCharSet(iBaseEncoding, charcode);
   return name && name[0] ? name : nullptr;
 }