Replace CFX_FloatArray with std::vector

xfa/fxfa/app/xfa_textlayout.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_textlayout.h"
 
 #include <algorithm>
 
 #include "core/fxcrt/fx_ext.h"
+#include "third_party/base/stl_util.h"
 #include "xfa/fde/cfde_path.h"
 #include "xfa/fde/css/fde_csscache.h"
 #include "xfa/fde/css/fde_cssstyleselector.h"
 #include "xfa/fde/fde_gedevice.h"
 #include "xfa/fde/fde_object.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fxfa/app/xfa_ffwidgetacc.h"
 #include "xfa/fxfa/parser/cxfa_measurement.h"
 #include "xfa/fxfa/xfa_ffapp.h"
@@ skipping 975 matching lines @@
   }
   FX_FLOAT fLinePos = m_pLoader->m_fStartLineOffset;
   int32_t iLineIndex = 0;
   if (iBlockCount > 1) {
     if (iBlockCount >= (iBlockIndex + 1) * 2) {
       iLineIndex = m_Blocks.ElementAt(iBlockIndex * 2);
     } else {
       iLineIndex = m_Blocks.ElementAt(iBlockCount - 1) +
                    m_Blocks.ElementAt(iBlockCount - 2);
     }
-    if (m_pLoader->m_BlocksHeight.GetSize() > 0) {
-      for (int32_t i = 0; i < iBlockIndex; i++) {
-        fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
-      }
+    if (!m_pLoader->m_BlocksHeight.empty()) {
+      for (int32_t i = 0; i < iBlockIndex; i++)
+        fLinePos -= m_pLoader->m_BlocksHeight[i * 2 + 1];
     }
   }
   int32_t iCount = m_pLoader->m_lineHeights.GetSize();
   int32_t i = 0;
   for (i = iLineIndex; i < iCount; i++) {
     FX_FLOAT fLineHeight = m_pLoader->m_lineHeights.ElementAt(i);
     if ((i == iLineIndex) && (fLineHeight - fContentAreaHeight > 0.001)) {
       fCalcHeight = 0;
       return true;
     }
     if (fLinePos + fLineHeight - fContentAreaHeight > 0.001) {
       if (iBlockCount >= (iBlockIndex + 1) * 2) {
         m_Blocks.SetAt(iBlockIndex * 2, iLineIndex);
         m_Blocks.SetAt(iBlockIndex * 2 + 1, i - iLineIndex);
       } else {
         m_Blocks.Add(iLineIndex);
         m_Blocks.Add(i - iLineIndex);
       }
       if (i == iLineIndex) {
         if (fCalcHeight <= fLinePos) {
-          if (m_pLoader->m_BlocksHeight.GetSize() > iBlockIndex * 2 &&
-              (m_pLoader->m_BlocksHeight.GetAt(iBlockIndex * 2) ==
-               iBlockIndex)) {
-            m_pLoader->m_BlocksHeight.SetAt(iBlockIndex * 2 + 1, fCalcHeight);
+          if (pdfium::CollectionSize<int32_t>(m_pLoader->m_BlocksHeight) >
+                  iBlockIndex * 2 &&
+              (m_pLoader->m_BlocksHeight[iBlockIndex * 2] == iBlockIndex)) {
+            m_pLoader->m_BlocksHeight[iBlockIndex * 2 + 1] = fCalcHeight;
           } else {
-            m_pLoader->m_BlocksHeight.Add((FX_FLOAT)iBlockIndex);
-            m_pLoader->m_BlocksHeight.Add(fCalcHeight);
+            m_pLoader->m_BlocksHeight.push_back((FX_FLOAT)iBlockIndex);
+            m_pLoader->m_BlocksHeight.push_back(fCalcHeight);
           }
         }
         return true;
       }
       fCalcHeight = fLinePos;
       return true;
     }
     fLinePos += fLineHeight;
   }
   return false;
@@ skipping 48 matching lines @@
     return false;
   if (m_pLoader->m_fWidth < 1)
     return false;
 
   m_pLoader->m_iTotalLines = -1;
   m_iLines = 0;
   FX_FLOAT fLinePos = 0;
   CXFA_Node* pNode = nullptr;
   CFX_SizeF szText(m_pLoader->m_fWidth, m_pLoader->m_fHeight);
   int32_t iCount = m_Blocks.GetSize();
-  int32_t iBlocksHeightCount = m_pLoader->m_BlocksHeight.GetSize();
+  int32_t iBlocksHeightCount =
+      pdfium::CollectionSize<int32_t>(m_pLoader->m_BlocksHeight);
   iBlocksHeightCount /= 2;
   if (iBlock < iBlocksHeightCount)
     return true;
   if (iBlock == iBlocksHeightCount) {
     Unload();
     m_pBreak.reset(CreateBreak(true));
     fLinePos = m_pLoader->m_fStartLineOffset;
     for (int32_t i = 0; i < iBlocksHeightCount; i++) {
-      fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
+      fLinePos -= m_pLoader->m_BlocksHeight[i * 2 + 1];
     }
     m_pLoader->m_iChar = 0;
     if (iCount > 1)
       m_pLoader->m_iTotalLines = m_Blocks.ElementAt(iBlock * 2 + 1);
     Loader(szText, fLinePos, true);
     if (iCount == 0 && m_pLoader->m_fStartLineOffset < 0.1f)
       UpdateAlign(szText.y, fLinePos);
   } else if (m_pTextDataNode) {
     iBlock *= 2;
     if (iBlock < iCount - 2)
@@ skipping 54 matching lines @@
   }
   int32_t iCountHeight = m_pLoader->m_lineHeights.GetSize();
   if (iCountHeight == 0) {
     return;
   }
   bool bEndItem = true;
   int32_t iBlockCount = m_Blocks.GetSize();
   FX_FLOAT fLinePos = m_pLoader->m_fStartLineOffset;
   int32_t iLineIndex = 0;
   if (iBlockIndex > 0) {
-    int32_t iBlockHeightCount = m_pLoader->m_BlocksHeight.GetSize();
+    int32_t iBlockHeightCount =
+        pdfium::CollectionSize<int32_t>(m_pLoader->m_BlocksHeight);
     iBlockHeightCount /= 2;
     if (iBlockHeightCount >= iBlockIndex) {
       for (int32_t i = 0; i < iBlockIndex; i++) {
-        fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
+        fLinePos -= m_pLoader->m_BlocksHeight[i * 2 + 1];
       }
     } else {
       fLinePos = 0;
     }
-    iLineIndex = m_Blocks.ElementAt(iBlockCount - 1) +
-                 m_Blocks.ElementAt(iBlockCount - 2);
+    iLineIndex = m_Blocks[iBlockCount - 1] + m_Blocks[iBlockCount - 2];
   }
   int32_t i = 0;
   for (i = iLineIndex; i < iCountHeight; i++) {
     FX_FLOAT fLineHeight = m_pLoader->m_lineHeights.ElementAt(i);
     if (fLinePos + fLineHeight - rtText.height > 0.001) {
       m_Blocks.Add(iLineIndex);
       m_Blocks.Add(i - iLineIndex);
       bEndItem = false;
       break;
     }
@@ skipping 883 matching lines @@
   m_tabstops.RemoveAll();
   m_iTabCount = 0;
 }
 
 void CXFA_TextTabstopsContext::Reset() {
   m_iTabIndex = -1;
   m_bTabstops = false;
   m_fTabWidth = 0;
   m_fLeft = 0;
 }