Make CPDF_Dictionary use unique pointers.

fpdfsdk/cpdfsdk_baannot.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 "fpdfsdk/cpdfsdk_baannot.h"
 
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
+#include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
+#include "core/fpdfapi/parser/cpdf_reference.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
+#include "core/fpdfapi/parser/cpdf_string.h"
 #include "core/fpdfapi/parser/fpdf_parser_decode.h"
 #include "fpdfsdk/cpdfsdk_datetime.h"
 #include "fpdfsdk/cpdfsdk_pageview.h"
 
 CPDFSDK_BAAnnot::CPDFSDK_BAAnnot(CPDF_Annot* pAnnot,
                                  CPDFSDK_PageView* pPageView)
     : CPDFSDK_Annot(pPageView), m_pAnnot(pAnnot) {}
 
 CPDFSDK_BAAnnot::~CPDFSDK_BAAnnot() {}
 
@@ skipping 59 matching lines @@
                                  const CFX_Matrix* pUser2Device,
                                  const CPDF_RenderOptions* pOptions) {
   m_pAnnot->DrawBorder(pDevice, pUser2Device, pOptions);
 }
 
 void CPDFSDK_BAAnnot::ClearCachedAP() {
   m_pAnnot->ClearCachedAP();
 }
 
 void CPDFSDK_BAAnnot::SetContents(const CFX_WideString& sContents) {
-  if (sContents.IsEmpty())
+  if (sContents.IsEmpty()) {
     m_pAnnot->GetAnnotDict()->RemoveFor("Contents");
-  else
-    m_pAnnot->GetAnnotDict()->SetStringFor("Contents",
-                                           PDF_EncodeText(sContents));
+  } else {
+    m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_String>(
+        "Contents", PDF_EncodeText(sContents), false);
+  }
 }
 
 CFX_WideString CPDFSDK_BAAnnot::GetContents() const {
   return m_pAnnot->GetAnnotDict()->GetUnicodeTextFor("Contents");
 }
 
 void CPDFSDK_BAAnnot::SetAnnotName(const CFX_WideString& sName) {
-  if (sName.IsEmpty())
+  if (sName.IsEmpty()) {
     m_pAnnot->GetAnnotDict()->RemoveFor("NM");
-  else
-    m_pAnnot->GetAnnotDict()->SetStringFor("NM", PDF_EncodeText(sName));
+  } else {
+    m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_String>(
+        "NM", PDF_EncodeText(sName), false);
+  }
 }
 
 CFX_WideString CPDFSDK_BAAnnot::GetAnnotName() const {
   return m_pAnnot->GetAnnotDict()->GetUnicodeTextFor("NM");
 }
 
 void CPDFSDK_BAAnnot::SetModifiedDate(const FX_SYSTEMTIME& st) {
   CPDFSDK_DateTime dt(st);
   CFX_ByteString str = dt.ToPDFDateTimeString();
-
   if (str.IsEmpty())
     m_pAnnot->GetAnnotDict()->RemoveFor("M");
   else
-    m_pAnnot->GetAnnotDict()->SetStringFor("M", str);
+    m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_String>("M", str, false);
 }
 
 FX_SYSTEMTIME CPDFSDK_BAAnnot::GetModifiedDate() const {
   FX_SYSTEMTIME systime;
   CFX_ByteString str = m_pAnnot->GetAnnotDict()->GetStringFor("M");
-
   CPDFSDK_DateTime dt(str);
   dt.ToSystemTime(systime);
-
   return systime;
 }
 
 void CPDFSDK_BAAnnot::SetFlags(uint32_t nFlags) {
-  m_pAnnot->GetAnnotDict()->SetIntegerFor("F", nFlags);
+  m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_Number>("F",
+                                                   static_cast<int>(nFlags));
 }
 
 uint32_t CPDFSDK_BAAnnot::GetFlags() const {
   return m_pAnnot->GetAnnotDict()->GetIntegerFor("F");
 }
 
 void CPDFSDK_BAAnnot::SetAppState(const CFX_ByteString& str) {
   if (str.IsEmpty())
     m_pAnnot->GetAnnotDict()->RemoveFor("AS");
   else
-    m_pAnnot->GetAnnotDict()->SetStringFor("AS", str);
+    m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_String>("AS", str, false);
 }
 
 CFX_ByteString CPDFSDK_BAAnnot::GetAppState() const {
   return m_pAnnot->GetAnnotDict()->GetStringFor("AS");
 }
 
 void CPDFSDK_BAAnnot::SetStructParent(int key) {
-  m_pAnnot->GetAnnotDict()->SetIntegerFor("StructParent", key);
+  m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_Number>("StructParent", key);
 }
 
 int CPDFSDK_BAAnnot::GetStructParent() const {
   return m_pAnnot->GetAnnotDict()->GetIntegerFor("StructParent");
 }
 
 // border
 void CPDFSDK_BAAnnot::SetBorderWidth(int nWidth) {
   CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArrayFor("Border");
   if (pBorder) {
     pBorder->SetNewAt<CPDF_Number>(2, nWidth);
   } else {
     CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictFor("BS");
-    if (!pBSDict) {
-      pBSDict =
-          new CPDF_Dictionary(m_pAnnot->GetDocument()->GetByteStringPool());
-      m_pAnnot->GetAnnotDict()->SetFor("BS", pBSDict);
-    }
-    pBSDict->SetIntegerFor("W", nWidth);
+    if (!pBSDict)
+      pBSDict = m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_Dictionary>("BS");
+
+    pBSDict->SetNewFor<CPDF_Number>("W", nWidth);
   }
 }
 
 int CPDFSDK_BAAnnot::GetBorderWidth() const {
   if (CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArrayFor("Border"))
     return pBorder->GetIntegerAt(2);
 
   if (CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictFor("BS"))
     return pBSDict->GetIntegerFor("W", 1);
 
   return 1;
 }
 
 void CPDFSDK_BAAnnot::SetBorderStyle(BorderStyle nStyle) {
   CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictFor("BS");
-  if (!pBSDict) {
-    pBSDict = new CPDF_Dictionary(m_pAnnot->GetDocument()->GetByteStringPool());
-    m_pAnnot->GetAnnotDict()->SetFor("BS", pBSDict);
-  }
+  if (!pBSDict)
+    pBSDict = m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_Dictionary>("BS");
 
   switch (nStyle) {
     case BorderStyle::SOLID:
-      pBSDict->SetNameFor("S", "S");
+      pBSDict->SetNewFor<CPDF_Name>("S", "S");
       break;
     case BorderStyle::DASH:
-      pBSDict->SetNameFor("S", "D");
+      pBSDict->SetNewFor<CPDF_Name>("S", "D");
       break;
     case BorderStyle::BEVELED:
-      pBSDict->SetNameFor("S", "B");
+      pBSDict->SetNewFor<CPDF_Name>("S", "B");
       break;
     case BorderStyle::INSET:
-      pBSDict->SetNameFor("S", "I");
+      pBSDict->SetNewFor<CPDF_Name>("S", "I");
       break;
     case BorderStyle::UNDERLINE:
-      pBSDict->SetNameFor("S", "U");
+      pBSDict->SetNewFor<CPDF_Name>("S", "U");
       break;
     default:
       break;
   }
 }
 
 BorderStyle CPDFSDK_BAAnnot::GetBorderStyle() const {
   CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictFor("BS");
   if (pBSDict) {
     CFX_ByteString sBorderStyle = pBSDict->GetStringFor("S", "S");
@@ skipping 15 matching lines @@
       CPDF_Array* pDP = pBorder->GetArrayAt(3);
       if (pDP && pDP->GetCount() > 0)
         return BorderStyle::DASH;
     }
   }
 
   return BorderStyle::SOLID;
 }
 
 void CPDFSDK_BAAnnot::SetColor(FX_COLORREF color) {
-  CPDF_Array* pArray = new CPDF_Array;
+  CPDF_Array* pArray = m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_Array>("C");
   pArray->AddNew<CPDF_Number>(static_cast<FX_FLOAT>(FXSYS_GetRValue(color)) /
                               255.0f);
   pArray->AddNew<CPDF_Number>(static_cast<FX_FLOAT>(FXSYS_GetGValue(color)) /
                               255.0f);
   pArray->AddNew<CPDF_Number>(static_cast<FX_FLOAT>(FXSYS_GetBValue(color)) /
                               255.0f);
-  m_pAnnot->GetAnnotDict()->SetFor("C", pArray);
 }
 
 void CPDFSDK_BAAnnot::RemoveColor() {
   m_pAnnot->GetAnnotDict()->RemoveFor("C");
 }
 
 bool CPDFSDK_BAAnnot::GetColor(FX_COLORREF& color) const {
   if (CPDF_Array* pEntry = m_pAnnot->GetAnnotDict()->GetArrayFor("C")) {
     size_t nCount = pEntry->GetCount();
     if (nCount == 1) {
@@ skipping 28 matching lines @@
 
   return false;
 }
 
 void CPDFSDK_BAAnnot::WriteAppearance(const CFX_ByteString& sAPType,
                                       const CFX_FloatRect& rcBBox,
                                       const CFX_Matrix& matrix,
                                       const CFX_ByteString& sContents,
                                       const CFX_ByteString& sAPState) {
   CPDF_Dictionary* pAPDict = m_pAnnot->GetAnnotDict()->GetDictFor("AP");
-  if (!pAPDict) {
-    pAPDict = new CPDF_Dictionary(m_pAnnot->GetDocument()->GetByteStringPool());
-    m_pAnnot->GetAnnotDict()->SetFor("AP", pAPDict);
-  }
+  if (!pAPDict)
+    pAPDict = m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_Dictionary>("AP");
 
   CPDF_Stream* pStream = nullptr;
   CPDF_Dictionary* pParentDict = nullptr;
   if (sAPState.IsEmpty()) {
     pParentDict = pAPDict;
     pStream = pAPDict->GetStreamFor(sAPType);
   } else {
     CPDF_Dictionary* pAPTypeDict = pAPDict->GetDictFor(sAPType);
-    if (!pAPTypeDict) {
-      pAPTypeDict =
-          new CPDF_Dictionary(m_pAnnot->GetDocument()->GetByteStringPool());
-      pAPDict->SetFor(sAPType, pAPTypeDict);
-    }
+    if (!pAPTypeDict)
+      pAPTypeDict = pAPDict->SetNewFor<CPDF_Dictionary>(sAPType);
+
     pParentDict = pAPTypeDict;
     pStream = pAPTypeDict->GetStreamFor(sAPState);
   }
 
   if (!pStream) {
     CPDF_Document* pDoc = m_pPageView->GetPDFDocument();
     pStream = pDoc->NewIndirect<CPDF_Stream>();
-    pParentDict->SetReferenceFor(sAPType, pDoc, pStream);
+    pParentDict->SetNewFor<CPDF_Reference>(sAPType, pDoc, pStream->GetObjNum());
   }
 
   CPDF_Dictionary* pStreamDict = pStream->GetDict();
   if (!pStreamDict) {
     pStreamDict =
         new CPDF_Dictionary(m_pAnnot->GetDocument()->GetByteStringPool());
-    pStreamDict->SetNameFor("Type", "XObject");
-    pStreamDict->SetNameFor("Subtype", "Form");
-    pStreamDict->SetIntegerFor("FormType", 1);
+    pStreamDict->SetNewFor<CPDF_Name>("Type", "XObject");
+    pStreamDict->SetNewFor<CPDF_Name>("Subtype", "Form");
+    pStreamDict->SetNewFor<CPDF_Number>("FormType", 1);
     pStream->InitStream(nullptr, 0, pStreamDict);
   }
 
   if (pStreamDict) {
     pStreamDict->SetMatrixFor("Matrix", matrix);
     pStreamDict->SetRectFor("BBox", rcBBox);
   }
 
   pStream->SetData((uint8_t*)sContents.c_str(), sContents.GetLength());
 }
 
 bool CPDFSDK_BAAnnot::IsVisible() const {
   uint32_t nFlags = GetFlags();
   return !((nFlags & ANNOTFLAG_INVISIBLE) || (nFlags & ANNOTFLAG_HIDDEN) ||
            (nFlags & ANNOTFLAG_NOVIEW));
 }
 
 CPDF_Action CPDFSDK_BAAnnot::GetAction() const {
   return CPDF_Action(m_pAnnot->GetAnnotDict()->GetDictFor("A"));
 }
 
 void CPDFSDK_BAAnnot::SetAction(const CPDF_Action& action) {
   CPDF_Dictionary* pDict = action.GetDict();
   if (pDict != m_pAnnot->GetAnnotDict()->GetDictFor("A")) {
     CPDF_Document* pDoc = m_pPageView->GetPDFDocument();
     if (pDict->IsInline())
       pDict = pDoc->AddIndirectObject(pDict->Clone())->AsDictionary();
-    m_pAnnot->GetAnnotDict()->SetReferenceFor("A", pDoc, pDict);
+    m_pAnnot->GetAnnotDict()->SetNewFor<CPDF_Reference>("A", pDoc,
+                                                        pDict->GetObjNum());
   }
 }
 
 void CPDFSDK_BAAnnot::RemoveAction() {
   m_pAnnot->GetAnnotDict()->RemoveFor("A");
 }
 
 CPDF_AAction CPDFSDK_BAAnnot::GetAAction() const {
   return CPDF_AAction(m_pAnnot->GetAnnotDict()->GetDictFor("AA"));
 }
 
 void CPDFSDK_BAAnnot::SetAAction(const CPDF_AAction& aa) {
   if (aa.GetDict() != m_pAnnot->GetAnnotDict()->GetDictFor("AA"))
-    m_pAnnot->GetAnnotDict()->SetFor("AA", aa.GetDict());
+    m_pAnnot->GetAnnotDict()->SetFor("AA", pdfium::WrapUnique(aa.GetDict()));
 }
 
 void CPDFSDK_BAAnnot::RemoveAAction() {
   m_pAnnot->GetAnnotDict()->RemoveFor("AA");
 }
 
 CPDF_Action CPDFSDK_BAAnnot::GetAAction(CPDF_AAction::AActionType eAAT) {
   CPDF_AAction AAction = GetAAction();
-
   if (AAction.ActionExist(eAAT))
     return AAction.GetAction(eAAT);
 
   if (eAAT == CPDF_AAction::ButtonUp)
     return GetAction();
 
   return CPDF_Action();
 }
 
 void CPDFSDK_BAAnnot::Annot_OnDraw(CFX_RenderDevice* pDevice,
                                    CFX_Matrix* pUser2Device,
                                    CPDF_RenderOptions* pOptions) {
   m_pAnnot->GetAPForm(m_pPageView->GetPDFPage(), CPDF_Annot::Normal);
   m_pAnnot->DrawAppearance(m_pPageView->GetPDFPage(), pDevice, pUser2Device,
                            CPDF_Annot::Normal, nullptr);
 }
 
 void CPDFSDK_BAAnnot::SetOpenState(bool bOpenState) {
   if (CPDF_Annot* pAnnot = m_pAnnot->GetPopupAnnot())
     pAnnot->SetOpenState(bOpenState);
 }