Remove FX_BOOL from core

core/fpdfdoc/cpdf_interform.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 <vector>
 
 #include "core/fpdfapi/font/cpdf_font.h"
 #include "core/fpdfapi/font/cpdf_fontencoding.h"
@@ skipping 145 matching lines @@
       continue;
 
     if (pSubst->m_Charset == (int)charSet) {
       csNameTag = csKey;
       return pFind;
     }
   }
   return nullptr;
 }
 
-FX_BOOL FindFont(CPDF_Dictionary* pFormDict,
-                 const CPDF_Font* pFont,
-                 CFX_ByteString& csNameTag) {
+bool FindFont(CPDF_Dictionary* pFormDict,
+              const CPDF_Font* pFont,
+              CFX_ByteString& csNameTag) {
   if (!pFormDict || !pFont)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
-    return FALSE;
+    return false;
 
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
     if (pElement->GetStringFor("Type") != "Font")
       continue;
     if (pFont->GetFontDict() == pElement) {
       csNameTag = csKey;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL FindFont(CPDF_Dictionary* pFormDict,
-                 CPDF_Document* pDocument,
-                 CFX_ByteString csFontName,
-                 CPDF_Font*& pFont,
-                 CFX_ByteString& csNameTag) {
+bool FindFont(CPDF_Dictionary* pFormDict,
+              CPDF_Document* pDocument,
+              CFX_ByteString csFontName,
+              CPDF_Font*& pFont,
+              CFX_ByteString& csNameTag) {
   if (!pFormDict)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pDR = pFormDict->GetDictFor("DR");
   if (!pDR)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pFonts = pDR->GetDictFor("Font");
   if (!pFonts)
-    return FALSE;
+    return false;
   if (csFontName.GetLength() > 0)
     csFontName.Remove(' ');
 
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj)
       continue;
 
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
     if (pElement->GetStringFor("Type") != "Font")
       continue;
 
     pFont = pDocument->LoadFont(pElement);
     if (!pFont)
       continue;
 
     CFX_ByteString csBaseFont;
     csBaseFont = pFont->GetBaseFont();
     csBaseFont.Remove(' ');
     if (csBaseFont == csFontName) {
       csNameTag = csKey;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
 void AddFont(CPDF_Dictionary*& pFormDict,
              CPDF_Document* pDocument,
              const CPDF_Font* pFont,
              CFX_ByteString& csNameTag) {
   if (!pFont)
     return;
   if (!pFormDict)
     InitDict(pFormDict, pDocument);
@@ skipping 70 matching lines @@
   }
 
  protected:
   CFX_WideString m_FullName;
   const FX_WCHAR* m_pCur;
   const FX_WCHAR* m_pEnd;
 };
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 typedef struct {
-  FX_BOOL bFind;
+  bool bFind;
   LOGFONTA lf;
 } PDF_FONTDATA;
 
 static int CALLBACK EnumFontFamExProc(ENUMLOGFONTEXA* lpelfe,
                                       NEWTEXTMETRICEX* lpntme,
                                       DWORD FontType,
                                       LPARAM lParam) {
   if (FontType != 0x004 || strchr(lpelfe->elfLogFont.lfFaceName, '@'))
     return 1;
 
   PDF_FONTDATA* pData = (PDF_FONTDATA*)lParam;
   memcpy(&pData->lf, &lpelfe->elfLogFont, sizeof(LOGFONTA));
-  pData->bFind = TRUE;
+  pData->bFind = true;
   return 0;
 }
 
-FX_BOOL RetrieveSpecificFont(LOGFONTA& lf) {
+bool RetrieveSpecificFont(LOGFONTA& lf) {
   PDF_FONTDATA fd;
   memset(&fd, 0, sizeof(PDF_FONTDATA));
   HDC hDC = ::GetDC(nullptr);
   EnumFontFamiliesExA(hDC, &lf, (FONTENUMPROCA)EnumFontFamExProc, (LPARAM)&fd,
                       0);
   ::ReleaseDC(nullptr, hDC);
   if (fd.bFind)
     memcpy(&lf, &fd.lf, sizeof(LOGFONTA));
 
   return fd.bFind;
 }
 
-FX_BOOL RetrieveSpecificFont(uint8_t charSet,
-                             uint8_t pitchAndFamily,
-                             LPCSTR pcsFontName,
-                             LOGFONTA& lf) {
+bool RetrieveSpecificFont(uint8_t charSet,
+                          uint8_t pitchAndFamily,
+                          LPCSTR pcsFontName,
+                          LOGFONTA& lf) {
   memset(&lf, 0, sizeof(LOGFONTA));
   lf.lfCharSet = charSet;
   lf.lfPitchAndFamily = pitchAndFamily;
   if (pcsFontName) {
     // TODO(dsinclair): Should this be strncpy?
     strcpy(lf.lfFaceName, pcsFontName);
   }
   return RetrieveSpecificFont(lf);
 }
 #endif  // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
@@ skipping 347 matching lines @@
   }
   if (!pResDict)
     return csTmp;
 
   CPDF_Dictionary* pDict = pResDict->GetDictFor(csType);
   if (!pDict)
     return csTmp;
 
   int num = 0;
   CFX_ByteString bsNum;
-  while (TRUE) {
+  while (true) {
     CFX_ByteString csKey = csTmp + bsNum;
     if (!pDict->KeyExist(csKey))
       return csKey;
     if (m < iCount)
       csTmp += csStr[m++];
     else
       bsNum.Format("%d", num++);
 
     m++;
   }
@@ skipping 13 matching lines @@
 }
 
 CFX_ByteString CPDF_InterForm::GetNativeFont(uint8_t charSet, void* pLogFont) {
   CFX_ByteString csFontName;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   LOGFONTA lf = {};
   if (charSet == FXFONT_ANSI_CHARSET) {
     csFontName = "Helvetica";
     return csFontName;
   }
-  FX_BOOL bRet = FALSE;
+  bool bRet = false;
   if (charSet == FXFONT_SHIFTJIS_CHARSET) {
     bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE,
                                 "MS Mincho", lf);
   } else if (charSet == FXFONT_GB2312_CHARSET) {
     bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "SimSun",
                                 lf);
   } else if (charSet == FXFONT_CHINESEBIG5_CHARSET) {
     bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "MingLiU",
                                 lf);
   }
@@ skipping 24 matching lines @@
                                          CPDF_Document* pDocument) {
   if (!pDocument)
     return nullptr;
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
   LOGFONTA lf;
   CFX_ByteString csFontName = GetNativeFont(charSet, &lf);
   if (!csFontName.IsEmpty()) {
     if (csFontName == "Helvetica")
       return AddStandardFont(pDocument, csFontName);
-    return pDocument->AddWindowsFont(&lf, FALSE, TRUE);
+    return pDocument->AddWindowsFont(&lf, false, true);
   }
 #endif
   return nullptr;
 }
 
 CPDF_Font* CPDF_InterForm::AddNativeFont(CPDF_Document* pDocument) {
   return pDocument ? AddNativeFont(GetNativeCharSet(), pDocument) : nullptr;
 }
 
 bool CPDF_InterForm::ValidateFieldName(
@@ skipping 110 matching lines @@
   }
   return nullptr;
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlByDict(
     const CPDF_Dictionary* pWidgetDict) const {
   const auto it = m_ControlMap.find(pWidgetDict);
   return it != m_ControlMap.end() ? it->second : nullptr;
 }
 
-FX_BOOL CPDF_InterForm::NeedConstructAP() const {
+bool CPDF_InterForm::NeedConstructAP() const {
   return m_pFormDict && m_pFormDict->GetBooleanFor("NeedAppearances");
 }
 
 int CPDF_InterForm::CountFieldsInCalculationOrder() {
   if (!m_pFormDict)
     return 0;
 
   CPDF_Array* pArray = m_pFormDict->GetArrayFor("CO");
   return pArray ? pArray->GetCount() : 0;
 }
@@ skipping 100 matching lines @@
       if (pChildDict) {
         if (pChildDict->GetObjNum() != dwParentObjNum)
           LoadField(pChildDict, nLevel + 1);
       }
     }
   } else {
     AddTerminalField(pFieldDict);
   }
 }
 
-FX_BOOL CPDF_InterForm::HasXFAForm() const {
+bool CPDF_InterForm::HasXFAForm() const {
   return m_pFormDict && m_pFormDict->GetArrayFor("XFA");
 }
 
 void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage) {
   CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
   if (!pPageDict)
     return;
 
   CPDF_Array* pAnnots = pPageDict->GetArrayFor("Annots");
   if (!pAnnots)
@@ skipping 159 matching lines @@
     if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField)) {
       if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetStringFor("V").IsEmpty())
         continue;
 
       CFX_WideString fullname = FPDF_GetFullName(pField->GetFieldDict());
       CPDF_Dictionary* pFieldDict =
           new CPDF_Dictionary(pDoc->GetByteStringPool());
       pFieldDict->SetFor("T", new CPDF_String(fullname));
       if (pField->GetType() == CPDF_FormField::CheckBox ||
           pField->GetType() == CPDF_FormField::RadioButton) {
-        CFX_WideString csExport = pField->GetCheckValue(FALSE);
+        CFX_WideString csExport = pField->GetCheckValue(false);
         CFX_ByteString csBExport = PDF_EncodeText(csExport);
         CPDF_Object* pOpt = FPDF_GetFieldAttr(pField->m_pDict, "Opt");
         if (pOpt)
           pFieldDict->SetStringFor("V", csBExport);
         else
           pFieldDict->SetNameFor("V", csBExport);
       } else {
         CPDF_Object* pV = FPDF_GetFieldAttr(pField->m_pDict, "V");
         if (pV)
           pFieldDict->SetFor("V", pV->CloneDirectObject());
       }
       pFields->Add(pFieldDict);
     }
   }
   return pDoc;
 }
 
 void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict,
                                      const CFX_WideString& parent_name,
-                                     FX_BOOL bNotify,
+                                     bool bNotify,
                                      int nLevel) {
   CFX_WideString name;
   if (!parent_name.IsEmpty())
     name = parent_name + L".";
 
   name += pFieldDict->GetUnicodeTextFor("T");
   CPDF_Array* pKids = pFieldDict->GetArrayFor("Kids");
   if (pKids) {
     for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDictAt(i);
@@ skipping 38 matching lines @@
     else if (iType == FIELDTYPE_LISTBOX)
       m_pFormNotify->AfterSelectionChange(pField);
     else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD)
       m_pFormNotify->AfterValueChange(pField);
   }
 }
 
 void CPDF_InterForm::SetFormNotify(IPDF_FormNotify* pNotify) {
   m_pFormNotify = pNotify;
 }