Remove CFX_ArrayTemplate from fpdfapi

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 363 matching lines @@
   if (!m_pRootDict)
     return;
 
   CPDF_Object* pInfoObj = GetOrParseIndirectObject(m_pParser->GetInfoObjNum());
   if (pInfoObj)
     m_pInfoDict = pInfoObj->GetDict();
 }
 
 void CPDF_Document::LoadDoc() {
   LoadDocInternal();
-  m_PageList.SetSize(RetrievePageCount());
+  LoadPages();
 }
 
 void CPDF_Document::LoadLinearizedDoc(
     const CPDF_LinearizedHeader* pLinearizationParams) {
   m_bLinearized = true;
   LoadDocInternal();
-  m_PageList.SetSize(pLinearizationParams->GetPageCount());
+  m_PageList.resize(pLinearizationParams->GetPageCount());
   m_iFirstPageNo = pLinearizationParams->GetFirstPageNo();
   m_dwFirstPageObjNum = pLinearizationParams->GetFirstPageObjNum();
 }
 
 void CPDF_Document::LoadPages() {
-  m_PageList.SetSize(RetrievePageCount());
+  m_PageList.resize(RetrievePageCount());
 }
 
 CPDF_Dictionary* CPDF_Document::TraversePDFPages(int iPage,
                                                  int* nPagesToGo,
                                                  size_t level) {
   if (*nPagesToGo < 0 || m_bReachedMaxPageLevel)
     return nullptr;
+
   CPDF_Dictionary* pPages = m_pTreeTraversal[level].first;
   CPDF_Array* pKidList = pPages->GetArrayFor("Kids");
   if (!pKidList) {
     if (*nPagesToGo != 1)
       return nullptr;
-    m_PageList.SetAt(iPage, pPages->GetObjNum());
+    m_PageList[iPage] = pPages->GetObjNum();
     return pPages;
   }
-
   if (level >= FX_MAX_PAGE_LEVEL) {
     m_pTreeTraversal.pop_back();
     m_bReachedMaxPageLevel = true;
     return nullptr;
   }
-
   CPDF_Dictionary* page = nullptr;
   for (size_t i = m_pTreeTraversal[level].second; i < pKidList->GetCount();
        i++) {
     if (*nPagesToGo == 0)
       break;
     CPDF_Dictionary* pKid = pKidList->GetDictAt(i);
     if (!pKid) {
       (*nPagesToGo)--;
       m_pTreeTraversal[level].second++;
       continue;
     }
     if (pKid == pPages) {
       m_pTreeTraversal[level].second++;
       continue;
     }
     if (!pKid->KeyExist("Kids")) {
-      m_PageList.SetAt(iPage - (*nPagesToGo) + 1, pKid->GetObjNum());
+      m_PageList[iPage - (*nPagesToGo) + 1] = pKid->GetObjNum();
       (*nPagesToGo)--;
       m_pTreeTraversal[level].second++;
       if (*nPagesToGo == 0) {
         page = pKid;
         break;
       }
     } else {
       // If the vector has size level+1, the child is not in yet
       if (m_pTreeTraversal.size() == level + 1)
         m_pTreeTraversal.push_back(std::make_pair(pKid, 0));
@@ skipping 20 matching lines @@
   m_bReachedMaxPageLevel = false;
   m_pTreeTraversal.clear();
 }
 
 CPDF_Dictionary* CPDF_Document::GetPagesDict() const {
   CPDF_Dictionary* pRoot = GetRoot();
   return pRoot ? pRoot->GetDictFor("Pages") : nullptr;
 }
 
 bool CPDF_Document::IsPageLoaded(int iPage) const {
-  return !!m_PageList.GetAt(iPage);
+  return !!m_PageList[iPage];
 }
 
 CPDF_Dictionary* CPDF_Document::GetPage(int iPage) {
-  if (iPage < 0 || iPage >= m_PageList.GetSize())
+  if (iPage < 0 || iPage >= pdfium::CollectionSize<int>(m_PageList))
     return nullptr;
 
   if (m_bLinearized && (iPage == m_iFirstPageNo)) {
     if (CPDF_Dictionary* pDict =
             ToDictionary(GetOrParseIndirectObject(m_dwFirstPageObjNum))) {
       return pDict;
     }
   }
-
-  int objnum = m_PageList.GetAt(iPage);
-  if (objnum) {
-    if (CPDF_Dictionary* pDict = ToDictionary(GetOrParseIndirectObject(objnum)))
-      return pDict;
-    return nullptr;
-  }
+  uint32_t objnum = m_PageList[iPage];
+  if (objnum)
+    return ToDictionary(GetOrParseIndirectObject(objnum));
 
   CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return nullptr;
 
   if (iPage - m_iNextPageToTraverse + 1 <= 0) {
     // This can happen when the page does not have an object number. On repeated
     // calls to this function for the same page index, this condition causes
     // TraversePDFPages() to incorrectly return nullptr.
     // Example "testing/corpus/fx/other/jetman_std.pdf"
     // We should restart traversing in this case.
     // TODO(art-snake): optimize this.
     ResetTraversal();
   }
   int nPagesToGo = iPage - m_iNextPageToTraverse + 1;
   if (m_pTreeTraversal.empty())
     m_pTreeTraversal.push_back(std::make_pair(pPages, 0));
   CPDF_Dictionary* pPage = TraversePDFPages(iPage, &nPagesToGo, 0);
   m_iNextPageToTraverse = iPage + 1;
   return pPage;
 }
 
 void CPDF_Document::SetPageObjNum(int iPage, uint32_t objNum) {
-  m_PageList.SetAt(iPage, objNum);
+  m_PageList[iPage] = objNum;
 }
 
 int CPDF_Document::FindPageIndex(CPDF_Dictionary* pNode,
                                  uint32_t& skip_count,
                                  uint32_t objnum,
                                  int& index,
                                  int level) {
   if (!pNode->KeyExist("Kids")) {
     if (objnum == pNode->GetObjNum())
       return index;
@@ skipping 16 matching lines @@
   if (count <= skip_count) {
     skip_count -= count;
     index += count;
     return -1;
   }
 
   if (count && count == pKidList->GetCount()) {
     for (size_t i = 0; i < count; i++) {
       if (CPDF_Reference* pKid = ToReference(pKidList->GetObjectAt(i))) {
         if (pKid->GetRefObjNum() == objnum) {
-          m_PageList.SetAt(index + i, objnum);
+          m_PageList[index + i] = objnum;
           return static_cast<int>(index + i);
         }
       }
     }
   }
 
   for (size_t i = 0; i < pKidList->GetCount(); i++) {
     CPDF_Dictionary* pKid = pKidList->GetDictAt(i);
     if (!pKid || pKid == pNode)
       continue;
 
     int found_index = FindPageIndex(pKid, skip_count, objnum, index, level + 1);
     if (found_index >= 0)
       return found_index;
   }
   return -1;
 }
 
 int CPDF_Document::GetPageIndex(uint32_t objnum) {
-  uint32_t nPages = m_PageList.GetSize();
+  uint32_t nPages = m_PageList.size();
   uint32_t skip_count = 0;
   bool bSkipped = false;
   for (uint32_t i = 0; i < nPages; i++) {
-    uint32_t objnum1 = m_PageList.GetAt(i);
-    if (objnum1 == objnum)
+    if (m_PageList[i] == objnum)
       return i;
 
-    if (!bSkipped && objnum1 == 0) {
+    if (!bSkipped && m_PageList[i] == 0) {
       skip_count = i;
       bSkipped = true;
     }
   }
   CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return -1;
 
   int index = 0;
   return FindPageIndex(pPages, skip_count, objnum, index);
 }
 
 int CPDF_Document::GetPageCount() const {
-  return m_PageList.GetSize();
+  return pdfium::CollectionSize<int>(m_PageList);
 }
 
 int CPDF_Document::RetrievePageCount() const {
   CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return 0;
 
   if (!pPages->KeyExist("Kids"))
     return 1;
 
@@ skipping 130 matching lines @@
       pPagesList = pPages->SetNewFor<CPDF_Array>("Kids");
     pPagesList->AddNew<CPDF_Reference>(this, pPageDict->GetObjNum());
     pPages->SetNewFor<CPDF_Number>("Count", nPages + 1);
     pPageDict->SetNewFor<CPDF_Reference>("Parent", this, pPages->GetObjNum());
     ResetTraversal();
   } else {
     std::set<CPDF_Dictionary*> stack = {pPages};
     if (!InsertDeletePDFPage(pPages, iPage, pPageDict, true, &stack))
       return false;
   }
-  m_PageList.InsertAt(iPage, pPageDict->GetObjNum());
+  m_PageList.insert(m_PageList.begin() + iPage, pPageDict->GetObjNum());
   return true;
 }
 
 void CPDF_Document::DeletePage(int iPage) {
   CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return;
 
   int nPages = pPages->GetIntegerFor("Count");
   if (iPage < 0 || iPage >= nPages)
     return;
 
   std::set<CPDF_Dictionary*> stack = {pPages};
   if (!InsertDeletePDFPage(pPages, iPage, nullptr, false, &stack))
     return;
 
-  m_PageList.RemoveAt(iPage);
+  m_PageList.erase(m_PageList.begin() + iPage);
 }
 
 CPDF_Font* CPDF_Document::AddStandardFont(const FX_CHAR* font,
                                           CPDF_FontEncoding* pEncoding) {
   CFX_ByteString name(font);
   if (PDF_GetStandardFontName(&name) < 0)
     return nullptr;
   return GetPageData()->GetStandardFont(name, pEncoding);
 }
 
@@ skipping 269 matching lines @@
   pFontDesc->SetNewFor<CPDF_Number>("CapHeight", capheight);
   pFontDict->SetNewFor<CPDF_Reference>(
       "FontDescriptor", this,
       AddIndirectObject(std::move(pFontDesc))->GetObjNum());
   hFont = SelectObject(hDC, hFont);
   DeleteObject(hFont);
   DeleteDC(hDC);
   return LoadFont(pBaseDict);
 }
 #endif  //  _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_