remove some CFX_ArrayTemplate in xfa_ffdocview.h

xfa/fxfa/app/xfa_ffdocview.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 "xfa/fxfa/xfa_ffdocview.h"
 
 #include "core/fxcrt/fx_ext.h"
 #include "third_party/base/ptr_util.h"
@@ skipping 120 matching lines @@
   ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, false, true,
                                nullptr);
   ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocReady, false, true,
                                nullptr);
   RunCalculateWidgets();
   RunValidate();
   if (RunLayout()) {
     ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, false, true,
                                  nullptr);
   }
-  m_CalculateAccs.RemoveAll();
+  m_CalculateAccs.clear();
   if (m_pFocusAcc && !m_pFocusWidget) {
     SetFocusWidgetAcc(m_pFocusAcc);
   }
   m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_End;
 }
 int32_t CXFA_FFDocView::GetLayoutStatus() {
   return m_iStatus;
 }
 void CXFA_FFDocView::ShowNullTestMsg() {
   int32_t iCount = pdfium::CollectionSize<int32_t>(m_arrNullTestMsg);
@@ skipping 12 matching lines @@
           L"Message limit exceeded. Remaining %d "
           L"validation errors not reported.",
           iRemain);
       wsMsg += FX_WSTRC(L"\n") + wsTemp;
     }
     pAppProvider->MsgBox(wsMsg, pAppProvider->GetAppTitle(), XFA_MBICON_Status,
                          XFA_MB_OK);
   }
   m_arrNullTestMsg.clear();
 }
+
 void CXFA_FFDocView::UpdateDocView() {
-  if (IsUpdateLocked()) {
+  if (IsUpdateLocked())
     return;
-  }
+
   LockUpdate();
-  int32_t iNewAdds = m_NewAddedNodes.GetSize();
-  for (int32_t i = 0; i < iNewAdds; i++) {
-    CXFA_Node* pNode = m_NewAddedNodes[i];
+  for (CXFA_Node* pNode : m_NewAddedNodes) {
     InitCalculate(pNode);
     InitValidate(pNode);
     ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Ready, true, true, nullptr);
   }
-  m_NewAddedNodes.RemoveAll();
+  m_NewAddedNodes.clear();
   RunSubformIndexChange();
   RunCalculateWidgets();
   RunValidate();
   ShowNullTestMsg();
-  if (RunLayout() && m_bLayoutEvent) {
+  if (RunLayout() && m_bLayoutEvent)
     RunEventLayoutReady();
-  }
+
   m_bLayoutEvent = false;
-  m_CalculateAccs.RemoveAll();
+  m_CalculateAccs.clear();
   RunInvalidate();
   UnlockUpdate();
 }
+
 int32_t CXFA_FFDocView::CountPageViews() {
   if (!m_pXFADocLayout) {
     return 0;
   }
   return m_pXFADocLayout->CountPages();
 }
 CXFA_FFPageView* CXFA_FFDocView::GetPageView(int32_t nIndex) {
   if (!m_pXFADocLayout) {
     return nullptr;
   }
@@ skipping 366 matching lines @@
     m_pDoc->GetDocEnvironment()->PageViewEvent(nullptr,
                                                XFA_PAGEVIEWEVENT_StopLayout);
     return true;
   }
   m_bInLayoutStatus = false;
   m_pDoc->GetDocEnvironment()->PageViewEvent(nullptr,
                                              XFA_PAGEVIEWEVENT_StopLayout);
   UnlockUpdate();
   return false;
 }
+
 void CXFA_FFDocView::RunSubformIndexChange() {
-  int32_t iSubforms = m_IndexChangedSubforms.GetSize();
-  for (int32_t i = 0; i < iSubforms; i++) {
-    CXFA_Node* pSubformNode = m_IndexChangedSubforms[i];
+  for (CXFA_Node* pSubformNode : m_IndexChangedSubforms) {
     CXFA_WidgetAcc* pWidgetAcc =
         static_cast<CXFA_WidgetAcc*>(pSubformNode->GetWidgetData());
-    if (!pWidgetAcc) {
+    if (!pWidgetAcc)
       continue;
-    }
+
     CXFA_EventParam eParam;
     eParam.m_eType = XFA_EVENT_IndexChange;
     eParam.m_pTarget = pWidgetAcc;
     pWidgetAcc->ProcessEvent(XFA_ATTRIBUTEENUM_IndexChange, &eParam);
   }
-  m_IndexChangedSubforms.RemoveAll();
+  m_IndexChangedSubforms.clear();
 }
+
 void CXFA_FFDocView::AddNewFormNode(CXFA_Node* pNode) {
-  m_NewAddedNodes.Add(pNode);
+  m_NewAddedNodes.push_back(pNode);
   InitLayout(pNode);
 }
+
 void CXFA_FFDocView::AddIndexChangedSubform(CXFA_Node* pNode) {
   ASSERT(pNode->GetElementType() == XFA_Element::Subform);
-  m_IndexChangedSubforms.Add(pNode);
+  m_IndexChangedSubforms.push_back(pNode);
 }
+
 void CXFA_FFDocView::RunDocClose() {
   CXFA_Node* pRootItem =
       ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
   if (!pRootItem) {
     return;
   }
   ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocClose, false, true,
                                nullptr);
 }
 void CXFA_FFDocView::DestroyDocView() {
   ClearInvalidateList();
   m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_None;
   m_iLock = 0;
-  m_ValidateAccs.RemoveAll();
-  m_BindItems.RemoveAll();
-  m_CalculateAccs.RemoveAll();
+  m_ValidateAccs.clear();
+  m_BindItems.clear();
+  m_CalculateAccs.clear();
 }
 bool CXFA_FFDocView::IsStaticNotify() {
   return m_pDoc->GetDocType() == XFA_DOCTYPE_Static;
 }
+
 void CXFA_FFDocView::AddCalculateWidgetAcc(CXFA_WidgetAcc* pWidgetAcc) {
-  int32_t iAccs = m_CalculateAccs.GetSize();
   CXFA_WidgetAcc* pCurrentAcc =
-      iAccs > 0 ? m_CalculateAccs[iAccs - 1] : nullptr;
-  if (pCurrentAcc != pWidgetAcc) {
-    m_CalculateAccs.Add(pWidgetAcc);
-  }
+      !m_CalculateAccs.empty() ? m_CalculateAccs.back() : nullptr;
+  if (pCurrentAcc != pWidgetAcc)
+    m_CalculateAccs.push_back(pWidgetAcc);
 }
+
 void CXFA_FFDocView::AddCalculateNodeNotify(CXFA_Node* pNodeChange) {
   CXFA_CalcData* pGlobalData =
       (CXFA_CalcData*)pNodeChange->GetUserData(XFA_CalcData);
   int32_t iCount = pGlobalData ? pGlobalData->m_Globals.GetSize() : 0;
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_WidgetAcc* pResultAcc = pGlobalData->m_Globals[i];
-    if (pResultAcc->GetNode()->HasRemovedChildren())
-      continue;
-
-    int32_t iAccs = m_CalculateAccs.GetSize();
-    CXFA_WidgetAcc* pCurrentAcc =
-        iAccs > 0 ? m_CalculateAccs[iAccs - 1] : nullptr;
-    if (pCurrentAcc != pResultAcc) {
-      m_CalculateAccs.Add(pResultAcc);
-    }
+    if (!pResultAcc->GetNode()->HasRemovedChildren())
+      AddCalculateWidgetAcc(pResultAcc);
   }
 }
+
 void CXFA_FFDocView::RunCalculateRecursive(int32_t& iIndex) {
-  while (iIndex < m_CalculateAccs.GetSize()) {
+  while (iIndex < pdfium::CollectionSize<int32_t>(m_CalculateAccs)) {
     CXFA_WidgetAcc* pCurAcc = m_CalculateAccs[iIndex];
     AddCalculateNodeNotify(pCurAcc->GetNode());
     int32_t iRefCount =
         (int32_t)(uintptr_t)pCurAcc->GetNode()->GetUserData(XFA_CalcRefCount);
     iRefCount++;
     pCurAcc->GetNode()->SetUserData(XFA_CalcRefCount,
                                     (void*)(uintptr_t)iRefCount);
     if (iRefCount > 11) {
       break;
     }
     if ((pCurAcc->ProcessCalculate()) == XFA_EVENTERROR_Success) {
       AddValidateWidget(pCurAcc);
     }
     iIndex++;
     RunCalculateRecursive(iIndex);
   }
 }
+
 int32_t CXFA_FFDocView::RunCalculateWidgets() {
   if (!m_pDoc->GetDocEnvironment()->IsCalculationsEnabled(m_pDoc)) {
     return XFA_EVENTERROR_Disabled;
   }
-  int32_t iCounts = m_CalculateAccs.GetSize();
+  int32_t iCounts = pdfium::CollectionSize<int32_t>(m_CalculateAccs);
   int32_t iIndex = 0;
-  if (iCounts > 0) {
+  if (iCounts > 0)
     RunCalculateRecursive(iIndex);
-  }
-  for (int32_t i = 0; i < m_CalculateAccs.GetSize(); i++) {
-    CXFA_WidgetAcc* pCurAcc = m_CalculateAccs[i];
+
+  for (CXFA_WidgetAcc* pCurAcc : m_CalculateAccs)
     pCurAcc->GetNode()->SetUserData(XFA_CalcRefCount, (void*)(uintptr_t)0);
-  }
-  m_CalculateAccs.RemoveAll();
+
+  m_CalculateAccs.clear();
   return XFA_EVENTERROR_Success;
 }
+
 void CXFA_FFDocView::AddValidateWidget(CXFA_WidgetAcc* pWidget) {
-  if (m_ValidateAccs.Find(pWidget) < 0)
-    m_ValidateAccs.Add(pWidget);
+  if (!pdfium::ContainsValue(m_ValidateAccs, pWidget))
+    m_ValidateAccs.push_back(pWidget);
 }
+
 bool CXFA_FFDocView::InitCalculate(CXFA_Node* pNode) {
   ExecEventActivityByDeepFirst(pNode, XFA_EVENT_InitCalculate, false, true,
                                nullptr);
   return true;
 }
+
 bool CXFA_FFDocView::InitValidate(CXFA_Node* pNode) {
-  if (!m_pDoc->GetDocEnvironment()->IsValidationsEnabled(m_pDoc)) {
+  if (!m_pDoc->GetDocEnvironment()->IsValidationsEnabled(m_pDoc))
     return false;
-  }
+
   ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Validate, false, true, nullptr);
-  m_ValidateAccs.RemoveAll();
+  m_ValidateAccs.clear();
   return true;
 }
+
 bool CXFA_FFDocView::RunValidate() {
-  if (!m_pDoc->GetDocEnvironment()->IsValidationsEnabled(m_pDoc)) {
+  if (!m_pDoc->GetDocEnvironment()->IsValidationsEnabled(m_pDoc))
     return false;
+
+  for (CXFA_WidgetAcc* pAcc : m_ValidateAccs) {
+    if (!pAcc->GetNode()->HasRemovedChildren())
+      pAcc->ProcessValidate();
   }
-  int32_t iCounts = m_ValidateAccs.GetSize();
-  for (int32_t i = 0; i < iCounts; i++) {
-    CXFA_WidgetAcc* pAcc = m_ValidateAccs[i];
-    if (pAcc->GetNode()->HasRemovedChildren())
-      continue;
-
-    pAcc->ProcessValidate();
-  }
-  m_ValidateAccs.RemoveAll();
+  m_ValidateAccs.clear();
   return true;
 }
 bool CXFA_FFDocView::RunEventLayoutReady() {
   CXFA_Node* pRootItem =
       ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
   if (!pRootItem) {
     return false;
   }
   ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, false, true,
                                nullptr);
   RunLayout();
   return true;
 }
 void CXFA_FFDocView::RunBindItems() {
-  for (int32_t i = 0; i < m_BindItems.GetSize(); i++) {
-    if (m_BindItems[i]->HasRemovedChildren())
+  for (const auto& item : m_BindItems) {
+    if (item->HasRemovedChildren())
       continue;
 
-    CXFA_Node* pWidgetNode = m_BindItems[i]->GetNodeItem(XFA_NODEITEM_Parent);
+    CXFA_Node* pWidgetNode = item->GetNodeItem(XFA_NODEITEM_Parent);
     CXFA_WidgetAcc* pAcc =
         static_cast<CXFA_WidgetAcc*>(pWidgetNode->GetWidgetData());
     if (!pAcc)
       continue;
 
-    CXFA_BindItems binditems(m_BindItems[i]);
+    CXFA_BindItems binditems(item);
     CXFA_ScriptContext* pScriptContext =
         pWidgetNode->GetDocument()->GetScriptContext();
     CFX_WideStringC wsRef;
     binditems.GetRef(wsRef);
     uint32_t dwStyle = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Properties |
                        XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_Parent |
                        XFA_RESOLVENODE_ALL;
     XFA_RESOLVENODE_RS rs;
     pScriptContext->ResolveObjects(pWidgetNode, wsRef, rs, dwStyle);
     int32_t iCount = rs.nodes.GetSize();
@@ skipping 31 matching lines @@
           CXFA_Node* nodeLabel = refNode->GetFirstChildByName(wsLabelRef);
           if (nodeLabel)
             wsLabel = nodeLabel->GetContent();
         }
       } else {
         wsLabel = wsValue;
       }
       pAcc->InsertItem(wsLabel, wsValue);
     }
   }
-  m_BindItems.RemoveAll();
+  m_BindItems.clear();
 }
 void CXFA_FFDocView::SetChangeMark() {
   if (m_iStatus < XFA_DOCVIEW_LAYOUTSTATUS_End) {
     return;
   }
   m_pDoc->GetDocEnvironment()->SetChangeMark(m_pDoc);
 }
 CXFA_Node* CXFA_FFDocView::GetRootSubform() {
   CXFA_Node* pFormPacketNode =
       ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
@@ skipping 44 matching lines @@
 }
 
 bool CXFA_WidgetAccIterator::SetCurrentWidgetAcc(CXFA_WidgetAcc* hWidget) {
   return false;
 }
 
 void CXFA_WidgetAccIterator::SkipTree() {
   m_ContentIterator.SkipChildrenAndMoveToNext();
   m_pCurWidgetAcc = nullptr;
 }