Replace CFX_FloatArray with std::vector

xfa/fxfa/app/xfa_ffwidgetacc.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/app/xfa_ffwidgetacc.h"
 
 #include <algorithm>
 #include <memory>
+#include <vector>
 
 #include "fxjs/cfxjse_value.h"
+#include "third_party/base/stl_util.h"
 #include "xfa/fde/tto/fde_textout.h"
 #include "xfa/fde/xml/fde_xml_imp.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_fwladapter.h"
 #include "xfa/fxfa/app/xfa_textlayout.h"
 #include "xfa/fxfa/cxfa_eventparam.h"
 #include "xfa/fxfa/parser/cxfa_layoutprocessor.h"
 #include "xfa/fxfa/parser/cxfa_scriptcontext.h"
@@ skipping 95 matching lines @@
       return false;
     m_pCapTextProvider.reset(
         new CXFA_TextProvider(pAcc, XFA_TEXTPROVIDERTYPE_Caption));
     m_pCapTextLayout.reset(new CXFA_TextLayout(m_pCapTextProvider.get()));
     return true;
   }
 
   std::unique_ptr<CXFA_TextLayout> m_pCapTextLayout;
   std::unique_ptr<CXFA_TextProvider> m_pCapTextProvider;
   std::unique_ptr<CFDE_TextOut> m_pTextOut;
-  std::unique_ptr<CFX_FloatArray> m_pFieldSplitArray;
+  std::vector<FX_FLOAT> m_FieldSplitArray;
 };
 
 class CXFA_TextEditData : public CXFA_FieldLayoutData {
  public:
 };
 
 class CXFA_ImageEditData : public CXFA_FieldLayoutData {
  public:
   CXFA_ImageEditData()
       : m_pDIBitmap(nullptr),
@@ skipping 1093 matching lines @@
   if (wsText.IsEmpty()) {
     iLinesCount = 1;
   } else {
     if (!pFieldData->m_pTextOut) {
       FX_FLOAT fWidth = 0;
       GetWidth(fWidth);
       CalculateAccWidthAndHeight(eUIType, fWidth, fHeight);
     }
     iLinesCount = pFieldData->m_pTextOut->GetTotalLines();
   }
-  if (!pFieldData->m_pFieldSplitArray) {
-    pFieldData->m_pFieldSplitArray.reset(new CFX_FloatArray);
-  }
-  CFX_FloatArray* pFieldArray = pFieldData->m_pFieldSplitArray.get();
-  int32_t iFieldSplitCount = pFieldArray->GetSize();
+  std::vector<FX_FLOAT>* pFieldArray = &pFieldData->m_FieldSplitArray;
+  int32_t iFieldSplitCount = pdfium::CollectionSize<int32_t>(*pFieldArray);
   for (int32_t i = 0; i < iBlockIndex * 3; i += 3) {
-    iLinesCount -= (int32_t)pFieldArray->GetAt(i + 1);
-    fHeight -= pFieldArray->GetAt(i + 2);
+    iLinesCount -= (int32_t)(*pFieldArray)[i + 1];
+    fHeight -= (*pFieldArray)[i + 2];
   }
   if (iLinesCount == 0) {
     return false;
   }
   FX_FLOAT fLineHeight = GetLineHeight();
   FX_FLOAT fFontSize = GetFontSize();
   FX_FLOAT fTextHeight = iLinesCount * fLineHeight - fLineHeight + fFontSize;
   FX_FLOAT fSpaceAbove = 0;
   FX_FLOAT fStartOffset = 0;
   if (fHeight > 0.1f && iBlockIndex == 0) {
     fStartOffset = fTopInset;
     fHeight -= (fTopInset + fBottomInset);
     if (CXFA_Para para = GetPara()) {
       fSpaceAbove = para.GetSpaceAbove();
       FX_FLOAT fSpaceBelow = para.GetSpaceBelow();
       fHeight -= (fSpaceAbove + fSpaceBelow);
       switch (para.GetVerticalAlign()) {
         case XFA_ATTRIBUTEENUM_Top:
           fStartOffset += fSpaceAbove;
           break;
         case XFA_ATTRIBUTEENUM_Middle:
           fStartOffset += ((fHeight - fTextHeight) / 2 + fSpaceAbove);
           break;
         case XFA_ATTRIBUTEENUM_Bottom:
           fStartOffset += (fHeight - fTextHeight + fSpaceAbove);
           break;
       }
     }
-    if (fStartOffset < 0.1f) {
+    if (fStartOffset < 0.1f)
       fStartOffset = 0;
-    }
   }
   for (int32_t i = iBlockIndex - 1; iBlockIndex > 0 && i < iBlockIndex; i++) {
-    fStartOffset = pFieldArray->GetAt(i * 3) - pFieldArray->GetAt(i * 3 + 2);
-    if (fStartOffset < 0.1f) {
+    fStartOffset = (*pFieldArray)[i * 3] - (*pFieldArray)[i * 3 + 2];
+    if (fStartOffset < 0.1f)
       fStartOffset = 0;
-    }
   }
   if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
-    pFieldArray->SetAt(0, fStartOffset);
+    (*pFieldArray)[0] = fStartOffset;
   } else {
-    pFieldArray->Add(fStartOffset);
+    pFieldArray->push_back(fStartOffset);
   }
   XFA_VERSION version = GetDoc()->GetXFADoc()->GetCurVersionMode();
   bool bCanSplitNoContent = false;
   XFA_ATTRIBUTEENUM eLayoutMode;
   GetNode()
       ->GetNodeItem(XFA_NODEITEM_Parent)
       ->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, true);
   if ((eLayoutMode == XFA_ATTRIBUTEENUM_Position ||
        eLayoutMode == XFA_ATTRIBUTEENUM_Tb ||
        eLayoutMode == XFA_ATTRIBUTEENUM_Row ||
@@ skipping 12 matching lines @@
       return true;
     }
   }
   if (bCanSplitNoContent) {
     if ((fCalcHeight - fTopInset - fSpaceAbove < fLineHeight)) {
       fCalcHeight = 0;
       return true;
     }
     if (fStartOffset + XFA_FLOAT_PERCISION >= fCalcHeight) {
       if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
-        pFieldArray->SetAt(iBlockIndex * 3 + 1, 0);
-        pFieldArray->SetAt(iBlockIndex * 3 + 2, fCalcHeight);
+        (*pFieldArray)[iBlockIndex * 3 + 1] = 0;
+        (*pFieldArray)[iBlockIndex * 3 + 2] = fCalcHeight;
       } else {
-        pFieldArray->Add(0);
-        pFieldArray->Add(fCalcHeight);
+        pFieldArray->push_back(0);
+        pFieldArray->push_back(fCalcHeight);
       }
       return false;
     }
     if (fCalcHeight - fStartOffset < fLineHeight) {
       fCalcHeight = fStartOffset;
       if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
-        pFieldArray->SetAt(iBlockIndex * 3 + 1, 0);
-        pFieldArray->SetAt(iBlockIndex * 3 + 2, fCalcHeight);
+        (*pFieldArray)[iBlockIndex * 3 + 1] = 0;
+        (*pFieldArray)[iBlockIndex * 3 + 2] = fCalcHeight;
       } else {
-        pFieldArray->Add(0);
-        pFieldArray->Add(fCalcHeight);
+        pFieldArray->push_back(0);
+        pFieldArray->push_back(fCalcHeight);
       }
       return true;
     }
     FX_FLOAT fTextNum =
         fCalcHeight + XFA_FLOAT_PERCISION - fCapReserve - fStartOffset;
     int32_t iLineNum =
         (int32_t)((fTextNum + (fLineHeight - fFontSize)) / fLineHeight);
     if (iLineNum >= iLinesCount) {
       if (fCalcHeight - fStartOffset - fTextHeight >= fFontSize) {
         if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
-          pFieldArray->SetAt(iBlockIndex * 3 + 1, (FX_FLOAT)iLinesCount);
-          pFieldArray->SetAt(iBlockIndex * 3 + 2, fCalcHeight);
+          (*pFieldArray)[iBlockIndex * 3 + 1] = (FX_FLOAT)iLinesCount;
+          (*pFieldArray)[iBlockIndex * 3 + 2] = fCalcHeight;
         } else {
-          pFieldArray->Add((FX_FLOAT)iLinesCount);
-          pFieldArray->Add(fCalcHeight);
+          pFieldArray->push_back((FX_FLOAT)iLinesCount);
+          pFieldArray->push_back(fCalcHeight);
         }
         return false;
       }
       if (fHeight - fStartOffset - fTextHeight < fFontSize) {
         iLineNum -= 1;
         if (iLineNum == 0) {
           fCalcHeight = 0;
           return true;
         }
       } else {
         iLineNum = (int32_t)(fTextNum / fLineHeight);
       }
     }
     if (iLineNum > 0) {
       FX_FLOAT fSplitHeight =
           iLineNum * fLineHeight + fCapReserve + fStartOffset;
       if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
-        pFieldArray->SetAt(iBlockIndex * 3 + 1, (FX_FLOAT)iLineNum);
-        pFieldArray->SetAt(iBlockIndex * 3 + 2, fSplitHeight);
+        (*pFieldArray)[iBlockIndex * 3 + 1] = (FX_FLOAT)iLineNum;
+        (*pFieldArray)[iBlockIndex * 3 + 2] = fSplitHeight;
       } else {
-        pFieldArray->Add((FX_FLOAT)iLineNum);
-        pFieldArray->Add(fSplitHeight);
+        pFieldArray->push_back((FX_FLOAT)iLineNum);
+        pFieldArray->push_back(fSplitHeight);
       }
       if (fabs(fSplitHeight - fCalcHeight) < XFA_FLOAT_PERCISION) {
         return false;
       }
       fCalcHeight = fSplitHeight;
       return true;
     }
   }
   fCalcHeight = 0;
   return true;
@@ skipping 298 matching lines @@
     if (pIDNode) {
       pEmbAcc = static_cast<CXFA_WidgetAcc*>(pIDNode->GetWidgetData());
     }
     if (pEmbAcc) {
       pEmbAcc->GetValue(wsValue, XFA_VALUEPICTURE_Display);
       return true;
     }
   }
   return false;
 }