Remove FX_BOOL from xfa.

xfa/fde/cfx_wordbreak.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 "xfa/fde/cfx_wordbreak.h"
 
 #include "xfa/fde/cfx_chariter.h"
 
@@ skipping 2771 matching lines @@
 
 void CFX_WordBreak::Attach(IFX_CharIter* pIter) {
   ASSERT(pIter);
   m_pCurIter.reset(pIter);
 }
 
 void CFX_WordBreak::Attach(const CFX_WideString& wsText) {
   m_pCurIter.reset(new CFX_CharIter(wsText));
 }
 
-FX_BOOL CFX_WordBreak::Next(FX_BOOL bPrev) {
+bool CFX_WordBreak::Next(bool bPrev) {
   std::unique_ptr<IFX_CharIter> pIter(
       (bPrev ? m_pPreIter : m_pCurIter)->Clone());
   if (pIter->IsEOF(!bPrev))
-    return FALSE;
+    return false;
 
   pIter->Next(bPrev);
-  if (!FindNextBreakPos(pIter.get(), bPrev, TRUE))
-    return FALSE;
+  if (!FindNextBreakPos(pIter.get(), bPrev, true))
+    return false;
 
   if (bPrev) {
     m_pCurIter = std::move(m_pPreIter);
-    m_pCurIter->Next(TRUE);
+    m_pCurIter->Next(true);
     m_pPreIter = std::move(pIter);
   } else {
     m_pPreIter = std::move(m_pCurIter);
     m_pPreIter->Next();
     m_pCurIter = std::move(pIter);
   }
-  return TRUE;
+  return true;
 }
 
 void CFX_WordBreak::SetAt(int32_t nIndex) {
   m_pPreIter.reset();
   m_pCurIter->SetAt(nIndex);
-  FindNextBreakPos(m_pCurIter.get(), TRUE, FALSE);
+  FindNextBreakPos(m_pCurIter.get(), true, false);
   m_pPreIter = std::move(m_pCurIter);
   m_pCurIter.reset(m_pPreIter->Clone());
-  FindNextBreakPos(m_pCurIter.get(), FALSE, FALSE);
+  FindNextBreakPos(m_pCurIter.get(), false, false);
 }
 
 int32_t CFX_WordBreak::GetWordPos() const {
   return m_pPreIter->GetAt();
 }
 
 int32_t CFX_WordBreak::GetWordLength() const {
   return m_pCurIter->GetAt() - m_pPreIter->GetAt() + 1;
 }
 
 void CFX_WordBreak::GetWord(CFX_WideString& wsWord) const {
   int32_t nWordLength = GetWordLength();
   if (nWordLength <= 0) {
     return;
   }
   FX_WCHAR* lpBuf = wsWord.GetBuffer(nWordLength);
   std::unique_ptr<IFX_CharIter> pTempIter(m_pPreIter->Clone());
   int32_t i = 0;
   while (pTempIter->GetAt() <= m_pCurIter->GetAt()) {
     lpBuf[i++] = pTempIter->GetChar();
     if (!pTempIter->Next())
       break;
   }
   wsWord.ReleaseBuffer(nWordLength);
 }
 
-FX_BOOL CFX_WordBreak::IsEOF(FX_BOOL bTail) const {
+bool CFX_WordBreak::IsEOF(bool bTail) const {
   return m_pCurIter->IsEOF(bTail);
 }
 
-FX_BOOL CFX_WordBreak::FindNextBreakPos(IFX_CharIter* pIter,
-                                        FX_BOOL bPrev,
-                                        FX_BOOL bFromNext) {
+bool CFX_WordBreak::FindNextBreakPos(IFX_CharIter* pIter,
+                                     bool bPrev,
+                                     bool bFromNext) {
   FX_WordBreakProp ePreType = FX_WordBreakProp_None;
   FX_WordBreakProp eCurType = FX_WordBreakProp_None;
   FX_WordBreakProp eNextType = FX_WordBreakProp_None;
   if (pIter->IsEOF(!bPrev)) {
-    return TRUE;
+    return true;
   }
   if (!(bFromNext || pIter->IsEOF(bPrev))) {
     pIter->Next(!bPrev);
     ePreType = GetWordBreakProperty(pIter->GetChar());
     pIter->Next(bPrev);
   }
   eCurType = GetWordBreakProperty(pIter->GetChar());
-  FX_BOOL bFirst = TRUE;
+  bool bFirst = true;
   do {
     pIter->Next(bPrev);
     eNextType = GetWordBreakProperty(pIter->GetChar());
     uint16_t wBreak =
         gs_FX_WordBreak_Table[eCurType] & ((uint16_t)(1 << eNextType));
     if (wBreak) {
       if (pIter->IsEOF(!bPrev)) {
         pIter->Next(!bPrev);
-        return TRUE;
+        return true;
       }
       if (bFirst) {
         int32_t nFlags = 0;
         if (eCurType == FX_WordBreakProp_MidLetter) {
           if (eNextType == FX_WordBreakProp_ALetter) {
             nFlags = 1;
           }
         } else if (eCurType == FX_WordBreakProp_MidNum) {
           if (eNextType == FX_WordBreakProp_Numberic) {
             nFlags = 2;
           }
         } else if (eCurType == FX_WordBreakProp_MidNumLet) {
           if (eNextType == FX_WordBreakProp_ALetter) {
             nFlags = 1;
           } else if (eNextType == FX_WordBreakProp_Numberic) {
             nFlags = 2;
           }
         }
         if (nFlags > 0) {
           ASSERT(nFlags <= 2);
           if (!((nFlags == 1 && ePreType == FX_WordBreakProp_ALetter) ||
                 (nFlags == 2 && ePreType == FX_WordBreakProp_Numberic))) {
             pIter->Next(!bPrev);
-            return TRUE;
+            return true;
           }
           pIter->Next(bPrev);
-          wBreak = FALSE;
+          wBreak = false;
         }
-        bFirst = FALSE;
+        bFirst = false;
       }
       if (wBreak) {
         int32_t nFlags = 0;
         if (eNextType == FX_WordBreakProp_MidLetter) {
           if (eCurType == FX_WordBreakProp_ALetter) {
             nFlags = 1;
           }
         } else if (eNextType == FX_WordBreakProp_MidNum) {
           if (eCurType == FX_WordBreakProp_Numberic) {
             nFlags = 2;
           }
         } else if (eNextType == FX_WordBreakProp_MidNumLet) {
           if (eCurType == FX_WordBreakProp_ALetter) {
             nFlags = 1;
           } else if (eCurType == FX_WordBreakProp_Numberic) {
             nFlags = 2;
           }
         }
         if (nFlags <= 0) {
           pIter->Next(!bPrev);
-          return TRUE;
+          return true;
         }
         ASSERT(nFlags <= 2);
         pIter->Next(bPrev);
         eNextType = (FX_WordBreakProp)GetWordBreakProperty(pIter->GetChar());
         if (!((nFlags == 1 && eNextType == FX_WordBreakProp_ALetter) ||
               (nFlags == 2 && eNextType == FX_WordBreakProp_Numberic))) {
           pIter->Next(!bPrev);
           pIter->Next(!bPrev);
-          return TRUE;
+          return true;
         }
       }
     }
     ePreType = eCurType;
     eCurType = eNextType;
-    bFirst = FALSE;
+    bFirst = false;
   } while (!pIter->IsEOF(!bPrev));
-  return TRUE;
+  return true;
 }