Make CPDF_Font::Create() return a std::unique_ptr.

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>
@@ skipping 281 matching lines @@
     uint32_t charcode = GetNextChar(pString, size, offset);
     width += GetCharWidthF(charcode);
   }
   return width;
 }
 
 CPDF_Font* CPDF_Font::GetStockFont(CPDF_Document* pDoc,
                                    const CFX_ByteStringC& name) {
   CFX_ByteString fontname(name);
   int font_id = PDF_GetStandardFontName(&fontname);
-  if (font_id < 0) {
+  if (font_id < 0)
     return nullptr;
-  }
+
   CPDF_FontGlobals* pFontGlobals =
       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
   CPDF_Font* pFont = pFontGlobals->Find(pDoc, font_id);
-  if (pFont) {
+  if (pFont)
     return pFont;
-  }
+
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
   pDict->SetNameFor("Type", "Font");
   pDict->SetNameFor("Subtype", "Type1");
   pDict->SetNameFor("BaseFont", fontname);
   pDict->SetNameFor("Encoding", "WinAnsiEncoding");
-  pFont = CPDF_Font::CreateFontF(nullptr, pDict);
-  pFontGlobals->Set(pDoc, font_id, pFont);
-  return pFont;
+  return pFontGlobals->Set(pDoc, font_id, CPDF_Font::Create(nullptr, pDict));
 }
 
-CPDF_Font* CPDF_Font::CreateFontF(CPDF_Document* pDoc,
-                                  CPDF_Dictionary* pFontDict) {
+std::unique_ptr<CPDF_Font> CPDF_Font::Create(CPDF_Document* pDoc,
+                                             CPDF_Dictionary* pFontDict) {
   CFX_ByteString type = pFontDict->GetStringFor("Subtype");
   std::unique_ptr<CPDF_Font> pFont;
   if (type == "TrueType") {
     CFX_ByteString tag = pFontDict->GetStringFor("BaseFont").Left(4);
     for (size_t i = 0; i < FX_ArraySize(kChineseFontNames); ++i) {
       if (tag == CFX_ByteString(kChineseFontNames[i], 4)) {
         CPDF_Dictionary* pFontDesc = pFontDict->GetDictFor("FontDescriptor");
         if (!pFontDesc || !pFontDesc->KeyExist("FontFile2"))
           pFont.reset(new CPDF_CIDFont);
         break;
       }
     }
     if (!pFont)
       pFont.reset(new CPDF_TrueTypeFont);
   } else if (type == "Type3") {
     pFont.reset(new CPDF_Type3Font);
   } else if (type == "Type0") {
     pFont.reset(new CPDF_CIDFont);
   } else {
     pFont.reset(new CPDF_Type1Font);
   }
   pFont->m_pFontDict = pFontDict;
   pFont->m_pDocument = pDoc;
   pFont->m_BaseFont = pFontDict->GetStringFor("BaseFont");
-  return pFont->Load() ? pFont.release() : nullptr;
+  return pFont->Load() ? std::move(pFont) : std::unique_ptr<CPDF_Font>();
 }
 
 uint32_t CPDF_Font::GetNextChar(const FX_CHAR* pString,
                                 int nStrLen,
                                 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);
@@ skipping 110 matching lines @@
   if (fallbackFont < 0 ||
       fallbackFont >= pdfium::CollectionSize<int>(m_FontFallbacks)) {
     return -1;
   }
   int glyph =
       FXFT_Get_Char_Index(m_FontFallbacks[fallbackFont]->GetFace(), charcode);
   if (glyph == 0 || glyph == 0xffff)
     return -1;
   return glyph;
 }