Remove FX_BOOL from core

core/fpdfdoc/cpdf_variabletext.cpp

 // Copyright 2016 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/fpdfdoc/cpdf_variabletext.h"
 
 #include "core/fpdfapi/font/cpdf_font.h"
 #include "core/fpdfdoc/cline.h"
@@ skipping 51 matching lines @@
     if (pDefFont->CharCodeFromUnicode(word) != CPDF_Font::kInvalidCharCode)
       return 0;
   }
   if (CPDF_Font* pSysFont = m_pFontMap->GetPDFFont(1)) {
     if (pSysFont->CharCodeFromUnicode(word) != CPDF_Font::kInvalidCharCode)
       return 1;
   }
   return -1;
 }
 
-FX_BOOL CPDF_VariableText::Provider::IsLatinWord(uint16_t word) {
+bool CPDF_VariableText::Provider::IsLatinWord(uint16_t word) {
   return (word >= 0x61 && word <= 0x7A) || (word >= 0x41 && word <= 0x5A) ||
          word == 0x2D || word == 0x27;
 }
 
 int32_t CPDF_VariableText::Provider::GetDefaultFontIndex() {
   return 0;
 }
 
 CPDF_VariableText::Iterator::Iterator(CPDF_VariableText* pVT)
     : m_CurPos(-1, -1, -1), m_pVT(pVT) {}
 
 CPDF_VariableText::Iterator::~Iterator() {}
 
 void CPDF_VariableText::Iterator::SetAt(int32_t nWordIndex) {
   m_CurPos = m_pVT->WordIndexToWordPlace(nWordIndex);
 }
 
 void CPDF_VariableText::Iterator::SetAt(const CPVT_WordPlace& place) {
   ASSERT(m_pVT);
   m_CurPos = place;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::NextWord() {
+bool CPDF_VariableText::Iterator::NextWord() {
   if (m_CurPos == m_pVT->GetEndWordPlace())
-    return FALSE;
+    return false;
 
   m_CurPos = m_pVT->GetNextWordPlace(m_CurPos);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::PrevWord() {
+bool CPDF_VariableText::Iterator::PrevWord() {
   if (m_CurPos == m_pVT->GetBeginWordPlace())
-    return FALSE;
+    return false;
 
   m_CurPos = m_pVT->GetPrevWordPlace(m_CurPos);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::NextLine() {
+bool CPDF_VariableText::Iterator::NextLine() {
   if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     if (m_CurPos.nLineIndex < pSection->m_LineArray.GetSize() - 1) {
       m_CurPos =
           CPVT_WordPlace(m_CurPos.nSecIndex, m_CurPos.nLineIndex + 1, -1);
-      return TRUE;
+      return true;
     }
     if (m_CurPos.nSecIndex < m_pVT->m_SectionArray.GetSize() - 1) {
       m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex + 1, 0, -1);
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::PrevLine() {
+bool CPDF_VariableText::Iterator::PrevLine() {
   if (m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     if (m_CurPos.nLineIndex > 0) {
       m_CurPos =
           CPVT_WordPlace(m_CurPos.nSecIndex, m_CurPos.nLineIndex - 1, -1);
-      return TRUE;
+      return true;
     }
     if (m_CurPos.nSecIndex > 0) {
       if (CSection* pLastSection =
               m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex - 1)) {
         m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex - 1,
                                   pLastSection->m_LineArray.GetSize() - 1, -1);
-        return TRUE;
+        return true;
       }
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::NextSection() {
+bool CPDF_VariableText::Iterator::NextSection() {
   if (m_CurPos.nSecIndex < m_pVT->m_SectionArray.GetSize() - 1) {
     m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex + 1, 0, -1);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::PrevSection() {
+bool CPDF_VariableText::Iterator::PrevSection() {
   ASSERT(m_pVT);
   if (m_CurPos.nSecIndex > 0) {
     m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex - 1, 0, -1);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::GetWord(CPVT_Word& word) const {
+bool CPDF_VariableText::Iterator::GetWord(CPVT_Word& word) const {
   word.WordPlace = m_CurPos;
   if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     if (pSection->m_LineArray.GetAt(m_CurPos.nLineIndex)) {
       if (CPVT_WordInfo* pWord =
               pSection->m_WordArray.GetAt(m_CurPos.nWordIndex)) {
         word.Word = pWord->Word;
         word.nCharset = pWord->nCharset;
         word.fWidth = m_pVT->GetWordWidth(*pWord);
         word.ptWord = m_pVT->InToOut(
             CFX_FloatPoint(pWord->fWordX + pSection->m_SecInfo.rcSection.left,
                            pWord->fWordY + pSection->m_SecInfo.rcSection.top));
         word.fAscent = m_pVT->GetWordAscent(*pWord);
         word.fDescent = m_pVT->GetWordDescent(*pWord);
         if (pWord->pWordProps)
           word.WordProps = *pWord->pWordProps;
 
         word.nFontIndex = m_pVT->GetWordFontIndex(*pWord);
         word.fFontSize = m_pVT->GetWordFontSize(*pWord);
-        return TRUE;
+        return true;
       }
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::SetWord(const CPVT_Word& word) {
+bool CPDF_VariableText::Iterator::SetWord(const CPVT_Word& word) {
   if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     if (CPVT_WordInfo* pWord =
             pSection->m_WordArray.GetAt(m_CurPos.nWordIndex)) {
       if (pWord->pWordProps)
         *pWord->pWordProps = word.WordProps;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::GetLine(CPVT_Line& line) const {
+bool CPDF_VariableText::Iterator::GetLine(CPVT_Line& line) const {
   ASSERT(m_pVT);
   line.lineplace = CPVT_WordPlace(m_CurPos.nSecIndex, m_CurPos.nLineIndex, -1);
   if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     if (CLine* pLine = pSection->m_LineArray.GetAt(m_CurPos.nLineIndex)) {
       line.ptLine = m_pVT->InToOut(CFX_FloatPoint(
           pLine->m_LineInfo.fLineX + pSection->m_SecInfo.rcSection.left,
           pLine->m_LineInfo.fLineY + pSection->m_SecInfo.rcSection.top));
       line.fLineWidth = pLine->m_LineInfo.fLineWidth;
       line.fLineAscent = pLine->m_LineInfo.fLineAscent;
       line.fLineDescent = pLine->m_LineInfo.fLineDescent;
       line.lineEnd = pLine->GetEndWordPlace();
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::GetSection(CPVT_Section& section) const {
+bool CPDF_VariableText::Iterator::GetSection(CPVT_Section& section) const {
   section.secplace = CPVT_WordPlace(m_CurPos.nSecIndex, 0, -1);
   if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     section.rcSection = m_pVT->InToOut(pSection->m_SecInfo.rcSection);
     if (pSection->m_SecInfo.pSecProps)
       section.SecProps = *pSection->m_SecInfo.pSecProps;
     if (pSection->m_SecInfo.pWordProps)
       section.WordProps = *pSection->m_SecInfo.pWordProps;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::Iterator::SetSection(const CPVT_Section& section) {
+bool CPDF_VariableText::Iterator::SetSection(const CPVT_Section& section) {
   if (CSection* pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
     if (pSection->m_SecInfo.pSecProps)
       *pSection->m_SecInfo.pSecProps = section.SecProps;
     if (pSection->m_SecInfo.pWordProps)
       *pSection->m_SecInfo.pWordProps = section.WordProps;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 CPDF_VariableText::CPDF_VariableText()
     : m_nLimitChar(0),
       m_nCharArray(0),
-      m_bMultiLine(FALSE),
-      m_bLimitWidth(FALSE),
-      m_bAutoFontSize(FALSE),
+      m_bMultiLine(false),
+      m_bLimitWidth(false),
+      m_bAutoFontSize(false),
       m_nAlignment(0),
       m_fLineLeading(0.0f),
       m_fCharSpace(0.0f),
       m_nHorzScale(100),
       m_wSubWord(0),
       m_fFontSize(0.0f),
-      m_bInitial(FALSE),
+      m_bInitial(false),
       m_pVTProvider(nullptr) {}
 
 CPDF_VariableText::~CPDF_VariableText() {
   ResetAll();
 }
 
 void CPDF_VariableText::Initialize() {
   if (!m_bInitial) {
     CPVT_SectionInfo secinfo;
     CPVT_WordPlace place;
     place.nSecIndex = 0;
     AddSection(place, secinfo);
     CPVT_LineInfo lineinfo;
     lineinfo.fLineAscent = GetFontAscent(GetDefaultFontIndex(), GetFontSize());
     lineinfo.fLineDescent =
         GetFontDescent(GetDefaultFontIndex(), GetFontSize());
     AddLine(place, lineinfo);
     if (CSection* pSection = m_SectionArray.GetAt(0))
       pSection->ResetLinePlace();
 
-    m_bInitial = TRUE;
+    m_bInitial = true;
   }
 }
 
 void CPDF_VariableText::ResetAll() {
-  m_bInitial = FALSE;
+  m_bInitial = false;
   ResetSectionArray();
 }
 
 CPVT_WordPlace CPDF_VariableText::InsertWord(const CPVT_WordPlace& place,
                                              uint16_t word,
                                              int32_t charset,
                                              const CPVT_WordProps* pWordProps) {
   int32_t nTotlaWords = GetTotalWords();
   if (m_nLimitChar > 0 && nTotlaWords >= m_nLimitChar)
     return place;
@@ skipping 74 matching lines @@
         break;
     }
     if (wp == oldwp)
       break;
   }
   return wp;
 }
 
 CPVT_WordPlace CPDF_VariableText::DeleteWords(
     const CPVT_WordRange& PlaceRange) {
-  FX_BOOL bLastSecPos = FALSE;
+  bool bLastSecPos = false;
   if (CSection* pSection = m_SectionArray.GetAt(PlaceRange.EndPos.nSecIndex))
     bLastSecPos = (PlaceRange.EndPos == pSection->GetEndWordPlace());
 
   ClearWords(PlaceRange);
   if (PlaceRange.BeginPos.nSecIndex != PlaceRange.EndPos.nSecIndex) {
     ClearEmptySections(PlaceRange);
     if (!bLastSecPos)
       LinkLatterSection(PlaceRange.BeginPos);
   }
   return PlaceRange.BeginPos;
 }
 
 CPVT_WordPlace CPDF_VariableText::DeleteWord(const CPVT_WordPlace& place) {
-  return ClearRightWord(AdjustLineHeader(place, TRUE));
+  return ClearRightWord(AdjustLineHeader(place, true));
 }
 
 CPVT_WordPlace CPDF_VariableText::BackSpaceWord(const CPVT_WordPlace& place) {
-  return ClearLeftWord(AdjustLineHeader(place, TRUE));
+  return ClearLeftWord(AdjustLineHeader(place, true));
 }
 
 void CPDF_VariableText::SetText(const CFX_WideString& swText) {
   DeleteWords(CPVT_WordRange(GetBeginWordPlace(), GetEndWordPlace()));
   CPVT_WordPlace wp(0, 0, -1);
   CPVT_SectionInfo secinfo;
   if (CSection* pSection = m_SectionArray.GetAt(0))
     pSection->m_SecInfo = secinfo;
 
   int32_t nCharCount = 0;
@@ skipping 36 matching lines @@
     nCharCount++;
   }
 }
 
 void CPDF_VariableText::UpdateWordPlace(CPVT_WordPlace& place) const {
   if (place.nSecIndex < 0)
     place = GetBeginWordPlace();
   if (place.nSecIndex >= m_SectionArray.GetSize())
     place = GetEndWordPlace();
 
-  place = AdjustLineHeader(place, TRUE);
+  place = AdjustLineHeader(place, true);
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex))
     pSection->UpdateWordPlace(place);
 }
 
 int32_t CPDF_VariableText::WordPlaceToWordIndex(
     const CPVT_WordPlace& place) const {
   CPVT_WordPlace newplace = place;
   UpdateWordPlace(newplace);
   int32_t nIndex = 0;
   int32_t i = 0;
   int32_t sz = 0;
   for (i = 0, sz = m_SectionArray.GetSize(); i < sz && i < newplace.nSecIndex;
        i++) {
     if (CSection* pSection = m_SectionArray.GetAt(i)) {
       nIndex += pSection->m_WordArray.GetSize();
       if (i != m_SectionArray.GetSize() - 1)
         nIndex += kReturnLength;
     }
   }
   if (i >= 0 && i < m_SectionArray.GetSize())
     nIndex += newplace.nWordIndex + kReturnLength;
   return nIndex;
 }
 
 CPVT_WordPlace CPDF_VariableText::WordIndexToWordPlace(int32_t index) const {
   CPVT_WordPlace place = GetBeginWordPlace();
   int32_t nOldIndex = 0, nIndex = 0;
-  FX_BOOL bFind = FALSE;
+  bool bFind = false;
   for (int32_t i = 0, sz = m_SectionArray.GetSize(); i < sz; i++) {
     if (CSection* pSection = m_SectionArray.GetAt(i)) {
       nIndex += pSection->m_WordArray.GetSize();
       if (nIndex == index) {
         place = pSection->GetEndWordPlace();
-        bFind = TRUE;
+        bFind = true;
         break;
       } else if (nIndex > index) {
         place.nSecIndex = i;
         place.nWordIndex = index - nOldIndex - 1;
         pSection->UpdateWordPlace(place);
-        bFind = TRUE;
+        bFind = true;
         break;
       }
       if (i != m_SectionArray.GetSize() - 1)
         nIndex += kReturnLength;
       nOldIndex = nIndex;
     }
   }
   if (!bFind)
     place = GetEndWordPlace();
   return place;
@@ skipping 43 matching lines @@
   return place;
 }
 
 CPVT_WordPlace CPDF_VariableText::SearchWordPlace(
     const CFX_FloatPoint& point) const {
   CFX_FloatPoint pt = OutToIn(point);
   CPVT_WordPlace place = GetBeginWordPlace();
   int32_t nLeft = 0;
   int32_t nRight = m_SectionArray.GetSize() - 1;
   int32_t nMid = m_SectionArray.GetSize() / 2;
-  FX_BOOL bUp = TRUE;
-  FX_BOOL bDown = TRUE;
+  bool bUp = true;
+  bool bDown = true;
   while (nLeft <= nRight) {
     if (CSection* pSection = m_SectionArray.GetAt(nMid)) {
       if (IsFloatBigger(pt.y, pSection->m_SecInfo.rcSection.top)) {
-        bUp = FALSE;
+        bUp = false;
       }
       if (IsFloatBigger(pSection->m_SecInfo.rcSection.bottom, pt.y)) {
-        bDown = FALSE;
+        bDown = false;
       }
       if (IsFloatSmaller(pt.y, pSection->m_SecInfo.rcSection.top)) {
         nRight = nMid - 1;
         nMid = (nLeft + nRight) / 2;
         continue;
       } else if (IsFloatBigger(pt.y, pSection->m_SecInfo.rcSection.bottom)) {
         nLeft = nMid + 1;
         nMid = (nLeft + nRight) / 2;
         continue;
       } else {
@@ skipping 132 matching lines @@
     return place;
   }
   CPVT_WordPlace newplace = place;
   newplace.nSecIndex =
       std::max(std::min(newplace.nSecIndex, m_SectionArray.GetSize() - 1), 0);
   if (CSection* pSection = m_SectionArray.GetAt(newplace.nSecIndex))
     return pSection->AddWord(newplace, wordinfo);
   return place;
 }
 
-FX_BOOL CPDF_VariableText::GetWordInfo(const CPVT_WordPlace& place,
-                                       CPVT_WordInfo& wordinfo) {
+bool CPDF_VariableText::GetWordInfo(const CPVT_WordPlace& place,
+                                    CPVT_WordInfo& wordinfo) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     if (CPVT_WordInfo* pWord = pSection->m_WordArray.GetAt(place.nWordIndex)) {
       wordinfo = *pWord;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::SetWordInfo(const CPVT_WordPlace& place,
-                                       const CPVT_WordInfo& wordinfo) {
+bool CPDF_VariableText::SetWordInfo(const CPVT_WordPlace& place,
+                                    const CPVT_WordInfo& wordinfo) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     if (CPVT_WordInfo* pWord = pSection->m_WordArray.GetAt(place.nWordIndex)) {
       *pWord = wordinfo;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::GetLineInfo(const CPVT_WordPlace& place,
-                                       CPVT_LineInfo& lineinfo) {
+bool CPDF_VariableText::GetLineInfo(const CPVT_WordPlace& place,
+                                    CPVT_LineInfo& lineinfo) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     if (CLine* pLine = pSection->m_LineArray.GetAt(place.nLineIndex)) {
       lineinfo = pLine->m_LineInfo;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_VariableText::GetSectionInfo(const CPVT_WordPlace& place,
-                                          CPVT_SectionInfo& secinfo) {
+bool CPDF_VariableText::GetSectionInfo(const CPVT_WordPlace& place,
+                                       CPVT_SectionInfo& secinfo) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     secinfo = pSection->m_SecInfo;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 void CPDF_VariableText::SetPlateRect(const CFX_FloatRect& rect) {
   m_rcPlate = rect;
 }
 
 void CPDF_VariableText::SetContentRect(const CPVT_FloatRect& rect) {
   m_rcContent = rect;
 }
 
@@ skipping 82 matching lines @@
 
 FX_FLOAT CPDF_VariableText::GetCharSpace(const CPVT_WordInfo& WordInfo) {
   return m_fCharSpace;
 }
 
 int32_t CPDF_VariableText::GetHorzScale(const CPVT_WordInfo& WordInfo) {
   return m_nHorzScale;
 }
 
 void CPDF_VariableText::ClearSectionRightWords(const CPVT_WordPlace& place) {
-  CPVT_WordPlace wordplace = AdjustLineHeader(place, TRUE);
+  CPVT_WordPlace wordplace = AdjustLineHeader(place, true);
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     for (int32_t w = pSection->m_WordArray.GetSize() - 1;
          w > wordplace.nWordIndex; w--) {
       delete pSection->m_WordArray.GetAt(w);
       pSection->m_WordArray.RemoveAt(w);
     }
   }
 }
 
 CPVT_WordPlace CPDF_VariableText::AdjustLineHeader(const CPVT_WordPlace& place,
-                                                   FX_BOOL bPrevOrNext) const {
+                                                   bool bPrevOrNext) const {
   if (place.nWordIndex < 0 && place.nLineIndex > 0)
     return bPrevOrNext ? GetPrevWordPlace(place) : GetNextWordPlace(place);
   return place;
 }
 
-FX_BOOL CPDF_VariableText::ClearEmptySection(const CPVT_WordPlace& place) {
+bool CPDF_VariableText::ClearEmptySection(const CPVT_WordPlace& place) {
   if (place.nSecIndex == 0 && m_SectionArray.GetSize() == 1)
-    return FALSE;
+    return false;
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     if (pSection->m_WordArray.GetSize() == 0) {
       delete pSection;
       m_SectionArray.RemoveAt(place.nSecIndex);
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
 void CPDF_VariableText::ClearEmptySections(const CPVT_WordRange& PlaceRange) {
   CPVT_WordPlace wordplace;
   for (int32_t s = PlaceRange.EndPos.nSecIndex;
        s > PlaceRange.BeginPos.nSecIndex; s--) {
     wordplace.nSecIndex = s;
     ClearEmptySection(wordplace);
   }
 }
 
 void CPDF_VariableText::LinkLatterSection(const CPVT_WordPlace& place) {
-  CPVT_WordPlace oldplace = AdjustLineHeader(place, TRUE);
+  CPVT_WordPlace oldplace = AdjustLineHeader(place, true);
   if (CSection* pNextSection = m_SectionArray.GetAt(place.nSecIndex + 1)) {
     if (CSection* pSection = m_SectionArray.GetAt(oldplace.nSecIndex)) {
       for (int32_t w = 0, sz = pNextSection->m_WordArray.GetSize(); w < sz;
            w++) {
         if (CPVT_WordInfo* pWord = pNextSection->m_WordArray.GetAt(w)) {
           oldplace.nWordIndex++;
           pSection->AddWord(oldplace, *pWord);
         }
       }
     }
     delete pNextSection;
     m_SectionArray.RemoveAt(place.nSecIndex + 1);
   }
 }
 
 void CPDF_VariableText::ClearWords(const CPVT_WordRange& PlaceRange) {
   CPVT_WordRange NewRange;
-  NewRange.BeginPos = AdjustLineHeader(PlaceRange.BeginPos, TRUE);
-  NewRange.EndPos = AdjustLineHeader(PlaceRange.EndPos, TRUE);
+  NewRange.BeginPos = AdjustLineHeader(PlaceRange.BeginPos, true);
+  NewRange.EndPos = AdjustLineHeader(PlaceRange.EndPos, true);
   for (int32_t s = NewRange.EndPos.nSecIndex; s >= NewRange.BeginPos.nSecIndex;
        s--) {
     if (CSection* pSection = m_SectionArray.GetAt(s))
       pSection->ClearWords(NewRange);
   }
 }
 
 CPVT_WordPlace CPDF_VariableText::ClearLeftWord(const CPVT_WordPlace& place) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     CPVT_WordPlace leftplace = GetPrevWordPlace(place);
     if (leftplace != place) {
       if (leftplace.nSecIndex != place.nSecIndex) {
         if (pSection->m_WordArray.GetSize() == 0)
           ClearEmptySection(place);
         else
           LinkLatterSection(leftplace);
       } else {
         pSection->ClearWord(place);
       }
     }
     return leftplace;
   }
   return place;
 }
 
 CPVT_WordPlace CPDF_VariableText::ClearRightWord(const CPVT_WordPlace& place) {
   if (CSection* pSection = m_SectionArray.GetAt(place.nSecIndex)) {
     CPVT_WordPlace rightplace =
-        AdjustLineHeader(GetNextWordPlace(place), FALSE);
+        AdjustLineHeader(GetNextWordPlace(place), false);
     if (rightplace != place) {
       if (rightplace.nSecIndex != place.nSecIndex)
         LinkLatterSection(place);
       else
         pSection->ClearWord(rightplace);
     }
   }
   return place;
 }
 
@@ skipping 125 matching lines @@
                                             int32_t nFontIndex) {
   return m_pVTProvider
              ? m_pVTProvider->GetWordFontIndex(word, charset, nFontIndex)
              : -1;
 }
 
 int32_t CPDF_VariableText::GetDefaultFontIndex() {
   return m_pVTProvider ? m_pVTProvider->GetDefaultFontIndex() : -1;
 }
 
-FX_BOOL CPDF_VariableText::IsLatinWord(uint16_t word) {
-  return m_pVTProvider ? m_pVTProvider->IsLatinWord(word) : FALSE;
+bool CPDF_VariableText::IsLatinWord(uint16_t word) {
+  return m_pVTProvider ? m_pVTProvider->IsLatinWord(word) : false;
 }
 
 CPDF_VariableText::Iterator* CPDF_VariableText::GetIterator() {
   if (!m_pVTIterator)
     m_pVTIterator.reset(new CPDF_VariableText::Iterator(this));
   return m_pVTIterator.get();
 }
 
 void CPDF_VariableText::SetProvider(CPDF_VariableText::Provider* pProvider) {
   m_pVTProvider = pProvider;
@@ skipping 27 matching lines @@
                        ptLeftTop.y);
 }
 
 CPVT_FloatRect CPDF_VariableText::OutToIn(const CFX_FloatRect& rect) const {
   CFX_FloatPoint ptLeftTop = OutToIn(CFX_FloatPoint(rect.left, rect.top));
   CFX_FloatPoint ptRightBottom =
       OutToIn(CFX_FloatPoint(rect.right, rect.bottom));
   return CPVT_FloatRect(ptLeftTop.x, ptLeftTop.y, ptRightBottom.x,
                         ptRightBottom.y);
 }