Remove CFX_SegmentedArray use from master

core/src/fpdftext/fpdf_text_int.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 <algorithm>
 #include <cctype>
 #include <cwctype>
 #include <memory>
@@ skipping 93 matching lines @@
 #define TEXT_LINEFEED_CHAR L'\n'
 #define TEXT_RETURN_CHAR L'\r'
 #define TEXT_EMPTY L""
 #define TEXT_BLANK L" "
 #define TEXT_RETURN_LINEFEED L"\r\n"
 #define TEXT_LINEFEED L"\n"
 #define TEXT_CHARRATIO_GAPDELTA 0.070
 
 CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, int flags)
     : m_pPage(pPage),
-      m_charList(512),
-      m_TempCharList(50),
       m_parserflag(flags),
       m_pPreTextObj(nullptr),
       m_bIsParsed(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0) {
   m_TextBuf.EstimateSize(0, 10240);
   pPage->GetDisplayMatrix(m_DisplayMatrix, 0, 0, (int)pPage->GetPageWidth(),
                           (int)pPage->GetPageHeight(), 0);
 }
 
@@ skipping 14 matching lines @@
     default:
       return false;
   }
 }
 FX_BOOL CPDF_TextPage::ParseTextPage() {
   m_bIsParsed = false;
   if (!m_pPage)
     return FALSE;
 
   m_TextBuf.Clear();
-  m_charList.RemoveAll();
+  m_CharList.clear();
   m_pPreTextObj = NULL;
   ProcessObject();
   m_bIsParsed = true;
   if (!m_ParseOptions.m_bGetCharCodeOnly) {
     m_CharIndex.RemoveAll();
-    int nCount = m_charList.GetSize();
+    int nCount = m_CharList.size();
     if (nCount) {
       m_CharIndex.Add(0);
     }
     for (int i = 0; i < nCount; i++) {
       int indexSize = m_CharIndex.GetSize();
       FX_BOOL bNormal = FALSE;
-      PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(i);
+      PAGECHAR_INFO charinfo = m_CharList[i];
       if (charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
         bNormal = TRUE;
       } else if (charinfo.m_Unicode == 0 || IsControlChar(charinfo)) {
         bNormal = FALSE;
       } else {
         bNormal = TRUE;
       }
       if (bNormal) {
         if (indexSize % 2) {
           m_CharIndex.Add(1);
         } else {
           if (indexSize <= 0) {
             continue;
           }
           m_CharIndex.SetAt(indexSize - 1,
                             m_CharIndex.GetAt(indexSize - 1) + 1);
         }
       } else {
         if (indexSize % 2) {
           if (indexSize <= 0) {
             continue;
           }
           m_CharIndex.SetAt(indexSize - 1, i + 1);

[Tom Sepez, 2016/01/22 20:52:05]

For instance, m_CharIndex is a "word array" (array of uint16_t), so the
assignment of i+1 (int) won't fit beyond 64k.

         } else {
           m_CharIndex.Add(i + 1);
         }
       }
     }
     int indexSize = m_CharIndex.GetSize();
     if (indexSize % 2) {
       m_CharIndex.RemoveAt(indexSize - 1);
     }
   }
   return TRUE;
 }
 int CPDF_TextPage::CountChars() const {
   if (m_ParseOptions.m_bGetCharCodeOnly) {
     return m_TextBuf.GetSize();
   }
-  return m_charList.GetSize();
+  return m_CharList.size();
 }
 int CPDF_TextPage::CharIndexFromTextIndex(int TextIndex) const {
   int indexSize = m_CharIndex.GetSize();
   int count = 0;
   for (int i = 0; i < indexSize; i += 2) {
     count += m_CharIndex.GetAt(i + 1);
     if (count > TextIndex) {
       return TextIndex - count + m_CharIndex.GetAt(i + 1) +
              m_CharIndex.GetAt(i);
     }
@@ skipping 20 matching lines @@
                                  CFX_RectArray& rectArray) const {
   if (m_ParseOptions.m_bGetCharCodeOnly) {
     return;
   }
   if (start < 0 || nCount == 0) {
     return;
   }
   if (!m_bIsParsed) {
     return;
   }
-  PAGECHAR_INFO info_curchar;
   CPDF_TextObject* pCurObj = NULL;
   CFX_FloatRect rect;
   int curPos = start;
   FX_BOOL flagNewRect = TRUE;
-  if (nCount + start > m_charList.GetSize() || nCount == -1) {
-    nCount = m_charList.GetSize() - start;
+  if (nCount + start > m_CharList.size() || nCount == -1) {
+    nCount = m_CharList.size() - start;
   }
   while (nCount--) {
-    info_curchar = *(PAGECHAR_INFO*)m_charList.GetAt(curPos++);
+    PAGECHAR_INFO info_curchar = m_CharList[curPos++];
     if (info_curchar.m_Flag == FPDFTEXT_CHAR_GENERATED) {
       continue;
     }
     if (info_curchar.m_CharBox.Width() < 0.01 ||
         info_curchar.m_CharBox.Height() < 0.01) {
       continue;
     }
     if (!pCurObj) {
       pCurObj = info_curchar.m_pTextObj;
     }
@@ skipping 56 matching lines @@
 }
 int CPDF_TextPage::GetIndexAtPos(CPDF_Point point,
                                  FX_FLOAT xTolerance,
                                  FX_FLOAT yTolerance) const {
   if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return -3;
 
   int pos = 0;
   int NearPos = -1;
   double xdif = 5000, ydif = 5000;
-  while (pos < m_charList.GetSize()) {
-    PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)(m_charList.GetAt(pos));
+  while (pos < m_CharList.size()) {
+    PAGECHAR_INFO charinfo = m_CharList[pos];
     CFX_FloatRect charrect = charinfo.m_CharBox;
     if (charrect.Contains(point.x, point.y)) {
       break;
     }
     if (xTolerance > 0 || yTolerance > 0) {
       CFX_FloatRect charRectExt;
       charrect.Normalize();
       charRectExt.left = charrect.left - xTolerance / 2;
       charRectExt.right = charrect.right + xTolerance / 2;
       charRectExt.top = charrect.top + yTolerance / 2;
@@ skipping 10 matching lines @@
                       : FXSYS_fabs(point.y - charrect.top);
         if (curYdif + curXdif < xdif + ydif) {
           ydif = curYdif;
           xdif = curXdif;
           NearPos = pos;
         }
       }
     }
     ++pos;
   }
-  if (pos >= m_charList.GetSize()) {
+  if (pos >= m_CharList.size()) {
     pos = NearPos;
   }
   return pos;
 }
 CFX_WideString CPDF_TextPage::GetTextByRect(const CFX_FloatRect& rect) const {
   CFX_WideString strText;
   if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return strText;
 
-  int nCount = m_charList.GetSize();
+  int nCount = m_CharList.size();

[Oliver Chang, 2016/01/22 20:17:56]

could we change this to a size_t?

   int pos = 0;
   FX_FLOAT posy = 0;
   FX_BOOL IsContainPreChar = FALSE;
   FX_BOOL ISAddLineFeed = FALSE;
   while (pos < nCount) {
-    PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(pos++);
+    PAGECHAR_INFO charinfo = m_CharList[pos++];
     if (IsRectIntersect(rect, charinfo.m_CharBox)) {
       if (FXSYS_fabs(posy - charinfo.m_OriginY) > 0 && !IsContainPreChar &&
           ISAddLineFeed) {
         posy = charinfo.m_OriginY;
         if (strText.GetLength() > 0) {
           strText += L"\r\n";
         }
       }
       IsContainPreChar = TRUE;
       ISAddLineFeed = FALSE;
@@ skipping 14 matching lines @@
   return strText;
 }
 void CPDF_TextPage::GetRectsArrayByRect(const CFX_FloatRect& rect,
                                         CFX_RectArray& resRectArray) const {
   if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return;
 
   CFX_FloatRect curRect;
   FX_BOOL flagNewRect = TRUE;
   CPDF_TextObject* pCurObj = NULL;
-  int nCount = m_charList.GetSize();
+  int nCount = m_CharList.size();

[Oliver Chang, 2016/01/22 20:17:56]

ditto, many more instances in this file.

   int pos = 0;
   while (pos < nCount) {
-    PAGECHAR_INFO info_curchar = *(PAGECHAR_INFO*)m_charList.GetAt(pos++);
+    PAGECHAR_INFO info_curchar = m_CharList[pos++];
     if (info_curchar.m_Flag == FPDFTEXT_CHAR_GENERATED) {
       continue;
     }
     if (IsRectIntersect(rect, info_curchar.m_CharBox)) {
       if (!pCurObj) {
         pCurObj = info_curchar.m_pTextObj;
       }
       if (pCurObj != info_curchar.m_pTextObj) {
         resRectArray.Add(curRect);
         pCurObj = info_curchar.m_pTextObj;
@@ skipping 31 matching lines @@
     return -3;
   }
   CPDF_Point point(x, y);
   return GetIndexAtPos(point, xTolerance, yTolerance);
 }
 
 void CPDF_TextPage::GetCharInfo(int index, FPDF_CHAR_INFO* info) const {
   if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return;
 
-  if (index < 0 || index >= m_charList.GetSize())
+  if (index < 0 || index >= m_CharList.size())
     return;
 
-  const PAGECHAR_INFO* charinfo =
-      static_cast<PAGECHAR_INFO*>(m_charList.GetAt(index));
+  const PAGECHAR_INFO* charinfo = &m_CharList[index];
   info->m_Charcode = charinfo->m_CharCode;
   info->m_OriginX = charinfo->m_OriginX;
   info->m_OriginY = charinfo->m_OriginY;
   info->m_Unicode = charinfo->m_Unicode;
   info->m_Flag = charinfo->m_Flag;
   info->m_CharBox = charinfo->m_CharBox;
   info->m_pTextObj = charinfo->m_pTextObj;
   if (charinfo->m_pTextObj && charinfo->m_pTextObj->GetFont()) {
     info->m_FontSize = charinfo->m_pTextObj->GetFontSize();
   } else {
     info->m_FontSize = kDefaultFontSize;
   }
   info->m_Matrix.Copy(charinfo->m_Matrix);
 }
 
 void CPDF_TextPage::CheckMarkedContentObject(int32_t& start,
                                              int32_t& nCount) const {
-  PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(start);
-  PAGECHAR_INFO charinfo2 =
-      *(PAGECHAR_INFO*)m_charList.GetAt(start + nCount - 1);
+  PAGECHAR_INFO charinfo = m_CharList[start];
+  PAGECHAR_INFO charinfo2 = m_CharList[start + nCount - 1];
   if (FPDFTEXT_CHAR_PIECE != charinfo.m_Flag &&
       FPDFTEXT_CHAR_PIECE != charinfo2.m_Flag) {
     return;
   }
   if (FPDFTEXT_CHAR_PIECE == charinfo.m_Flag) {
     PAGECHAR_INFO charinfo1 = charinfo;
     int startIndex = start;
     while (FPDFTEXT_CHAR_PIECE == charinfo1.m_Flag &&
            charinfo1.m_Index == charinfo.m_Index) {
       startIndex--;
       if (startIndex < 0) {
         break;
       }
-      charinfo1 = *(PAGECHAR_INFO*)m_charList.GetAt(startIndex);
+      charinfo1 = m_CharList[startIndex];
     }
     startIndex++;
     start = startIndex;
   }
   if (FPDFTEXT_CHAR_PIECE == charinfo2.m_Flag) {
     PAGECHAR_INFO charinfo3 = charinfo2;
     int endIndex = start + nCount - 1;
     while (FPDFTEXT_CHAR_PIECE == charinfo3.m_Flag &&
            charinfo3.m_Index == charinfo2.m_Index) {
       endIndex++;
-      if (endIndex >= m_charList.GetSize()) {
+      if (endIndex >= m_CharList.size()) {
         break;
       }
-      charinfo3 = *(PAGECHAR_INFO*)m_charList.GetAt(endIndex);
+      charinfo3 = m_CharList[endIndex];
     }
     endIndex--;
     nCount = endIndex - start + 1;
   }
 }
 CFX_WideString CPDF_TextPage::GetPageText(int start, int nCount) const {
   if (!m_bIsParsed || nCount == 0)
     return L"";
 
   if (start < 0)
     start = 0;
 
   if (nCount == -1) {
-    nCount = m_charList.GetSize() - start;
+    nCount = m_CharList.size() - start;
     return m_TextBuf.GetWideString().Mid(start,
                                          m_TextBuf.GetWideString().GetLength());
   }
-  if (nCount <= 0 || m_charList.GetSize() <= 0) {
+  if (nCount <= 0 || m_CharList.empty()) {
     return L"";
   }
-  if (nCount + start > m_charList.GetSize() - 1) {
-    nCount = m_charList.GetSize() - start;
+  if (nCount + start > static_cast<int>(m_CharList.size()) - 1) {
+    nCount = static_cast<int>(m_CharList.size()) - start;
   }
   if (nCount <= 0) {
     return L"";
   }
   CheckMarkedContentObject(start, nCount);
   int startindex = 0;
-  PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(start);
+  PAGECHAR_INFO charinfo = m_CharList[start];
   int startOffset = 0;
   while (charinfo.m_Index == -1) {
     startOffset++;
-    if (startOffset > nCount || start + startOffset >= m_charList.GetSize()) {
+    if (startOffset > nCount || start + startOffset >= m_CharList.size()) {
       return L"";
     }
-    charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(start + startOffset);
+    charinfo = m_CharList[start + startOffset];
   }
   startindex = charinfo.m_Index;
-  charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(start + nCount - 1);
+  charinfo = m_CharList[start + nCount - 1];
   int nCountOffset = 0;
   while (charinfo.m_Index == -1) {
     nCountOffset++;
     if (nCountOffset >= nCount) {
       return L"";
     }
-    charinfo =
-        *(PAGECHAR_INFO*)m_charList.GetAt(start + nCount - nCountOffset - 1);
+    charinfo = m_CharList[start + nCount - nCountOffset - 1];
   }
   nCount = start + nCount - nCountOffset - startindex;
   if (nCount <= 0) {
     return L"";
   }
   return m_TextBuf.GetWideString().Mid(startindex, nCount);
 }
 int CPDF_TextPage::CountRects(int start, int nCount) {
   if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed || start < 0)
     return -1;
 
-  if (nCount == -1 || nCount + start > m_charList.GetSize()) {
-    nCount = m_charList.GetSize() - start;
+  if (nCount == -1 || nCount + start > static_cast<int>(m_CharList.size())) {
+    nCount = static_cast<int>(m_CharList.size()) - start;
   }
   m_SelRects.RemoveAll();
   GetRectArray(start, nCount, m_SelRects);
   return m_SelRects.GetSize();
 }
 void CPDF_TextPage::GetRect(int rectIndex,
                             FX_FLOAT& left,
                             FX_FLOAT& top,
                             FX_FLOAT& right,
                             FX_FLOAT& bottom) const {
@@ skipping 80 matching lines @@
   return GetBaselineRotate(rect, Rotate);
 }
 int CPDF_TextPage::CountBoundedSegments(FX_FLOAT left,
                                         FX_FLOAT top,
                                         FX_FLOAT right,
                                         FX_FLOAT bottom,
                                         FX_BOOL bContains) {
   if (m_ParseOptions.m_bGetCharCodeOnly)
     return -1;
 
-  m_Segment.RemoveAll();
+  m_Segments.RemoveAll();
   if (!m_bIsParsed)
     return -1;
 
   CFX_FloatRect rect(left, bottom, right, top);
   rect.Normalize();
-  int nCount = m_charList.GetSize();
+  int nCount = m_CharList.size();
   int pos = 0;
   FPDF_SEGMENT segment;
   segment.m_Start = 0;
   segment.m_nCount = 0;
   int segmentStatus = 0;
   FX_BOOL IsContainPreChar = FALSE;
   while (pos < nCount) {
-    PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(pos);
+    PAGECHAR_INFO charinfo = m_CharList[pos];
     if (bContains && rect.Contains(charinfo.m_CharBox)) {
       if (segmentStatus == 0 || segmentStatus == 2) {
         segment.m_Start = pos;
         segment.m_nCount = 1;
         segmentStatus = 1;
       } else if (segmentStatus == 1) {
         segment.m_nCount++;
       }
       IsContainPreChar = TRUE;
     } else if (!bContains &&
@@ skipping 13 matching lines @@
           segment.m_Start = pos;
           segment.m_nCount = 1;
           segmentStatus = 1;
         } else if (segmentStatus == 1) {
           segment.m_nCount++;
         }
         IsContainPreChar = FALSE;
       } else {
         if (segmentStatus == 1) {
           segmentStatus = 2;
-          m_Segment.Add(segment);
+          m_Segments.Add(segment);
           segment.m_Start = 0;
           segment.m_nCount = 0;
         }
       }
     } else {
       if (segmentStatus == 1) {
         segmentStatus = 2;
-        m_Segment.Add(segment);
+        m_Segments.Add(segment);
         segment.m_Start = 0;
         segment.m_nCount = 0;
       }
       IsContainPreChar = FALSE;
     }
     pos++;
   }
   if (segmentStatus == 1) {
     segmentStatus = 2;
-    m_Segment.Add(segment);
+    m_Segments.Add(segment);
     segment.m_Start = 0;
     segment.m_nCount = 0;
   }
-  return m_Segment.GetSize();
+  return m_Segments.GetSize();
 }
 void CPDF_TextPage::GetBoundedSegment(int index, int& start, int& count) const {
   if (m_ParseOptions.m_bGetCharCodeOnly) {
     return;
   }
-  if (index < 0 || index >= m_Segment.GetSize()) {
+  if (index < 0 || index >= m_Segments.GetSize()) {
     return;
   }
-  start = m_Segment.GetAt(index).m_Start;
-  count = m_Segment.GetAt(index).m_nCount;
+  start = m_Segments.GetAt(index).m_Start;
+  count = m_Segments.GetAt(index).m_nCount;
 }
 int CPDF_TextPage::GetWordBreak(int index, int direction) const {
   if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return -1;
 
   if (direction != FPDFTEXT_LEFT && direction != FPDFTEXT_RIGHT)
     return -1;
 
-  if (index < 0 || index >= m_charList.GetSize())
+  if (index < 0 || index >= m_CharList.size())
     return -1;
 
-  PAGECHAR_INFO charinfo;
-  charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(index);
+  PAGECHAR_INFO charinfo = m_CharList[index];
   if (charinfo.m_Index == -1 || charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
     return index;
   }
   if (!IsLetter(charinfo.m_Unicode)) {
     return index;
   }
   int breakPos = index;
   if (direction == FPDFTEXT_LEFT) {
     while (--breakPos > 0) {
-      charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(breakPos);
-      if (!IsLetter(charinfo.m_Unicode)) {
-        return breakPos;
-      }
+      if (!IsLetter(m_CharList[breakPos].m_Unicode))
+        break;
     }
   } else if (direction == FPDFTEXT_RIGHT) {
-    while (++breakPos < m_charList.GetSize()) {
-      charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(breakPos);
-      if (!IsLetter(charinfo.m_Unicode)) {
-        return breakPos;
-      }
+    while (++breakPos < m_CharList.size()) {
+      if (!IsLetter(m_CharList[breakPos].m_Unicode))
+        break;
     }
   }
   return breakPos;
 }
 int32_t CPDF_TextPage::FindTextlineFlowDirection() {
   if (!m_pPage) {
     return -1;
   }
   const int32_t nPageWidth = (int32_t)((CPDF_Page*)m_pPage)->GetPageWidth();
   const int32_t nPageHeight = (int32_t)((CPDF_Page*)m_pPage)->GetPageHeight();
@@ skipping 169 matching lines @@
     }
   }
   return w;
 }
 void CPDF_TextPage::OnPiece(CFX_BidiChar* pBidi, CFX_WideString& str) {
   int32_t start, count;
   CFX_BidiChar::Direction ret = pBidi->GetBidiInfo(&start, &count);
   if (ret == CFX_BidiChar::RIGHT) {
     for (int i = start + count - 1; i >= start; i--) {
       m_TextBuf.AppendChar(str.GetAt(i));
-      m_charList.Add(*(PAGECHAR_INFO*)m_TempCharList.GetAt(i));
+      m_CharList.push_back(m_TempCharList[i]);
     }
   } else {
     int end = start + count;
     for (int i = start; i < end; i++) {
       m_TextBuf.AppendChar(str.GetAt(i));
-      m_charList.Add(*(PAGECHAR_INFO*)m_TempCharList.GetAt(i));
+      m_CharList.push_back(m_TempCharList[i]);
     }
   }
 }
 void CPDF_TextPage::AddCharInfoByLRDirection(CFX_WideString& str, int i) {
-  PAGECHAR_INFO Info = *(PAGECHAR_INFO*)m_TempCharList.GetAt(i);
+  PAGECHAR_INFO Info = m_TempCharList[i];
   FX_WCHAR wChar = str.GetAt(i);
   if (!IsControlChar(Info)) {
     Info.m_Index = m_TextBuf.GetLength();
     if (wChar >= 0xFB00 && wChar <= 0xFB06) {
       FX_WCHAR* pDst = NULL;
       FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
       if (nCount >= 1) {
         pDst = FX_Alloc(FX_WCHAR, nCount);
         FX_Unicode_GetNormalization(wChar, pDst);
         for (int nIndex = 0; nIndex < nCount; nIndex++) {
           PAGECHAR_INFO Info2 = Info;
           Info2.m_Unicode = pDst[nIndex];
           Info2.m_Flag = FPDFTEXT_CHAR_PIECE;
           m_TextBuf.AppendChar(Info2.m_Unicode);
           if (!m_ParseOptions.m_bGetCharCodeOnly) {
-            m_charList.Add(Info2);
+            m_CharList.push_back(Info2);
           }
         }
         FX_Free(pDst);
         return;
       }
     }
     m_TextBuf.AppendChar(wChar);
   } else {
     Info.m_Index = -1;
   }
   if (!m_ParseOptions.m_bGetCharCodeOnly) {
-    m_charList.Add(Info);
+    m_CharList.push_back(Info);
   }
 }
 void CPDF_TextPage::AddCharInfoByRLDirection(CFX_WideString& str, int i) {
-  PAGECHAR_INFO Info = *(PAGECHAR_INFO*)m_TempCharList.GetAt(i);
+  PAGECHAR_INFO Info = m_TempCharList[i];
   if (!IsControlChar(Info)) {
     Info.m_Index = m_TextBuf.GetLength();
     FX_WCHAR wChar = FX_GetMirrorChar(str.GetAt(i), TRUE, FALSE);
     FX_WCHAR* pDst = NULL;
     FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
     if (nCount >= 1) {
       pDst = FX_Alloc(FX_WCHAR, nCount);
       FX_Unicode_GetNormalization(wChar, pDst);
       for (int nIndex = 0; nIndex < nCount; nIndex++) {
         PAGECHAR_INFO Info2 = Info;
         Info2.m_Unicode = pDst[nIndex];
         Info2.m_Flag = FPDFTEXT_CHAR_PIECE;
         m_TextBuf.AppendChar(Info2.m_Unicode);
         if (!m_ParseOptions.m_bGetCharCodeOnly) {
-          m_charList.Add(Info2);
+          m_CharList.push_back(Info2);
         }
       }
       FX_Free(pDst);
       return;
     }
     Info.m_Unicode = wChar;
     m_TextBuf.AppendChar(Info.m_Unicode);
   } else {
     Info.m_Index = -1;
   }
   if (!m_ParseOptions.m_bGetCharCodeOnly) {
-    m_charList.Add(Info);
+    m_CharList.push_back(Info);
   }
 }
 void CPDF_TextPage::CloseTempLine() {
-  int count1 = m_TempCharList.GetSize();
+  int count1 = m_TempCharList.size();
   if (count1 <= 0) {
     return;
   }
   std::unique_ptr<CFX_BidiChar> pBidiChar(new CFX_BidiChar);
   CFX_WideString str = m_TempTextBuf.GetWideString();
   CFX_WordArray order;
   FX_BOOL bR2L = FALSE;
   int32_t start = 0, count = 0;
   int nR2L = 0, nL2R = 0;
   FX_BOOL bPrevSpace = FALSE;
   for (int i = 0; i < str.GetLength(); i++) {
     if (str.GetAt(i) == 32) {
       if (bPrevSpace) {
         m_TempTextBuf.Delete(i, 1);
-        m_TempCharList.Delete(i);
+        m_TempCharList.erase(m_TempCharList.begin() + i);
         str.Delete(i);
         count1--;
         i--;
         continue;
       }
       bPrevSpace = TRUE;
     } else {
       bPrevSpace = FALSE;
     }
     if (pBidiChar->AppendChar(str.GetAt(i))) {
@@ skipping 82 matching lines @@
             break;
           } else {
             j += 3;
           }
         }
         if (j == 3) {
           i = -3;
           bL2R = TRUE;
           continue;
         }
-        int end = m_TempCharList.GetSize() - 1;
+        int end = m_TempCharList.size() - 1;
         if (j < count) {
           end = order.GetAt(j) - 1;
         }
         i = j - 3;
         for (int n = end; n >= start; n--) {
           AddCharInfoByRLDirection(str, n);
         }
       } else {
         int end = start + count1;
         for (int n = start; n < end; n++) {
           AddCharInfoByLRDirection(str, n);
         }
       }
     }
   }
   order.RemoveAll();
-  m_TempCharList.RemoveAll();
+  m_TempCharList.clear();
   m_TempTextBuf.Delete(0, m_TempTextBuf.GetLength());
 }
 void CPDF_TextPage::ProcessTextObject(CPDF_TextObject* pTextObj,
                                       const CFX_Matrix& formMatrix,
                                       FX_POSITION ObjPos) {
   CFX_FloatRect re(pTextObj->m_Left, pTextObj->m_Bottom, pTextObj->m_Right,
                    pTextObj->m_Top);
   if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f) {
     return;
   }
@@ skipping 199 matching lines @@
     charinfo.m_Unicode = wChar;
     charinfo.m_CharCode = pFont->CharCodeFromUnicode(wChar);
     charinfo.m_Flag = FPDFTEXT_CHAR_PIECE;
     charinfo.m_pTextObj = pTextObj;
     charinfo.m_CharBox.top = charBox.top;
     charinfo.m_CharBox.left = charBox.left;
     charinfo.m_CharBox.right = charBox.right;
     charinfo.m_CharBox.bottom = charBox.bottom;
     charinfo.m_Matrix.Copy(matrix);
     m_TempTextBuf.AppendChar(wChar);
-    m_TempCharList.Add(charinfo);
+    m_TempCharList.push_back(charinfo);
   }
 }
-void CPDF_TextPage::FindPreviousTextObject(void) {
-  if (m_TempCharList.GetSize() < 1 && m_charList.GetSize() < 1) {
+void CPDF_TextPage::FindPreviousTextObject() {
+  if (m_TempCharList.empty() && m_CharList.empty())
     return;
-  }
-  PAGECHAR_INFO preChar;
-  if (m_TempCharList.GetSize() >= 1) {
-    preChar =
-        *(PAGECHAR_INFO*)m_TempCharList.GetAt(m_TempCharList.GetSize() - 1);
-  } else {
-    preChar = *(PAGECHAR_INFO*)m_charList.GetAt(m_charList.GetSize() - 1);
-  }
-  if (preChar.m_pTextObj) {
+
+  PAGECHAR_INFO preChar =
+      m_TempCharList.empty() ? m_CharList.back() : m_TempCharList.back();
+
+  if (preChar.m_pTextObj)
     m_pPreTextObj = preChar.m_pTextObj;
-  }
 }
 void CPDF_TextPage::SwapTempTextBuf(int32_t iCharListStartAppend,
                                     int32_t iBufStartAppend) {
-  int32_t i, j;
-  i = iCharListStartAppend;
-  j = m_TempCharList.GetSize() - 1;
+  int32_t i = iCharListStartAppend;
+  int32_t j = m_TempCharList.size() - 1;
   for (; i < j; i++, j--) {
     std::swap(m_TempCharList[i], m_TempCharList[j]);
     std::swap(m_TempCharList[i].m_Index, m_TempCharList[j].m_Index);
   }
   FX_WCHAR* pTempBuffer = m_TempTextBuf.GetBuffer();
   i = iBufStartAppend;
   j = m_TempTextBuf.GetLength() - 1;
   for (; i < j; i++, j--) {
     std::swap(pTempBuffer[i], pTempBuffer[j]);
   }
@@ skipping 66 matching lines @@
           CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
                         Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top));
     }
     PAGECHAR_INFO generateChar;
     if (result == 1) {
       if (GenerateCharInfo(TEXT_BLANK_CHAR, generateChar)) {
         if (!formMatrix.IsIdentity()) {
           generateChar.m_Matrix.Copy(formMatrix);
         }
         m_TempTextBuf.AppendChar(TEXT_BLANK_CHAR);
-        m_TempCharList.Add(generateChar);
+        m_TempCharList.push_back(generateChar);
       }
     } else if (result == 2) {
       CloseTempLine();
       if (m_TextBuf.GetSize()) {
         if (m_ParseOptions.m_bGetCharCodeOnly) {
           m_TextBuf.AppendChar(TEXT_RETURN_CHAR);
           m_TextBuf.AppendChar(TEXT_LINEFEED_CHAR);
         } else {
           if (GenerateCharInfo(TEXT_RETURN_CHAR, generateChar)) {
             m_TextBuf.AppendChar(TEXT_RETURN_CHAR);
             if (!formMatrix.IsIdentity()) {
               generateChar.m_Matrix.Copy(formMatrix);
             }
-            m_charList.Add(generateChar);
+            m_CharList.push_back(generateChar);
           }
           if (GenerateCharInfo(TEXT_LINEFEED_CHAR, generateChar)) {
             m_TextBuf.AppendChar(TEXT_LINEFEED_CHAR);
             if (!formMatrix.IsIdentity()) {
               generateChar.m_Matrix.Copy(formMatrix);
             }
-            m_charList.Add(generateChar);
+            m_CharList.push_back(generateChar);
           }
         }
       }
     } else if (result == 3 && !m_ParseOptions.m_bOutputHyphen) {
       int32_t nChars = pTextObj->CountChars();
       if (nChars == 1) {
         CPDF_TextObjectItem item;
         pTextObj->GetCharInfo(0, &item);
         CFX_WideString wstrItem =
             pTextObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
         if (wstrItem.IsEmpty()) {
           wstrItem += (FX_WCHAR)item.m_CharCode;
         }
         FX_WCHAR curChar = wstrItem.GetAt(0);
         if (0x2D == curChar || 0xAD == curChar) {
           return;
         }
       }
       while (m_TempTextBuf.GetSize() > 0 &&
              m_TempTextBuf.GetWideString().GetAt(m_TempTextBuf.GetLength() -
                                                  1) == 0x20) {
         m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
-        m_TempCharList.Delete(m_TempCharList.GetSize() - 1);
+        m_TempCharList.pop_back();
       }
-      PAGECHAR_INFO* cha =
-          (PAGECHAR_INFO*)m_TempCharList.GetAt(m_TempCharList.GetSize() - 1);
+      PAGECHAR_INFO* cha = &m_TempCharList[m_TempCharList.size() - 1];
       m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
       cha->m_Unicode = 0x2;
       cha->m_Flag = FPDFTEXT_CHAR_HYPHEN;
       m_TempTextBuf.AppendChar(0xfffe);
     }
   } else {
     m_CurlineRect =
         CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
                       Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top);
   }
   if (FPDFTEXT_MC_DELAY == bPreMKC) {
     ProcessMarkedContent(Obj);
     m_pPreTextObj = pTextObj;
     m_perMatrix.Copy(formMatrix);
     return;
   }
   m_pPreTextObj = pTextObj;
   m_perMatrix.Copy(formMatrix);
   int nItems = pTextObj->CountItems();
   FX_FLOAT baseSpace = _CalculateBaseSpace(pTextObj, matrix);
 
   const FX_BOOL bR2L = IsRightToLeft(pTextObj, pFont, nItems);
   const FX_BOOL bIsBidiAndMirrorInverse =
       bR2L && (matrix.a * matrix.d - matrix.b * matrix.c) < 0;
   int32_t iBufStartAppend = m_TempTextBuf.GetLength();
-  int32_t iCharListStartAppend = m_TempCharList.GetSize();
+  int32_t iCharListStartAppend = m_TempCharList.size();
 
   FX_FLOAT spacing = 0;
   for (int i = 0; i < nItems; i++) {
     CPDF_TextObjectItem item;
     PAGECHAR_INFO charinfo;
     charinfo.m_OriginX = 0;
     charinfo.m_OriginY = 0;
     pTextObj->GetItemInfo(i, &item);
     if (item.m_CharCode == (FX_DWORD)-1) {
       CFX_WideString str = m_TempTextBuf.GetWideString();
@@ skipping 41 matching lines @@
         charinfo.m_pTextObj = pTextObj;
         charinfo.m_Index = m_TextBuf.GetLength();
         m_TempTextBuf.AppendChar(TEXT_BLANK_CHAR);
         charinfo.m_CharCode = -1;
         charinfo.m_Matrix.Copy(formMatrix);
         matrix.Transform(item.m_OriginX, item.m_OriginY, charinfo.m_OriginX,
                          charinfo.m_OriginY);
         charinfo.m_CharBox =
             CFX_FloatRect(charinfo.m_OriginX, charinfo.m_OriginY,
                           charinfo.m_OriginX, charinfo.m_OriginY);
-        m_TempCharList.Add(charinfo);
+        m_TempCharList.push_back(charinfo);
       }
       if (item.m_CharCode == (FX_DWORD)-1) {
         continue;
       }
     }
     spacing = 0;
     CFX_WideString wstrItem = pFont->UnicodeFromCharCode(item.m_CharCode);
     FX_BOOL bNoUnicode = FALSE;
     FX_WCHAR wChar = wstrItem.GetAt(0);
     if ((wstrItem.IsEmpty() || wChar == 0) && item.m_CharCode) {
@@ skipping 31 matching lines @@
           charinfo.m_CharBox.bottom + pTextObj->GetFontSize();
     }
     if (fabsf(charinfo.m_CharBox.right - charinfo.m_CharBox.left) < 0.01f) {
       charinfo.m_CharBox.right =
           charinfo.m_CharBox.left + pTextObj->GetCharWidth(charinfo.m_CharCode);
     }
     matrix.TransformRect(charinfo.m_CharBox);
     charinfo.m_Matrix.Copy(matrix);
     if (wstrItem.IsEmpty()) {
       charinfo.m_Unicode = 0;
-      m_TempCharList.Add(charinfo);
+      m_TempCharList.push_back(charinfo);
       m_TempTextBuf.AppendChar(0xfffe);
       continue;
     } else {
       int nTotal = wstrItem.GetLength();
       FX_BOOL bDel = FALSE;
-      const int count = std::min(m_TempCharList.GetSize(), 7);
+      const int count = std::min(static_cast<int>(m_TempCharList.size()), 7);
       FX_FLOAT threshold = charinfo.m_Matrix.TransformXDistance(
           (FX_FLOAT)TEXT_CHARRATIO_GAPDELTA * pTextObj->GetFontSize());
-      for (int n = m_TempCharList.GetSize();
-           n > m_TempCharList.GetSize() - count; n--) {
-        PAGECHAR_INFO* charinfo1 = (PAGECHAR_INFO*)m_TempCharList.GetAt(n - 1);
+      for (int n = m_TempCharList.size(); n > m_TempCharList.size() - count;
+           n--) {
+        PAGECHAR_INFO* charinfo1 = &m_TempCharList[n - 1];
         if (charinfo1->m_CharCode == charinfo.m_CharCode &&
             charinfo1->m_pTextObj->GetFont() ==
                 charinfo.m_pTextObj->GetFont() &&
             FXSYS_fabs(charinfo1->m_OriginX - charinfo.m_OriginX) < threshold &&
             FXSYS_fabs(charinfo1->m_OriginY - charinfo.m_OriginY) < threshold) {
           bDel = TRUE;
           break;
         }
       }
       if (!bDel) {
         for (int nIndex = 0; nIndex < nTotal; nIndex++) {
           charinfo.m_Unicode = wstrItem.GetAt(nIndex);
           if (charinfo.m_Unicode) {
             charinfo.m_Index = m_TextBuf.GetLength();
             m_TempTextBuf.AppendChar(charinfo.m_Unicode);
           } else {
             m_TempTextBuf.AppendChar(0xfffe);
           }
-          m_TempCharList.Add(charinfo);
+          m_TempCharList.push_back(charinfo);
         }
       } else if (i == 0) {
         CFX_WideString str = m_TempTextBuf.GetWideString();
         if (!str.IsEmpty() &&
             str.GetAt(str.GetLength() - 1) == TEXT_BLANK_CHAR) {
           m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
-          m_TempCharList.Delete(m_TempCharList.GetSize() - 1);
+          m_TempCharList.pop_back();
         }
       }
     }
   }
   if (bIsBidiAndMirrorInverse) {
     SwapTempTextBuf(iCharListStartAppend, iBufStartAppend);
   }
 }
 int32_t CPDF_TextPage::GetTextObjectWritingMode(
     const CPDF_TextObject* pTextObj) {
@@ skipping 38 matching lines @@
   if (0x2D == wcTmp || 0xAD == wcTmp) {
     if (--nIndex > 0) {
       FX_WCHAR preChar = strCurText.GetAt((nIndex));
       if (((preChar >= L'A' && preChar <= L'Z') ||
            (preChar >= L'a' && preChar <= L'z')) &&
           ((curChar >= L'A' && curChar <= L'Z') ||
            (curChar >= L'a' && curChar <= L'z'))) {
         return TRUE;
       }
     }
-    int size = m_TempCharList.GetSize();
+    int size = m_TempCharList.size();
     PAGECHAR_INFO preChar;
     if (size) {
-      preChar = (PAGECHAR_INFO)m_TempCharList[size - 1];
+      preChar = m_TempCharList[size - 1];
     } else {
-      size = m_charList.GetSize();
+      size = m_CharList.size();
       if (size == 0) {
         return FALSE;
       }
-      preChar = (PAGECHAR_INFO)m_charList[size - 1];
+      preChar = m_CharList[size - 1];
     }
     if (FPDFTEXT_CHAR_PIECE == preChar.m_Flag &&
         (0xAD == preChar.m_Unicode || 0x2D == preChar.m_Unicode)) {
       return TRUE;
     }
   }
   return FALSE;
 }
 int CPDF_TextPage::ProcessInsertObject(const CPDF_TextObject* pObj,
                                        const CFX_Matrix& formMatrix) {
@@ skipping 156 matching lines @@
   if (!pTextObj1 || !pTextObj2) {
     return FALSE;
   }
   CFX_FloatRect rcPreObj(pTextObj2->m_Left, pTextObj2->m_Bottom,
                          pTextObj2->m_Right, pTextObj2->m_Top);
   CFX_FloatRect rcCurObj(pTextObj1->m_Left, pTextObj1->m_Bottom,
                          pTextObj1->m_Right, pTextObj1->m_Top);
   if (rcPreObj.IsEmpty() && rcCurObj.IsEmpty() &&
       !m_ParseOptions.m_bGetCharCodeOnly) {
     FX_FLOAT dbXdif = FXSYS_fabs(rcPreObj.left - rcCurObj.left);
-    int nCount = m_charList.GetSize();
+    int nCount = m_CharList.size();

[Oliver Chang, 2016/01/22 21:26:23]

this can probably be just a size_t instead of being casted.

[Tom Sepez, 2016/01/22 21:41:56]

Acknowledged.

     if (nCount >= 2) {
-      PAGECHAR_INFO perCharTemp = (PAGECHAR_INFO)m_charList[nCount - 2];
+      PAGECHAR_INFO perCharTemp = m_CharList[nCount - 2];
       FX_FLOAT dbSpace = perCharTemp.m_CharBox.Width();
       if (dbXdif > dbSpace) {
         return FALSE;
       }
     }
   }
   if (!rcPreObj.IsEmpty() || !rcCurObj.IsEmpty()) {
     rcPreObj.Intersect(rcCurObj);
     if (rcPreObj.IsEmpty()) {
       return FALSE;
@@ skipping 50 matching lines @@
     }
     if (IsSameTextObject((CPDF_TextObject*)pObj, pTextObj)) {
       return TRUE;
     }
     i++;
   }
   return FALSE;
 }
 
 FX_BOOL CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info) {
-  int size = m_TempCharList.GetSize();
+  int size = m_TempCharList.size();

[Oliver Chang, 2016/01/22 21:26:23]

this one too

[Tom Sepez, 2016/01/22 21:41:56]

Acknowledged.

   PAGECHAR_INFO preChar;
   if (size) {
-    preChar = (PAGECHAR_INFO)m_TempCharList[size - 1];
+    preChar = m_TempCharList[size - 1];
   } else {
-    size = m_charList.GetSize();
+    size = m_CharList.size();
     if (size == 0) {
       return FALSE;
     }
-    preChar = (PAGECHAR_INFO)m_charList[size - 1];
+    preChar = m_CharList[size - 1];
   }
   info.m_Index = m_TextBuf.GetLength();
   info.m_Unicode = unicode;
   info.m_pTextObj = NULL;
   info.m_CharCode = -1;
   info.m_Flag = FPDFTEXT_CHAR_GENERATED;
   int preWidth = 0;
   if (preChar.m_pTextObj && preChar.m_CharCode != (FX_DWORD)-1)
     preWidth = GetCharWidth(preChar.m_CharCode, preChar.m_pTextObj->GetFont());
 
@@ skipping 634 matching lines @@
   if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
     return;
   }
   CPDF_LinkExt* link = NULL;
   link = m_LinkList.GetAt(index);
   if (!link) {
     return;
   }
   m_pTextPage->GetRectArray(link->m_Start, link->m_Count, rects);
 }