Use std::vector as internal storage for CPDF_Array

core/fpdfdoc/doc_form.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 <vector>
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_fontencoding.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_page.h"
@@ skipping 259 matching lines @@
     return;
 
   m_pFormDict = pRoot->GetDictBy("AcroForm");
   if (!m_pFormDict)
     return;
 
   CPDF_Array* pFields = m_pFormDict->GetArrayBy("Fields");
   if (!pFields)
     return;
 
-  int count = pFields->GetCount();
-  for (int i = 0; i < count; i++) {
+  for (size_t i = 0; i < pFields->GetCount(); i++)
     LoadField(pFields->GetDictAt(i));
-  }
 }
 
 CPDF_InterForm::~CPDF_InterForm() {
   for (auto it : m_ControlMap)
     delete it.second;
 
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i) {
     delete m_pFieldTree->m_Root.GetField(i);
   }
@@ skipping 402 matching lines @@
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlAtPoint(CPDF_Page* pPage,
                                                     FX_FLOAT pdf_x,
                                                     FX_FLOAT pdf_y,
                                                     int* z_order) const {
   CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayBy("Annots");
   if (!pAnnotList)
     return nullptr;
 
-  for (uint32_t i = pAnnotList->GetCount(); i > 0; --i) {
-    uint32_t annot_index = i - 1;
+  for (size_t i = pAnnotList->GetCount(); i > 0; --i) {
+    size_t annot_index = i - 1;
     CPDF_Dictionary* pAnnot = pAnnotList->GetDictAt(annot_index);
     if (!pAnnot)
       continue;
 
     const auto it = m_ControlMap.find(pAnnot);
     if (it == m_ControlMap.end())
       continue;
 
     CPDF_FormControl* pControl = it->second;
     CFX_FloatRect rect = pControl->GetRect();
     if (!rect.Contains(pdf_x, pdf_y))
       continue;
 
     if (z_order)
-      *z_order = annot_index;
+      *z_order = static_cast<int>(annot_index);
     return pControl;
   }
   return nullptr;
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlByDict(
     const CPDF_Dictionary* pWidgetDict) const {
   const auto it = m_ControlMap.find(pWidgetDict);
   return it != m_ControlMap.end() ? it->second : nullptr;
 }
 
 FX_BOOL CPDF_InterForm::NeedConstructAP() {
   return m_pFormDict && m_pFormDict->GetBooleanBy("NeedAppearances");
 }
 void CPDF_InterForm::NeedConstructAP(FX_BOOL bNeedAP) {
   if (!m_pFormDict) {
     InitInterFormDict(m_pFormDict, m_pDocument);
   }
   m_pFormDict->SetAtBoolean("NeedAppearances", bNeedAP);
   m_bGenerateAP = bNeedAP;
 }
+
 int CPDF_InterForm::CountFieldsInCalculationOrder() {
   if (!m_pFormDict) {
     return 0;
   }
   CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
   return pArray ? pArray->GetCount() : 0;
 }
+
 CPDF_FormField* CPDF_InterForm::GetFieldInCalculationOrder(int index) {
   if (!m_pFormDict || index < 0) {
     return NULL;
   }
   CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
   if (!pArray) {
     return NULL;
   }
   if (CPDF_Dictionary* pElement =
           ToDictionary(pArray->GetDirectObjectAt(index))) {
     return GetFieldByDict(pElement);
   }
   return NULL;
 }
 int CPDF_InterForm::FindFieldInCalculationOrder(const CPDF_FormField* pField) {
   if (!m_pFormDict || !pField) {
     return -1;
   }
   CPDF_Array* pArray = m_pFormDict->GetArrayBy("CO");
   if (!pArray) {
     return -1;
   }
-  for (uint32_t i = 0; i < pArray->GetCount(); i++) {
+  for (size_t i = 0; i < pArray->GetCount(); i++) {
     CPDF_Object* pElement = pArray->GetDirectObjectAt(i);
     if (pElement == pField->m_pDict) {
       return i;
     }
   }
   return -1;
 }
 uint32_t CPDF_InterForm::CountFormFonts() {
   return CountInterFormFonts(m_pFormDict);
 }
@@ skipping 109 matching lines @@
   CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
   if (!pKids) {
     AddTerminalField(pFieldDict);
     return;
   }
   CPDF_Dictionary* pFirstKid = pKids->GetDictAt(0);
   if (!pFirstKid) {
     return;
   }
   if (pFirstKid->KeyExist("T") || pFirstKid->KeyExist("Kids")) {
-    for (uint32_t i = 0; i < pKids->GetCount(); i++) {
+    for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pChildDict = pKids->GetDictAt(i);
       if (pChildDict) {
         if (pChildDict->GetObjNum() != dwParentObjNum) {
           LoadField(pChildDict, nLevel + 1);
         }
       }
     }
   } else {
     AddTerminalField(pFieldDict);
   }
 }
 FX_BOOL CPDF_InterForm::HasXFAForm() const {
   return m_pFormDict && m_pFormDict->GetArrayBy("XFA");
 }
 void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage) {
   CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
   if (!pPageDict) {
     return;
   }
   CPDF_Array* pAnnots = pPageDict->GetArrayBy("Annots");
   if (!pAnnots) {
     return;
   }
-  int iAnnotCount = pAnnots->GetCount();
-  for (int i = 0; i < iAnnotCount; i++) {
+  for (size_t i = 0; i < pAnnots->GetCount(); i++) {
     CPDF_Dictionary* pAnnot = pAnnots->GetDictAt(i);
     if (pAnnot && pAnnot->GetStringBy("Subtype") == "Widget") {
       LoadField(pAnnot);
     }
   }
 }
 CPDF_FormField* CPDF_InterForm::AddTerminalField(CPDF_Dictionary* pFieldDict) {
   if (!pFieldDict->KeyExist("T")) {
     return NULL;
   }
@@ skipping 37 matching lines @@
         pDict->SetAtName("T", "");
     }
     m_pFieldTree->SetField(csWName, pField);
   }
   CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
   if (!pKids) {
     if (pFieldDict->GetStringBy("Subtype") == "Widget") {
       AddControl(pField, pFieldDict);
     }
   } else {
-    for (uint32_t i = 0; i < pKids->GetCount(); i++) {
+    for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDictAt(i);
       if (!pKid) {
         continue;
       }
       if (pKid->GetStringBy("Subtype") != "Widget") {
         continue;
       }
       AddControl(pField, pKid);
     }
   }
@@ skipping 117 matching lines @@
                                      const CFX_WideString& parent_name,
                                      FX_BOOL bNotify,
                                      int nLevel) {
   CFX_WideString name;
   if (!parent_name.IsEmpty()) {
     name = parent_name + L".";
   }
   name += pFieldDict->GetUnicodeTextBy("T");
   CPDF_Array* pKids = pFieldDict->GetArrayBy("Kids");
   if (pKids) {
-    for (uint32_t i = 0; i < pKids->GetCount(); i++) {
+    for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDictAt(i);
       if (!pKid) {
         continue;
       }
       if (nLevel <= nMaxRecursion) {
         FDF_ImportField(pKid, name, bNotify, nLevel + 1);
       }
     }
     return;
   }
@@ skipping 51 matching lines @@
   if (!pFields) {
     return FALSE;
   }
   m_bsEncoding = pMainDict->GetStringBy("Encoding");
   if (bNotify && m_pFormNotify) {
     int iRet = m_pFormNotify->BeforeFormImportData(this);
     if (iRet < 0) {
       return FALSE;
     }
   }
-  for (uint32_t i = 0; i < pFields->GetCount(); i++) {
+  for (size_t i = 0; i < pFields->GetCount(); i++) {
     CPDF_Dictionary* pField = pFields->GetDictAt(i);
     if (!pField) {
       continue;
     }
     FDF_ImportField(pField, L"", bNotify);
   }
   if (bNotify && m_pFormNotify) {
     m_pFormNotify->AfterFormImportData(this);
   }
   return TRUE;
 }
 void CPDF_InterForm::SetFormNotify(const CPDF_FormNotify* pNotify) {
   m_pFormNotify = (CPDF_FormNotify*)pNotify;
 }