use unique_ptr in fpdf_font_cid.cpp

core/fpdfapi/font/fpdf_font_cid.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 "core/fpdfapi/font/font_int.h"
 
+#include <memory>
+#include <utility>
+
 #include "core/fpdfapi/cmaps/cmap_int.h"
 #include "core/fpdfapi/cpdf_modulemgr.h"
 #include "core/fpdfapi/font/ttgsubtable.h"
 #include "core/fpdfapi/page/cpdf_pagemodule.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_simple_parser.h"
 #include "core/fxcrt/fx_ext.h"
 #include "core/fxge/fx_freetype.h"
 #include "third_party/base/stl_util.h"
@@ skipping 252 matching lines @@
       --iSeg;
     }
     --size;
     ++offset;
   }
   return 1;
 }
 
 }  // namespace
 
-CPDF_CMapManager::CPDF_CMapManager() {
-  FXSYS_memset(m_CID2UnicodeMaps, 0, sizeof m_CID2UnicodeMaps);
+CPDF_CMapManager::CPDF_CMapManager() {}
+
+CPDF_CMapManager::~CPDF_CMapManager() {}
+
+CFX_MaybeOwned<CPDF_CMap> CPDF_CMapManager::GetPredefinedCMap(
+    const CFX_ByteString& name,
+    bool bPromptCJK) {
+  auto it = m_CMaps.find(name);
+  if (it != m_CMaps.end())
+    return CFX_MaybeOwned<CPDF_CMap>(it->second.get());  // Unowned.
+
+  std::unique_ptr<CPDF_CMap> pCMap = LoadPredefinedCMap(name, bPromptCJK);
+  if (name.IsEmpty())
+    return CFX_MaybeOwned<CPDF_CMap>(std::move(pCMap));  // Owned.
+
+  CPDF_CMap* pUnowned = pCMap.get();
+  m_CMaps[name] = std::move(pCMap);
+  return CFX_MaybeOwned<CPDF_CMap>(pUnowned);  // Unowned.
 }
-CPDF_CMapManager::~CPDF_CMapManager() {
-  for (const auto& pair : m_CMaps) {
-    delete pair.second;
-  }
-  m_CMaps.clear();
-  for (size_t i = 0; i < FX_ArraySize(m_CID2UnicodeMaps); ++i) {
-    delete m_CID2UnicodeMaps[i];
-  }
-}
-CPDF_CMap* CPDF_CMapManager::GetPredefinedCMap(const CFX_ByteString& name,
-                                               bool bPromptCJK) {
-  auto it = m_CMaps.find(name);
-  if (it != m_CMaps.end()) {
-    return it->second;
-  }
-  CPDF_CMap* pCMap = LoadPredefinedCMap(name, bPromptCJK);
-  if (!name.IsEmpty()) {

[Tom Sepez, 2017/01/18 23:16:25]

note: leak here if name is empty and we don't stick new object into map where it
will be deleted later.  Caller can't distinguish between these cases ....

-    m_CMaps[name] = pCMap;
-  }
-  return pCMap;
-}
-CPDF_CMap* CPDF_CMapManager::LoadPredefinedCMap(const CFX_ByteString& name,
-                                                bool bPromptCJK) {
-  CPDF_CMap* pCMap = new CPDF_CMap;
+
+std::unique_ptr<CPDF_CMap> CPDF_CMapManager::LoadPredefinedCMap(
+    const CFX_ByteString& name,
+    bool bPromptCJK) {
+  auto pCMap = pdfium::MakeUnique<CPDF_CMap>();
   const FX_CHAR* pname = name.c_str();
-  if (*pname == '/') {
+  if (*pname == '/')
     pname++;
-  }
+
   pCMap->LoadPredefined(this, pname, bPromptCJK);
   return pCMap;
 }
 
 CPDF_CID2UnicodeMap* CPDF_CMapManager::GetCID2UnicodeMap(CIDSet charset,
                                                          bool bPromptCJK) {
   if (!m_CID2UnicodeMaps[charset])
     m_CID2UnicodeMaps[charset] = LoadCID2UnicodeMap(charset, bPromptCJK);
-  return m_CID2UnicodeMaps[charset];
+
+  return m_CID2UnicodeMaps[charset].get();
 }
-CPDF_CID2UnicodeMap* CPDF_CMapManager::LoadCID2UnicodeMap(CIDSet charset,
-                                                          bool bPromptCJK) {
-  CPDF_CID2UnicodeMap* pMap = new CPDF_CID2UnicodeMap();
+
+std::unique_ptr<CPDF_CID2UnicodeMap> CPDF_CMapManager::LoadCID2UnicodeMap(
+    CIDSet charset,
+    bool bPromptCJK) {
+  auto pMap = pdfium::MakeUnique<CPDF_CID2UnicodeMap>();
   pMap->Load(this, charset, bPromptCJK);
   return pMap;
 }
 
 CPDF_CMapParser::CPDF_CMapParser()
     : m_pCMap(nullptr), m_Status(0), m_CodeSeq(0) {}
 
 CPDF_CMapParser::~CPDF_CMapParser() {}
 
 void CPDF_CMapParser::Initialize(CPDF_CMap* pCMap) {
@@ skipping 439 matching lines @@
   m_EmbeddedCount = pFontGlobals->m_EmbeddedToUnicodes[charset].m_Count;
 }
 
 CIDSet CharsetFromOrdering(const CFX_ByteStringC& ordering) {
   for (size_t charset = 1; charset < FX_ArraySize(g_CharsetNames); ++charset) {
     if (ordering == g_CharsetNames[charset])
       return CIDSetFromSizeT(charset);
   }
   return CIDSET_UNKNOWN;
 }