Clean up CPDF_TextPage.

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 21 matching lines @@
 #define FPDFTEXT_MATCHWHOLEWORD 0x00000002
 #define FPDFTEXT_CONSECUTIVE 0x00000004
 
 #define FPDFTEXT_CHAR_ERROR -1
 #define FPDFTEXT_CHAR_NORMAL 0
 #define FPDFTEXT_CHAR_GENERATED 1
 #define FPDFTEXT_CHAR_UNUNICODE 2
 #define FPDFTEXT_CHAR_HYPHEN 3
 #define FPDFTEXT_CHAR_PIECE 4
 
-#define TEXT_BLANK_CHAR L' '
+#define TEXT_SPACE_CHAR L' '
 #define TEXT_LINEFEED_CHAR L'\n'
 #define TEXT_RETURN_CHAR L'\r'
 #define TEXT_EMPTY L""
-#define TEXT_BLANK L" "
+#define TEXT_SPACE L" "
 #define TEXT_RETURN_LINEFEED L"\r\n"
 #define TEXT_LINEFEED L"\n"
 #define TEXT_CHARRATIO_GAPDELTA 0.070
 
 namespace {
 
 const FX_FLOAT kDefaultFontSize = 1.0f;
 const uint16_t* const g_UnicodeData_Normalization_Maps[5] = {
     nullptr, g_UnicodeData_Normalization_Map1, g_UnicodeData_Normalization_Map2,
     g_UnicodeData_Normalization_Map3, g_UnicodeData_Normalization_Map4};
@@ skipping 86 matching lines @@
   return (FX_STRSIZE)wFind;
 }
 
 }  // namespace
 
 CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, FPDFText_Direction flags)
     : m_pPage(pPage),
       m_parserflag(flags),
       m_pPreTextObj(nullptr),
       m_bIsParsed(false),
-      m_TextlineDir(-1),
+      m_TextlineDir(TextOrientation::Unknown),
       m_CurlineRect(0, 0, 0, 0) {
   m_TextBuf.EstimateSize(0, 10240);
   pPage->GetDisplayMatrix(m_DisplayMatrix, 0, 0, (int)pPage->GetPageWidth(),
                           (int)pPage->GetPageHeight(), 0);
 }
 
 bool CPDF_TextPage::IsControlChar(const PAGECHAR_INFO& charInfo) {
   switch (charInfo.m_Unicode) {
     case 0x2:
     case 0x3:
@@ skipping 12 matching lines @@
 void CPDF_TextPage::ParseTextPage() {
   m_bIsParsed = false;
   m_TextBuf.Clear();
   m_CharList.clear();
   m_pPreTextObj = nullptr;
   ProcessObject();
 
   m_bIsParsed = true;
   m_CharIndex.clear();
   int nCount = pdfium::CollectionSize<int>(m_CharList);
-  if (nCount) {
+  if (nCount)
     m_CharIndex.push_back(0);
-  }
+
   for (int i = 0; i < nCount; i++) {
     int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
-    FX_BOOL bNormal = FALSE;
     const 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 (charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED ||
+        (charinfo.m_Unicode != 0 && !IsControlChar(charinfo))) {
       if (indexSize % 2) {
         m_CharIndex.push_back(1);
       } else {
-        if (indexSize <= 0) {
+        if (indexSize <= 0)
           continue;
-        }
         m_CharIndex[indexSize - 1] += 1;
       }
     } else {
       if (indexSize % 2) {
-        if (indexSize <= 0) {
+        if (indexSize <= 0)
           continue;
-        }
         m_CharIndex[indexSize - 1] = i + 1;
       } else {
         m_CharIndex.push_back(i + 1);
       }
     }
   }
   int indexSize = pdfium::CollectionSize<int>(m_CharIndex);
-  if (indexSize % 2) {
+  if (indexSize % 2)
     m_CharIndex.erase(m_CharIndex.begin() + indexSize - 1);
-  }
 }
 
 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) {
@@ skipping 444 matching lines @@
   }
   if (segmentStatus == 1) {
     segmentStatus = 2;
     m_Segments.Add(segment);
     segment.m_Start = 0;
     segment.m_nCount = 0;
   }
   return m_Segments.GetSize();
 }
 
-int32_t CPDF_TextPage::FindTextlineFlowDirection() {
+CPDF_TextPage::TextOrientation CPDF_TextPage::FindTextlineFlowOrientation()
+    const {
   const int32_t nPageWidth = static_cast<int32_t>(m_pPage->GetPageWidth());
   const int32_t nPageHeight = static_cast<int32_t>(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();
   int32_t index = 0;
   FX_FLOAT fLineHeight = 0.0f;
   if (m_pPage->GetPageObjectList()->empty())
-    return -1;
+    return TextOrientation::Unknown;
 
   for (auto& pPageObj : *m_pPage->GetPageObjectList()) {
     if (!pPageObj || !pPageObj->IsText())
       continue;
 
     int32_t minH =
         (int32_t)pPageObj->m_Left < 0 ? 0 : (int32_t)pPageObj->m_Left;
     int32_t maxH = (int32_t)pPageObj->m_Right > nPageWidth
                        ? nPageWidth
                        : (int32_t)pPageObj->m_Right;
@@ skipping 33 matching lines @@
   for (index = 0; index < nPageHeight; index++) {
     if (1 == nVerticalMask[index])
       break;
   }
   nStartV = index;
   for (index = nPageHeight; index > 0; index--) {
     if (1 == nVerticalMask[index - 1])
       break;
   }
   nEndV = index;
-  for (index = nStartV; index < nEndV; index++) {
+  for (index = nStartV; index < nEndV; index++)
     nSumV += nVerticalMask[index];
-  }
   nSumV /= nEndV - nStartV;
-  if ((nEndV - nStartV) < (int32_t)(2 * fLineHeight)) {
-    return 0;
-  }
-  if ((nEndH - nStartH) < (int32_t)(2 * fLineHeight)) {
-    return 1;
-  }
-  if (nSumH > 0.8f) {
-    return 0;
-  }
-  if (nSumH - nSumV > 0.0f) {
-    return 0;
-  }
-  if (nSumV - nSumH > 0.0f) {
-    return 1;
-  }
-  return -1;
+
+  if ((nEndV - nStartV) < (int32_t)(2 * fLineHeight))
+    return TextOrientation::Horizontal;
+  if ((nEndH - nStartH) < (int32_t)(2 * fLineHeight))
+    return TextOrientation::Vertical;
+
+  if (nSumH > 0.8f)
+    return TextOrientation::Horizontal;
+
+  if (nSumH > nSumV)
+    return TextOrientation::Horizontal;
+  if (nSumH < nSumV)
+    return TextOrientation::Vertical;
+  return TextOrientation::Unknown;
+}
+
+void CPDF_TextPage::AppendGeneratedCharacter(FX_WCHAR unicode,
+                                             const CFX_Matrix& formMatrix) {
+  PAGECHAR_INFO generateChar;
+  if (!GenerateCharInfo(unicode, generateChar))
+    return;
+
+  m_TextBuf.AppendChar(unicode);
+  if (!formMatrix.IsIdentity())
+    generateChar.m_Matrix.Copy(formMatrix);
+  m_CharList.push_back(generateChar);
 }
 
 void CPDF_TextPage::ProcessObject() {
   if (m_pPage->GetPageObjectList()->empty())
     return;
 
-  m_TextlineDir = FindTextlineFlowDirection();
+  m_TextlineDir = FindTextlineFlowOrientation();
   const CPDF_PageObjectList* pObjList = m_pPage->GetPageObjectList();
   for (auto it = pObjList->begin(); it != pObjList->end(); ++it) {
     if (CPDF_PageObject* pObj = it->get()) {
       if (pObj->IsText()) {
         CFX_Matrix matrix;
         ProcessTextObject(pObj->AsText(), matrix, pObjList, it);
       } else if (pObj->IsForm()) {
         CFX_Matrix formMatrix(1, 0, 0, 1, 0, 0);
         ProcessFormObject(pObj->AsForm(), formMatrix);
       }
@@ skipping 37 matching lines @@
   CFX_ByteString str;
   pFont->AppendChar(str, charCode);
   if (int w = pFont->GetStringWidth(str.c_str(), 1))
     return w;
 
   return pFont->GetCharBBox(charCode).Width();
 }
 
 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 = nullptr;
-      FX_STRSIZE nCount = Unicode_GetNormalization(wChar, pDst);
-      if (nCount >= 1) {
-        pDst = FX_Alloc(FX_WCHAR, nCount);
-        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 {
+  if (IsControlChar(info)) {
     info.m_Index = -1;
+    m_CharList.push_back(info);
+    return;
   }
-  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);
+  info.m_Index = m_TextBuf.GetLength();
+  if (wChar >= 0xFB00 && wChar <= 0xFB06) {
     FX_WCHAR* pDst = nullptr;
     FX_STRSIZE nCount = Unicode_GetNormalization(wChar, pDst);
     if (nCount >= 1) {
       pDst = FX_Alloc(FX_WCHAR, nCount);
       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;
     }
-    info.m_Unicode = wChar;
-    m_TextBuf.AppendChar(info.m_Unicode);
-  } else {
-    info.m_Index = -1;
   }
+  m_TextBuf.AppendChar(wChar);
   m_CharList.push_back(info);
 }
 
+void CPDF_TextPage::AddCharInfoByRLDirection(FX_WCHAR wChar,
+                                             PAGECHAR_INFO info) {
+  if (IsControlChar(info)) {
+    info.m_Index = -1;
+    m_CharList.push_back(info);
+    return;
+  }
+
+  info.m_Index = m_TextBuf.GetLength();
+  wChar = FX_GetMirrorChar(wChar, TRUE, FALSE);
+  FX_WCHAR* pDst = nullptr;
+  FX_STRSIZE nCount = Unicode_GetNormalization(wChar, pDst);
+  if (nCount >= 1) {
+    pDst = FX_Alloc(FX_WCHAR, nCount);
+    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;
+  }
+  info.m_Unicode = wChar;
+  m_TextBuf.AppendChar(info.m_Unicode);
+  m_CharList.push_back(info);
+}
+
 void CPDF_TextPage::CloseTempLine() {
   if (m_TempCharList.empty())
     return;
 
   CFX_WideString str = m_TempTextBuf.MakeString();
   FX_BOOL bPrevSpace = FALSE;
   for (int i = 0; i < str.GetLength(); i++) {
     if (str.GetAt(i) != ' ') {
       bPrevSpace = FALSE;
       continue;
@@ skipping 238 matching lines @@
 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;
 }
+
 void CPDF_TextPage::SwapTempTextBuf(int32_t iCharListStartAppend,
                                     int32_t iBufStartAppend) {
   int32_t i = iCharListStartAppend;
   int32_t j = pdfium::CollectionSize<int32_t>(m_TempCharList) - 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;
@@ skipping 33 matching lines @@
   CPDF_Font* pFont = pTextObj->GetFont();
   CFX_Matrix matrix;
   pTextObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
   FPDFText_MarkedContent ePreMKC = PreMarkedContent(Obj);
   if (ePreMKC == FPDFText_MarkedContent::Done) {
     m_pPreTextObj = pTextObj;
     m_perMatrix.Copy(formMatrix);
     return;
   }
-  int result = 0;
+  GenerateCharacter result = GenerateCharacter::None;
   if (m_pPreTextObj) {
     result = ProcessInsertObject(pTextObj, formMatrix);
-    if (2 == result) {
+    if (result == GenerateCharacter::LineBreak) {
       m_CurlineRect =
           CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
                         Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top);
     } else {
       m_CurlineRect.Union(
           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);
+    switch (result) {
+      case GenerateCharacter::None:
+        break;
+      case GenerateCharacter::Space: {
+        PAGECHAR_INFO generateChar;
+        if (GenerateCharInfo(TEXT_SPACE_CHAR, generateChar)) {
+          if (!formMatrix.IsIdentity())
+            generateChar.m_Matrix.Copy(formMatrix);
+          m_TempTextBuf.AppendChar(TEXT_SPACE_CHAR);
+          m_TempCharList.push_back(generateChar);
         }
-        m_TempTextBuf.AppendChar(TEXT_BLANK_CHAR);
-        m_TempCharList.push_back(generateChar);
+        break;
       }
-    } else if (result == 2) {
-      CloseTempLine();
-      if (m_TextBuf.GetSize()) {
-        if (GenerateCharInfo(TEXT_RETURN_CHAR, generateChar)) {
-          m_TextBuf.AppendChar(TEXT_RETURN_CHAR);
-          if (!formMatrix.IsIdentity()) {
-            generateChar.m_Matrix.Copy(formMatrix);
+      case GenerateCharacter::LineBreak:
+        CloseTempLine();
+        if (m_TextBuf.GetSize()) {
+          AppendGeneratedCharacter(TEXT_RETURN_CHAR, formMatrix);
+          AppendGeneratedCharacter(TEXT_LINEFEED_CHAR, formMatrix);
+        }
+        break;
+      case GenerateCharacter::Hyphen:
+        if (pTextObj->CountChars() == 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;
           }
-          m_CharList.push_back(generateChar);
+          FX_WCHAR curChar = wstrItem.GetAt(0);
+          if (curChar == 0x2D || curChar == 0xAD)
+            return;
         }
-        if (GenerateCharInfo(TEXT_LINEFEED_CHAR, generateChar)) {
-          m_TextBuf.AppendChar(TEXT_LINEFEED_CHAR);
-          if (!formMatrix.IsIdentity()) {
-            generateChar.m_Matrix.Copy(formMatrix);
-          }
-          m_CharList.push_back(generateChar);
+        while (m_TempTextBuf.GetSize() > 0 &&
+               m_TempTextBuf.AsStringC().GetAt(m_TempTextBuf.GetLength() - 1) ==
+                   0x20) {
+          m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
+          m_TempCharList.pop_back();
         }
-      }
-    } else if (result == 3) {
-      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.AsStringC().GetAt(m_TempTextBuf.GetLength() - 1) ==
-                 0x20) {
+        PAGECHAR_INFO* charinfo = &m_TempCharList.back();
         m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
-        m_TempCharList.pop_back();
-      }
-      PAGECHAR_INFO* charinfo = &m_TempCharList.back();
-      m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
-      charinfo->m_Unicode = 0x2;
-      charinfo->m_Flag = FPDFTEXT_CHAR_HYPHEN;
-      m_TempTextBuf.AppendChar(0xfffe);
+        charinfo->m_Unicode = 0x2;
+        charinfo->m_Flag = FPDFTEXT_CHAR_HYPHEN;
+        m_TempTextBuf.AppendChar(0xfffe);
+        break;
     }
   } 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 (ePreMKC == FPDFText_MarkedContent::Delay) {
     ProcessMarkedContent(Obj);
     m_pPreTextObj = pTextObj;
     m_perMatrix.Copy(formMatrix);
@@ skipping 16 matching lines @@
     CPDF_TextObjectItem item;
     PAGECHAR_INFO charinfo;
     charinfo.m_OriginX = 0;
     charinfo.m_OriginY = 0;
     pTextObj->GetItemInfo(i, &item);
     if (item.m_CharCode == (uint32_t)-1) {
       CFX_WideString str = m_TempTextBuf.MakeString();
       if (str.IsEmpty()) {
         str = m_TextBuf.AsStringC();
       }
-      if (str.IsEmpty() || str.GetAt(str.GetLength() - 1) == TEXT_BLANK_CHAR) {
+      if (str.IsEmpty() || str.GetAt(str.GetLength() - 1) == TEXT_SPACE_CHAR)
         continue;
-      }
+
       FX_FLOAT fontsize_h = pTextObj->m_TextState.GetFontSizeH();
       spacing = -fontsize_h * item.m_OriginX / 1000;
       continue;
     }
     FX_FLOAT charSpace = pTextObj->m_TextState.GetObject()->m_CharSpace;
     if (charSpace > 0.001) {
       spacing += matrix.TransformDistance(charSpace);
     } else if (charSpace < -0.001) {
       spacing -= matrix.TransformDistance(FXSYS_fabs(charSpace));
     }
@@ skipping 13 matching lines @@
       }
       if (threshold == 0) {
         threshold = fontsize_h;
         int this_width = FXSYS_abs(GetCharWidth(item.m_CharCode, pFont));
         threshold = this_width > last_width ? (FX_FLOAT)this_width
                                             : (FX_FLOAT)last_width;
         threshold = NormalizeThreshold(threshold);
         threshold = fontsize_h * threshold / 1000;
       }
       if (threshold && (spacing && spacing >= threshold)) {
-        charinfo.m_Unicode = TEXT_BLANK_CHAR;
+        charinfo.m_Unicode = TEXT_SPACE_CHAR;
         charinfo.m_Flag = FPDFTEXT_CHAR_GENERATED;
         charinfo.m_pTextObj = pTextObj;
         charinfo.m_Index = m_TextBuf.GetLength();
-        m_TempTextBuf.AppendChar(TEXT_BLANK_CHAR);
+        m_TempTextBuf.AppendChar(TEXT_SPACE_CHAR);
         charinfo.m_CharCode = CPDF_Font::kInvalidCharCode;
         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.push_back(charinfo);
       }
       if (item.m_CharCode == CPDF_Font::kInvalidCharCode) {
@@ skipping 73 matching lines @@
             charinfo.m_Index = m_TextBuf.GetLength();
             m_TempTextBuf.AppendChar(charinfo.m_Unicode);
           } else {
             m_TempTextBuf.AppendChar(0xfffe);
           }
           m_TempCharList.push_back(charinfo);
         }
       } else if (i == 0) {
         CFX_WideString str = m_TempTextBuf.MakeString();
         if (!str.IsEmpty() &&
-            str.GetAt(str.GetLength() - 1) == TEXT_BLANK_CHAR) {
+            str.GetAt(str.GetLength() - 1) == TEXT_SPACE_CHAR) {
           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) {
+CPDF_TextPage::TextOrientation CPDF_TextPage::GetTextObjectWritingMode(
+    const CPDF_TextObject* pTextObj) const {
   int32_t nChars = pTextObj->CountChars();
-  if (nChars == 1) {
+  if (nChars == 1)
     return m_TextlineDir;
-  }
+
   CPDF_TextObjectItem first, last;
   pTextObj->GetCharInfo(0, &first);
   pTextObj->GetCharInfo(nChars - 1, &last);
   CFX_Matrix textMatrix;
   pTextObj->GetTextMatrix(&textMatrix);
   textMatrix.TransformPoint(first.m_OriginX, first.m_OriginY);
   textMatrix.TransformPoint(last.m_OriginX, last.m_OriginY);
   FX_FLOAT dX = FXSYS_fabs(last.m_OriginX - first.m_OriginX);
   FX_FLOAT dY = FXSYS_fabs(last.m_OriginY - first.m_OriginY);
-  if (dX <= 0.0001f && dY <= 0.0001f) {
-    return -1;
-  }
+  if (dX <= 0.0001f && dY <= 0.0001f)
+    return TextOrientation::Unknown;
+
   CFX_VectorF v(dX, dY);
   v.Normalize();
-  if (v.y <= 0.0872f) {
-    return v.x <= 0.0872f ? m_TextlineDir : 0;
-  }
-  if (v.x <= 0.0872f) {
-    return 1;
-  }
+  if (v.y <= 0.0872f)
+    return v.x <= 0.0872f ? m_TextlineDir : TextOrientation::Horizontal;
+
+  if (v.x <= 0.0872f)
+    return TextOrientation::Vertical;
+
   return m_TextlineDir;
 }
+
 FX_BOOL CPDF_TextPage::IsHyphen(FX_WCHAR curChar) {
   CFX_WideString strCurText = m_TempTextBuf.MakeString();
   if (strCurText.GetLength() == 0) {
     strCurText = m_TextBuf.AsStringC();
   }
   FX_STRSIZE nCount = strCurText.GetLength();
   int nIndex = nCount - 1;
   FX_WCHAR wcTmp = strCurText.GetAt(nIndex);
   while (wcTmp == 0x20 && nIndex <= nCount - 1 && nIndex >= 0) {
     wcTmp = strCurText.GetAt(--nIndex);
@@ skipping 17 matching lines @@
       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) {
+CPDF_TextPage::GenerateCharacter CPDF_TextPage::ProcessInsertObject(
+    const CPDF_TextObject* pObj,
+    const CFX_Matrix& formMatrix) {
   FindPreviousTextObject();
-  FX_BOOL bNewline = FALSE;
-  int WritingMode = GetTextObjectWritingMode(pObj);
-  if (WritingMode == -1) {
+  TextOrientation WritingMode = GetTextObjectWritingMode(pObj);
+  if (WritingMode == TextOrientation::Unknown)
     WritingMode = GetTextObjectWritingMode(m_pPreTextObj);
-  }
+
   CFX_FloatRect this_rect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right,
                           pObj->m_Top);
   CFX_FloatRect prev_rect(m_pPreTextObj->m_Left, m_pPreTextObj->m_Bottom,
                           m_pPreTextObj->m_Right, m_pPreTextObj->m_Top);
   CPDF_TextObjectItem PrevItem, item;
   int nItem = m_pPreTextObj->CountItems();
   m_pPreTextObj->GetItemInfo(nItem - 1, &PrevItem);
   pObj->GetItemInfo(0, &item);
   CFX_WideString wstrItem =
       pObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
   if (wstrItem.IsEmpty()) {
     wstrItem += (FX_WCHAR)item.m_CharCode;
   }
   FX_WCHAR curChar = wstrItem.GetAt(0);
-  if (WritingMode == 0) {
+  if (WritingMode == TextOrientation::Horizontal) {
     if (this_rect.Height() > 4.5 && prev_rect.Height() > 4.5) {
       FX_FLOAT top =
           this_rect.top < prev_rect.top ? this_rect.top : prev_rect.top;
       FX_FLOAT bottom = this_rect.bottom > prev_rect.bottom ? this_rect.bottom
                                                             : prev_rect.bottom;
       if (bottom >= top) {
-        if (IsHyphen(curChar)) {
-          return 3;
-        }
-        return 2;
+        return IsHyphen(curChar) ? GenerateCharacter::Hyphen
+                                 : GenerateCharacter::LineBreak;
       }
     }
-  } else if (WritingMode == 1) {
+  } else if (WritingMode == TextOrientation::Vertical) {
     if (this_rect.Width() > pObj->GetFontSize() * 0.1f &&
         prev_rect.Width() > m_pPreTextObj->GetFontSize() * 0.1f) {
       FX_FLOAT left = this_rect.left > m_CurlineRect.left ? this_rect.left
                                                           : m_CurlineRect.left;
       FX_FLOAT right = this_rect.right < m_CurlineRect.right
                            ? this_rect.right
                            : m_CurlineRect.right;
       if (right <= left) {
-        if (IsHyphen(curChar)) {
-          return 3;
-        }
-        return 2;
+        return IsHyphen(curChar) ? GenerateCharacter::Hyphen
+                                 : GenerateCharacter::LineBreak;
       }
     }
   }
   FX_FLOAT last_pos = PrevItem.m_OriginX;
   int nLastWidth = GetCharWidth(PrevItem.m_CharCode, m_pPreTextObj->GetFont());
   FX_FLOAT last_width = nLastWidth * m_pPreTextObj->GetFontSize() / 1000;
   last_width = FXSYS_fabs(last_width);
   int nThisWidth = GetCharWidth(item.m_CharCode, pObj->GetFont());
   FX_FLOAT this_width = nThisWidth * pObj->GetFontSize() / 1000;
   this_width = FXSYS_fabs(this_width);
   FX_FLOAT threshold =
       last_width > this_width ? last_width / 4 : this_width / 4;
   CFX_Matrix prev_matrix, prev_reverse;
   m_pPreTextObj->GetTextMatrix(&prev_matrix);
   prev_matrix.Concat(m_perMatrix);
   prev_reverse.SetReverse(prev_matrix);
   FX_FLOAT x = pObj->GetPosX();
   FX_FLOAT y = pObj->GetPosY();
   formMatrix.Transform(x, y);
   prev_reverse.Transform(x, y);
   if (last_width < this_width) {
     threshold = prev_reverse.TransformDistance(threshold);
   }
-  CFX_FloatRect rect1(m_pPreTextObj->m_Left, pObj->m_Bottom,
-                      m_pPreTextObj->m_Right, pObj->m_Top);
-  CFX_FloatRect rect2(m_pPreTextObj->m_Left, m_pPreTextObj->m_Bottom,
-                      m_pPreTextObj->m_Right, m_pPreTextObj->m_Top);
-  CFX_FloatRect rect3 = rect1;
-  rect1.Intersect(rect2);
-  if (WritingMode == 0) {
+  bool bNewline = false;
+  if (WritingMode == TextOrientation::Horizontal) {
+    CFX_FloatRect rect1(m_pPreTextObj->m_Left, pObj->m_Bottom,
+                        m_pPreTextObj->m_Right, pObj->m_Top);
+    CFX_FloatRect rect2(m_pPreTextObj->m_Left, m_pPreTextObj->m_Bottom,
+                        m_pPreTextObj->m_Right, m_pPreTextObj->m_Top);
+    CFX_FloatRect rect3 = rect1;
+    rect1.Intersect(rect2);
     if ((rect1.IsEmpty() && rect2.Height() > 5 && rect3.Height() > 5) ||
         ((y > threshold * 2 || y < threshold * -3) &&
          (FXSYS_fabs(y) < 1 ? FXSYS_fabs(x) < FXSYS_fabs(y) : TRUE))) {
-      bNewline = TRUE;
+      bNewline = true;
       if (nItem > 1) {
         CPDF_TextObjectItem tempItem;
         m_pPreTextObj->GetItemInfo(0, &tempItem);
         CFX_Matrix m;
         m_pPreTextObj->GetTextMatrix(&m);
         if (PrevItem.m_OriginX > tempItem.m_OriginX &&
             m_DisplayMatrix.a > 0.9 && m_DisplayMatrix.b < 0.1 &&
             m_DisplayMatrix.c < 0.1 && m_DisplayMatrix.d < -0.9 && m.b < 0.1 &&
             m.c < 0.1) {
           CFX_FloatRect re(0, m_pPreTextObj->m_Bottom, 1000,
                            m_pPreTextObj->m_Top);
           if (re.Contains(pObj->GetPosX(), pObj->GetPosY())) {
-            bNewline = FALSE;
+            bNewline = false;
           } else {
             CFX_FloatRect rect(0, pObj->m_Bottom, 1000, pObj->m_Top);
             if (rect.Contains(m_pPreTextObj->GetPosX(),
                               m_pPreTextObj->GetPosY())) {
-              bNewline = FALSE;
+              bNewline = false;
             }
           }
         }
       }
     }
   }
-  if (bNewline)
-    return IsHyphen(curChar) ? 3 : 2;
+  if (bNewline) {
+    return IsHyphen(curChar) ? GenerateCharacter::Hyphen
+                             : GenerateCharacter::LineBreak;
+  }
 
   int32_t nChars = pObj->CountChars();
   if (nChars == 1 && (0x2D == curChar || 0xAD == curChar) &&
       IsHyphen(curChar)) {
-    return 3;
+    return GenerateCharacter::Hyphen;
   }
   CFX_WideString PrevStr =
       m_pPreTextObj->GetFont()->UnicodeFromCharCode(PrevItem.m_CharCode);
   FX_WCHAR preChar = PrevStr.GetAt(PrevStr.GetLength() - 1);
   CFX_Matrix matrix;
   pObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
   threshold = (FX_FLOAT)(nLastWidth > nThisWidth ? nLastWidth : nThisWidth);
   threshold = threshold > 400
                   ? (threshold < 700
@@ skipping 10 matching lines @@
   threshold /= 1000;
   if ((threshold < 1.4881 && threshold > 1.4879) ||
       (threshold < 1.39001 && threshold > 1.38999)) {
     threshold *= 1.5;
   }
   if (FXSYS_fabs(last_pos + last_width - x) > threshold && curChar != L' ' &&
       preChar != L' ') {
     if (curChar != L' ' && preChar != L' ') {
       if ((x - last_pos - last_width) > threshold ||
           (last_pos - x - last_width) > threshold) {
-        return 1;
+        return GenerateCharacter::Space;
       }
       if (x < 0 && (last_pos - x - last_width) > threshold) {
-        return 1;
+        return GenerateCharacter::Space;
       }
       if ((x - last_pos - last_width) > this_width ||
           (x - last_pos - this_width) > last_width) {
-        return 1;
+        return GenerateCharacter::Space;
       }
     }
   }
-  return 0;
+  return GenerateCharacter::None;
 }
 
 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,
@@ skipping 229 matching lines @@
   int nCount = pdfium::CollectionSize<int>(m_csFindWhatArray);
   int nResultPos = 0;
   int nStartPos = 0;
   nStartPos = m_findNextStart;
   FX_BOOL bSpaceStart = FALSE;
   for (int iWord = 0; iWord < nCount; iWord++) {
     CFX_WideString csWord = m_csFindWhatArray[iWord];
     if (csWord.IsEmpty()) {
       if (iWord == nCount - 1) {
         FX_WCHAR strInsert = m_strText.GetAt(nStartPos);
-        if (strInsert == TEXT_LINEFEED_CHAR || strInsert == TEXT_BLANK_CHAR ||
+        if (strInsert == TEXT_LINEFEED_CHAR || strInsert == TEXT_SPACE_CHAR ||
             strInsert == TEXT_RETURN_CHAR || strInsert == 160) {
           nResultPos = nStartPos + 1;
           break;
         }
         iWord = -1;
       } else if (iWord == 0) {
         bSpaceStart = TRUE;
       }
       continue;
     }
@@ skipping 13 matching lines @@
       int curChar = csWord.GetAt(0);
       CFX_WideString lastWord = m_csFindWhatArray[iWord - 1];
       int lastChar = lastWord.GetAt(lastWord.GetLength() - 1);
       if (nStartPos == nResultPos &&
           !(IsIgnoreSpaceCharacter(lastChar) ||
             IsIgnoreSpaceCharacter(curChar))) {
         bMatch = FALSE;
       }
       for (int d = PreResEndPos; d < nResultPos; d++) {
         FX_WCHAR strInsert = m_strText.GetAt(d);
-        if (strInsert != TEXT_LINEFEED_CHAR && strInsert != TEXT_BLANK_CHAR &&
+        if (strInsert != TEXT_LINEFEED_CHAR && strInsert != TEXT_SPACE_CHAR &&
             strInsert != TEXT_RETURN_CHAR && strInsert != 160) {
           bMatch = FALSE;
           break;
         }
       }
     } else if (bSpaceStart) {
       if (nResultPos > 0) {
         FX_WCHAR strInsert = m_strText.GetAt(nResultPos - 1);
-        if (strInsert != TEXT_LINEFEED_CHAR && strInsert != TEXT_BLANK_CHAR &&
+        if (strInsert != TEXT_LINEFEED_CHAR && strInsert != TEXT_SPACE_CHAR &&
             strInsert != TEXT_RETURN_CHAR && strInsert != 160) {
           bMatch = FALSE;
           m_resStart = nResultPos;
         } else {
           m_resStart = nResultPos - 1;
         }
       }
     }
     if (m_bMatchWholeWord && bMatch) {
       bMatch = IsMatchWholeWord(m_strText, nResultPos, endIndex);
@@ skipping 70 matching lines @@
 }
 
 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);
+        ExtractSubString(csWord, findwhat.c_str(), index, TEXT_SPACE_CHAR);
     if (csWord.IsEmpty()) {
       if (ret) {
         m_csFindWhatArray.push_back(L"");
         index++;
         continue;
       } else {
         break;
       }
     }
     int pos = 0;
@@ skipping 274 matching lines @@
   return index < m_LinkArray.size() ? m_LinkArray[index].m_strUrl : L"";
 }
 
 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);
 }