Make AddIndirectObject() take a unique_ptr.

core/fpdfapi/parser/cpdf_document.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/parser/cpdf_document.h"
 
 #include <memory>
 #include <set>
@@ skipping 292 matching lines @@
     basefont += ",Bold";
   else if (italic)
     basefont += ",Italic";
   pBaseDict->SetNameFor("Subtype", "TrueType");
   pBaseDict->SetNameFor("BaseFont", basefont);
   pBaseDict->SetNumberFor("FirstChar", 32);
   pBaseDict->SetNumberFor("LastChar", 255);
   pBaseDict->SetFor("Widths", pWidths);
 }
 
-CPDF_Dictionary* CalculateFontDesc(CPDF_Document* pDoc,
-                                   CFX_ByteString basefont,
-                                   int flags,
-                                   int italicangle,
-                                   int ascend,
-                                   int descend,
-                                   CPDF_Array* bbox,
-                                   int32_t stemV) {
-  CPDF_Dictionary* pFontDesc = new CPDF_Dictionary(pDoc->GetByteStringPool());
+std::unique_ptr<CPDF_Dictionary> CalculateFontDesc(CPDF_Document* pDoc,
+                                                   CFX_ByteString basefont,
+                                                   int flags,
+                                                   int italicangle,
+                                                   int ascend,
+                                                   int descend,
+                                                   CPDF_Array* bbox,
+                                                   int32_t stemV) {
+  auto pFontDesc =
+      pdfium::MakeUnique<CPDF_Dictionary>(pDoc->GetByteStringPool());
   pFontDesc->SetNameFor("Type", "FontDescriptor");
   pFontDesc->SetNameFor("FontName", basefont);
   pFontDesc->SetIntegerFor("Flags", flags);
   pFontDesc->SetFor("FontBBox", bbox);
   pFontDesc->SetIntegerFor("ItalicAngle", italicangle);
   pFontDesc->SetIntegerFor("Ascent", ascend);
   pFontDesc->SetIntegerFor("Descent", descend);
   pFontDesc->SetIntegerFor("StemV", stemV);
   return pFontDesc;
 }
@@ skipping 309 matching lines @@
   return m_pDocPage->GetIccProfile(pStream);
 }
 
 CPDF_Image* CPDF_Document::LoadImageFromPageData(uint32_t dwStreamObjNum) {
   ASSERT(dwStreamObjNum);
   return m_pDocPage->GetImage(dwStreamObjNum);
 }
 
 void CPDF_Document::CreateNewDoc() {
   ASSERT(!m_pRootDict && !m_pInfoDict);
-  m_pRootDict = new CPDF_Dictionary(m_pByteStringPool);
+  m_pRootDict = NewIndirect<CPDF_Dictionary>(m_pByteStringPool);
   m_pRootDict->SetNameFor("Type", "Catalog");
-  AddIndirectObject(m_pRootDict);
 
-  CPDF_Dictionary* pPages = new CPDF_Dictionary(m_pByteStringPool);
+  CPDF_Dictionary* pPages = NewIndirect<CPDF_Dictionary>(m_pByteStringPool);
   pPages->SetNameFor("Type", "Pages");
   pPages->SetNumberFor("Count", 0);
   pPages->SetFor("Kids", new CPDF_Array);
-  m_pRootDict->SetReferenceFor("Pages", this, AddIndirectObject(pPages));
-  m_pInfoDict = new CPDF_Dictionary(m_pByteStringPool);
-  AddIndirectObject(m_pInfoDict);
+  m_pRootDict->SetReferenceFor("Pages", this, pPages);
+  m_pInfoDict = NewIndirect<CPDF_Dictionary>(m_pByteStringPool);
 }
 
 CPDF_Dictionary* CPDF_Document::CreateNewPage(int iPage) {
-  CPDF_Dictionary* pDict = new CPDF_Dictionary(m_pByteStringPool);
+  CPDF_Dictionary* pDict = NewIndirect<CPDF_Dictionary>(m_pByteStringPool);
   pDict->SetNameFor("Type", "Page");
-  uint32_t dwObjNum = AddIndirectObject(pDict);
+  uint32_t dwObjNum = pDict->GetObjNum();
   if (!InsertNewPage(iPage, pDict)) {
     DeleteIndirectObject(dwObjNum);
     return nullptr;
   }
   return pDict;
 }
 
 bool CPDF_Document::InsertDeletePDFPage(CPDF_Dictionary* pPages,
                                         int nPagesToGo,
                                         CPDF_Dictionary* pPageDict,
@@ skipping 95 matching lines @@
 
 size_t CPDF_Document::CalculateEncodingDict(int charset,
                                             CPDF_Dictionary* pBaseDict) {
   size_t i;
   for (i = 0; i < FX_ArraySize(g_FX_CharsetUnicodes); ++i) {
     if (g_FX_CharsetUnicodes[i].m_Charset == charset)
       break;
   }
   if (i == FX_ArraySize(g_FX_CharsetUnicodes))
     return i;
-  CPDF_Dictionary* pEncodingDict = new CPDF_Dictionary(m_pByteStringPool);
+
+  CPDF_Dictionary* pEncodingDict =
+      NewIndirect<CPDF_Dictionary>(m_pByteStringPool);
   pEncodingDict->SetNameFor("BaseEncoding", "WinAnsiEncoding");
+
   CPDF_Array* pArray = new CPDF_Array;
   pArray->AddInteger(128);
+
   const uint16_t* pUnicodes = g_FX_CharsetUnicodes[i].m_pUnicodes;
   for (int j = 0; j < 128; j++) {
     CFX_ByteString name = PDF_AdobeNameFromUnicode(pUnicodes[j]);
     pArray->AddName(name.IsEmpty() ? ".notdef" : name);
   }
   pEncodingDict->SetFor("Differences", pArray);
-  pBaseDict->SetReferenceFor("Encoding", this,
-                             AddIndirectObject(pEncodingDict));
-
+  pBaseDict->SetReferenceFor("Encoding", this, pEncodingDict);
   return i;
 }
 
 CPDF_Dictionary* CPDF_Document::ProcessbCJK(
     CPDF_Dictionary* pBaseDict,
     int charset,
     bool bVert,
     CFX_ByteString basefont,
     std::function<void(FX_WCHAR, FX_WCHAR, CPDF_Array*)> Insert) {
-  CPDF_Dictionary* pFontDict = new CPDF_Dictionary(m_pByteStringPool);
+  CPDF_Dictionary* pFontDict = NewIndirect<CPDF_Dictionary>(m_pByteStringPool);
   CFX_ByteString cmap;
   CFX_ByteString ordering;
   int supplement = 0;
   CPDF_Array* pWidthArray = new CPDF_Array;
   switch (charset) {
     case FXFONT_CHINESEBIG5_CHARSET:
       cmap = bVert ? "ETenms-B5-V" : "ETenms-B5-H";
       ordering = "CNS1";
       supplement = 4;
       pWidthArray->AddInteger(1);
@@ skipping 36 matching lines @@
   pFontDict->SetNameFor("Type", "Font");
   pFontDict->SetNameFor("Subtype", "CIDFontType2");
   pFontDict->SetNameFor("BaseFont", basefont);
   CPDF_Dictionary* pCIDSysInfo = new CPDF_Dictionary(m_pByteStringPool);
   pCIDSysInfo->SetStringFor("Registry", "Adobe");
   pCIDSysInfo->SetStringFor("Ordering", ordering);
   pCIDSysInfo->SetIntegerFor("Supplement", supplement);
   pFontDict->SetFor("CIDSystemInfo", pCIDSysInfo);
   CPDF_Array* pArray = new CPDF_Array;
   pBaseDict->SetFor("DescendantFonts", pArray);
-  pArray->AddReference(this, AddIndirectObject(pFontDict));
+  pArray->AddReference(this, pFontDict->GetObjNum());
   return pFontDict;
 }
 
 CPDF_Font* CPDF_Document::AddFont(CFX_Font* pFont, int charset, bool bVert) {
   if (!pFont)
     return nullptr;
 
   bool bCJK = charset == FXFONT_CHINESEBIG5_CHARSET ||
               charset == FXFONT_GB2312_CHARSET ||
               charset == FXFONT_HANGUL_CHARSET ||
               charset == FXFONT_SHIFTJIS_CHARSET;
   CFX_ByteString basefont = pFont->GetFamilyName();
   basefont.Replace(" ", "");
   int flags =
       CalculateFlags(pFont->IsBold(), pFont->IsItalic(), pFont->IsFixedWidth(),
                      false, false, charset == FXFONT_SYMBOL_CHARSET);
 
-  CPDF_Dictionary* pBaseDict = new CPDF_Dictionary(m_pByteStringPool);
+  auto pBaseDict = pdfium::MakeUnique<CPDF_Dictionary>(m_pByteStringPool);

[dsinclair, 2016/11/15 18:55:51]

Why not NewIndirect here?

[Tom Sepez, 2016/11/15 19:15:16]

Ok, I guess we always add it (no return before line 923).  Done

   pBaseDict->SetNameFor("Type", "Font");
   std::unique_ptr<CFX_UnicodeEncoding> pEncoding(
       new CFX_UnicodeEncoding(pFont));
-  CPDF_Dictionary* pFontDict = pBaseDict;
+  CPDF_Dictionary* pFontDict = pBaseDict.get();
   if (!bCJK) {
     CPDF_Array* pWidths = new CPDF_Array;
     for (int charcode = 32; charcode < 128; charcode++) {
       int glyph_index = pEncoding->GlyphFromCharCode(charcode);
       int char_width = pFont->GetGlyphWidth(glyph_index);
       pWidths->AddInteger(char_width);
     }
     if (charset == FXFONT_ANSI_CHARSET || charset == FXFONT_DEFAULT_CHARSET ||
         charset == FXFONT_SYMBOL_CHARSET) {
       pBaseDict->SetNameFor("Encoding", "WinAnsiEncoding");
       for (int charcode = 128; charcode <= 255; charcode++) {
         int glyph_index = pEncoding->GlyphFromCharCode(charcode);
         int char_width = pFont->GetGlyphWidth(glyph_index);
         pWidths->AddInteger(char_width);
       }
     } else {
-      size_t i = CalculateEncodingDict(charset, pBaseDict);
+      size_t i = CalculateEncodingDict(charset, pBaseDict.get());
       if (i < FX_ArraySize(g_FX_CharsetUnicodes)) {
         const uint16_t* pUnicodes = g_FX_CharsetUnicodes[i].m_pUnicodes;
         for (int j = 0; j < 128; j++) {
           int glyph_index = pEncoding->GlyphFromCharCode(pUnicodes[j]);
           int char_width = pFont->GetGlyphWidth(glyph_index);
           pWidths->AddInteger(char_width);
         }
       }
     }
-    ProcessNonbCJK(pBaseDict, pFont->IsBold(), pFont->IsItalic(), basefont,
-                   pWidths);
+    ProcessNonbCJK(pBaseDict.get(), pFont->IsBold(), pFont->IsItalic(),
+                   basefont, pWidths);
   } else {
-    pFontDict = ProcessbCJK(pBaseDict, charset, bVert, basefont,
+    pFontDict = ProcessbCJK(pBaseDict.get(), charset, bVert, basefont,
                             [pFont, &pEncoding](FX_WCHAR start, FX_WCHAR end,
                                                 CPDF_Array* widthArr) {
                               InsertWidthArray1(pFont, pEncoding.get(), start,
                                                 end, widthArr);
                             });
   }
-  AddIndirectObject(pBaseDict);
+  CPDF_Dictionary* pUnownedBaseDict =
+      ToDictionary(AddIndirectObject(std::move(pBaseDict)));
   int italicangle =
       pFont->GetSubstFont() ? pFont->GetSubstFont()->m_ItalicAngle : 0;
   FX_RECT bbox;
   pFont->GetBBox(bbox);
   CPDF_Array* pBBox = new CPDF_Array;
   pBBox->AddInteger(bbox.left);
   pBBox->AddInteger(bbox.bottom);
   pBBox->AddInteger(bbox.right);
   pBBox->AddInteger(bbox.top);
   int32_t nStemV = 0;
   if (pFont->GetSubstFont()) {
     nStemV = pFont->GetSubstFont()->m_Weight / 5;
   } else {
     static const FX_CHAR stem_chars[] = {'i', 'I', '!', '1'};
     const size_t count = FX_ArraySize(stem_chars);
     uint32_t glyph = pEncoding->GlyphFromCharCode(stem_chars[0]);
     nStemV = pFont->GetGlyphWidth(glyph);
     for (size_t i = 1; i < count; i++) {
       glyph = pEncoding->GlyphFromCharCode(stem_chars[i]);
       int width = pFont->GetGlyphWidth(glyph);
       if (width > 0 && width < nStemV)
         nStemV = width;
     }
   }
-  CPDF_Dictionary* pFontDesc =
+  CPDF_Dictionary* pFontDesc = ToDictionary(AddIndirectObject(
       CalculateFontDesc(this, basefont, flags, italicangle, pFont->GetAscent(),
-                        pFont->GetDescent(), pBBox, nStemV);
-  pFontDict->SetReferenceFor("FontDescriptor", this,
-                             AddIndirectObject(pFontDesc));
-  return LoadFont(pBaseDict);
+                        pFont->GetDescent(), pBBox, nStemV)));
+  pFontDict->SetReferenceFor("FontDescriptor", this, pFontDesc);
+  return LoadFont(pUnownedBaseDict);
 }
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTW* pLogFont,
                                          bool bVert,
                                          bool bTranslateName) {
   LOGFONTA lfa;
   FXSYS_memcpy(&lfa, pLogFont, (char*)lfa.lfFaceName - (char*)&lfa);
   CFX_ByteString face = CFX_ByteString::FromUnicode(pLogFont->lfFaceName);
   if (face.GetLength() >= LF_FACESIZE)
@@ skipping 40 matching lines @@
     basefont = pLogFont->lfFaceName;
 
   int italicangle = ptm->otmItalicAngle / 10;
   int ascend = ptm->otmrcFontBox.top;
   int descend = ptm->otmrcFontBox.bottom;
   int capheight = ptm->otmsCapEmHeight;
   int bbox[4] = {ptm->otmrcFontBox.left, ptm->otmrcFontBox.bottom,
                  ptm->otmrcFontBox.right, ptm->otmrcFontBox.top};
   FX_Free(tm_buf);
   basefont.Replace(" ", "");
-  CPDF_Dictionary* pBaseDict = new CPDF_Dictionary(m_pByteStringPool);
+  auto pBaseDict = pdfium::MakeUnique<CPDF_Dictionary>(m_pByteStringPool);

[dsinclair, 2016/11/15 18:55:51]

ditto

[Tom Sepez, 2016/11/15 19:15:16]

Done.

   pBaseDict->SetNameFor("Type", "Font");
-  CPDF_Dictionary* pFontDict = pBaseDict;
+  CPDF_Dictionary* pFontDict = pBaseDict.get();
   if (!bCJK) {
     if (pLogFont->lfCharSet == FXFONT_ANSI_CHARSET ||
         pLogFont->lfCharSet == FXFONT_DEFAULT_CHARSET ||
         pLogFont->lfCharSet == FXFONT_SYMBOL_CHARSET) {
       pBaseDict->SetNameFor("Encoding", "WinAnsiEncoding");
     } else {
-      CalculateEncodingDict(pLogFont->lfCharSet, pBaseDict);
+      CalculateEncodingDict(pLogFont->lfCharSet, pBaseDict.get());
     }
     int char_widths[224];
     GetCharWidth(hDC, 32, 255, char_widths);
     CPDF_Array* pWidths = new CPDF_Array;
     for (size_t i = 0; i < 224; i++)
       pWidths->AddInteger(char_widths[i]);
-    ProcessNonbCJK(pBaseDict, pLogFont->lfWeight > FW_MEDIUM,
+    ProcessNonbCJK(pBaseDict.get(), pLogFont->lfWeight > FW_MEDIUM,
                    pLogFont->lfItalic != 0, basefont, pWidths);
   } else {
     pFontDict =
-        ProcessbCJK(pBaseDict, pLogFont->lfCharSet, bVert, basefont,
+        ProcessbCJK(pBaseDict.get(), pLogFont->lfCharSet, bVert, basefont,
                     [&hDC](FX_WCHAR start, FX_WCHAR end, CPDF_Array* widthArr) {
                       InsertWidthArray(hDC, start, end, widthArr);
                     });
   }
-  AddIndirectObject(pBaseDict);
+  CPDF_Dictionary* pUnownedBaseDict =
+      AddIndirectObject(std::move(pBaseDict))->AsDictionary();
   CPDF_Array* pBBox = new CPDF_Array;
   for (int i = 0; i < 4; i++)
     pBBox->AddInteger(bbox[i]);
-  CPDF_Dictionary* pFontDesc =
+  std::unique_ptr<CPDF_Dictionary> pFontDesc =
       CalculateFontDesc(this, basefont, flags, italicangle, ascend, descend,
                         pBBox, pLogFont->lfWeight / 5);
   pFontDesc->SetIntegerFor("CapHeight", capheight);
   pFontDict->SetReferenceFor("FontDescriptor", this,
-                             AddIndirectObject(pFontDesc));
+                             AddIndirectObject(std::move(pFontDesc)));
   hFont = SelectObject(hDC, hFont);
   DeleteObject(hFont);
   DeleteDC(hDC);
-  return LoadFont(pBaseDict);
+  return LoadFont(pUnownedBaseDict);
 }
 #endif  //  _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_