Fix the way to access marked content.

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 "core/src/fpdftext/text_int.h"
 
 #include <algorithm>
 #include <cctype>
@@ skipping 116 matching lines @@
     case 0x94:
     case 0x96:
     case 0x97:
     case 0x98:
     case 0xfffe:
       return charInfo.m_Flag != FPDFTEXT_CHAR_HYPHEN;
     default:
       return false;
   }
 }
+
 FX_BOOL CPDF_TextPage::ParseTextPage() {
   m_bIsParsed = false;
   if (!m_pPage)
     return FALSE;
 
   m_TextBuf.Clear();
   m_CharList.clear();
   m_pPreTextObj = NULL;
   ProcessObject();
   m_bIsParsed = true;
@@ skipping 32 matching lines @@
         m_CharIndex.push_back(i + 1);
       }
     }
   }
   int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   if (indexSize % 2) {
     m_CharIndex.erase(m_CharIndex.begin() + indexSize - 1);
   }
   return TRUE;
 }
+
 int CPDF_TextPage::CountChars() const {
   return pdfium::CollectionSize<int>(m_CharList);
 }
+
 int CPDF_TextPage::CharIndexFromTextIndex(int TextIndex) const {
   int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   int count = 0;
   for (int i = 0; i < indexSize; i += 2) {
     count += m_CharIndex[i + 1];
     if (count > TextIndex)
       return TextIndex - count + m_CharIndex[i + 1] + m_CharIndex[i];
   }
   return -1;
 }
+
 int CPDF_TextPage::TextIndexFromCharIndex(int CharIndex) const {
   int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   int count = 0;
   for (int i = 0; i < indexSize; i += 2) {
     count += m_CharIndex[i + 1];
     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;
@@ skipping 65 matching lines @@
       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);
 }
+
 int CPDF_TextPage::GetIndexAtPos(CPDF_Point point,
                                  FX_FLOAT xTolerance,
                                  FX_FLOAT yTolerance) const {
   if (!m_bIsParsed)
     return -3;
 
   int pos = 0;
   int NearPos = -1;
   double xdif = 5000;
   double ydif = 5000;
@@ skipping 60 matching lines @@
         IsContainPreChar = false;
         IsAddLineFeed = false;
       }
     } else {
       IsContainPreChar = false;
       IsAddLineFeed = true;
     }
   }
   return strText;
 }
+
 void CPDF_TextPage::GetRectsArrayByRect(const CFX_FloatRect& rect,
                                         CFX_RectArray& resRectArray) const {
   if (!m_bIsParsed)
     return;
 
   CFX_FloatRect curRect;
   bool flagNewRect = true;
   CPDF_TextObject* pCurObj = nullptr;
   for (auto info_curchar : m_CharList) {
     if (info_curchar.m_Flag == FPDFTEXT_CHAR_GENERATED) {
@@ skipping 17 matching lines @@
     } 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);
 }
+
 int CPDF_TextPage::GetIndexAtPos(FX_FLOAT x,
                                  FX_FLOAT y,
                                  FX_FLOAT xTolerance,
                                  FX_FLOAT yTolerance) const {
   CPDF_Point point(x, y);
   return GetIndexAtPos(point, xTolerance, yTolerance);
 }
 
 void CPDF_TextPage::GetCharInfo(int index, FPDF_CHAR_INFO* info) const {
   if (!m_bIsParsed)
@@ skipping 48 matching lines @@
       endIndex++;
       if (endIndex >= pdfium::CollectionSize<int>(m_CharList)) {
         break;
       }
       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 = pdfium::CollectionSize<int>(m_CharList) - start;
     return m_TextBuf.GetWideString().Mid(start,
@@ skipping 29 matching lines @@
       return L"";
     }
     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_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();
 }
+
 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())
     return;
@@ skipping 61 matching lines @@
 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 57 matching lines @@
     pos++;
   }
   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 11 matching lines @@
         break;
     }
   } else if (direction == FPDFTEXT_RIGHT) {
     while (++breakPos < pdfium::CollectionSize<int>(m_CharList)) {
       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();
   std::vector<uint8_t> nHorizontalMask(nPageWidth);
   std::vector<uint8_t> nVerticalMask(nPageHeight);
   uint8_t* pDataH = nHorizontalMask.data();
   uint8_t* pDataV = nVerticalMask.data();
@@ skipping 77 matching lines @@
     return 0;
   }
   if (nSumH - nSumV > 0.0f) {
     return 0;
   }
   if (nSumV - nSumH > 0.0f) {
     return 1;
   }
   return -1;
 }
+
 void CPDF_TextPage::ProcessObject() {
   CPDF_PageObject* pPageObj = NULL;
   if (!m_pPage) {
     return;
   }
   FX_POSITION pos;
   pos = m_pPage->GetFirstObjectPosition();
   if (!pos) {
     return;
   }
@@ skipping 13 matching lines @@
     }
     pPageObj = NULL;
   }
   int count = m_LineObj.GetSize();
   for (int i = 0; i < count; i++) {
     ProcessTextObject(m_LineObj.GetAt(i));
   }
   m_LineObj.RemoveAll();
   CloseTempLine();
 }
+
 void CPDF_TextPage::ProcessFormObject(CPDF_FormObject* pFormObj,
                                       const CFX_Matrix& formMatrix) {
   CPDF_PageObject* pPageObj = NULL;
   FX_POSITION pos;
   if (!pFormObj) {
     return;
   }
   pos = pFormObj->m_pForm->GetFirstObjectPosition();
   if (!pos) {
     return;
   }
   CFX_Matrix curFormMatrix;
   curFormMatrix.Copy(pFormObj->m_FormMatrix);
   curFormMatrix.Concat(formMatrix);
   while (pos) {
     pPageObj = pFormObj->m_pForm->GetNextObject(pos);
     if (pPageObj) {
       if (pPageObj->m_Type == CPDF_PageObject::TEXT) {
         ProcessTextObject((CPDF_TextObject*)pPageObj, curFormMatrix, pos);
       } else if (pPageObj->m_Type == CPDF_PageObject::FORM) {
         ProcessFormObject((CPDF_FormObject*)pPageObj, curFormMatrix);
       }
     }
     pPageObj = NULL;
   }
 }
+
 int CPDF_TextPage::GetCharWidth(FX_DWORD charCode, CPDF_Font* pFont) const {
   if (charCode == -1) {
     return 0;
   }
   int w = pFont->GetCharWidthF(charCode);
   if (w == 0) {
     CFX_ByteString str;
     pFont->AppendChar(str, charCode);
     w = pFont->GetStringWidth(str, 1);
     if (w == 0) {
       FX_RECT BBox;
       pFont->GetCharBBox(charCode, BBox);
       w = BBox.right - BBox.left;
     }
   }
   return w;
 }
+
 void CPDF_TextPage::OnPiece(CFX_BidiChar* pBidi, CFX_WideString& str) {
   CFX_BidiChar::Segment seg = pBidi->GetSegmentInfo();
   if (seg.direction == CFX_BidiChar::RIGHT) {
     for (int i = seg.start + seg.count; i > seg.start; i--) {
       m_TextBuf.AppendChar(str.GetAt(i - i));
       m_CharList.push_back(m_TempCharList[i - 1]);
     }
   } else {
     for (int i = seg.start; i < seg.start + seg.count; i++) {
       m_TextBuf.AppendChar(str.GetAt(i));
       m_CharList.push_back(m_TempCharList[i]);
     }
   }
 }
+
 void CPDF_TextPage::AddCharInfoByLRDirection(FX_WCHAR wChar,
                                              PAGECHAR_INFO info) {
   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);
           m_CharList.push_back(info2);
         }
         FX_Free(pDst);
         return;
       }
     }
     m_TextBuf.AppendChar(wChar);
   } else {
     info.m_Index = -1;
   }
   m_CharList.push_back(info);
 }
+
 void CPDF_TextPage::AddCharInfoByRLDirection(FX_WCHAR wChar,
                                              PAGECHAR_INFO info) {
   if (!IsControlChar(info)) {
     info.m_Index = m_TextBuf.GetLength();
     wChar = FX_GetMirrorChar(wChar, 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);
@@ skipping 132 matching lines @@
   }
   if (i < 0) {
     m_LineObj.InsertAt(0, Obj);
   }
 }
 
 int32_t CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
   CPDF_ContentMarkData* pMarkData =
       (CPDF_ContentMarkData*)pTextObj->m_ContentMark.GetObject();
-  if (!pMarkData) {
+  if (!pMarkData)
     return FPDFTEXT_MC_PASS;
-  }
+
   int nContentMark = pMarkData->CountItems();
-  if (nContentMark < 1) {
+  if (nContentMark < 1)
     return FPDFTEXT_MC_PASS;
-  }
   CFX_WideString actText;
   FX_BOOL bExist = FALSE;
   CPDF_Dictionary* pDict = NULL;
   int n = 0;
   for (n = 0; n < nContentMark; n++) {
     CPDF_ContentMarkItem& item = pMarkData->GetItem(n);
-    CFX_ByteString tagStr = (CFX_ByteString)item.GetName();
-    pDict = ToDictionary(static_cast<CPDF_Object*>(item.GetParam()));
+    if (item.GetParamType() == CPDF_ContentMarkItem::ParamType::None)
+      continue;
+    pDict = item.GetParam();
     CPDF_String* temp =
         ToString(pDict ? pDict->GetElement("ActualText") : nullptr);
     if (temp) {
       bExist = TRUE;
       actText = temp->GetUnicodeText();
     }
   }
-  if (!bExist) {
+  if (!bExist)
     return FPDFTEXT_MC_PASS;
-  }
+
   if (m_pPreTextObj) {
-    if (CPDF_ContentMarkData* pPreMarkData =
-            (CPDF_ContentMarkData*)m_pPreTextObj->m_ContentMark.GetObject()) {
-      if (pPreMarkData->CountItems() == n) {
-        CPDF_ContentMarkItem& item = pPreMarkData->GetItem(n - 1);
-        if (pDict == item.GetParam()) {
-          return FPDFTEXT_MC_DONE;
-        }
-      }
+    CPDF_ContentMarkData* pPreMarkData =
+        (CPDF_ContentMarkData*)m_pPreTextObj->m_ContentMark.GetObject();
+    if (pPreMarkData && pPreMarkData->CountItems() == n &&
+        pDict == pPreMarkData->GetItem(n - 1).GetParam()) {
+      return FPDFTEXT_MC_DONE;
     }
   }
+  FX_STRSIZE nItems = actText.GetLength();
+  if (nItems < 1)
+    return FPDFTEXT_MC_PASS;
+
   CPDF_Font* pFont = pTextObj->GetFont();
-  FX_STRSIZE nItems = actText.GetLength();
-  if (nItems < 1) {
-    return FPDFTEXT_MC_PASS;
-  }
   bExist = FALSE;
   for (FX_STRSIZE i = 0; i < nItems; i++) {
-    FX_WCHAR wChar = actText.GetAt(i);
-    if (-1 == pFont->CharCodeFromUnicode(wChar)) {
-      continue;
-    } else {
+    if (pFont->CharCodeFromUnicode(actText.GetAt(i)) != -1) {
       bExist = TRUE;
       break;
     }
   }
-  if (!bExist) {
+  if (!bExist)
     return FPDFTEXT_MC_PASS;
-  }
+
   bExist = FALSE;
   for (FX_STRSIZE i = 0; i < nItems; i++) {
     FX_WCHAR wChar = actText.GetAt(i);
     if ((wChar > 0x80 && wChar < 0xFFFD) || (wChar <= 0x80 && isprint(wChar))) {
       bExist = TRUE;
       break;
     }
   }
-  if (!bExist) {
+  if (!bExist)
     return FPDFTEXT_MC_DONE;
-  }
+
   return FPDFTEXT_MC_DELAY;
 }
+
 void CPDF_TextPage::ProcessMarkedContent(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
   CPDF_ContentMarkData* pMarkData =
       (CPDF_ContentMarkData*)pTextObj->m_ContentMark.GetObject();
-  if (!pMarkData) {
+  if (!pMarkData)
     return;
-  }
+
   int nContentMark = pMarkData->CountItems();
-  if (nContentMark < 1) {
+  if (nContentMark < 1)
     return;
-  }
   CFX_WideString actText;
   CPDF_Dictionary* pDict = NULL;
-  int n = 0;
-  for (n = 0; n < nContentMark; n++) {
+  for (int n = 0; n < nContentMark; n++) {
     CPDF_ContentMarkItem& item = pMarkData->GetItem(n);
-    CFX_ByteString tagStr = (CFX_ByteString)item.GetName();
-    pDict = ToDictionary(static_cast<CPDF_Object*>(item.GetParam()));
-    CPDF_String* temp =
-        ToString(pDict ? pDict->GetElement("ActualText") : nullptr);
-    if (temp) {
-      actText = temp->GetUnicodeText();
-    }
+    if (item.GetParamType() == CPDF_ContentMarkItem::ParamType::None)
+      continue;
+    pDict = item.GetParam();
+    if (pDict)
+      actText = pDict->GetUnicodeTextBy("ActualText");
   }
   FX_STRSIZE nItems = actText.GetLength();
-  if (nItems < 1) {
+  if (nItems < 1)
     return;
-  }
+
   CPDF_Font* pFont = pTextObj->GetFont();
   CFX_Matrix formMatrix = Obj.m_formMatrix;
   CFX_Matrix matrix;
   pTextObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
   FX_FLOAT fPosX = pTextObj->GetPosX();
   FX_FLOAT fPosY = pTextObj->GetPosY();
   int nCharInfoIndex = m_TextBuf.GetLength();
   CFX_FloatRect charBox;
   charBox.top = pTextObj->m_Top;
@@ skipping 18 matching lines @@
     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.push_back(charinfo);
   }
 }
+
 void CPDF_TextPage::FindPreviousTextObject() {
   if (m_TempCharList.empty() && m_CharList.empty())
     return;
 
   PAGECHAR_INFO preChar =
       m_TempCharList.empty() ? m_CharList.back() : m_TempCharList.back();
 
   if (preChar.m_pTextObj)
     m_pPreTextObj = preChar.m_pTextObj;
 }
@@ skipping 290 matching lines @@
           m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
           m_TempCharList.pop_back();
         }
       }
     }
   }
   if (bIsBidiAndMirrorInverse) {
     SwapTempTextBuf(iCharListStartAppend, iBufStartAppend);
   }
 }
+
 int32_t CPDF_TextPage::GetTextObjectWritingMode(
     const CPDF_TextObject* pTextObj) {
   int32_t nChars = pTextObj->CountChars();
   if (nChars == 1) {
     return m_TextlineDir;
   }
   CPDF_TextObjectItem first, last;
   pTextObj->GetCharInfo(0, &first);
   pTextObj->GetCharInfo(nChars - 1, &last);
   CFX_Matrix textMatrix;
@@ skipping 45 matching lines @@
     } else {
       return FALSE;
     }
     if (FPDFTEXT_CHAR_PIECE == preInfo->m_Flag &&
         (0xAD == preInfo->m_Unicode || 0x2D == preInfo->m_Unicode)) {
       return TRUE;
     }
   }
   return FALSE;
 }
+
 int CPDF_TextPage::ProcessInsertObject(const CPDF_TextObject* pObj,
                                        const CFX_Matrix& formMatrix) {
   FindPreviousTextObject();
   FX_BOOL bNewline = FALSE;
   int WritingMode = GetTextObjectWritingMode(pObj);
   if (WritingMode == -1) {
     WritingMode = GetTextObjectWritingMode(m_pPreTextObj);
   }
   CFX_FloatRect this_rect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right,
                           pObj->m_Top);
@@ skipping 136 matching lines @@
         return 1;
       }
       if ((x - last_pos - last_width) > this_width ||
           (x - last_pos - this_width) > last_width) {
         return 1;
       }
     }
   }
   return 0;
 }
+
 FX_BOOL CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1,
                                         CPDF_TextObject* pTextObj2) {
   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()) {
@@ skipping 37 matching lines @@
           GetCharWidth(itemPer.m_CharCode, pTextObj2->GetFont()) *
               pTextObj2->GetFontSize() / 1000 * 0.9 ||
       FXSYS_fabs(pTextObj1->GetPosY() - pTextObj2->GetPosY()) >
           std::max(std::max(rcPreObj.Height(), rcPreObj.Width()),
                    pTextObj2->GetFontSize()) /
               8) {
     return FALSE;
   }
   return TRUE;
 }
+
 FX_BOOL CPDF_TextPage::IsSameAsPreTextObject(CPDF_TextObject* pTextObj,
                                              FX_POSITION ObjPos) {
   if (!pTextObj) {
     return FALSE;
   }
   int i = 0;
   if (!ObjPos) {
     ObjPos = m_pPage->GetLastObjectPosition();
   }
   CPDF_PageObject* pObj = m_pPage->GetPrevObject(ObjPos);
@@ skipping 43 matching lines @@
                                  info.m_OriginY);
   return TRUE;
 }
 
 FX_BOOL CPDF_TextPage::IsRectIntersect(const CFX_FloatRect& rect1,
                                        const CFX_FloatRect& rect2) {
   CFX_FloatRect rect = rect1;
   rect.Intersect(rect2);
   return !rect.IsEmpty();
 }
+
 FX_BOOL CPDF_TextPage::IsLetter(FX_WCHAR unicode) {
   if (unicode < L'A') {
     return FALSE;
   }
   if (unicode > L'Z' && unicode < L'a') {
     return FALSE;
   }
   if (unicode > L'z') {
     return FALSE;
   }
   return TRUE;
 }
+
 CPDF_TextPageFind::CPDF_TextPageFind(const IPDF_TextPage* pTextPage)
     : m_pTextPage(pTextPage),
       m_flags(0),
       m_findNextStart(-1),
       m_findPreStart(-1),
       m_bMatchCase(FALSE),
       m_bMatchWholeWord(FALSE),
       m_resStart(0),
       m_resEnd(-1),
       m_IsFind(FALSE) {
@@ skipping 24 matching lines @@
       } else {
         m_CharIndex.push_back(i + 1);
       }
     }
   }
   int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
   if (indexSize % 2) {
     m_CharIndex.erase(m_CharIndex.begin() + indexSize - 1);
   }
 }
+
 int CPDF_TextPageFind::GetCharIndex(int index) const {
   return m_pTextPage->CharIndexFromTextIndex(index);
 }
+
 FX_BOOL CPDF_TextPageFind::FindFirst(const CFX_WideString& findwhat,
                                      int flags,
                                      int startPos) {
   if (!m_pTextPage) {
     return FALSE;
   }
   if (m_strText.IsEmpty() || m_bMatchCase != (flags & FPDFTEXT_MATCHCASE)) {
     m_strText = m_pTextPage->GetPageText();
   }
   CFX_WideString findwhatStr = findwhat;
@@ skipping 30 matching lines @@
     m_csFindWhatArray.Add(findwhatStr);
   }
   if (m_csFindWhatArray.GetSize() <= 0) {
     return FALSE;
   }
   m_IsFind = TRUE;
   m_resStart = 0;
   m_resEnd = -1;
   return TRUE;
 }
+
 FX_BOOL CPDF_TextPageFind::FindNext() {
   if (!m_pTextPage) {
     return FALSE;
   }
   m_resArray.RemoveAll();
   if (m_findNextStart == -1) {
     return FALSE;
   }
   if (m_strText.IsEmpty()) {
     m_IsFind = FALSE;
@@ skipping 87 matching lines @@
   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;
 }
+
 FX_BOOL CPDF_TextPageFind::FindPrev() {
   if (!m_pTextPage) {
     return FALSE;
   }
   m_resArray.RemoveAll();
   if (m_strText.IsEmpty() || m_findPreStart < 0) {
     m_IsFind = FALSE;
     return m_IsFind;
   }
   CPDF_TextPageFind findEngine(m_pTextPage);
@@ skipping 25 matching lines @@
   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;
 }
+
 void CPDF_TextPageFind::ExtractFindWhat(const CFX_WideString& findwhat) {
   if (findwhat.IsEmpty()) {
     return;
   }
   int index = 0;
   while (1) {
     CFX_WideString csWord = TEXT_EMPTY;
     int ret =
         ExtractSubString(csWord, findwhat.c_str(), index, TEXT_BLANK_CHAR);
     if (csWord.IsEmpty()) {
@@ skipping 28 matching lines @@
         continue;
       }
       pos++;
     }
     if (!csWord.IsEmpty()) {
       m_csFindWhatArray.Add(csWord);
     }
     index++;
   }
 }
+
 FX_BOOL CPDF_TextPageFind::IsMatchWholeWord(const CFX_WideString& csPageText,
                                             int startPos,
                                             int endPos) {
   FX_WCHAR char_left = 0;
   FX_WCHAR char_right = 0;
   int char_count = endPos - startPos + 1;
   if (char_count < 1) {
     return FALSE;
   }
   if (char_count == 1 && csPageText.GetAt(startPos) > 255) {
@@ skipping 26 matching lines @@
         char_left <= L'9') {
       return FALSE;
     }
     if (csPageText.GetAt(endPos) >= L'0' && csPageText.GetAt(endPos) <= L'9' &&
         char_right >= L'0' && char_right <= L'9') {
       return FALSE;
     }
   }
   return TRUE;
 }
+
 FX_BOOL CPDF_TextPageFind::ExtractSubString(CFX_WideString& rString,
                                             const FX_WCHAR* lpszFullString,
                                             int iSubString,
                                             FX_WCHAR chSep) {
   if (!lpszFullString) {
     return FALSE;
   }
   while (iSubString--) {
     lpszFullString = FXSYS_wcschr(lpszFullString, chSep);
     if (!lpszFullString) {
       rString.Empty();
       return FALSE;
     }
     lpszFullString++;
     while (*lpszFullString == chSep) {
       lpszFullString++;
     }
   }
   const FX_WCHAR* lpchEnd = FXSYS_wcschr(lpszFullString, chSep);
   int nLen = lpchEnd ? (int)(lpchEnd - lpszFullString)
                      : (int)FXSYS_wcslen(lpszFullString);
   ASSERT(nLen >= 0);
   FXSYS_memcpy(rString.GetBuffer(nLen), lpszFullString,
                nLen * sizeof(FX_WCHAR));
   rString.ReleaseBuffer();
   return TRUE;
 }
+
 CFX_WideString CPDF_TextPageFind::MakeReverse(const CFX_WideString& str) {
   CFX_WideString str2;
   str2.Empty();
   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;
 }
 
 CPDF_LinkExtract::CPDF_LinkExtract()
     : m_pTextPage(nullptr), m_bIsParsed(false) {
 }
 
@@ skipping 18 matching lines @@
 
 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 == CHAR_GENERATED || pageChar.m_Unicode == 0x20 ||
         pos == TotalChar - 1) {
       int nCount = pos - start;
       if (pos == TotalChar - 1) {
@@ skipping 15 matching lines @@
             (CheckWebLink(strBeCheck) || CheckMailLink(strBeCheck))) {
           AppendToLinkList(start, nCount, strBeCheck);
         }
       }
       start = ++pos;
     } else {
       pos++;
     }
   }
 }
+
 FX_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;
   }
   if (str.Find(L"http://") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"http://"));
     return TRUE;
   }
   if (str.Find(L"https://www.") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"https://www."));
     return TRUE;
   }
   if (str.Find(L"https://") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"https://"));
     return TRUE;
   }
   if (str.Find(L"www.") != -1) {
     strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"www."));
     strBeCheck = L"http://" + strBeCheck;
     return TRUE;
   }
   return FALSE;
 }
+
 bool CPDF_LinkExtract::CheckMailLink(CFX_WideString& str) {
   int aPos = str.Find(L'@');
   // Invalid when no '@'.
   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--) {
@@ skipping 84 matching lines @@
     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);
 }