Remove CFX_ArrayTemplate from fpdfapi

core/fpdfapi/parser/cpdf_data_avail.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/parser/cpdf_data_avail.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 435 matching lines @@
 
 bool CPDF_DataAvail::IsFirstCheck(uint32_t dwPage) {
   return m_pageMapCheckState.insert(dwPage).second;
 }
 
 void CPDF_DataAvail::ResetFirstCheck(uint32_t dwPage) {
   m_pageMapCheckState.erase(dwPage);
 }
 
 bool CPDF_DataAvail::CheckPage(DownloadHints* pHints) {
-  uint32_t iPageObjs = m_PageObjList.GetSize();
-  CFX_ArrayTemplate<uint32_t> UnavailObjList;
-  for (uint32_t i = 0; i < iPageObjs; ++i) {
-    uint32_t dwPageObjNum = m_PageObjList.GetAt(i);
-    bool bExist = false;
+  std::vector<uint32_t> UnavailObjList;
+  for (uint32_t dwPageObjNum : m_PageObjList) {
+    bool bExists = false;
     std::unique_ptr<CPDF_Object> pObj =
-        GetObject(dwPageObjNum, pHints, &bExist);
+        GetObject(dwPageObjNum, pHints, &bExists);
     if (!pObj) {
-      if (bExist)
-        UnavailObjList.Add(dwPageObjNum);
+      if (bExists)
+        UnavailObjList.push_back(dwPageObjNum);
       continue;
     }
-
     CPDF_Array* pArray = ToArray(pObj.get());
     if (pArray) {
       for (const auto& pArrayObj : *pArray) {
         if (CPDF_Reference* pRef = ToReference(pArrayObj.get()))
-          UnavailObjList.Add(pRef->GetRefObjNum());
+          UnavailObjList.push_back(pRef->GetRefObjNum());
       }
     }
     if (!pObj->IsDictionary())
       continue;
 
     CFX_ByteString type = pObj->GetDict()->GetStringFor("Type");
     if (type == "Pages") {
       m_PagesArray.push_back(std::move(pObj));
       continue;
     }
   }
-
-  m_PageObjList.RemoveAll();
-  if (UnavailObjList.GetSize()) {
-    m_PageObjList.Append(UnavailObjList);
+  m_PageObjList.clear();
+  if (!UnavailObjList.empty()) {
+    m_PageObjList = std::move(UnavailObjList);
     return false;
   }
-
-  uint32_t iPages = m_PagesArray.size();
-  for (uint32_t i = 0; i < iPages; i++) {
+  size_t iPages = m_PagesArray.size();
+  for (size_t i = 0; i < iPages; ++i) {
     std::unique_ptr<CPDF_Object> pPages = std::move(m_PagesArray[i]);
     if (pPages && !GetPageKids(m_pCurrentParser, pPages.get())) {
       m_PagesArray.clear();
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
     }
   }
   m_PagesArray.clear();
-  if (!m_PageObjList.GetSize())
+  if (m_PageObjList.empty())
     m_docStatus = PDF_DATAAVAIL_DONE;
 
   return true;
 }
 
 bool CPDF_DataAvail::GetPageKids(CPDF_Parser* pParser, CPDF_Object* pPages) {
   if (!pParser) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   CPDF_Dictionary* pDict = pPages->GetDict();
   CPDF_Object* pKids = pDict ? pDict->GetObjectFor("Kids") : nullptr;
   if (!pKids)
     return true;
 
   switch (pKids->GetType()) {
     case CPDF_Object::REFERENCE:
-      m_PageObjList.Add(pKids->AsReference()->GetRefObjNum());
+      m_PageObjList.push_back(pKids->AsReference()->GetRefObjNum());
       break;
     case CPDF_Object::ARRAY: {
       CPDF_Array* pKidsArray = pKids->AsArray();
       for (size_t i = 0; i < pKidsArray->GetCount(); ++i) {
         if (CPDF_Reference* pRef = ToReference(pKidsArray->GetObjectAt(i)))
-          m_PageObjList.Add(pRef->GetRefObjNum());
+          m_PageObjList.push_back(pRef->GetRefObjNum());
       }
     } break;
     default:
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
   }
   return true;
 }
 
 bool CPDF_DataAvail::CheckPages(DownloadHints* pHints) {
-  bool bExist = false;
+  bool bExists = false;
   std::unique_ptr<CPDF_Object> pPages =
-      GetObject(m_PagesObjNum, pHints, &bExist);
-  if (!bExist) {
+      GetObject(m_PagesObjNum, pHints, &bExists);
+  if (!bExists) {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return true;
   }
 
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return true;
     }
     return false;
@@ skipping 562 matching lines @@
         m_bCurPageDictLoadOK = true;
         m_docStatus = PDF_DATAAVAIL_PAGE;
         return true;
     }
   }
 }
 
 bool CPDF_DataAvail::CheckArrayPageNode(uint32_t dwPageNo,
                                         PageNode* pPageNode,
                                         DownloadHints* pHints) {
-  bool bExist = false;
-  std::unique_ptr<CPDF_Object> pPages = GetObject(dwPageNo, pHints, &bExist);
-  if (!bExist) {
+  bool bExists = false;
+  std::unique_ptr<CPDF_Object> pPages = GetObject(dwPageNo, pHints, &bExists);
+  if (!bExists) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return false;
     }
     return false;
@@ skipping 14 matching lines @@
     auto pNode = pdfium::MakeUnique<PageNode>();
     pNode->m_dwPageNo = pKid->GetRefObjNum();
     pPageNode->m_ChildNodes.push_back(std::move(pNode));
   }
   return true;
 }
 
 bool CPDF_DataAvail::CheckUnknownPageNode(uint32_t dwPageNo,
                                           PageNode* pPageNode,
                                           DownloadHints* pHints) {
-  bool bExist = false;
-  std::unique_ptr<CPDF_Object> pPage = GetObject(dwPageNo, pHints, &bExist);
-  if (!bExist) {
+  bool bExists = false;
+  std::unique_ptr<CPDF_Object> pPage = GetObject(dwPageNo, pHints, &bExists);
+  if (!bExists) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   if (!pPage) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR)
       m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
@@ skipping 111 matching lines @@
   }
   if (m_PageNode.m_type == PDF_PAGENODE_PAGE) {
     m_docStatus = iPage == 0 ? PDF_DATAAVAIL_DONE : PDF_DATAAVAIL_ERROR;
     return true;
   }
   int32_t iCount = -1;
   return CheckPageNode(m_PageNode, iPage, iCount, pHints, 0);
 }
 
 bool CPDF_DataAvail::CheckPageCount(DownloadHints* pHints) {
-  bool bExist = false;
+  bool bExists = false;
   std::unique_ptr<CPDF_Object> pPages =
-      GetObject(m_PagesObjNum, pHints, &bExist);
-  if (!bExist) {
+      GetObject(m_PagesObjNum, pHints, &bExists);
+  if (!bExists) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
-
   if (!pPages)
     return false;
 
   CPDF_Dictionary* pPagesDict = pPages->GetDict();
   if (!pPagesDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
-
   if (!pPagesDict->KeyExist("Kids"))
     return true;
 
   return pPagesDict->GetIntegerFor("Count") > 0;
 }
 
 bool CPDF_DataAvail::LoadDocPages(DownloadHints* pHints) {
   if (!CheckUnknownPageNode(m_PagesObjNum, &m_PageNode, pHints))
     return false;
 
@@ skipping 372 matching lines @@
     return false;
   std::vector<CPDF_Object*> obj_array;
   obj_array.push_back(pAcroForm);
   std::vector<CPDF_Object*> dummy;
   return AreObjectsAvailable(obj_array, true, nullptr, dummy);
 }
 
 CPDF_DataAvail::PageNode::PageNode() : m_type(PDF_PAGENODE_UNKNOWN) {}
 
 CPDF_DataAvail::PageNode::~PageNode() {}