Remove CFX_ArrayTemplate from CPDF_LinkExtract

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 244 matching lines @@
         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 {
+                                 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;
   if (nCount + start > pdfium::CollectionSize<int>(m_CharList) ||
       nCount == -1) {
     nCount = pdfium::CollectionSize<int>(m_CharList) - start;
   }
   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->Add(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->Add(rect);
 }
 
 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 228 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);
+  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 {
   if (!m_bIsParsed)
     return;
@@ skipping 36 matching lines @@
     Rotate = (int)(a * 180 / FX_PI + 0.5);
   }
   if (Rotate < 0) {
     Rotate = -Rotate;
   } else if (Rotate > 0) {
     Rotate = 360 - Rotate;
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_TextPage::GetBaselineRotate(const CFX_FloatRect& rect,
-                                         int& Rotate) {
-  int start, end, count,
-      n = CountBoundedSegments(rect.left, rect.top, rect.right, rect.bottom,
-                               TRUE);
-  if (n < 1) {
-    return FALSE;
-  }
-  if (n > 1) {
-    GetBoundedSegment(n - 1, start, count);
-    end = start + count - 1;
-    GetBoundedSegment(0, start, count);
-  } else {
-    GetBoundedSegment(0, start, count);
-    end = start + count - 1;
-  }
-  return GetBaselineRotate(start, end, Rotate);
-}
-FX_BOOL CPDF_TextPage::GetBaselineRotate(int rectIndex, int& Rotate) {
-  if (!m_bIsParsed)
-    return FALSE;
-
-  if (rectIndex < 0 || rectIndex >= m_SelRects.GetSize())
-    return FALSE;
-
-  CFX_FloatRect rect = m_SelRects.GetAt(rectIndex);
-  return GetBaselineRotate(rect, Rotate);
-}
-
 int CPDF_TextPage::CountBoundedSegments(FX_FLOAT left,
                                         FX_FLOAT top,
                                         FX_FLOAT right,
                                         FX_FLOAT bottom,
                                         FX_BOOL bContains) {
   m_Segments.RemoveAll();
   if (!m_bIsParsed)
     return -1;
 
   CFX_FloatRect rect(left, bottom, right, top);
@@ skipping 58 matching lines @@
   }
   if (segmentStatus == 1) {
     segmentStatus = 2;
     m_Segments.Add(segment);
     segment.m_Start = 0;
     segment.m_nCount = 0;
   }
   return m_Segments.GetSize();
 }
 
-void CPDF_TextPage::GetBoundedSegment(int index, int& start, int& count) const {
-  if (index < 0 || index >= m_Segments.GetSize()) {
-    return;
-  }
-  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_bIsParsed)
     return -1;
 
   if (direction != FPDFTEXT_LEFT && direction != FPDFTEXT_RIGHT)
     return -1;
 
   if (index < 0 || index >= pdfium::CollectionSize<int>(m_CharList))
     return -1;
 
@@ skipping 1342 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_pTextPage->GetRectArray(resStart, resEnd - resStart + 1, &m_resArray);
   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 25 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_pTextPage->GetRectArray(order, MatchedCount, &m_resArray);
   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 137 matching lines @@
 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;
 }
 
-CPDF_LinkExtract::CPDF_LinkExtract()
-    : m_pTextPage(nullptr), m_bIsParsed(false) {}
+CPDF_LinkExtract::CPDF_LinkExtract(const CPDF_TextPage* pTextPage)
+    : m_pTextPage(pTextPage) {}
 
 CPDF_LinkExtract::~CPDF_LinkExtract() {
-  DeleteLinkList();
 }
 
-FX_BOOL CPDF_LinkExtract::ExtractLinks(const CPDF_TextPage* pTextPage) {
-  if (!pTextPage || !pTextPage->IsParsed())
-    return FALSE;
+void CPDF_LinkExtract::ExtractLinks() {
+  m_LinkArray.clear();
+  if (!m_pTextPage->IsParsed())
+    return;
 
-  m_pTextPage = (const CPDF_TextPage*)pTextPage;
   m_strPageText = m_pTextPage->GetPageText(0, -1);
-  DeleteLinkList();
-  if (m_strPageText.IsEmpty()) {
-    return FALSE;
-  }
+  if (m_strPageText.IsEmpty())
+    return;
+
   ParseLink();
-  m_bIsParsed = true;
-  return TRUE;
-}
-
-void CPDF_LinkExtract::DeleteLinkList() {
-  while (m_LinkList.GetSize()) {
-    CPDF_LinkExt* linkinfo = NULL;
-    linkinfo = m_LinkList.GetAt(0);
-    m_LinkList.RemoveAt(0);
-    delete linkinfo;
-  }
-  m_LinkList.RemoveAll();
-}
-
-int CPDF_LinkExtract::CountLinks() const {
-  if (!m_bIsParsed) {
-    return -1;
-  }
-  return m_LinkList.GetSize();
 }
 
 void CPDF_LinkExtract::ParseLink() {
   int start = 0, pos = 0;
   int TotalChar = m_pTextPage->CountChars();
   while (pos < TotalChar) {
     FPDF_CHAR_INFO pageChar;
     m_pTextPage->GetCharInfo(pos, &pageChar);
     if (pageChar.m_Flag == FPDFTEXT_CHAR_GENERATED ||
         pageChar.m_Unicode == 0x20 || pos == TotalChar - 1) {
       int nCount = pos - start;
       if (pos == TotalChar - 1) {
         nCount++;
       }
       CFX_WideString strBeCheck;
       strBeCheck = m_pTextPage->GetPageText(start, nCount);
       if (strBeCheck.GetLength() > 5) {
         while (strBeCheck.GetLength() > 0) {
           FX_WCHAR ch = strBeCheck.GetAt(strBeCheck.GetLength() - 1);
           if (ch == L')' || ch == L',' || ch == L'>' || ch == L'.') {
             strBeCheck = strBeCheck.Mid(0, strBeCheck.GetLength() - 1);
             nCount--;
           } else {
             break;
           }
         }
         if (nCount > 5 &&
             (CheckWebLink(strBeCheck) || CheckMailLink(strBeCheck))) {
-          AppendToLinkList(start, nCount, strBeCheck);
+          m_LinkArray.push_back({start, nCount, strBeCheck});
         }
       }
       start = ++pos;
     } else {
       pos++;
     }
   }
 }
 
-FX_BOOL CPDF_LinkExtract::CheckWebLink(CFX_WideString& strBeCheck) {
+bool CPDF_LinkExtract::CheckWebLink(CFX_WideString& strBeCheck) {
   CFX_WideString str = strBeCheck;
   str.MakeLower();
   if (str.Find(L"http://www.") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"http://www."));
-    return TRUE;
+    return true;
   }
   if (str.Find(L"http://") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"http://"));
-    return TRUE;
+    return true;
   }
   if (str.Find(L"https://www.") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"https://www."));
-    return TRUE;
+    return true;
   }
   if (str.Find(L"https://") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"https://"));
-    return TRUE;
+    return true;
   }
   if (str.Find(L"www.") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"www."));
     strBeCheck = L"http://" + strBeCheck;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 bool CPDF_LinkExtract::CheckMailLink(CFX_WideString& str) {
   int aPos = str.Find(L'@');
   // Invalid when no '@'.
-  if (aPos < 1) {
-    return FALSE;
-  }
+  if (aPos < 1)
+    return false;
 
   // Check the local part.
   int pPos = aPos;  // Used to track the position of '@' or '.'.
   for (int i = aPos - 1; i >= 0; i--) {
     FX_WCHAR ch = str.GetAt(i);
-    if (ch == L'_' || ch == L'-' || FXSYS_iswalnum(ch)) {
+    if (ch == L'_' || ch == L'-' || FXSYS_iswalnum(ch))
       continue;
-    }
+
     if (ch != L'.' || i == pPos - 1 || i == 0) {
       if (i == aPos - 1) {
         // There is '.' or invalid char before '@'.
         return FALSE;
       }
       // End extracting for other invalid chars, '.' at the beginning, or
       // consecutive '.'.
       int removed_len = i == pPos - 1 ? i + 2 : i + 1;
       str = str.Right(str.GetLength() - removed_len);
       break;
     }
     // Found a valid '.'.
     pPos = i;
   }
 
   // Check the domain name part.
   aPos = str.Find(L'@');
-  if (aPos < 1) {
-    return FALSE;
-  }
+  if (aPos < 1)
+    return false;
+
   str.TrimRight(L'.');
   // At least one '.' in domain name, but not at the beginning.
   // TODO(weili): RFC5322 allows domain names to be a local name without '.'.
   // Check whether we should remove this check.
   int ePos = str.Find(L'.', aPos + 1);
-  if (ePos == -1 || ePos == aPos + 1) {
-    return FALSE;
-  }
+  if (ePos == -1 || ePos == aPos + 1)
+    return false;
+
   // Validate all other chars in domain name.
   int nLen = str.GetLength();
   pPos = 0;  // Used to track the position of '.'.
   for (int i = aPos + 1; i < nLen; i++) {
     FX_WCHAR wch = str.GetAt(i);
-    if (wch == L'-' || FXSYS_iswalnum(wch)) {
+    if (wch == L'-' || FXSYS_iswalnum(wch))
       continue;
-    }
+
     if (wch != L'.' || i == pPos + 1) {
       // Domain name should end before invalid char.
       int host_end = i == pPos + 1 ? i - 2 : i - 1;
       if (pPos > 0 && host_end - aPos >= 3) {
         // Trim the ending invalid chars if there is at least one '.' and name.
         str = str.Left(host_end + 1);
         break;
       }
-      return FALSE;
+      return false;
     }
     pPos = i;
   }
 
-  if (str.Find(L"mailto:") == -1) {
+  if (str.Find(L"mailto:") == -1)
     str = L"mailto:" + str;
-  }
-  return TRUE;
+
+  return true;
 }
 
-void CPDF_LinkExtract::AppendToLinkList(int start,
-                                        int count,
-                                        const CFX_WideString& strUrl) {
-  CPDF_LinkExt* linkInfo = new CPDF_LinkExt;
-  linkInfo->m_strUrl = strUrl;
-  linkInfo->m_Start = start;
-  linkInfo->m_Count = count;
-  m_LinkList.Add(linkInfo);
+CFX_WideString CPDF_LinkExtract::GetURL(size_t index) const {
+  return index < m_LinkArray.size() ? m_LinkArray[index].m_strUrl : L"";
 }
 
-CFX_WideString CPDF_LinkExtract::GetURL(int index) const {
-  if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
-    return 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);
   }
-  CPDF_LinkExt* link = NULL;
-  link = m_LinkList.GetAt(index);
-  if (!link) {
-    return L"";
-  }
-  return link->m_strUrl;
 }
-void CPDF_LinkExtract::GetBoundedSegment(int index,
-                                         int& start,
-                                         int& count) const {
-  if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
-    return;
-  }
-  CPDF_LinkExt* link = NULL;
-  link = m_LinkList.GetAt(index);
-  if (!link) {
-    return;
-  }
-  start = link->m_Start;
-  count = link->m_Count;
-}
-
-void CPDF_LinkExtract::GetRects(int index, CFX_RectArray& rects) const {
-  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);
-}