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 38 matching lines @@
 #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};
 
 FX_BOOL IsIgnoreSpaceCharacter(FX_WCHAR curChar) {
-  if (curChar < 255) {
+  if (curChar < 255)
     return FALSE;
-  }
   if ((curChar >= 0x0600 && curChar <= 0x06FF) ||
       (curChar >= 0xFE70 && curChar <= 0xFEFF) ||
       (curChar >= 0xFB50 && curChar <= 0xFDFF) ||
       (curChar >= 0x0400 && curChar <= 0x04FF) ||
       (curChar >= 0x0500 && curChar <= 0x052F) ||
       (curChar >= 0xA640 && curChar <= 0xA69F) ||
       (curChar >= 0x2DE0 && curChar <= 0x2DFF) || curChar == 8467 ||
       (curChar >= 0x2000 && curChar <= 0x206F)) {
     return FALSE;
   }
   return TRUE;
 }
 
 FX_FLOAT NormalizeThreshold(FX_FLOAT threshold) {
-  if (threshold < 300) {
+  if (threshold < 300)
     return threshold / 2.0f;
-  }
-  if (threshold < 500) {
+  if (threshold < 500)
     return threshold / 4.0f;
-  }
-  if (threshold < 700) {
+  if (threshold < 700)
     return threshold / 5.0f;
-  }
   return threshold / 6.0f;
 }
 
 FX_FLOAT CalculateBaseSpace(const CPDF_TextObject* pTextObj,
                             const CFX_Matrix& matrix) {
   FX_FLOAT baseSpace = 0.0;
   const int nItems = pTextObj->CountItems();
   if (pTextObj->m_TextState.GetObject()->m_CharSpace && nItems >= 3) {
-    FX_BOOL bAllChar = TRUE;
+    bool bAllChar = true;
     FX_FLOAT spacing = matrix.TransformDistance(
         pTextObj->m_TextState.GetObject()->m_CharSpace);
     baseSpace = spacing;
     for (int i = 0; i < nItems; i++) {
       CPDF_TextObjectItem item;
       pTextObj->GetItemInfo(i, &item);
-      if (item.m_CharCode == (uint32_t)-1) {
+      if (item.m_CharCode == static_cast<uint32_t>(-1)) {
         FX_FLOAT fontsize_h = pTextObj->m_TextState.GetFontSizeH();
         FX_FLOAT kerning = -fontsize_h * item.m_OriginX / 1000;
         baseSpace = std::min(baseSpace, kerning + spacing);
-        bAllChar = FALSE;
+        bAllChar = false;
       }
     }
-    if (baseSpace < 0.0 || (nItems == 3 && !bAllChar)) {
+    if (baseSpace < 0.0 || (nItems == 3 && !bAllChar))
       baseSpace = 0.0;
-    }
   }
   return baseSpace;
 }
 
 FX_STRSIZE Unicode_GetNormalization(FX_WCHAR wch, FX_WCHAR* pDst) {
   wch = wch & 0xFFFF;
   FX_WCHAR wFind = g_UnicodeData_Normalization[wch];
   if (!wFind) {
-    if (pDst) {
+    if (pDst)
       *pDst = wch;
-    }
     return 1;
   }
   if (wFind >= 0x8000) {
     wch = wFind - 0x8000;
     wFind = 1;
   } else {
     wch = wFind & 0x0FFF;
     wFind >>= 12;
   }
   const uint16_t* pMap = g_UnicodeData_Normalization_Maps[wFind];
   if (pMap == g_UnicodeData_Normalization_Map4) {
     pMap = g_UnicodeData_Normalization_Map4 + wch;
     wFind = (FX_WCHAR)(*pMap++);
   } else {
     pMap += wch;
   }
   if (pDst) {
     FX_WCHAR n = wFind;
-    while (n--) {
+    while (n--)
       *pDst++ = *pMap++;
-    }
   }
   return (FX_STRSIZE)wFind;
 }
 
 float MaskPercentFilled(const std::vector<bool>& mask,
                         int32_t start,
                         int32_t end) {
   if (start >= end)
     return 0;
   float count = std::count_if(mask.begin() + start, mask.begin() + end,
@@ skipping 109 matching lines @@
 
   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;
+  bool bFlagNewRect = true;
   while (nCount--) {
     PAGECHAR_INFO info_curchar = m_CharList[curPos++];
-    if (info_curchar.m_Flag == FPDFTEXT_CHAR_GENERATED) {
+    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) {
+    if (!pCurObj)
       pCurObj = info_curchar.m_pTextObj;
-    }
     if (pCurObj != info_curchar.m_pTextObj) {
       rectArray.push_back(rect);
       pCurObj = info_curchar.m_pTextObj;
-      flagNewRect = TRUE;
+      bFlagNewRect = true;
     }
-    if (flagNewRect) {
+    if (bFlagNewRect) {
       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);
       rect.left = info_curchar.m_CharBox.left;
       rect.right = info_curchar.m_CharBox.right;
       if (pCurObj->GetFont()->GetTypeDescent()) {
         rect.bottom = orgY +
                       pCurObj->GetFont()->GetTypeDescent() *
                           pCurObj->GetFontSize() / 1000;
         FX_FLOAT xPosTemp = orgX;
         matrix.Transform(xPosTemp, rect.bottom);
       } else {
         rect.bottom = info_curchar.m_CharBox.bottom;
       }
       if (pCurObj->GetFont()->GetTypeAscent()) {
         rect.top =
             orgY +
             pCurObj->GetFont()->GetTypeAscent() * pCurObj->GetFontSize() / 1000;
         FX_FLOAT xPosTemp =
             orgX +
             GetCharWidth(info_curchar.m_CharCode, pCurObj->GetFont()) *
                 pCurObj->GetFontSize() / 1000;
         matrix.Transform(xPosTemp, rect.top);
       } else {
         rect.top = info_curchar.m_CharBox.top;
       }
-      flagNewRect = FALSE;
+      bFlagNewRect = false;
       rect = info_curchar.m_CharBox;
       rect.Normalize();
     } else {
       info_curchar.m_CharBox.Normalize();
-      if (rect.left > info_curchar.m_CharBox.left) {
-        rect.left = info_curchar.m_CharBox.left;
-      }
-      if (rect.right < info_curchar.m_CharBox.right) {
-        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;
-      }
+      rect.left = std::min(rect.left, info_curchar.m_CharBox.left);
+      rect.right = std::max(rect.right, info_curchar.m_CharBox.right);
+      rect.top = std::max(rect.top, info_curchar.m_CharBox.top);
+      rect.bottom = std::min(rect.bottom, info_curchar.m_CharBox.bottom);
     }
   }
   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;
   double xdif = 5000;
   double ydif = 5000;
   while (pos < pdfium::CollectionSize<int>(m_CharList)) {
     PAGECHAR_INFO charinfo = m_CharList[pos];
     CFX_FloatRect charrect = charinfo.m_CharBox;
-    if (charrect.Contains(point.x, point.y)) {
+    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;
       charRectExt.bottom = charrect.bottom - yTolerance / 2;
       if (charRectExt.Contains(point.x, point.y)) {
         double curXdif, curYdif;
         curXdif = FXSYS_fabs(point.x - charrect.left) <
@@ skipping 22 matching lines @@
 
   FX_FLOAT posy = 0;
   bool IsContainPreChar = false;
   bool IsAddLineFeed = false;
   CFX_WideString strText;
   for (const auto& charinfo : m_CharList) {
     if (IsRectIntersect(rect, charinfo.m_CharBox)) {
       if (FXSYS_fabs(posy - charinfo.m_OriginY) > 0 && !IsContainPreChar &&
           IsAddLineFeed) {
         posy = charinfo.m_OriginY;
-        if (strText.GetLength() > 0) {
+        if (!strText.IsEmpty())
           strText += L"\r\n";
-        }
       }
       IsContainPreChar = true;
       IsAddLineFeed = false;
-      if (charinfo.m_Unicode) {
+      if (charinfo.m_Unicode)
         strText += charinfo.m_Unicode;
-      }
     } else if (charinfo.m_Unicode == 32) {
       if (IsContainPreChar && charinfo.m_Unicode) {
         strText += charinfo.m_Unicode;
         IsContainPreChar = false;
         IsAddLineFeed = false;
       }
     } else {
       IsContainPreChar = false;
       IsAddLineFeed = true;
     }
   }
   return strText;
 }
 
-std::vector<CFX_FloatRect> CPDF_TextPage::GetRectsArrayByRect(
-    const CFX_FloatRect& rect) const {
-  if (!m_bIsParsed)
-    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) {
-      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);
-    }
-  }
-  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);
 }
 
 void CPDF_TextPage::GetCharInfo(int index, FPDF_CHAR_INFO* info) const {
   if (!m_bIsParsed)
     return;
 
   if (index < 0 || index >= pdfium::CollectionSize<int>(m_CharList))
     return;
 
   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()) {
+  if (charinfo.m_pTextObj && charinfo.m_pTextObj->GetFont())
     info->m_FontSize = charinfo.m_pTextObj->GetFontSize();
-  } else {
+  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 = 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) {
+      if (startIndex < 0)
         break;
-      }
       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 >= pdfium::CollectionSize<int>(m_CharList)) {
+      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 CFX_WideString(
         m_TextBuf.AsStringC().Mid(start, m_TextBuf.AsStringC().GetLength()));
   }
-  if (nCount <= 0 || m_CharList.empty()) {
+  if (nCount <= 0 || m_CharList.empty())
     return L"";
-  }
-  if (nCount + start > pdfium::CollectionSize<int>(m_CharList) - 1) {
+  if (nCount + start > pdfium::CollectionSize<int>(m_CharList) - 1)
     nCount = pdfium::CollectionSize<int>(m_CharList) - start;
-  }
-  if (nCount <= 0) {
+  if (nCount <= 0)
     return L"";
-  }
   CheckMarkedContentObject(start, nCount);
   int startindex = 0;
   PAGECHAR_INFO charinfo = m_CharList[start];
   int startOffset = 0;
   while (charinfo.m_Index == -1) {
     startOffset++;
     if (startOffset > nCount ||
         start + startOffset >= pdfium::CollectionSize<int>(m_CharList)) {
       return L"";
     }
     charinfo = m_CharList[start + startOffset];
   }
   startindex = charinfo.m_Index;
   charinfo = m_CharList[start + nCount - 1];
   int nCountOffset = 0;
   while (charinfo.m_Index == -1) {
     nCountOffset++;
-    if (nCountOffset >= nCount) {
+    if (nCountOffset >= nCount)
       return L"";
-    }
     charinfo = m_CharList[start + nCount - nCountOffset - 1];
   }
   nCount = start + nCount - nCountOffset - startindex;
-  if (nCount <= 0) {
+  if (nCount <= 0)
     return L"";
-  }
   return CFX_WideString(m_TextBuf.AsStringC().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;
@@ skipping 12 matching lines @@
 
   if (rectIndex < 0 || rectIndex >= pdfium::CollectionSize<int>(m_SelRects))
     return;
 
   left = m_SelRects[rectIndex].left;
   top = m_SelRects[rectIndex].top;
   right = m_SelRects[rectIndex].right;
   bottom = m_SelRects[rectIndex].bottom;
 }
 
-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);
-  rect.Normalize();
-
-  FPDF_SEGMENT segment;
-  segment.m_Start = 0;
-  segment.m_nCount = 0;
-
-  int pos = 0;
-  int segmentStatus = 0;
-  FX_BOOL IsContainPreChar = FALSE;
-  for (const auto& charinfo : m_CharList) {
-    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 &&
-               (IsRectIntersect(rect, charinfo.m_CharBox) ||
-                rect.Contains(charinfo.m_OriginX, charinfo.m_OriginY))) {
-      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 (charinfo.m_Unicode == 32) {
-      if (IsContainPreChar == TRUE) {
-        if (segmentStatus == 0 || segmentStatus == 2) {
-          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_Segments.Add(segment);
-          segment.m_Start = 0;
-          segment.m_nCount = 0;
-        }
-      }
-    } else {
-      if (segmentStatus == 1) {
-        segmentStatus = 2;
-        m_Segments.Add(segment);
-        segment.m_Start = 0;
-        segment.m_nCount = 0;
-      }
-      IsContainPreChar = FALSE;
-    }
-    pos++;
-  }
-  if (segmentStatus == 1) {
-    segmentStatus = 2;
-    m_Segments.Add(segment);
-    segment.m_Start = 0;
-    segment.m_nCount = 0;
-  }
-  return m_Segments.GetSize();
-}
-
 CPDF_TextPage::TextOrientation CPDF_TextPage::FindTextlineFlowOrientation()
     const {
   if (m_pPage->GetPageObjectList()->empty())
     return TextOrientation::Unknown;
 
   const int32_t nPageWidth = static_cast<int32_t>(m_pPage->GetPageWidth());
   const int32_t nPageHeight = static_cast<int32_t>(m_pPage->GetPageHeight());
   std::vector<bool> nHorizontalMask(nPageWidth);
   std::vector<bool> nVerticalMask(nPageHeight);
   FX_FLOAT fLineHeight = 0.0f;
@@ skipping 85 matching lines @@
   CPDF_PageObjectList* pObjectList = pFormObj->m_pForm->GetPageObjectList();
   if (pObjectList->empty())
     return;
 
   CFX_Matrix curFormMatrix;
   curFormMatrix.Copy(pFormObj->m_FormMatrix);
   curFormMatrix.Concat(formMatrix);
 
   for (auto it = pObjectList->begin(); it != pObjectList->end(); ++it) {
     if (CPDF_PageObject* pPageObj = it->get()) {
-      if (pPageObj->IsText()) {
+      if (pPageObj->IsText())
         ProcessTextObject(pPageObj->AsText(), curFormMatrix, pObjectList, it);
-      } else if (pPageObj->IsForm()) {
+      else if (pPageObj->IsForm())
         ProcessFormObject(pPageObj->AsForm(), curFormMatrix);
-      }
     }
   }
 }
 
 int CPDF_TextPage::GetCharWidth(uint32_t charCode, CPDF_Font* pFont) const {
   if (charCode == CPDF_Font::kInvalidCharCode)
     return 0;
 
   if (int w = pFont->GetCharWidthF(charCode))
     return w;
@@ skipping 64 matching lines @@
   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;
+  bool bPrevSpace = false;
   for (int i = 0; i < str.GetLength(); i++) {
     if (str.GetAt(i) != ' ') {
-      bPrevSpace = FALSE;
+      bPrevSpace = false;
       continue;
     }
     if (bPrevSpace) {
       m_TempTextBuf.Delete(i, 1);
       m_TempCharList.erase(m_TempCharList.begin() + i);
       str.Delete(i);
       i--;
     }
-    bPrevSpace = TRUE;
+    bPrevSpace = true;
   }
   CFX_BidiString bidi(str);
   if (m_parserflag == FPDFText_Direction::Right)
     bidi.SetOverallDirectionRight();
   CFX_BidiChar::Direction eCurrentDirection = bidi.OverallDirection();
   for (const auto& segment : bidi) {
     if (segment.direction == CFX_BidiChar::RIGHT ||
         (segment.direction == CFX_BidiChar::NEUTRAL &&
          eCurrentDirection == CFX_BidiChar::RIGHT)) {
       eCurrentDirection = CFX_BidiChar::RIGHT;
       for (int m = segment.start + segment.count; m > segment.start; --m)
         AddCharInfoByRLDirection(bidi.CharAt(m - 1), m_TempCharList[m - 1]);
     } else {
       eCurrentDirection = CFX_BidiChar::LEFT;
       for (int m = segment.start; m < segment.start + segment.count; m++)
         AddCharInfoByLRDirection(bidi.CharAt(m), m_TempCharList[m]);
     }
   }
   m_TempCharList.clear();
   m_TempTextBuf.Delete(0, m_TempTextBuf.GetLength());
 }
 
 void CPDF_TextPage::ProcessTextObject(
     CPDF_TextObject* pTextObj,
     const CFX_Matrix& formMatrix,
     const CPDF_PageObjectList* pObjList,
     CPDF_PageObjectList::const_iterator 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) {
+  if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f)
     return;
-  }
   int count = m_LineObj.GetSize();
   PDFTEXT_Obj Obj;
   Obj.m_pTextObj = pTextObj;
   Obj.m_formMatrix = formMatrix;
   if (count == 0) {
     m_LineObj.Add(Obj);
     return;
   }
-  if (IsSameAsPreTextObject(pTextObj, pObjList, ObjPos)) {
+  if (IsSameAsPreTextObject(pTextObj, pObjList, ObjPos))
     return;
-  }
   PDFTEXT_Obj prev_Obj = m_LineObj.GetAt(count - 1);
   CPDF_TextObjectItem item;
   int nItem = prev_Obj.m_pTextObj->CountItems();
   prev_Obj.m_pTextObj->GetItemInfo(nItem - 1, &item);
   FX_FLOAT prev_width =
       GetCharWidth(item.m_CharCode, prev_Obj.m_pTextObj->GetFont()) *
       prev_Obj.m_pTextObj->GetFontSize() / 1000;
   CFX_Matrix prev_matrix;
   prev_Obj.m_pTextObj->GetTextMatrix(&prev_matrix);
   prev_width = FXSYS_fabs(prev_width);
@@ skipping 11 matching lines @@
   FX_FLOAT threshold =
       prev_width > this_width ? prev_width / 4 : this_width / 4;
   FX_FLOAT prev_x = prev_Obj.m_pTextObj->GetPosX(),
            prev_y = prev_Obj.m_pTextObj->GetPosY();
   prev_Obj.m_formMatrix.Transform(prev_x, prev_y);
   m_DisplayMatrix.Transform(prev_x, prev_y);
   FX_FLOAT this_x = pTextObj->GetPosX(), this_y = pTextObj->GetPosY();
   formMatrix.Transform(this_x, this_y);
   m_DisplayMatrix.Transform(this_x, this_y);
   if (FXSYS_fabs(this_y - prev_y) > threshold * 2) {
-    for (int i = 0; i < count; i++) {
+    for (int i = 0; i < count; i++)
       ProcessTextObject(m_LineObj.GetAt(i));
-    }
     m_LineObj.RemoveAll();
     m_LineObj.Add(Obj);
     return;
   }
   int i = 0;
   for (i = count - 1; i >= 0; i--) {
     PDFTEXT_Obj prev_text_obj = m_LineObj.GetAt(i);
     FX_FLOAT Prev_x = prev_text_obj.m_pTextObj->GetPosX(),
              Prev_y = prev_text_obj.m_pTextObj->GetPosY();
     prev_text_obj.m_formMatrix.Transform(Prev_x, Prev_y);
     m_DisplayMatrix.Transform(Prev_x, Prev_y);
     if (this_x >= Prev_x) {
       if (i == count - 1)
         m_LineObj.Add(Obj);
       else
         m_LineObj.InsertAt(i + 1, Obj);
       break;
     }
   }
-  if (i < 0) {
+  if (i < 0)
     m_LineObj.InsertAt(0, Obj);
-  }
 }
 
 FPDFText_MarkedContent CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
   const CPDF_ContentMarkData* pMarkData = pTextObj->m_ContentMark.GetObject();
   if (!pMarkData)
     return FPDFText_MarkedContent::Pass;
 
   int nContentMark = pMarkData->CountItems();
   if (nContentMark < 1)
     return FPDFText_MarkedContent::Pass;
 
   CFX_WideString actText;
-  FX_BOOL bExist = FALSE;
+  bool bExist = false;
   CPDF_Dictionary* pDict = nullptr;
   int n = 0;
   for (n = 0; n < nContentMark; n++) {
     const CPDF_ContentMarkItem& item = pMarkData->GetItem(n);
     if (item.GetParamType() == CPDF_ContentMarkItem::ParamType::None)
       continue;
     pDict = item.GetParam();
     CPDF_String* temp =
         ToString(pDict ? pDict->GetObjectBy("ActualText") : nullptr);
     if (temp) {
-      bExist = TRUE;
+      bExist = true;
       actText = temp->GetUnicodeText();
     }
   }
   if (!bExist)
     return FPDFText_MarkedContent::Pass;
 
   if (m_pPreTextObj) {
     const CPDF_ContentMarkData* pPreMarkData =
         m_pPreTextObj->m_ContentMark.GetObject();
     if (pPreMarkData && pPreMarkData->CountItems() == n &&
         pDict == pPreMarkData->GetItem(n - 1).GetParam()) {
       return FPDFText_MarkedContent::Done;
     }
   }
   FX_STRSIZE nItems = actText.GetLength();
   if (nItems < 1)
     return FPDFText_MarkedContent::Pass;
 
   CPDF_Font* pFont = pTextObj->GetFont();
-  bExist = FALSE;
+  bExist = false;
   for (FX_STRSIZE i = 0; i < nItems; i++) {
     if (pFont->CharCodeFromUnicode(actText.GetAt(i)) !=
         CPDF_Font::kInvalidCharCode) {
-      bExist = TRUE;
+      bExist = true;
       break;
     }
   }
   if (!bExist)
     return FPDFText_MarkedContent::Pass;
 
-  bExist = FALSE;
+  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;
+      bExist = true;
       break;
     }
   }
   if (!bExist)
     return FPDFText_MarkedContent::Done;
 
   return FPDFText_MarkedContent::Delay;
 }
 
 void CPDF_TextPage::ProcessMarkedContent(PDFTEXT_Obj Obj) {
@@ skipping 27 matching lines @@
   FX_FLOAT fPosX = pTextObj->GetPosX();
   FX_FLOAT fPosY = pTextObj->GetPosY();
   int nCharInfoIndex = m_TextBuf.GetLength();
   CFX_FloatRect charBox;
   charBox.top = pTextObj->m_Top;
   charBox.left = pTextObj->m_Left;
   charBox.right = pTextObj->m_Right;
   charBox.bottom = pTextObj->m_Bottom;
   for (FX_STRSIZE k = 0; k < nItems; k++) {
     FX_WCHAR wChar = actText.GetAt(k);
-    if (wChar <= 0x80 && !isprint(wChar)) {
+    if (wChar <= 0x80 && !isprint(wChar))
       wChar = 0x20;
-    }
-    if (wChar >= 0xFFFD) {
+    if (wChar >= 0xFFFD)
       continue;
-    }
     PAGECHAR_INFO charinfo;
     charinfo.m_OriginX = fPosX;
     charinfo.m_OriginY = fPosY;
     charinfo.m_Index = nCharInfoIndex;
     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;
@@ skipping 20 matching lines @@
                                     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;
   j = m_TempTextBuf.GetLength() - 1;
-  for (; i < j; i++, j--) {
+  for (; i < j; i++, j--)
     std::swap(pTempBuffer[i], pTempBuffer[j]);
-  }
 }
 
 FX_BOOL CPDF_TextPage::IsRightToLeft(const CPDF_TextObject* pTextObj,
                                      const CPDF_Font* pFont,
                                      int nItems) const {
   CFX_WideString str;
   for (int32_t i = 0; i < nItems; i++) {
     CPDF_TextObjectItem item;
     pTextObj->GetItemInfo(i, &item);
-    if (item.m_CharCode == (uint32_t)-1) {
+    if (item.m_CharCode == static_cast<uint32_t>(-1))
       continue;
-    }
     CFX_WideString wstrItem = pFont->UnicodeFromCharCode(item.m_CharCode);
     FX_WCHAR wChar = wstrItem.GetAt(0);
-    if ((wstrItem.IsEmpty() || wChar == 0) && item.m_CharCode) {
+    if ((wstrItem.IsEmpty() || wChar == 0) && item.m_CharCode)
       wChar = (FX_WCHAR)item.m_CharCode;
-    }
     if (wChar)
       str += wChar;
   }
   return CFX_BidiString(str).OverallDirection() == CFX_BidiChar::RIGHT;
 }
 
 void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
-  if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f) {
+  if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f)
     return;
-  }
   CFX_Matrix formMatrix = Obj.m_formMatrix;
   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;
@@ skipping 29 matching lines @@
           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()) {
+          if (wstrItem.IsEmpty())
             wstrItem += (FX_WCHAR)item.m_CharCode;
-          }
           FX_WCHAR curChar = wstrItem.GetAt(0);
           if (curChar == 0x2D || curChar == 0xAD)
             return;
         }
         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();
         }
@@ skipping 27 matching lines @@
   int32_t iCharListStartAppend =
       pdfium::CollectionSize<int32_t>(m_TempCharList);
 
   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 == (uint32_t)-1) {
+    if (item.m_CharCode == static_cast<uint32_t>(-1)) {
       CFX_WideString str = m_TempTextBuf.MakeString();
-      if (str.IsEmpty()) {
+      if (str.IsEmpty())
         str = m_TextBuf.AsStringC();
-      }
       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) {
+    if (charSpace > 0.001)
       spacing += matrix.TransformDistance(charSpace);
-    } else if (charSpace < -0.001) {
+    else if (charSpace < -0.001)
       spacing -= matrix.TransformDistance(FXSYS_fabs(charSpace));
-    }
     spacing -= baseSpace;
     if (spacing && i > 0) {
       int last_width = 0;
       FX_FLOAT fontsize_h = pTextObj->m_TextState.GetFontSizeH();
       uint32_t space_charcode = pFont->CharCodeFromUnicode(' ');
       FX_FLOAT threshold = 0;
-      if (space_charcode != CPDF_Font::kInvalidCharCode) {
+      if (space_charcode != CPDF_Font::kInvalidCharCode)
         threshold = fontsize_h * pFont->GetCharWidthF(space_charcode) / 1000;
-      }
-      if (threshold > fontsize_h / 3) {
+      if (threshold > fontsize_h / 3)
         threshold = 0;
-      } else {
+      else
         threshold /= 2;
-      }
       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_SPACE_CHAR;
         charinfo.m_Flag = FPDFTEXT_CHAR_GENERATED;
         charinfo.m_pTextObj = pTextObj;
         charinfo.m_Index = m_TextBuf.GetLength();
         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) {
+      if (item.m_CharCode == CPDF_Font::kInvalidCharCode)
         continue;
-      }
     }
     spacing = 0;
     CFX_WideString wstrItem = pFont->UnicodeFromCharCode(item.m_CharCode);
-    FX_BOOL bNoUnicode = FALSE;
+    bool bNoUnicode = false;
     FX_WCHAR wChar = wstrItem.GetAt(0);
     if ((wstrItem.IsEmpty() || wChar == 0) && item.m_CharCode) {
-      if (wstrItem.IsEmpty()) {
+      if (wstrItem.IsEmpty())
         wstrItem += (FX_WCHAR)item.m_CharCode;
-      } else {
+      else
         wstrItem.SetAt(0, (FX_WCHAR)item.m_CharCode);
-      }
-      bNoUnicode = TRUE;
+      bNoUnicode = true;
     }
     charinfo.m_Index = -1;
     charinfo.m_CharCode = item.m_CharCode;
-    if (bNoUnicode) {
+    if (bNoUnicode)
       charinfo.m_Flag = FPDFTEXT_CHAR_UNUNICODE;
-    } else {
+    else
       charinfo.m_Flag = FPDFTEXT_CHAR_NORMAL;
-    }
     charinfo.m_pTextObj = pTextObj;
     charinfo.m_OriginX = 0, charinfo.m_OriginY = 0;
     matrix.Transform(item.m_OriginX, item.m_OriginY, charinfo.m_OriginX,
                      charinfo.m_OriginY);
     FX_RECT rect =
         charinfo.m_pTextObj->GetFont()->GetCharBBox(charinfo.m_CharCode);
     charinfo.m_CharBox.top =
         rect.top * pTextObj->GetFontSize() / 1000 + item.m_OriginY;
     charinfo.m_CharBox.left =
         rect.left * pTextObj->GetFontSize() / 1000 + item.m_OriginX;
@@ skipping 11 matching lines @@
     }
     matrix.TransformRect(charinfo.m_CharBox);
     charinfo.m_Matrix.Copy(matrix);
     if (wstrItem.IsEmpty()) {
       charinfo.m_Unicode = 0;
       m_TempCharList.push_back(charinfo);
       m_TempTextBuf.AppendChar(0xfffe);
       continue;
     } else {
       int nTotal = wstrItem.GetLength();
-      FX_BOOL bDel = FALSE;
+      bool bDel = false;
       const int count =
           std::min(pdfium::CollectionSize<int>(m_TempCharList), 7);
       FX_FLOAT threshold = charinfo.m_Matrix.TransformXDistance(
           (FX_FLOAT)TEXT_CHARRATIO_GAPDELTA * pTextObj->GetFontSize());
       for (int n = pdfium::CollectionSize<int>(m_TempCharList);
            n > pdfium::CollectionSize<int>(m_TempCharList) - count; n--) {
         const 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;
+          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.push_back(charinfo);
         }
       } else if (i == 0) {
         CFX_WideString str = m_TempTextBuf.MakeString();
         if (!str.IsEmpty() &&
             str.GetAt(str.GetLength() - 1) == TEXT_SPACE_CHAR) {
           m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
           m_TempCharList.pop_back();
         }
       }
     }
   }
-  if (bIsBidiAndMirrorInverse) {
+  if (bIsBidiAndMirrorInverse)
     SwapTempTextBuf(iCharListStartAppend, iBufStartAppend);
-  }
 }
 
 CPDF_TextPage::TextOrientation CPDF_TextPage::GetTextObjectWritingMode(
     const CPDF_TextObject* pTextObj) const {
   int32_t nChars = pTextObj->CountChars();
   if (nChars == 1)
     return m_TextlineDir;
 
   CPDF_TextObjectItem first, last;
   pTextObj->GetCharInfo(0, &first);
@@ skipping 13 matching lines @@
     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) {
+  if (strCurText.IsEmpty())
     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) {
+  while (wcTmp == 0x20 && nIndex <= nCount - 1 && nIndex >= 0)
     wcTmp = strCurText.GetAt(--nIndex);
-  }
   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;
       }
     }
     const PAGECHAR_INFO* preInfo;
-    if (!m_TempCharList.empty()) {
+    if (!m_TempCharList.empty())
       preInfo = &m_TempCharList.back();
-    } else if (!m_CharList.empty()) {
+    else if (!m_CharList.empty())
       preInfo = &m_CharList.back();
-    } else {
+    else
       return FALSE;
-    }
     if (FPDFTEXT_CHAR_PIECE == preInfo->m_Flag &&
         (0xAD == preInfo->m_Unicode || 0x2D == preInfo->m_Unicode)) {
       return TRUE;
     }
   }
   return FALSE;
 }
 
 CPDF_TextPage::GenerateCharacter CPDF_TextPage::ProcessInsertObject(
     const CPDF_TextObject* pObj,
     const CFX_Matrix& formMatrix) {
   FindPreviousTextObject();
   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;
-  }
+  if (wstrItem.IsEmpty())
+    wstrItem += static_cast<FX_WCHAR>(item.m_CharCode);
   FX_WCHAR curChar = wstrItem.GetAt(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) {
         return IsHyphen(curChar) ? GenerateCharacter::Hyphen
                                  : GenerateCharacter::LineBreak;
@@ skipping 23 matching lines @@
   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) {
+  if (last_width < this_width)
     threshold = prev_reverse.TransformDistance(threshold);
-  }
   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) &&
@@ skipping 57 matching lines @@
       (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 GenerateCharacter::Space;
       }
-      if (x < 0 && (last_pos - x - last_width) > threshold) {
+      if (x < 0 && (last_pos - x - last_width) > threshold)
         return GenerateCharacter::Space;
-      }
       if ((x - last_pos - last_width) > this_width ||
           (x - last_pos - this_width) > last_width) {
         return GenerateCharacter::Space;
       }
     }
   }
   return GenerateCharacter::None;
 }
 
 FX_BOOL CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1,
                                         CPDF_TextObject* pTextObj2) {
-  if (!pTextObj1 || !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()) {
     FX_FLOAT dbXdif = FXSYS_fabs(rcPreObj.left - rcCurObj.left);
     size_t nCount = m_CharList.size();
     if (nCount >= 2) {
       PAGECHAR_INFO perCharTemp = m_CharList[nCount - 2];
       FX_FLOAT dbSpace = perCharTemp.m_CharBox.Width();
-      if (dbXdif > dbSpace) {
+      if (dbXdif > dbSpace)
         return FALSE;
-      }
     }
   }
   if (!rcPreObj.IsEmpty() || !rcCurObj.IsEmpty()) {
     rcPreObj.Intersect(rcCurObj);
-    if (rcPreObj.IsEmpty()) {
+    if (rcPreObj.IsEmpty())
       return FALSE;
-    }
     if (FXSYS_fabs(rcPreObj.Width() - rcCurObj.Width()) >
         rcCurObj.Width() / 2) {
       return FALSE;
     }
-    if (pTextObj2->GetFontSize() != pTextObj1->GetFontSize()) {
+    if (pTextObj2->GetFontSize() != pTextObj1->GetFontSize())
       return FALSE;
-    }
   }
   int nPreCount = pTextObj2->CountItems();
   int nCurCount = pTextObj1->CountItems();
-  if (nPreCount != nCurCount) {
+  if (nPreCount != nCurCount)
     return FALSE;
-  }
   // If both objects have no items, consider them same.
   if (!nPreCount)
     return TRUE;
 
   CPDF_TextObjectItem itemPer = {0, 0.0f, 0.0f};
   CPDF_TextObjectItem itemCur = {0, 0.0f, 0.0f};
   for (int i = 0; i < nPreCount; i++) {
     pTextObj2->GetItemInfo(i, &itemPer);
     pTextObj1->GetItemInfo(i, &itemCur);
-    if (itemCur.m_CharCode != itemPer.m_CharCode) {
+    if (itemCur.m_CharCode != itemPer.m_CharCode)
       return FALSE;
-    }
   }
   if (FXSYS_fabs(pTextObj1->GetPosX() - pTextObj2->GetPosX()) >
           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;
   }
@@ skipping 12 matching lines @@
       continue;
     if (IsSameTextObject(pOtherObj->AsText(), pTextObj))
       return TRUE;
     ++i;
   }
   return FALSE;
 }
 
 FX_BOOL CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info) {
   const PAGECHAR_INFO* preChar;
-  if (!m_TempCharList.empty()) {
+  if (!m_TempCharList.empty())
     preChar = &m_TempCharList.back();
-  } else if (!m_CharList.empty()) {
+  else if (!m_CharList.empty())
     preChar = &m_CharList.back();
-  } else {
+  else
     return FALSE;
-  }
   info.m_Index = m_TextBuf.GetLength();
   info.m_Unicode = unicode;
   info.m_pTextObj = nullptr;
   info.m_CharCode = CPDF_Font::kInvalidCharCode;
   info.m_Flag = FPDFTEXT_CHAR_GENERATED;
   int preWidth = 0;
   if (preChar->m_pTextObj && preChar->m_CharCode != -1) {
     preWidth =
         GetCharWidth(preChar->m_CharCode, preChar->m_pTextObj->GetFont());
   }
@@ skipping 569 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);
 }