Remove FX_BOOL from xfa.

xfa/fde/css/fde_cssdeclaration.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/css/fde_cssdeclaration.h"
 
 #include "core/fxcrt/fx_ext.h"
 
 IFDE_CSSValue* CFDE_CSSDeclaration::GetProperty(FDE_CSSPROPERTY eProperty,
-                                                FX_BOOL& bImportant) const {
+                                                bool& bImportant) const {
   for (const FDE_CSSPropertyHolder* pHolder = m_pFirstProperty; pHolder;
        pHolder = pHolder->pNext) {
     if (pHolder->eProperty == eProperty) {
       bImportant = pHolder->bImportant;
       return pHolder->pValue;
     }
   }
   return nullptr;
 }
 FX_POSITION CFDE_CSSDeclaration::GetStartPosition() const {
   return (FX_POSITION)m_pFirstProperty;
 }
 void CFDE_CSSDeclaration::GetNextProperty(FX_POSITION& pos,
                                           FDE_CSSPROPERTY& eProperty,
                                           IFDE_CSSValue*& pValue,
-                                          FX_BOOL& bImportant) const {
+                                          bool& bImportant) const {
   const FDE_CSSPropertyHolder* pHolder = (const FDE_CSSPropertyHolder*)pos;
   bImportant = pHolder->bImportant;
   eProperty = (FDE_CSSPROPERTY)pHolder->eProperty;
   pValue = pHolder->pValue;
   pos = (FX_POSITION)pHolder->pNext;
 }
 FX_POSITION CFDE_CSSDeclaration::GetStartCustom() const {
   return (FX_POSITION)m_pFirstCustom;
 }
 void CFDE_CSSDeclaration::GetNextCustom(FX_POSITION& pos,
@@ skipping 40 matching lines @@
   return FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(eUnit, fValue);
 }
 inline IFDE_CSSPrimitiveValue* CFDE_CSSDeclaration::NewEnumValue(
     IFX_MemoryAllocator* pStaticStore,
     FDE_CSSPROPERTYVALUE eValue) const {
   return FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(eValue);
 }
 void CFDE_CSSDeclaration::AddPropertyHolder(IFX_MemoryAllocator* pStaticStore,
                                             FDE_CSSPROPERTY eProperty,
                                             IFDE_CSSValue* pValue,
-                                            FX_BOOL bImportant) {
+                                            bool bImportant) {
   FDE_CSSPropertyHolder* pHolder =
       FXTARGET_NewWith(pStaticStore) FDE_CSSPropertyHolder;
   pHolder->bImportant = bImportant;
   pHolder->eProperty = eProperty;
   pHolder->pValue = pValue;
   pHolder->pNext = nullptr;
   if (m_pLastProperty)
     m_pLastProperty->pNext = pHolder;
   else
     m_pFirstProperty = pHolder;
   m_pLastProperty = pHolder;
 }
-FX_BOOL CFDE_CSSDeclaration::AddProperty(const FDE_CSSPROPERTYARGS* pArgs,
-                                         const FX_WCHAR* pszValue,
-                                         int32_t iValueLen) {
+bool CFDE_CSSDeclaration::AddProperty(const FDE_CSSPROPERTYARGS* pArgs,
+                                      const FX_WCHAR* pszValue,
+                                      int32_t iValueLen) {
   ASSERT(iValueLen > 0);
-  FX_BOOL bImportant = FALSE;
+  bool bImportant = false;
   if (iValueLen >= 10 && pszValue[iValueLen - 10] == '!' &&
       FXSYS_wcsnicmp(L"important", pszValue + iValueLen - 9, 9) == 0) {
     if ((iValueLen -= 10) == 0) {
-      return FALSE;
+      return false;
     }
-    bImportant = TRUE;
+    bImportant = true;
   }
   const uint32_t dwType = pArgs->pProperty->dwType;
   switch (dwType & 0x0F) {
     case FDE_CSSVALUETYPE_Primitive: {
       static const uint32_t g_ValueGuessOrder[] = {
           FDE_CSSVALUETYPE_MaybeNumber,   FDE_CSSVALUETYPE_MaybeEnum,
           FDE_CSSVALUETYPE_MaybeColor,    FDE_CSSVALUETYPE_MaybeURI,
           FDE_CSSVALUETYPE_MaybeFunction, FDE_CSSVALUETYPE_MaybeString,
       };
       static const int32_t g_ValueGuessCount =
@@ skipping 22 matching lines @@
             break;
           case FDE_CSSVALUETYPE_MaybeString:
             pCSSValue = ParseString(pArgs, pszValue, iValueLen);
             break;
           default:
             break;
         }
         if (pCSSValue) {
           AddPropertyHolder(pArgs->pStaticStore, pArgs->pProperty->eName,
                             pCSSValue, bImportant);
-          return TRUE;
+          return true;
         }
         if (FDE_IsOnlyValue(dwType, g_ValueGuessOrder[i])) {
-          return FALSE;
+          return false;
         }
       }
     } break;
     case FDE_CSSVALUETYPE_Shorthand: {
       IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
       IFDE_CSSValue *pColor, *pStyle, *pWidth;
       switch (pArgs->pProperty->eName) {
         case FDE_CSSPROPERTY_Font:
           return ParseFontProperty(pArgs, pszValue, iValueLen, bImportant);
         case FDE_CSSPROPERTY_Background:
@@ skipping 13 matching lines @@
                               FDE_CSSPROPERTY_BorderTopStyle,
                               FDE_CSSPROPERTY_BorderTopWidth);
             AddBorderProperty(pStaticStore, pColor, pStyle, pWidth, bImportant,
                               FDE_CSSPROPERTY_BorderRightColor,
                               FDE_CSSPROPERTY_BorderRightStyle,
                               FDE_CSSPROPERTY_BorderRightWidth);
             AddBorderProperty(pStaticStore, pColor, pStyle, pWidth, bImportant,
                               FDE_CSSPROPERTY_BorderBottomColor,
                               FDE_CSSPROPERTY_BorderBottomStyle,
                               FDE_CSSPROPERTY_BorderBottomWidth);
-            return TRUE;
+            return true;
           }
           break;
         case FDE_CSSPROPERTY_BorderLeft:
           if (ParseBorderPropoerty(pStaticStore, pszValue, iValueLen, pColor,
                                    pStyle, pWidth)) {
             AddBorderProperty(pStaticStore, pColor, pStyle, pWidth, bImportant,
                               FDE_CSSPROPERTY_BorderLeftColor,
                               FDE_CSSPROPERTY_BorderLeftStyle,
                               FDE_CSSPROPERTY_BorderLeftWidth);
-            return TRUE;
+            return true;
           }
           break;
         case FDE_CSSPROPERTY_BorderTop:
           if (ParseBorderPropoerty(pStaticStore, pszValue, iValueLen, pColor,
                                    pStyle, pWidth)) {
             AddBorderProperty(pStaticStore, pColor, pStyle, pWidth, bImportant,
                               FDE_CSSPROPERTY_BorderTopColor,
                               FDE_CSSPROPERTY_BorderTopStyle,
                               FDE_CSSPROPERTY_BorderTopWidth);
-            return TRUE;
+            return true;
           }
           break;
         case FDE_CSSPROPERTY_BorderRight:
           if (ParseBorderPropoerty(pStaticStore, pszValue, iValueLen, pColor,
                                    pStyle, pWidth)) {
             AddBorderProperty(pStaticStore, pColor, pStyle, pWidth, bImportant,
                               FDE_CSSPROPERTY_BorderRightColor,
                               FDE_CSSPROPERTY_BorderRightStyle,
                               FDE_CSSPROPERTY_BorderRightWidth);
-            return TRUE;
+            return true;
           }
           break;
         case FDE_CSSPROPERTY_BorderBottom:
           if (ParseBorderPropoerty(pStaticStore, pszValue, iValueLen, pColor,
                                    pStyle, pWidth)) {
             AddBorderProperty(pStaticStore, pColor, pStyle, pWidth, bImportant,
                               FDE_CSSPROPERTY_BorderBottomColor,
                               FDE_CSSPROPERTY_BorderBottomStyle,
                               FDE_CSSPROPERTY_BorderBottomWidth);
-            return TRUE;
+            return true;
           }
           break;
         case FDE_CSSPROPERTY_Overflow:
           return ParseOverflowProperty(pArgs, pszValue, iValueLen, bImportant);
         case FDE_CSSPROPERTY_ColumnRule:
           return ParseColumnRuleProperty(pArgs, pszValue, iValueLen,
                                          bImportant);
         default:
           break;
       }
     } break;
     case FDE_CSSVALUETYPE_List:
       switch (pArgs->pProperty->eName) {
         case FDE_CSSPROPERTY_CounterIncrement:
         case FDE_CSSPROPERTY_CounterReset:
           return ParseCounterProperty(pArgs, pszValue, iValueLen, bImportant);
         case FDE_CSSPROPERTY_Content:
           return ParseContentProperty(pArgs, pszValue, iValueLen, bImportant);
         default:
           return ParseValueListProperty(pArgs, pszValue, iValueLen, bImportant);
       }
     default:
-      ASSERT(FALSE);
+      ASSERT(false);
       break;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CFDE_CSSDeclaration::AddProperty(const FDE_CSSPROPERTYARGS* pArgs,
-                                         const FX_WCHAR* pszName,
-                                         int32_t iNameLen,
-                                         const FX_WCHAR* pszValue,
-                                         int32_t iValueLen) {
+bool CFDE_CSSDeclaration::AddProperty(const FDE_CSSPROPERTYARGS* pArgs,
+                                      const FX_WCHAR* pszName,
+                                      int32_t iNameLen,
+                                      const FX_WCHAR* pszValue,
+                                      int32_t iValueLen) {
   FDE_CSSCustomProperty* pProperty =
       FXTARGET_NewWith(pArgs->pStaticStore) FDE_CSSCustomProperty;
   pProperty->pwsName = CopyToLocal(pArgs, pszName, iNameLen);
   pProperty->pwsValue = CopyToLocal(pArgs, pszValue, iValueLen);
   pProperty->pNext = nullptr;
   if (m_pLastCustom)
     m_pLastCustom->pNext = pProperty;
   else
     m_pFirstCustom = pProperty;
   m_pLastCustom = pProperty;
-  return TRUE;
+  return true;
 }
 IFDE_CSSValue* CFDE_CSSDeclaration::ParseNumber(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen) {
   FX_FLOAT fValue;
   FDE_CSSPRIMITIVETYPE eUnit;
   if (!FDE_ParseCSSNumber(pszValue, iValueLen, fValue, eUnit)) {
     return nullptr;
   }
@@ skipping 108 matching lines @@
         break;
     }
   }
   IFDE_CSSValueList* pArgumentList = FXTARGET_NewWith(pArgs->pStaticStore)
       CFDE_CSSValueList(pArgs->pStaticStore, argumentArr);
   CFDE_CSSFunction* pFunction = FXTARGET_NewWith(pArgs->pStaticStore)
       CFDE_CSSFunction(pszFuncName, pArgumentList);
   return FXTARGET_NewWith(pArgs->pStaticStore)
       CFDE_CSSPrimitiveValue(pFunction);
 }
-FX_BOOL CFDE_CSSDeclaration::ParseContentProperty(
-    const FDE_CSSPROPERTYARGS* pArgs,
-    const FX_WCHAR* pszValue,
-    int32_t iValueLen,
-    FX_BOOL bImportant) {
+bool CFDE_CSSDeclaration::ParseContentProperty(const FDE_CSSPROPERTYARGS* pArgs,
+                                               const FX_WCHAR* pszValue,
+                                               int32_t iValueLen,
+                                               bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   FDE_CSSPRIMITIVETYPE eType;
   CFDE_CSSValueArray list;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_URI:
         list.Add(FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
             eType, CopyToLocal(pArgs, pszValue, iValueLen)));
         break;
       case FDE_CSSPRIMITIVETYPE_Number:
-        return FALSE;
+        return false;
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
         if (pValue) {
           switch (pValue->eName) {
             case FDE_CSSPROPERTYVALUE_Normal:
             case FDE_CSSPROPERTYVALUE_None: {
               if (list.GetSize() == 0) {
                 list.Add(NewEnumValue(pStaticStore, pValue->eName));
               } else {
-                return FALSE;
+                return false;
               }
             } break;
             case FDE_CSSPROPERTYVALUE_OpenQuote:
             case FDE_CSSPROPERTYVALUE_CloseQuote:
             case FDE_CSSPROPERTYVALUE_NoOpenQuote:
             case FDE_CSSPROPERTYVALUE_NoCloseQuote:
               list.Add(NewEnumValue(pStaticStore, pValue->eName));
               break;
             default:
-              return FALSE;
+              return false;
           }
           continue;
         }
         IFDE_CSSValue* pFunction = ParseFunction(pArgs, pszValue, iValueLen);
         if (pFunction) {
           list.Add(pFunction);
           continue;
         }
         list.Add(FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
             eType, CopyToLocal(pArgs, pszValue, iValueLen)));
       } break;
       case FDE_CSSPRIMITIVETYPE_RGB:
-        return FALSE;
+        return false;
       default:
         break;
     }
   }
   if (list.GetSize() == 0) {
-    return FALSE;
+    return false;
   }
   AddPropertyHolder(pStaticStore, pArgs->pProperty->eName,
                     FXTARGET_NewWith(pStaticStore)
                         CFDE_CSSValueList(pStaticStore, list),
                     bImportant);
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseCounterProperty(
-    const FDE_CSSPROPERTYARGS* pArgs,
-    const FX_WCHAR* pszValue,
-    int32_t iValueLen,
-    FX_BOOL bImportant) {
+bool CFDE_CSSDeclaration::ParseCounterProperty(const FDE_CSSPROPERTYARGS* pArgs,
+                                               const FX_WCHAR* pszValue,
+                                               int32_t iValueLen,
+                                               bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   CFDE_CSSValueArray list;
   CFDE_CSSValueArray listFull;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_Number: {
         FX_FLOAT fValue;
         if (FDE_ParseCSSNumber(pszValue, iValueLen, fValue, eType)) {
           if (list.GetSize() == 1) {
             list.Add(NewNumberValue(pStaticStore, eType, fValue));
             listFull.Add(FXTARGET_NewWith(pStaticStore)
                              CFDE_CSSValueList(pStaticStore, list));
             list.RemoveAll();
           } else {
-            return FALSE;
+            return false;
           }
         }
       } break;
       case FDE_CSSPRIMITIVETYPE_String: {
         if (list.GetSize() == 0) {
           pszValue = CopyToLocal(pArgs, pszValue, iValueLen);
           list.Add(FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
               FDE_CSSPRIMITIVETYPE_String, pszValue));
         } else {
           listFull.Add(FXTARGET_NewWith(pStaticStore)
                            CFDE_CSSValueList(pStaticStore, list));
           list.RemoveAll();
           pszValue = CopyToLocal(pArgs, pszValue, iValueLen);
           list.Add(FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
               FDE_CSSPRIMITIVETYPE_String, pszValue));
         }
       } break;
       default:
         break;
     }
   }
   if (list.GetSize() == 1) {
     listFull.Add(FXTARGET_NewWith(pStaticStore)
                      CFDE_CSSValueList(pStaticStore, list));
   }
   if (listFull.GetSize() == 0) {
-    return FALSE;
+    return false;
   }
   AddPropertyHolder(pStaticStore, pArgs->pProperty->eName,
                     FXTARGET_NewWith(pStaticStore)
                         CFDE_CSSValueList(pStaticStore, listFull),
                     bImportant);
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseValueListProperty(
+bool CFDE_CSSDeclaration::ParseValueListProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
-    FX_BOOL bImportant) {
+    bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   FX_WCHAR separator =
       (pArgs->pProperty->eName == FDE_CSSPROPERTY_FontFamily) ? ',' : ' ';
   CFDE_CSSValueListParser parser(pszValue, iValueLen, separator);
   const uint32_t dwType = pArgs->pProperty->dwType;
   FDE_CSSPRIMITIVETYPE eType;
   CFDE_CSSValueArray list;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_Number:
@@ skipping 35 matching lines @@
             list.Add(FXTARGET_NewWith(pStaticStore)
                          CFDE_CSSPrimitiveValue(dwColor));
           }
         }
         break;
       default:
         break;
     }
   }
   if (list.GetSize() == 0) {
-    return FALSE;
+    return false;
   }
   switch (pArgs->pProperty->eName) {
     case FDE_CSSPROPERTY_BorderColor:
       return Add4ValuesProperty(
           pStaticStore, list, bImportant, FDE_CSSPROPERTY_BorderLeftColor,
           FDE_CSSPROPERTY_BorderTopColor, FDE_CSSPROPERTY_BorderRightColor,
           FDE_CSSPROPERTY_BorderBottomColor);
     case FDE_CSSPROPERTY_BorderStyle:
       return Add4ValuesProperty(
           pStaticStore, list, bImportant, FDE_CSSPROPERTY_BorderLeftStyle,
@@ skipping 12 matching lines @@
     case FDE_CSSPROPERTY_Padding:
       return Add4ValuesProperty(
           pStaticStore, list, bImportant, FDE_CSSPROPERTY_PaddingLeft,
           FDE_CSSPROPERTY_PaddingTop, FDE_CSSPROPERTY_PaddingRight,
           FDE_CSSPROPERTY_PaddingBottom);
     default: {
       CFDE_CSSValueList* pList =
           FXTARGET_NewWith(pStaticStore) CFDE_CSSValueList(pStaticStore, list);
       AddPropertyHolder(pStaticStore, pArgs->pProperty->eName, pList,
                         bImportant);
-      return TRUE;
+      return true;
     } break;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CFDE_CSSDeclaration::Add4ValuesProperty(
-    IFX_MemoryAllocator* pStaticStore,
-    const CFDE_CSSValueArray& list,
-    FX_BOOL bImportant,
-    FDE_CSSPROPERTY eLeft,
-    FDE_CSSPROPERTY eTop,
-    FDE_CSSPROPERTY eRight,
-    FDE_CSSPROPERTY eBottom) {
+bool CFDE_CSSDeclaration::Add4ValuesProperty(IFX_MemoryAllocator* pStaticStore,
+                                             const CFDE_CSSValueArray& list,
+                                             bool bImportant,
+                                             FDE_CSSPROPERTY eLeft,
+                                             FDE_CSSPROPERTY eTop,
+                                             FDE_CSSPROPERTY eRight,
+                                             FDE_CSSPROPERTY eBottom) {
   switch (list.GetSize()) {
     case 1:
       AddPropertyHolder(pStaticStore, eLeft, list[0], bImportant);
       AddPropertyHolder(pStaticStore, eTop, list[0], bImportant);
       AddPropertyHolder(pStaticStore, eRight, list[0], bImportant);
       AddPropertyHolder(pStaticStore, eBottom, list[0], bImportant);
-      return TRUE;
+      return true;
     case 2:
       AddPropertyHolder(pStaticStore, eLeft, list[1], bImportant);
       AddPropertyHolder(pStaticStore, eTop, list[0], bImportant);
       AddPropertyHolder(pStaticStore, eRight, list[1], bImportant);
       AddPropertyHolder(pStaticStore, eBottom, list[0], bImportant);
-      return TRUE;
+      return true;
     case 3:
       AddPropertyHolder(pStaticStore, eLeft, list[1], bImportant);
       AddPropertyHolder(pStaticStore, eTop, list[0], bImportant);
       AddPropertyHolder(pStaticStore, eRight, list[1], bImportant);
       AddPropertyHolder(pStaticStore, eBottom, list[2], bImportant);
-      return TRUE;
+      return true;
     case 4:
       AddPropertyHolder(pStaticStore, eLeft, list[3], bImportant);
       AddPropertyHolder(pStaticStore, eTop, list[0], bImportant);
       AddPropertyHolder(pStaticStore, eRight, list[1], bImportant);
       AddPropertyHolder(pStaticStore, eBottom, list[2], bImportant);
-      return TRUE;
+      return true;
     default:
       break;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseBorderPropoerty(
+bool CFDE_CSSDeclaration::ParseBorderPropoerty(
     IFX_MemoryAllocator* pStaticStore,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
     IFDE_CSSValue*& pColor,
     IFDE_CSSValue*& pStyle,
     IFDE_CSSValue*& pWidth) const {
   pColor = pStyle = pWidth = nullptr;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
@@ skipping 63 matching lines @@
       default:
         break;
     }
   }
   if (!pColor)
     pColor = FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue((FX_ARGB)0);
   if (!pStyle)
     pStyle = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
   if (!pWidth)
     pWidth = NewNumberValue(pStaticStore, FDE_CSSPRIMITIVETYPE_Number, 0.0f);
-  return TRUE;
+  return true;
 }
 void CFDE_CSSDeclaration::AddBorderProperty(IFX_MemoryAllocator* pStaticStore,
                                             IFDE_CSSValue* pColor,
                                             IFDE_CSSValue* pStyle,
                                             IFDE_CSSValue* pWidth,
-                                            FX_BOOL bImportant,
+                                            bool bImportant,
                                             FDE_CSSPROPERTY eColor,
                                             FDE_CSSPROPERTY eStyle,
                                             FDE_CSSPROPERTY eWidth) {
   AddPropertyHolder(pStaticStore, eStyle, pStyle, bImportant);
   AddPropertyHolder(pStaticStore, eWidth, pWidth, bImportant);
   AddPropertyHolder(pStaticStore, eColor, pColor, bImportant);
 }
-FX_BOOL CFDE_CSSDeclaration::ParseListStyleProperty(
+bool CFDE_CSSDeclaration::ParseListStyleProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
-    FX_BOOL bImportant) {
+    bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   IFDE_CSSPrimitiveValue* pType = nullptr;
   IFDE_CSSPrimitiveValue* pImage = nullptr;
   IFDE_CSSPrimitiveValue* pPosition = nullptr;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_URI:
         if (!pImage) {
@@ skipping 49 matching lines @@
   if (!pImage)
     pImage = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
   if (!pType)
     pType = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ListStylePosition, pPosition,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ListStyleImage, pImage,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ListStyleType, pType,
                     bImportant);
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseBackgroundProperty(
+bool CFDE_CSSDeclaration::ParseBackgroundProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
-    FX_BOOL bImportant) {
+    bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   IFDE_CSSPrimitiveValue* pColor = nullptr;
   IFDE_CSSPrimitiveValue* pImage = nullptr;
   IFDE_CSSPrimitiveValue* pRepeat = nullptr;
   IFDE_CSSPrimitiveValue* pPosX = nullptr;
   IFDE_CSSPrimitiveValue* pPosY = nullptr;
   IFDE_CSSPrimitiveValue* pAttachment = nullptr;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
@@ skipping 110 matching lines @@
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_BackgroundColor, pColor,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_BackgroundImage, pImage,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_BackgroundRepeat, pRepeat,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_BackgroundPosition, pPosList,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_BackgroundAttachment,
                     pAttachment, bImportant);
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseFontProperty(const FDE_CSSPROPERTYARGS* pArgs,
-                                               const FX_WCHAR* pszValue,
-                                               int32_t iValueLen,
-                                               FX_BOOL bImportant) {
+bool CFDE_CSSDeclaration::ParseFontProperty(const FDE_CSSPROPERTYARGS* pArgs,
+                                            const FX_WCHAR* pszValue,
+                                            int32_t iValueLen,
+                                            bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, '/');
   IFDE_CSSPrimitiveValue* pStyle = nullptr;
   IFDE_CSSPrimitiveValue* pVariant = nullptr;
   IFDE_CSSPrimitiveValue* pWeight = nullptr;
   IFDE_CSSPrimitiveValue* pFontSize = nullptr;
   IFDE_CSSPrimitiveValue* pLineHeight = nullptr;
   CFDE_CSSValueArray familyList;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
@@ skipping 104 matching lines @@
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_FontSize, pFontSize,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_LineHeight, pLineHeight,
                     bImportant);
   if (familyList.GetSize() > 0) {
     CFDE_CSSValueList* pList = FXTARGET_NewWith(pStaticStore)
         CFDE_CSSValueList(pStaticStore, familyList);
     AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_FontFamily, pList,
                       bImportant);
   }
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseColumnRuleProperty(
+bool CFDE_CSSDeclaration::ParseColumnRuleProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
-    FX_BOOL bImportant) {
+    bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   IFDE_CSSPrimitiveValue* pColumnRuleWidth = nullptr;
   IFDE_CSSPrimitiveValue* pColumnRuleStyle = nullptr;
   IFDE_CSSPrimitiveValue* pColumnRuleColor = nullptr;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pValue =
@@ skipping 49 matching lines @@
             FDE_ParseCSSColor(pszValue, iValueLen, dwColor)) {
           pColumnRuleColor = FXTARGET_NewWith(pStaticStore)
               CFDE_CSSPrimitiveValue((FX_ARGB)dwColor);
         }
       } break;
       default:
         break;
     }
   }
   if (!pColumnRuleColor && !pColumnRuleStyle && !pColumnRuleWidth)
-    return FALSE;
+    return false;
 
   if (!pColumnRuleStyle)
     pColumnRuleStyle = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
   if (!pColumnRuleWidth)
     pColumnRuleWidth = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Medium);
   if (!pColumnRuleColor) {
     pColumnRuleColor =
         FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue((FX_ARGB)0);
   }
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ColumnRuleStyle,
                     pColumnRuleStyle, bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ColumnRuleWidth,
                     pColumnRuleWidth, bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ColumnRuleColor,
                     pColumnRuleColor, bImportant);
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseTextEmphasisProperty(
-    FDE_CSSPROPERTYARGS* pArgs,
-    const FX_WCHAR* pszValue,
-    int32_t iValueLen,
-    FX_BOOL bImportant) {
+bool CFDE_CSSDeclaration::ParseTextEmphasisProperty(FDE_CSSPROPERTYARGS* pArgs,
+                                                    const FX_WCHAR* pszValue,
+                                                    int32_t iValueLen,
+                                                    bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   CFDE_CSSValueArray arrEmphasisStyle;
   FDE_CSSPRIMITIVETYPE eType;
   IFDE_CSSPrimitiveValue* pEmphasisColor = nullptr;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
@@ skipping 26 matching lines @@
   if (arrEmphasisStyle.GetSize() != 0) {
     AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_TextEmphasisStyle,
                       FXTARGET_NewWith(pStaticStore)
                           CFDE_CSSValueList(pStaticStore, arrEmphasisStyle),
                       bImportant);
   }
   if (pEmphasisColor) {
     AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_TextEmphasisColor,
                       pEmphasisColor, bImportant);
   }
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseColumnsProperty(
-    const FDE_CSSPROPERTYARGS* pArgs,
-    const FX_WCHAR* pszValue,
-    int32_t iValueLen,
-    FX_BOOL bImportant) {
+bool CFDE_CSSDeclaration::ParseColumnsProperty(const FDE_CSSPROPERTYARGS* pArgs,
+                                               const FX_WCHAR* pszValue,
+                                               int32_t iValueLen,
+                                               bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   IFDE_CSSPrimitiveValue* pColumnWidth = nullptr;
   IFDE_CSSPrimitiveValue* pColumnCount = nullptr;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
@@ skipping 14 matching lines @@
                 pColumnWidth = NewNumberValue(pStaticStore, eType, fValue);
               break;
           }
         }
       } break;
       default:
         break;
     }
   }
   if (!pColumnWidth && !pColumnCount)
-    return FALSE;
+    return false;
 
   if (!pColumnWidth)
     pColumnWidth = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Auto);
   else if (!pColumnCount)
     pColumnCount = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Auto);
 
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ColumnWidth, pColumnWidth,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_ColumnCount, pColumnCount,
                     bImportant);
-  return TRUE;
+  return true;
 }
-FX_BOOL CFDE_CSSDeclaration::ParseOverflowProperty(
+bool CFDE_CSSDeclaration::ParseOverflowProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
-    FX_BOOL bImportant) {
+    bool bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   IFDE_CSSPrimitiveValue* pOverflowX = nullptr;
   IFDE_CSSPrimitiveValue* pOverflowY = nullptr;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     if (eType == FDE_CSSPRIMITIVETYPE_String) {
       const FDE_CSSPROPERTYVALUETABLE* pValue =
           FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
       if (pValue) {
         switch (pValue->eName) {
           case FDE_CSSOVERFLOW_Visible:
           case FDE_CSSOVERFLOW_Hidden:
           case FDE_CSSOVERFLOW_Scroll:
           case FDE_CSSOVERFLOW_Auto:
           case FDE_CSSOVERFLOW_NoDisplay:
           case FDE_CSSOVERFLOW_NoContent:
             if (pOverflowX && pOverflowY)
-              return FALSE;
+              return false;
             if (!pOverflowX) {
               pOverflowX = NewEnumValue(pStaticStore, pValue->eName);
             } else if (!pOverflowY) {
               pOverflowY = NewEnumValue(pStaticStore, pValue->eName);
             }
             break;
           default:
             break;
         }
       }
     }
   }
   if (!pOverflowX && !pOverflowY)
-    return FALSE;
+    return false;
 
   if (!pOverflowY)
     pOverflowY = NewEnumValue(pStaticStore, pOverflowX->GetEnum());
 
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_OverflowX, pOverflowX,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_OverflowY, pOverflowY,
                     bImportant);
-  return TRUE;
+  return true;
 }