Replace CFX_RectArray with std::vector<CFX_FloatRect>

core/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 242 matching lines @@
     if (m_CharIndex[i + 1] + m_CharIndex[i] > CharIndex) {
       if (CharIndex - m_CharIndex[i] < 0)
         return -1;
 
       return CharIndex - m_CharIndex[i] + count - m_CharIndex[i + 1];
     }
   }
   return -1;
 }
 
-void CPDF_TextPage::GetRectArray(int start,
-                                 int nCount,
-                                 CFX_RectArray* rectArray) const {
-  if (start < 0 || nCount == 0) {
-    return;
-  }
-  if (!m_bIsParsed) {
-    return;
-  }
-  CPDF_TextObject* pCurObj = NULL;
-  CFX_FloatRect rect;
-  int curPos = start;
-  FX_BOOL flagNewRect = TRUE;
+std::vector<CFX_FloatRect> CPDF_TextPage::GetRectArray(int start,
+                                                       int nCount) const {
+  if (start < 0 || nCount == 0 || !m_bIsParsed)
+    return std::vector<CFX_FloatRect>();
+
   if (nCount + start > pdfium::CollectionSize<int>(m_CharList) ||
       nCount == -1) {
     nCount = pdfium::CollectionSize<int>(m_CharList) - start;
   }
+
+  std::vector<CFX_FloatRect> rectArray;
+  CPDF_TextObject* pCurObj = nullptr;
+  CFX_FloatRect rect;
+  int curPos = start;
+  FX_BOOL flagNewRect = TRUE;
   while (nCount--) {
     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;
     }
     if (pCurObj != info_curchar.m_pTextObj) {
-      rectArray->Add(rect);
+      rectArray.push_back(rect);
       pCurObj = info_curchar.m_pTextObj;
       flagNewRect = TRUE;
     }
     if (flagNewRect) {
       FX_FLOAT orgX = info_curchar.m_OriginX, orgY = info_curchar.m_OriginY;
       CFX_Matrix matrix, matrix_reverse;
       info_curchar.m_pTextObj->GetTextMatrix(&matrix);
       matrix.Concat(info_curchar.m_Matrix);
       matrix_reverse.SetReverse(matrix);
       matrix_reverse.Transform(orgX, orgY);
@@ skipping 32 matching lines @@
         rect.right = info_curchar.m_CharBox.right;
       }
       if (rect.top < info_curchar.m_CharBox.top) {
         rect.top = info_curchar.m_CharBox.top;
       }
       if (rect.bottom > info_curchar.m_CharBox.bottom) {
         rect.bottom = info_curchar.m_CharBox.bottom;
       }
     }
   }
-  rectArray->Add(rect);
+  rectArray.push_back(rect);
+  return rectArray;
 }
 
 int CPDF_TextPage::GetIndexAtPos(CFX_FloatPoint point,
                                  FX_FLOAT xTolerance,
                                  FX_FLOAT yTolerance) const {
   if (!m_bIsParsed)
     return -3;
 
   int pos = 0;
   int NearPos = -1;
@@ skipping 63 matching lines @@
         IsAddLineFeed = false;
       }
     } else {
       IsContainPreChar = false;
       IsAddLineFeed = true;
     }
   }
   return strText;
 }
 
-void CPDF_TextPage::GetRectsArrayByRect(const CFX_FloatRect& rect,
-                                        CFX_RectArray& resRectArray) const {
+std::vector<CFX_FloatRect> CPDF_TextPage::GetRectsArrayByRect(
+    const CFX_FloatRect& rect) const {
   if (!m_bIsParsed)
-    return;
+    return std::vector<CFX_FloatRect>();
 
   CFX_FloatRect curRect;
+  std::vector<CFX_FloatRect> result;
   bool flagNewRect = true;
   CPDF_TextObject* pCurObj = nullptr;
   for (auto info_curchar : m_CharList) {
     if (info_curchar.m_Flag == FPDFTEXT_CHAR_GENERATED) {
       continue;
     }
     if (!IsRectIntersect(rect, info_curchar.m_CharBox)) {
       continue;
     }
     if (!pCurObj) {
       pCurObj = info_curchar.m_pTextObj;
     }
     if (pCurObj != info_curchar.m_pTextObj) {
-      resRectArray.Add(curRect);
+      result.push_back(curRect);
       pCurObj = info_curchar.m_pTextObj;
       flagNewRect = true;
     }
     if (flagNewRect) {
       curRect = info_curchar.m_CharBox;
       curRect.Normalize();
       flagNewRect = false;
     } else {
       info_curchar.m_CharBox.Normalize();
       curRect.left = std::min(curRect.left, info_curchar.m_CharBox.left);
       curRect.bottom = std::min(curRect.bottom, info_curchar.m_CharBox.bottom);
       curRect.right = std::max(curRect.right, info_curchar.m_CharBox.right);
       curRect.top = std::max(curRect.top, info_curchar.m_CharBox.top);
     }
   }
-  resRectArray.Add(curRect);
+  result.push_back(curRect);
+  return result;
 }
 
 int CPDF_TextPage::GetIndexAtPos(FX_FLOAT x,
                                  FX_FLOAT y,
                                  FX_FLOAT xTolerance,
                                  FX_FLOAT yTolerance) const {
   CFX_FloatPoint point(x, y);
   return GetIndexAtPos(point, xTolerance, yTolerance);
 }
 
@@ skipping 108 matching lines @@
 }
 
 int CPDF_TextPage::CountRects(int start, int nCount) {
   if (!m_bIsParsed || start < 0)
     return -1;
 
   if (nCount == -1 ||
       nCount + start > pdfium::CollectionSize<int>(m_CharList)) {
     nCount = pdfium::CollectionSize<int>(m_CharList) - start;
   }
-  m_SelRects.RemoveAll();
-  GetRectArray(start, nCount, &m_SelRects);
-  return m_SelRects.GetSize();
+  m_SelRects = GetRectArray(start, nCount);
+  return pdfium::CollectionSize<int>(m_SelRects);
 }
 
 void CPDF_TextPage::GetRect(int rectIndex,
                             FX_FLOAT& left,
                             FX_FLOAT& top,
                             FX_FLOAT& right,
                             FX_FLOAT& bottom) const {
   if (!m_bIsParsed)
     return;
 
-  if (rectIndex < 0 || rectIndex >= m_SelRects.GetSize())
+  if (rectIndex < 0 || rectIndex >= pdfium::CollectionSize<int>(m_SelRects))
     return;
 
-  left = m_SelRects.GetAt(rectIndex).left;
-  top = m_SelRects.GetAt(rectIndex).top;
-  right = m_SelRects.GetAt(rectIndex).right;
-  bottom = m_SelRects.GetAt(rectIndex).bottom;
+  left = m_SelRects[rectIndex].left;
+  top = m_SelRects[rectIndex].top;
+  right = m_SelRects[rectIndex].right;
+  bottom = m_SelRects[rectIndex].bottom;
 }
 
 FX_BOOL CPDF_TextPage::GetBaselineRotate(int start, int end, int& Rotate) {
   if (end == start) {
     return FALSE;
   }
   FPDF_CHAR_INFO info_start;
   FPDF_CHAR_INFO info_end;
   GetCharInfo(start, &info_start);
   GetCharInfo(end, &info_end);
@@ skipping 1366 matching lines @@
   m_IsFind = TRUE;
   m_resStart = 0;
   m_resEnd = -1;
   return TRUE;
 }
 
 FX_BOOL CPDF_TextPageFind::FindNext() {
   if (!m_pTextPage) {
     return FALSE;
   }
-  m_resArray.RemoveAll();
+  m_resArray.clear();
   if (m_findNextStart == -1) {
     return FALSE;
   }
   if (m_strText.IsEmpty()) {
     m_IsFind = FALSE;
     return m_IsFind;
   }
   int strLen = m_strText.GetLength();
   if (m_findNextStart > strLen - 1) {
     m_IsFind = FALSE;
@@ skipping 71 matching lines @@
         nStartPos = m_resStart + m_csFindWhatArray[1].GetLength();
       } else {
         nStartPos = m_resStart + m_csFindWhatArray[0].GetLength();
       }
     }
   }
   m_resEnd = nResultPos + m_csFindWhatArray.back().GetLength() - 1;
   m_IsFind = TRUE;
   int resStart = GetCharIndex(m_resStart);
   int resEnd = GetCharIndex(m_resEnd);
-  m_pTextPage->GetRectArray(resStart, resEnd - resStart + 1, &m_resArray);
+  m_resArray = m_pTextPage->GetRectArray(resStart, resEnd - resStart + 1);
   if (m_flags & FPDFTEXT_CONSECUTIVE) {
     m_findNextStart = m_resStart + 1;
     m_findPreStart = m_resEnd - 1;
   } else {
     m_findNextStart = m_resEnd + 1;
     m_findPreStart = m_resStart - 1;
   }
   return m_IsFind;
 }
 
 FX_BOOL CPDF_TextPageFind::FindPrev() {
   if (!m_pTextPage) {
     return FALSE;
   }
-  m_resArray.RemoveAll();
+  m_resArray.clear();
   if (m_strText.IsEmpty() || m_findPreStart < 0) {
     m_IsFind = FALSE;
     return m_IsFind;
   }
   CPDF_TextPageFind findEngine(m_pTextPage);
   FX_BOOL ret = findEngine.FindFirst(m_findWhat, m_flags);
   if (!ret) {
     m_IsFind = FALSE;
     return m_IsFind;
   }
@@ skipping 10 matching lines @@
       MatchedCount = MatchedCount1;
     }
   }
   if (order == -1) {
     m_IsFind = FALSE;
     return m_IsFind;
   }
   m_resStart = m_pTextPage->TextIndexFromCharIndex(order);
   m_resEnd = m_pTextPage->TextIndexFromCharIndex(order + MatchedCount - 1);
   m_IsFind = TRUE;
-  m_pTextPage->GetRectArray(order, MatchedCount, &m_resArray);
+  m_resArray = m_pTextPage->GetRectArray(order, MatchedCount);
   if (m_flags & FPDFTEXT_CONSECUTIVE) {
     m_findNextStart = m_resStart + 1;
     m_findPreStart = m_resEnd - 1;
   } else {
     m_findNextStart = m_resEnd + 1;
     m_findPreStart = m_resStart - 1;
   }
   return m_IsFind;
 }
 
@@ skipping 123 matching lines @@
 CFX_WideString CPDF_TextPageFind::MakeReverse(const CFX_WideString& str) {
   CFX_WideString str2;
   str2.clear();
   int nlen = str.GetLength();
   for (int i = nlen - 1; i >= 0; i--) {
     str2 += str.GetAt(i);
   }
   return str2;
 }
 
-void CPDF_TextPageFind::GetRectArray(CFX_RectArray& rects) const {
-  rects.Copy(m_resArray);
-}
-
 int CPDF_TextPageFind::GetCurOrder() const {
   return GetCharIndex(m_resStart);
 }
 
 int CPDF_TextPageFind::GetMatchedCount() const {
   int resStart = GetCharIndex(m_resStart);
   int resEnd = GetCharIndex(m_resEnd);
   return resEnd - resStart + 1;
 }
 
@@ skipping 143 matching lines @@
   if (str.Find(L"mailto:") == -1)
     str = L"mailto:" + str;
 
   return true;
 }
 
 CFX_WideString CPDF_LinkExtract::GetURL(size_t index) const {
   return index < m_LinkArray.size() ? m_LinkArray[index].m_strUrl : L"";
 }
 
-void CPDF_LinkExtract::GetRects(size_t index, CFX_RectArray* pRects) const {
-  if (index < m_LinkArray.size()) {
-    m_pTextPage->GetRectArray(m_LinkArray[index].m_Start,
-                              m_LinkArray[index].m_Count, pRects);
-  }
+std::vector<CFX_FloatRect> CPDF_LinkExtract::GetRects(size_t index) const {
+  if (index >= m_LinkArray.size())
+    return std::vector<CFX_FloatRect>();
+
+  return m_pTextPage->GetRectArray(m_LinkArray[index].m_Start,
+                                   m_LinkArray[index].m_Count);
 }