Replace CXFA_StrokeArray and CXFA_WidgetArray with std::vector

xfa/fxfa/app/xfa_ffpageview.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_ffpageview.h"
 
+#include <memory>
+#include <vector>
+
+#include "third_party/base/ptr_util.h"
+#include "third_party/base/stl_util.h"
 #include "xfa/fde/fde_render.h"
 #include "xfa/fxfa/app/xfa_ffcheckbutton.h"
 #include "xfa/fxfa/app/xfa_ffchoicelist.h"
 #include "xfa/fxfa/app/xfa_fffield.h"
 #include "xfa/fxfa/app/xfa_ffimageedit.h"
 #include "xfa/fxfa/app/xfa_ffpushbutton.h"
 #include "xfa/fxfa/app/xfa_fftextedit.h"
 #include "xfa/fxfa/app/xfa_fwladapter.h"
 #include "xfa/fxfa/xfa_ffdoc.h"
 #include "xfa/fxfa/xfa_ffdocview.h"
@@ skipping 202 matching lines @@
       XFA_VERSION_205;
   Reset();
 }
 
 CXFA_FFTabOrderPageWidgetIterator::~CXFA_FFTabOrderPageWidgetIterator() {}
 
 void CXFA_FFTabOrderPageWidgetIterator::Reset() {
   CreateTabOrderWidgetArray();
   m_iCurWidget = -1;
 }
+
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::MoveToFirst() {
-  if (m_TabOrderWidgetArray.GetSize() > 0) {
-    for (int32_t i = 0; i < m_TabOrderWidgetArray.GetSize(); i++) {
-      if (PageWidgetFilter(m_TabOrderWidgetArray[i], m_dwFilter, true,
-                           m_bIgnorerelevant)) {
-        m_iCurWidget = i;
-        return m_TabOrderWidgetArray[m_iCurWidget];
-      }
+  for (int32_t i = 0;
+       i < pdfium::CollectionSize<int32_t>(m_TabOrderWidgetArray); i++) {
+    if (PageWidgetFilter(m_TabOrderWidgetArray[i], m_dwFilter, true,
+                         m_bIgnorerelevant)) {
+      m_iCurWidget = i;
+      return m_TabOrderWidgetArray[m_iCurWidget];
     }
   }
   return nullptr;
 }
+
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::MoveToLast() {
-  if (m_TabOrderWidgetArray.GetSize() > 0) {
-    for (int32_t i = m_TabOrderWidgetArray.GetSize() - 1; i >= 0; i--) {
+  if (!m_TabOrderWidgetArray.empty()) {

[npm, 2017/01/23 14:49:50]

Do you need this if, or can it also be deleted?

[Tom Sepez, 2017/01/23 18:36:51]

I kept it so that if we decide to go to signed indexing, we don't compute  0 - 1
= big on line 251.

[npm, 2017/01/23 18:51:51]

Won't it be -1, since you are using int? Also, why keep here and remove from the
above method?

[Tom Sepez, 2017/01/23 18:59:45]

Fixed.

+    for (int32_t i = pdfium::CollectionSize<int32_t>(m_TabOrderWidgetArray) - 1;
+         i >= 0; i--) {
       if (PageWidgetFilter(m_TabOrderWidgetArray[i], m_dwFilter, true,
                            m_bIgnorerelevant)) {
         m_iCurWidget = i;
         return m_TabOrderWidgetArray[m_iCurWidget];
       }
     }
   }
   return nullptr;
 }
+
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::MoveToNext() {
-  for (int32_t i = m_iCurWidget + 1; i < m_TabOrderWidgetArray.GetSize(); i++) {
+  for (int32_t i = m_iCurWidget + 1;
+       i < pdfium::CollectionSize<int32_t>(m_TabOrderWidgetArray); i++) {
     if (PageWidgetFilter(m_TabOrderWidgetArray[i], m_dwFilter, true,
                          m_bIgnorerelevant)) {
       m_iCurWidget = i;
       return m_TabOrderWidgetArray[m_iCurWidget];
     }
   }
   m_iCurWidget = -1;
   return nullptr;
 }
+
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::MoveToPrevious() {
   for (int32_t i = m_iCurWidget - 1; i >= 0; i--) {
     if (PageWidgetFilter(m_TabOrderWidgetArray[i], m_dwFilter, true,
                          m_bIgnorerelevant)) {
       m_iCurWidget = i;
       return m_TabOrderWidgetArray[m_iCurWidget];
     }
   }
   m_iCurWidget = -1;
   return nullptr;
 }
+
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::GetCurrentWidget() {
-  if (m_iCurWidget >= 0) {
-    return m_TabOrderWidgetArray[m_iCurWidget];
-  }
-  return nullptr;
+  return m_iCurWidget >= 0 ? m_TabOrderWidgetArray[m_iCurWidget] : nullptr;
 }
+
 bool CXFA_FFTabOrderPageWidgetIterator::SetCurrentWidget(
     CXFA_FFWidget* hWidget) {
-  int32_t iWidgetIndex = m_TabOrderWidgetArray.Find(hWidget);
-  if (iWidgetIndex >= 0) {
-    m_iCurWidget = iWidgetIndex;
-    return true;
-  }
-  return false;
+  auto it = std::find(m_TabOrderWidgetArray.begin(),
+                      m_TabOrderWidgetArray.end(), hWidget);
+  if (it == m_TabOrderWidgetArray.end())
+    return false;
+
+  m_iCurWidget = it - m_TabOrderWidgetArray.begin();
+  return true;
 }
+
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::GetTraverseWidget(
     CXFA_FFWidget* pWidget) {
   CXFA_WidgetAcc* pAcc = pWidget->GetDataAcc();
   CXFA_Node* pTraversal = pAcc->GetNode()->GetChild(0, XFA_Element::Traversal);
   if (pTraversal) {
     CXFA_Node* pTraverse = pTraversal->GetChild(0, XFA_Element::Traverse);
     if (pTraverse) {
       CFX_WideString wsTraverseWidgetName;
       if (pTraverse->GetAttribute(XFA_ATTRIBUTE_Ref, wsTraverseWidgetName)) {
         return FindWidgetByName(wsTraverseWidgetName, pWidget);
       }
     }
   }
   return nullptr;
 }
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::FindWidgetByName(
     const CFX_WideString& wsWidgetName,
     CXFA_FFWidget* pRefWidget) {
   return pRefWidget->GetDocView()->GetWidgetByName(wsWidgetName, pRefWidget);
 }
+
 void CXFA_FFTabOrderPageWidgetIterator::CreateTabOrderWidgetArray() {
-  m_TabOrderWidgetArray.RemoveAll();
-  CXFA_WidgetArray SpaceOrderWidgetArray;
-  CreateSpaceOrderWidgetArray(SpaceOrderWidgetArray);
-  int32_t nWidgetCount = SpaceOrderWidgetArray.GetSize();
-  if (nWidgetCount < 1) {
+  m_TabOrderWidgetArray.clear();
+
+  std::vector<CXFA_FFWidget*> SpaceOrderWidgetArray;
+  CreateSpaceOrderWidgetArray(&SpaceOrderWidgetArray);
+  if (SpaceOrderWidgetArray.empty())
     return;
-  }
+
+  int32_t nWidgetCount = pdfium::CollectionSize<int32_t>(SpaceOrderWidgetArray);
   CXFA_FFWidget* hWidget = SpaceOrderWidgetArray[0];
-  for (; m_TabOrderWidgetArray.GetSize() < nWidgetCount;) {
-    if (m_TabOrderWidgetArray.Find(hWidget) < 0) {
-      m_TabOrderWidgetArray.Add(hWidget);
+  while (pdfium::CollectionSize<int32_t>(m_TabOrderWidgetArray) <
+         nWidgetCount) {
+    if (!pdfium::ContainsValue(m_TabOrderWidgetArray, hWidget)) {
+      m_TabOrderWidgetArray.push_back(hWidget);
       CXFA_WidgetAcc* pWidgetAcc = hWidget->GetDataAcc();
       if (pWidgetAcc->GetUIType() == XFA_Element::ExclGroup) {
-        int32_t iWidgetIndex = SpaceOrderWidgetArray.Find(hWidget) + 1;
+        auto it = std::find(SpaceOrderWidgetArray.begin(),
+                            SpaceOrderWidgetArray.end(), hWidget);
+        int32_t iWidgetIndex = it != SpaceOrderWidgetArray.end()
+                                   ? it - SpaceOrderWidgetArray.begin() + 1
+                                   : 0;
         while (true) {
           CXFA_FFWidget* pRadio =
-              SpaceOrderWidgetArray[(iWidgetIndex) % nWidgetCount];
+              SpaceOrderWidgetArray[iWidgetIndex % nWidgetCount];
           if (pRadio->GetDataAcc()->GetExclGroup() != pWidgetAcc) {
             break;
           }
-          if (m_TabOrderWidgetArray.Find(hWidget) < 0) {
-            m_TabOrderWidgetArray.Add(pRadio);
+          if (!pdfium::ContainsValue(m_TabOrderWidgetArray, hWidget)) {
+            m_TabOrderWidgetArray.push_back(pRadio);
           }
           iWidgetIndex++;
         }
       }
       if (CXFA_FFWidget* hTraverseWidget = GetTraverseWidget(hWidget)) {
         hWidget = hTraverseWidget;
         continue;
       }
     }
-    int32_t iWidgetIndex = SpaceOrderWidgetArray.Find(hWidget);
-    hWidget = SpaceOrderWidgetArray[(iWidgetIndex + 1) % nWidgetCount];
+    auto it = std::find(SpaceOrderWidgetArray.begin(),
+                        SpaceOrderWidgetArray.end(), hWidget);
+    int32_t iWidgetIndex = it != SpaceOrderWidgetArray.end()
+                               ? it - SpaceOrderWidgetArray.begin() + 1
+                               : 0;
+    hWidget = SpaceOrderWidgetArray[iWidgetIndex % nWidgetCount];
   }
 }
+
 static int32_t XFA_TabOrderWidgetComparator(const void* phWidget1,
                                             const void* phWidget2) {
   CXFA_FFWidget* pWidget1 = (*(CXFA_TabParam**)phWidget1)->m_pWidget;
   CXFA_FFWidget* pWidget2 = (*(CXFA_TabParam**)phWidget2)->m_pWidget;
   CFX_RectF rt1, rt2;
   pWidget1->GetWidgetRect(rt1);
   pWidget2->GetWidgetRect(rt2);
   FX_FLOAT x1 = rt1.left, y1 = rt1.top, x2 = rt2.left, y2 = rt2.top;
   if (y1 < y2 || (y1 - y2 < XFA_FLOAT_PERCISION && x1 < x2)) {
     return -1;
@@ skipping 42 matching lines @@
     } else {
       pSearchItem = sIterator->MoveToNext();
     }
   }
   int32_t iChildren = tabParams.GetSize();
   if (iChildren > 1) {
     FXSYS_qsort(tabParams.GetData(), iChildren, sizeof(void*),
                 XFA_TabOrderWidgetComparator);
   }
   for (int32_t iStart = 0; iStart < iChildren; iStart++) {
-    CXFA_TabParam* pParam = tabParams[iStart];
-    pContainer->m_Children.Add(pParam->m_pWidget);
-    if (pParam->m_Children.GetSize() > 0) {
-      pContainer->m_Children.Append(pParam->m_Children);
-    }
-    delete pParam;
+    std::unique_ptr<CXFA_TabParam> pParam(tabParams[iStart]);
+    pContainer->m_Children.push_back(pParam->m_pWidget);
+    pContainer->m_Children.insert(pContainer->m_Children.end(),
+                                  pParam->m_Children.begin(),
+                                  pParam->m_Children.end());
   }
   tabParams.RemoveAll();
 }
 void CXFA_FFTabOrderPageWidgetIterator::CreateSpaceOrderWidgetArray(
-    CXFA_WidgetArray& WidgetArray) {
+    std::vector<CXFA_FFWidget*>* WidgetArray) {
   CXFA_LayoutItemIterator sIterator;
   sIterator.Init(m_pPageView);
-  CXFA_TabParam* pParam = new CXFA_TabParam;
+  auto pParam = pdfium::MakeUnique<CXFA_TabParam>();
   bool bCurrentItem = false;
   bool bContentArea = false;
-  OrderContainer(&sIterator, nullptr, pParam, bCurrentItem, bContentArea);
-  if (pParam->m_Children.GetSize() > 0) {
-    WidgetArray.Append(pParam->m_Children);
-  }
+  OrderContainer(&sIterator, nullptr, pParam.get(), bCurrentItem, bContentArea);
+  WidgetArray->insert(WidgetArray->end(), pParam->m_Children.begin(),
+                      pParam->m_Children.end());
+
   sIterator.Reset();
   bCurrentItem = false;
   bContentArea = false;
-  pParam->m_Children.RemoveAll();
-  OrderContainer(&sIterator, nullptr, pParam, bCurrentItem, bContentArea, true);
-  if (pParam->m_Children.GetSize() > 0) {
-    WidgetArray.Append(pParam->m_Children);
-  }
-  delete pParam;
+  pParam->m_Children.clear();
+  OrderContainer(&sIterator, nullptr, pParam.get(), bCurrentItem, bContentArea,
+                 true);
+  WidgetArray->insert(WidgetArray->end(), pParam->m_Children.begin(),
+                      pParam->m_Children.end());
 }
+
 CXFA_FFWidget* CXFA_FFTabOrderPageWidgetIterator::GetWidget(
     CXFA_LayoutItem* pLayoutItem) {
   if (CXFA_FFWidget* pWidget = XFA_GetWidgetFromLayoutItem(pLayoutItem)) {
     if (!pWidget->IsLoaded() &&
         (pWidget->GetStatus() & XFA_WidgetStatus_Visible)) {
       pWidget->LoadWidget();
     }
     return pWidget;
   }
   return nullptr;
 }
 
 CXFA_TabParam::CXFA_TabParam() : m_pWidget(nullptr) {}
 
 CXFA_TabParam::~CXFA_TabParam() {}