Use std::vector for fx_ucd.h arrays.

xfa/fgas/layout/fgas_rtfbreak.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/fgas/layout/fgas_rtfbreak.h"
 
 #include <algorithm>
 
@@ skipping 255 matching lines @@
   int32_t iCount = m_pCurLine->CountChars();
   if (iCount < 1) {
     return;
   }
   CFX_RTFChar& tc = m_pCurLine->GetChar(iCount - 1);
   if (tc.m_dwStatus == 0) {
     tc.m_dwStatus = FX_RTFBREAK_PieceBreak;
   }
 }
 CFX_RTFChar* CFX_RTFBreak::GetLastChar(int32_t index) const {
-  CFX_RTFCharArray& tca = m_pCurLine->m_LineChars;
-  int32_t iCount = tca.GetSize();
+  std::vector<CFX_RTFChar>& tca = m_pCurLine->m_LineChars;
+  int32_t iCount = pdfium::CollectionSize<int32_t>(tca);
   if (index < 0 || index >= iCount) {
     return nullptr;
   }
-  CFX_RTFChar* pTC;
   int32_t iStart = iCount - 1;
   while (iStart > -1) {
-    pTC = tca.GetDataPtr(iStart--);
+    CFX_RTFChar* pTC = &tca[iStart--];
     if (pTC->m_iCharWidth >= 0 ||
         pTC->GetCharType() != FX_CHARTYPE_Combination) {
       if (--index < 0) {
         return pTC;
       }
     }
   }
   return nullptr;
 }
 CFX_RTFLine* CFX_RTFBreak::GetRTFLine(bool bReady) const {
@@ skipping 47 matching lines @@
     &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Others,
     &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Others,
 };
 uint32_t CFX_RTFBreak::AppendChar(FX_WCHAR wch) {
   ASSERT(m_pFont && m_pCurLine);
   if (m_bCharCode)
     return AppendChar_CharCode(wch);
 
   uint32_t dwProps = kTextLayoutCodeProperties[(uint16_t)wch];
   FX_CHARTYPE chartype = GetCharTypeFromProp(dwProps);
-  CFX_RTFCharArray& tca = m_pCurLine->m_LineChars;
-  CFX_RTFChar* pCurChar = tca.AddSpace();
+  m_pCurLine->m_LineChars.emplace_back();
+  CFX_RTFChar* pCurChar = &m_pCurLine->m_LineChars.back();
   pCurChar->m_dwStatus = 0;
   pCurChar->m_wCharCode = wch;
   pCurChar->m_dwCharProps = dwProps;
   pCurChar->m_dwCharStyles = 0;
   pCurChar->m_dwLayoutStyles = 0;
   pCurChar->m_iFontSize = m_iFontSize;
   pCurChar->m_iFontHeight = m_iFontHeight;
   pCurChar->m_iHorizontalScale = m_iHorizontalScale;
   pCurChar->m_iVertialScale = m_iVerticalScale;
   pCurChar->m_nRotation = m_iCharRotation;
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_dwIdentity = m_dwIdentity;
   if (m_pUserData) {
     m_pUserData->Retain();
   }
   pCurChar->m_pUserData = m_pUserData;
   uint32_t dwRet1 = FX_RTFBREAK_None;
   if (chartype != FX_CHARTYPE_Combination &&
       GetUnifiedCharType(m_eCharType) != GetUnifiedCharType(chartype)) {
     if (!m_bSingleLine && !m_bOrphanLine &&
         m_eCharType != FX_CHARTYPE_Unknown &&
         m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
       if (m_eCharType != FX_CHARTYPE_Space || chartype != FX_CHARTYPE_Control) {
         dwRet1 = EndBreak(FX_RTFBREAK_LineBreak);
         int32_t iCount = m_pCurLine->CountChars();
         if (iCount > 0) {
-          pCurChar = m_pCurLine->m_LineChars.GetDataPtr(iCount - 1);
+          pCurChar = &m_pCurLine->m_LineChars[iCount - 1];
         }
       }
     }
   }
   int32_t iRotation = m_iRotation;
   if (m_bVertical && (dwProps & 0x8000) != 0) {
     iRotation = (iRotation + 1) % 4;
   }
   uint32_t dwRet2 =
       (this->*g_FX_RTFBreak_lpfAppendChar[chartype >> FX_CHARTYPEBITS])(
           pCurChar, iRotation);
   m_eCharType = chartype;
   return std::max(dwRet1, dwRet2);
 }
 
 uint32_t CFX_RTFBreak::AppendChar_CharCode(FX_WCHAR wch) {
   ASSERT(m_pFont && m_pCurLine);
   ASSERT(m_bCharCode);
   m_pCurLine->m_iMBCSChars++;
-  CFX_RTFCharArray& tca = m_pCurLine->m_LineChars;
-  CFX_RTFChar* pCurChar = tca.AddSpace();
+  m_pCurLine->m_LineChars.emplace_back();
+  CFX_RTFChar* pCurChar = &m_pCurLine->m_LineChars.back();
   pCurChar->m_dwStatus = 0;
   pCurChar->m_wCharCode = wch;
   pCurChar->m_dwCharProps = 0;
   pCurChar->m_dwCharStyles = 0;
   pCurChar->m_dwLayoutStyles = m_dwLayoutStyles;
   pCurChar->m_iFontSize = m_iFontSize;
   pCurChar->m_iFontHeight = m_iFontHeight;
   pCurChar->m_iHorizontalScale = m_iHorizontalScale;
   pCurChar->m_iVertialScale = m_iVerticalScale;
   pCurChar->m_nRotation = m_iCharRotation;
@@ skipping 277 matching lines @@
           bDone = true;
         }
         break;
       default:
         SplitTextLine(m_pCurLine, pNextLine, !m_bPagination && bAllChars);
         bDone = true;
         break;
     }
   }
   if (m_bPagination || m_pCurLine->m_iMBCSChars > 0) {
-    const CFX_RTFChar* pCurChars = m_pCurLine->m_LineChars.GetData();
+    const CFX_RTFChar* pCurChars = m_pCurLine->m_LineChars.data();
     const CFX_RTFChar* pTC;
     CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
     CFX_RTFPiece tp;
     tp.m_pChars = &m_pCurLine->m_LineChars;
     bool bNew = true;
     uint32_t dwIdentity = (uint32_t)-1;
     int32_t iLast = m_pCurLine->CountChars() - 1, j = 0;
     for (int32_t i = 0; i <= iLast;) {
       pTC = pCurChars + i;
       if (bNew) {
@@ skipping 34 matching lines @@
     int32_t iEndPos = m_pCurLine->GetLineEnd();
     GetBreakPos(m_pCurLine->m_LineChars, iEndPos, bAllChars, true);
   }
   return false;
 }
 void CFX_RTFBreak::EndBreak_BidiLine(CFX_TPOArray& tpos, uint32_t dwStatus) {
   FX_TPO tpo;
   CFX_RTFPiece tp;
   CFX_RTFChar* pTC;
   int32_t i, j;
-  CFX_RTFCharArray& chars = m_pCurLine->m_LineChars;
+  std::vector<CFX_RTFChar>& chars = m_pCurLine->m_LineChars;
   int32_t iCount = m_pCurLine->CountChars();
   bool bDone = (!m_bPagination && !m_bCharCode &&
                 (m_pCurLine->m_iArabicChars > 0 || m_bRTL));
   if (bDone) {
     int32_t iBidiNum = 0;
     for (i = 0; i < iCount; i++) {
-      pTC = chars.GetDataPtr(i);
+      pTC = &chars[i];
       pTC->m_iBidiPos = i;
       if (pTC->GetCharType() != FX_CHARTYPE_Control) {
         iBidiNum = i;
       }
       if (i == 0) {
         pTC->m_iBidiLevel = 1;
       }
     }
     FX_BidiLine(chars, iBidiNum + 1, m_bRTL ? 1 : 0);
   } else {
     for (i = 0; i < iCount; i++) {
-      pTC = chars.GetDataPtr(i);
+      pTC = &chars[i];
       pTC->m_iBidiLevel = 0;
       pTC->m_iBidiPos = 0;
       pTC->m_iBidiOrder = 0;
     }
   }
   tp.m_dwStatus = FX_RTFBREAK_PieceBreak;
   tp.m_iStartPos = m_pCurLine->m_iStart;
   tp.m_pChars = &chars;
   CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
   int32_t iBidiLevel = -1, iCharWidth;
   uint32_t dwIdentity = (uint32_t)-1;
   i = j = 0;
   while (i < iCount) {
-    pTC = chars.GetDataPtr(i);
+    pTC = &chars[i];
     if (iBidiLevel < 0) {
       iBidiLevel = pTC->m_iBidiLevel;
       iCharWidth = pTC->m_iCharWidth;
       if (iCharWidth < 1) {
         tp.m_iWidth = 0;
       } else {
         tp.m_iWidth = iCharWidth;
       }
       tp.m_iBidiLevel = iBidiLevel;
       tp.m_iBidiPos = pTC->m_iBidiOrder;
@@ skipping 128 matching lines @@
     }
     if (iOffset > 0) {
       for (i = 0; i < iCount; i++) {
         CFX_RTFPiece& ttp = pCurPieces->GetAt(i);
         ttp.m_iStartPos += iOffset;
       }
     }
   }
 }
 
-int32_t CFX_RTFBreak::GetBreakPos(CFX_RTFCharArray& tca,
+int32_t CFX_RTFBreak::GetBreakPos(std::vector<CFX_RTFChar>& tca,
                                   int32_t& iEndPos,
                                   bool bAllChars,
                                   bool bOnlyBrk) {
-  int32_t iLength = tca.GetSize() - 1;
+  int32_t iLength = pdfium::CollectionSize<int32_t>(tca) - 1;
   if (iLength < 1)
     return iLength;
 
   int32_t iBreak = -1, iBreakPos = -1, iIndirect = -1, iIndirectPos = -1,
           iLast = -1, iLastPos = -1;
   if (m_bSingleLine || m_bOrphanLine || iEndPos <= m_iBoundaryEnd) {
     if (!bAllChars || m_bCharCode)
       return iLength;
 
     iBreak = iLength;
     iBreakPos = iEndPos;
   }
-  CFX_RTFChar* pCharArray = tca.GetData();
+  CFX_RTFChar* pCharArray = tca.data();
   if (m_bCharCode) {
     const CFX_RTFChar* pChar;
     int32_t iCharWidth;
     while (iLength > 0) {
       if (iEndPos <= m_iBoundaryEnd)
         break;
 
       pChar = pCharArray + iLength--;
       iCharWidth = pChar->m_iCharWidth;
       if (iCharWidth > 0)
@@ skipping 100 matching lines @@
 
 void CFX_RTFBreak::SplitTextLine(CFX_RTFLine* pCurLine,
                                  CFX_RTFLine* pNextLine,
                                  bool bAllChars) {
   ASSERT(pCurLine && pNextLine);
   int32_t iCount = pCurLine->CountChars();
   if (iCount < 2) {
     return;
   }
   int32_t iEndPos = pCurLine->GetLineEnd();
-  CFX_RTFCharArray& curChars = pCurLine->m_LineChars;
+  std::vector<CFX_RTFChar>& curChars = pCurLine->m_LineChars;
   int32_t iCharPos = GetBreakPos(curChars, iEndPos, bAllChars, false);
   if (iCharPos < 0) {
     iCharPos = 0;
   }
   iCharPos++;
   if (iCharPos >= iCount) {
     pNextLine->RemoveAll(true);
-    CFX_Char* pTC = curChars.GetDataPtr(iCharPos - 1);
+    CFX_Char* pTC = &curChars[iCharPos - 1];
     pTC->m_nBreakType = FX_LBT_UNKNOWN;
     return;
   }
-  CFX_RTFCharArray& nextChars = pNextLine->m_LineChars;
-  int cur_size = curChars.GetSize();
-  nextChars.SetSize(cur_size - iCharPos);
-  FXSYS_memcpy(nextChars.GetData(), curChars.GetDataPtr(iCharPos),
-               (cur_size - iCharPos) * sizeof(CFX_RTFChar));
-  iCount -= iCharPos;
-  cur_size = curChars.GetSize();
-  curChars.RemoveAt(cur_size - iCount, iCount);
+  std::vector<CFX_RTFChar>& nextChars = pNextLine->m_LineChars;
+  nextChars =
+      std::vector<CFX_RTFChar>(curChars.begin() + iCharPos, curChars.end());
+  curChars.erase(curChars.begin() + iCharPos, curChars.end());
   pNextLine->m_iStart = pCurLine->m_iStart;
   pNextLine->m_iWidth = pCurLine->GetLineEnd() - iEndPos;
   pCurLine->m_iWidth = iEndPos;
-  curChars.GetDataPtr(iCharPos - 1)->m_nBreakType = FX_LBT_UNKNOWN;
-  iCount = nextChars.GetSize();
-  CFX_RTFChar* pNextChars = nextChars.GetData();
+  curChars[iCharPos - 1].m_nBreakType = FX_LBT_UNKNOWN;
+  iCount = pdfium::CollectionSize<int>(nextChars);
+  CFX_RTFChar* pNextChars = nextChars.data();
   for (int32_t i = 0; i < iCount; i++) {
     CFX_RTFChar* tc = pNextChars + i;
     if (tc->GetCharType() >= FX_CHARTYPE_ArabicAlef) {
       pCurLine->m_iArabicChars--;
       pNextLine->m_iArabicChars++;
     }
     if (tc->m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_MBCSCode) {
       pCurLine->m_iMBCSChars--;
       pNextLine->m_iMBCSChars++;
     }
@@ skipping 449 matching lines @@
       fFontSize(12.0f),
       dwLayoutStyles(0),
       iCharRotation(0),
       iBidiLevel(0),
       pRect(nullptr),
       wLineBreakChar(L'\n'),
       iHorizontalScale(100),
       iVerticalScale(100) {}
 
 FX_RTFTEXTOBJ::~FX_RTFTEXTOBJ() {}