Get rid of NULLs in 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/include/fx_ext.h"
 #include "xfa/fgas/crt/fgas_system.h"
 
 IFDE_CSSValue* CFDE_CSSDeclaration::GetProperty(FDE_CSSPROPERTY eProperty,
                                                 FX_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 NULL;
+  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 {
   const FDE_CSSPropertyHolder* pHolder = (const FDE_CSSPropertyHolder*)pos;
-  ASSERT(pHolder != NULL);
   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,
                                         CFX_WideString& wsName,
                                         CFX_WideString& wsValue) const {
   const FDE_CSSCustomProperty* pProperty = (const FDE_CSSCustomProperty*)pos;
-  if (pProperty == NULL) {
+  if (!pProperty)
     return;
-  }
+
   wsName = pProperty->pwsName;
   wsValue = pProperty->pwsValue;
   pos = (FX_POSITION)pProperty->pNext;
 }
 const FX_WCHAR* CFDE_CSSDeclaration::CopyToLocal(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen) {
   ASSERT(iValueLen > 0);
   std::unordered_map<uint32_t, FX_WCHAR*>* pCache = pArgs->pStringCache;
@@ skipping 30 matching lines @@
 }
 void CFDE_CSSDeclaration::AddPropertyHolder(IFX_MemoryAllocator* pStaticStore,
                                             FDE_CSSPROPERTY eProperty,
                                             IFDE_CSSValue* pValue,
                                             FX_BOOL bImportant) {
   FDE_CSSPropertyHolder* pHolder =
       FXTARGET_NewWith(pStaticStore) FDE_CSSPropertyHolder;
   pHolder->bImportant = bImportant;
   pHolder->eProperty = eProperty;
   pHolder->pValue = pValue;
-  pHolder->pNext = NULL;
-  if (m_pLastProperty == NULL) {
-    m_pLastProperty = m_pFirstProperty = pHolder;
-  } else {
+  pHolder->pNext = nullptr;
+  if (m_pLastProperty)
     m_pLastProperty->pNext = pHolder;
-    m_pLastProperty = pHolder;
-  }
+  else
+    m_pFirstProperty = pHolder;
+  m_pLastProperty = pHolder;
 }
 FX_BOOL CFDE_CSSDeclaration::AddProperty(const FDE_CSSPROPERTYARGS* pArgs,
                                          const FX_WCHAR* pszValue,
                                          int32_t iValueLen) {
   ASSERT(iValueLen > 0);
   FX_BOOL bImportant = FALSE;
   if (iValueLen >= 10 && pszValue[iValueLen - 10] == '!' &&
       FX_wcsnicmp(L"important", pszValue + iValueLen - 9, 9) == 0) {
     if ((iValueLen -= 10) == 0) {
       return FALSE;
     }
     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 =
           sizeof(g_ValueGuessOrder) / sizeof(uint32_t);
       for (int32_t i = 0; i < g_ValueGuessCount; ++i) {
         const uint32_t dwMatch = dwType & g_ValueGuessOrder[i];
         if (dwMatch == 0) {
           continue;
         }
-        IFDE_CSSValue* pCSSValue = NULL;
+        IFDE_CSSValue* pCSSValue = nullptr;
         switch (dwMatch) {
           case FDE_CSSVALUETYPE_MaybeFunction:
             pCSSValue = ParseFunction(pArgs, pszValue, iValueLen);
             break;
           case FDE_CSSVALUETYPE_MaybeNumber:
             pCSSValue = ParseNumber(pArgs, pszValue, iValueLen);
             break;
           case FDE_CSSVALUETYPE_MaybeEnum:
             pCSSValue = ParseEnum(pArgs, pszValue, iValueLen);
             break;
           case FDE_CSSVALUETYPE_MaybeColor:
             pCSSValue = ParseColor(pArgs, pszValue, iValueLen);
             break;
           case FDE_CSSVALUETYPE_MaybeURI:
             pCSSValue = ParseURI(pArgs, pszValue, iValueLen);
             break;
           case FDE_CSSVALUETYPE_MaybeString:
             pCSSValue = ParseString(pArgs, pszValue, iValueLen);
             break;
           default:
             break;
         }
-        if (pCSSValue != NULL) {
+        if (pCSSValue) {
           AddPropertyHolder(pArgs->pStaticStore, pArgs->pProperty->eName,
                             pCSSValue, bImportant);
           return TRUE;
         }
         if (FDE_IsOnlyValue(dwType, g_ValueGuessOrder[i])) {
           return FALSE;
         }
       }
     } break;
     case FDE_CSSVALUETYPE_Shorthand: {
@@ skipping 96 matching lines @@
 }
 FX_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 = NULL;
-  if (m_pLastCustom == NULL) {
-    m_pLastCustom = m_pFirstCustom = pProperty;
-  } else {
+  pProperty->pNext = nullptr;
+  if (m_pLastCustom)
     m_pLastCustom->pNext = pProperty;
-    m_pLastCustom = pProperty;
-  }
+  else
+    m_pFirstCustom = pProperty;
+  m_pLastCustom = pProperty;
   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 NULL;
+    return nullptr;
   }
   return NewNumberValue(pArgs->pStaticStore, eUnit, fValue);
 }
 IFDE_CSSValue* CFDE_CSSDeclaration::ParseEnum(const FDE_CSSPROPERTYARGS* pArgs,
                                               const FX_WCHAR* pszValue,
                                               int32_t iValueLen) {
   const FDE_CSSPROPERTYVALUETABLE* pValue =
       FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
-  return pValue ? NewEnumValue(pArgs->pStaticStore, pValue->eName) : NULL;
+  return pValue ? NewEnumValue(pArgs->pStaticStore, pValue->eName) : nullptr;
 }
 IFDE_CSSValue* CFDE_CSSDeclaration::ParseColor(const FDE_CSSPROPERTYARGS* pArgs,
                                                const FX_WCHAR* pszValue,
                                                int32_t iValueLen) {
   FX_ARGB dwColor;
   if (!FDE_ParseCSSColor(pszValue, iValueLen, dwColor)) {
-    return NULL;
+    return nullptr;
   }
   return FXTARGET_NewWith(pArgs->pStaticStore) CFDE_CSSPrimitiveValue(dwColor);
 }
 IFDE_CSSValue* CFDE_CSSDeclaration::ParseURI(const FDE_CSSPROPERTYARGS* pArgs,
                                              const FX_WCHAR* pszValue,
                                              int32_t iValueLen) {
   int32_t iOffset;
   if (!FDE_ParseCSSURI(pszValue, iValueLen, iOffset, iValueLen)) {
-    return NULL;
+    return nullptr;
   }
   if (iValueLen <= 0) {
-    return NULL;
+    return nullptr;
   }
   pszValue = CopyToLocal(pArgs, pszValue + iOffset, iValueLen);
   return pszValue
              ? FXTARGET_NewWith(pArgs->pStaticStore)
                    CFDE_CSSPrimitiveValue(FDE_CSSPRIMITIVETYPE_URI, pszValue)
-             : NULL;
+             : nullptr;
 }
 IFDE_CSSValue* CFDE_CSSDeclaration::ParseString(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen) {
   int32_t iOffset;
   if (!FDE_ParseCSSString(pszValue, iValueLen, iOffset, iValueLen)) {
-    return NULL;
+    return nullptr;
   }
   if (iValueLen <= 0) {
-    return NULL;
+    return nullptr;
   }
   pszValue = CopyToLocal(pArgs, pszValue + iOffset, iValueLen);
   return pszValue
              ? FXTARGET_NewWith(pArgs->pStaticStore)
                    CFDE_CSSPrimitiveValue(FDE_CSSPRIMITIVETYPE_String, pszValue)
-             : NULL;
+             : nullptr;
 }
 IFDE_CSSValue* CFDE_CSSDeclaration::ParseFunction(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen) {
   if (pszValue[iValueLen - 1] != ')') {
-    return NULL;
+    return nullptr;
   }
   int32_t iStartBracket = 0;
   while (pszValue[iStartBracket] != '(') {
     if (iStartBracket < iValueLen) {
       iStartBracket++;
     } else {
-      return NULL;
+      return nullptr;
     }
   }
   if (iStartBracket == 0) {
-    return NULL;
+    return nullptr;
   }
   const FX_WCHAR* pszFuncName = CopyToLocal(pArgs, pszValue, iStartBracket);
   pszValue += (iStartBracket + 1);
   iValueLen -= (iStartBracket + 2);
   CFDE_CSSValueArray argumentArr;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ',');
   FDE_CSSPRIMITIVETYPE ePrimitiveType;
   while (parser.NextValue(ePrimitiveType, pszValue, iValueLen)) {
     switch (ePrimitiveType) {
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pPropertyValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pPropertyValue != NULL) {
+        if (pPropertyValue) {
           argumentArr.Add(
               NewEnumValue(pArgs->pStaticStore, pPropertyValue->eName));
           continue;
         }
         IFDE_CSSValue* pFunctionValue =
             ParseFunction(pArgs, pszValue, iValueLen);
-        if (pFunctionValue != NULL) {
+        if (pFunctionValue) {
           argumentArr.Add(pFunctionValue);
           continue;
         }
         argumentArr.Add(FXTARGET_NewWith(pArgs->pStaticStore)
                             CFDE_CSSPrimitiveValue(
                                 FDE_CSSPRIMITIVETYPE_String,
                                 CopyToLocal(pArgs, pszValue, iValueLen)));
       } break;
       case FDE_CSSPRIMITIVETYPE_Number: {
         FX_FLOAT fValue;
@@ skipping 30 matching lines @@
     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;
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pValue != NULL) {
+        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;
               }
             } 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;
           }
           continue;
         }
         IFDE_CSSValue* pFunction = ParseFunction(pArgs, pszValue, iValueLen);
-        if (pFunction != NULL) {
+        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;
       default:
         break;
@@ skipping 92 matching lines @@
           if (FDE_ParseCSSColor(pszValue, iValueLen, dwColor)) {
             list.Add(FXTARGET_NewWith(pStaticStore)
                          CFDE_CSSPrimitiveValue(dwColor));
             continue;
           }
         }
         if (dwType & FDE_CSSVALUETYPE_MaybeEnum) {
           const FDE_CSSPROPERTYVALUETABLE* pValue =
               FDE_GetCSSPropertyValueByName(
                   CFX_WideStringC(pszValue, iValueLen));
-          if (pValue != NULL) {
+          if (pValue) {
             list.Add(NewEnumValue(pStaticStore, pValue->eName));
             continue;
           }
         }
         if (dwType & FDE_CSSVALUETYPE_MaybeString) {
           pszValue = CopyToLocal(pArgs, pszValue, iValueLen);
           list.Add(FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
               FDE_CSSPRIMITIVETYPE_String, pszValue));
         }
         break;
@@ skipping 87 matching lines @@
   }
   return FALSE;
 }
 FX_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 = NULL;
+  pColor = pStyle = pWidth = nullptr;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_Number:
-        if (pWidth == NULL) {
+        if (!pWidth) {
           FX_FLOAT fValue;
           if (FDE_ParseCSSNumber(pszValue, iValueLen, fValue, eType)) {
             pWidth = NewNumberValue(pStaticStore, eType, fValue);
           }
         }
         break;
       case FDE_CSSPRIMITIVETYPE_RGB:
-        if (pColor == NULL) {
+        if (!pColor) {
           FX_ARGB dwColor;
           if (FDE_ParseCSSColor(pszValue, iValueLen, dwColor)) {
             pColor =
                 FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(dwColor);
           }
         }
         break;
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSCOLORTABLE* pColorItem =
             FDE_GetCSSColorByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pColorItem != NULL) {
-          if (pColor == NULL) {
+        if (pColorItem) {
+          if (!pColor) {
             pColor = FXTARGET_NewWith(pStaticStore)
                 CFDE_CSSPrimitiveValue(pColorItem->dwValue);
           }
           continue;
         }
         const FDE_CSSPROPERTYVALUETABLE* pValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pValue == NULL) {
+        if (!pValue)
           continue;
-        }
+
         switch (pValue->eName) {
           case FDE_CSSPROPERTYVALUE_Transparent:
-            if (pColor == NULL) {
+            if (!pColor) {
               pColor = FXTARGET_NewWith(pStaticStore)
                   CFDE_CSSPrimitiveValue((FX_ARGB)0);
             }
             break;
           case FDE_CSSPROPERTYVALUE_Thin:
           case FDE_CSSPROPERTYVALUE_Thick:
           case FDE_CSSPROPERTYVALUE_Medium:
-            if (pWidth == NULL) {
+            if (!pWidth)
               pWidth = NewEnumValue(pStaticStore, pValue->eName);
-            }
             break;
           case FDE_CSSPROPERTYVALUE_None:
           case FDE_CSSPROPERTYVALUE_Hidden:
           case FDE_CSSPROPERTYVALUE_Dotted:
           case FDE_CSSPROPERTYVALUE_Dashed:
           case FDE_CSSPROPERTYVALUE_Solid:
           case FDE_CSSPROPERTYVALUE_Double:
           case FDE_CSSPROPERTYVALUE_Groove:
           case FDE_CSSPROPERTYVALUE_Ridge:
           case FDE_CSSPROPERTYVALUE_Inset:
           case FDE_CSSPROPERTYVALUE_Outset:
-            if (pStyle == NULL) {
+            if (!pStyle)
               pStyle = NewEnumValue(pStaticStore, pValue->eName);
-            }
             break;
           default:
             break;
         }
       }; break;
       default:
         break;
     }
   }
-  if (pColor == NULL) {
+  if (!pColor)
     pColor = FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue((FX_ARGB)0);
-  }
-  if (pStyle == NULL) {
+  if (!pStyle)
     pStyle = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
-  }
-  if (pWidth == NULL) {
+  if (!pWidth)
     pWidth = NewNumberValue(pStaticStore, FDE_CSSPRIMITIVETYPE_Number, 0.0f);
-  }
   return TRUE;
 }
 void CFDE_CSSDeclaration::AddBorderProperty(IFX_MemoryAllocator* pStaticStore,
                                             IFDE_CSSValue* pColor,
                                             IFDE_CSSValue* pStyle,
                                             IFDE_CSSValue* pWidth,
                                             FX_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(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
     FX_BOOL bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
-  IFDE_CSSPrimitiveValue *pType = NULL, *pImage = NULL, *pPosition = NULL;
+  IFDE_CSSPrimitiveValue *pType = nullptr, *pImage = nullptr,
+                         *pPosition = nullptr;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_URI:
-        if (pImage == NULL) {
+        if (!pImage) {
           pImage = FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
               eType, CopyToLocal(pArgs, pszValue, iValueLen));
         }
         break;
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pValue == NULL) {
+        if (!pValue)
           break;
-        }
+
         switch (pValue->eName) {
           case FDE_CSSPROPERTYVALUE_None:
-            if (pImage == NULL) {
+            if (!pImage)
               pImage = NewEnumValue(pStaticStore, pValue->eName);
-            } else if (pType == NULL) {
+            else if (!pType)
               pImage = NewEnumValue(pStaticStore, pValue->eName);
-            }
             break;
           case FDE_CSSPROPERTYVALUE_Inside:
           case FDE_CSSPROPERTYVALUE_Outside:
-            if (pPosition == NULL) {
+            if (!pPosition)
               pPosition = NewEnumValue(pStaticStore, pValue->eName);
-            }
             break;
           case FDE_CSSPROPERTYVALUE_Disc:
           case FDE_CSSPROPERTYVALUE_Circle:
           case FDE_CSSPROPERTYVALUE_Square:
           case FDE_CSSPROPERTYVALUE_Decimal:
           case FDE_CSSPROPERTYVALUE_DecimalLeadingZero:
           case FDE_CSSPROPERTYVALUE_LowerRoman:
           case FDE_CSSPROPERTYVALUE_UpperRoman:
           case FDE_CSSPROPERTYVALUE_LowerGreek:
           case FDE_CSSPROPERTYVALUE_LowerLatin:
           case FDE_CSSPROPERTYVALUE_UpperLatin:
           case FDE_CSSPROPERTYVALUE_Armenian:
           case FDE_CSSPROPERTYVALUE_Georgian:
           case FDE_CSSPROPERTYVALUE_LowerAlpha:
           case FDE_CSSPROPERTYVALUE_UpperAlpha:
-            if (pType == NULL) {
+            if (!pType)
               pType = NewEnumValue(pStaticStore, pValue->eName);
-            }
             break;
           default:
             break;
         }
       }; break;
       default:
         break;
     }
   }
-  if (pPosition == NULL) {
+  if (!pPosition)
     pPosition = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Outside);
-  }
-  if (pImage == NULL) {
+  if (!pImage)
     pImage = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
-  }
-  if (pType == NULL) {
+  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;
 }
 FX_BOOL CFDE_CSSDeclaration::ParseBackgroundProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
     FX_BOOL bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
-  IFDE_CSSPrimitiveValue *pColor = NULL, *pImage = NULL, *pRepeat = NULL;
-  IFDE_CSSPrimitiveValue *pPosX = NULL, *pPosY = NULL, *pAttachment = NULL;
+  IFDE_CSSPrimitiveValue *pColor = nullptr, *pImage = nullptr,
+                         *pRepeat = nullptr;
+  IFDE_CSSPrimitiveValue *pPosX = nullptr, *pPosY = nullptr,
+                         *pAttachment = nullptr;
   FDE_CSSPRIMITIVETYPE eType;
   while (parser.NextValue(eType, pszValue, iValueLen)) {
     switch (eType) {
       case FDE_CSSPRIMITIVETYPE_URI:
-        if (pImage == NULL) {
+        if (!pImage) {
           pImage = FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
               eType, CopyToLocal(pArgs, pszValue, iValueLen));
         }
         break;
       case FDE_CSSPRIMITIVETYPE_Number: {
         FX_FLOAT fValue;
         if (!FDE_ParseCSSNumber(pszValue, iValueLen, fValue, eType)) {
           break;
         }
-        if (pPosX == NULL) {
+        if (!pPosX)
           pPosX = NewNumberValue(pStaticStore, eType, fValue);
-        } else if (pPosY == NULL) {
+        else if (!pPosY)
           pPosY = NewNumberValue(pStaticStore, eType, fValue);
-        }
       } break;
       case FDE_CSSPRIMITIVETYPE_String: {
         const FDE_CSSPROPERTYVALUETABLE* pValue =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pValue != NULL) {
+        if (pValue) {
           switch (pValue->eName) {
             case FDE_CSSPROPERTYVALUE_None:
-              if (pImage == NULL) {
+              if (!pImage)
                 pImage = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             case FDE_CSSPROPERTYVALUE_Transparent:
-              if (pColor == NULL) {
+              if (!pColor) {
                 pColor = FXTARGET_NewWith(pStaticStore)
                     CFDE_CSSPrimitiveValue((FX_ARGB)0);
               }
               break;
             case FDE_CSSPROPERTYVALUE_Fixed:
             case FDE_CSSPROPERTYVALUE_Scroll:
-              if (pAttachment == NULL) {
+              if (!pAttachment)
                 pAttachment = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             case FDE_CSSPROPERTYVALUE_Repeat:
             case FDE_CSSPROPERTYVALUE_RepeatX:
             case FDE_CSSPROPERTYVALUE_RepeatY:
             case FDE_CSSPROPERTYVALUE_NoRepeat:
-              if (pRepeat == NULL) {
+              if (!pRepeat)
                 pRepeat = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             case FDE_CSSPROPERTYVALUE_Left:
             case FDE_CSSPROPERTYVALUE_Right:
-              if (pPosX == NULL) {
+              if (!pPosX)
                 pPosX = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             case FDE_CSSPROPERTYVALUE_Top:
             case FDE_CSSPROPERTYVALUE_Bottom:
-              if (pPosY == NULL) {
+              if (!pPosY)
                 pPosX = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             case FDE_CSSPROPERTYVALUE_Center:
-              if (pPosX == NULL) {
+              if (!pPosX)
                 pPosX = NewEnumValue(pStaticStore, pValue->eName);
-              } else if (pPosY == NULL) {
+              else if (!pPosY)
                 pPosX = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             default:
               break;
           }
           break;
         }
         const FDE_CSSCOLORTABLE* pColorItem =
             FDE_GetCSSColorByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pColorItem != NULL) {
-          if (pColor == NULL) {
+        if (pColorItem) {
+          if (!pColor) {
             pColor = FXTARGET_NewWith(pStaticStore)
                 CFDE_CSSPrimitiveValue(pColorItem->dwValue);
           }
         }
       } break;
       case FDE_CSSPRIMITIVETYPE_RGB:
-        if (pColor == NULL) {
+        if (!pColor) {
           FX_ARGB dwColor;
           if (FDE_ParseCSSColor(pszValue, iValueLen, dwColor)) {
             pColor =
                 FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(dwColor);
           }
         }
         break;
       default:
         break;
     }
   }
-  if (pColor == NULL) {
+  if (!pColor) {
     pColor = FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue((FX_ARGB)0);
   }
-  if (pImage == NULL) {
+  if (!pImage)
     pImage = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
-  }
-  if (pRepeat == NULL) {
+
+  if (!pRepeat)
     pRepeat = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Repeat);
-  }
-  if (pAttachment == NULL) {
+
+  if (!pAttachment)
     pAttachment = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Scroll);
-  }
-  if (pPosX == NULL) {
+
+  if (!pPosX) {
     pPosX = NewNumberValue(pStaticStore, FDE_CSSPRIMITIVETYPE_Number, 0.0f);
     pPosY = NewNumberValue(pStaticStore, FDE_CSSPRIMITIVETYPE_Number, 0.0f);
-  } else if (pPosY == NULL) {
+  } else if (!pPosY) {
     pPosY = NewNumberValue(pStaticStore, FDE_CSSPRIMITIVETYPE_Number, 0.0f);
   }
   CFDE_CSSValueArray position;
   position.Add(pPosX);
   position.Add(pPosY);
   CFDE_CSSValueList* pPosList =
       FXTARGET_NewWith(pStaticStore) CFDE_CSSValueList(pStaticStore, position);
   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;
 }
 FX_BOOL CFDE_CSSDeclaration::ParseFontProperty(const FDE_CSSPROPERTYARGS* pArgs,
                                                const FX_WCHAR* pszValue,
                                                int32_t iValueLen,
                                                FX_BOOL bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, '/');
-  IFDE_CSSPrimitiveValue *pStyle = NULL, *pVariant = NULL, *pWeight = NULL;
-  IFDE_CSSPrimitiveValue *pFontSize = NULL, *pLineHeight = NULL;
+  IFDE_CSSPrimitiveValue *pStyle = nullptr, *pVariant = nullptr,
+                         *pWeight = nullptr;
+  IFDE_CSSPrimitiveValue *pFontSize = nullptr, *pLineHeight = nullptr;
   CFDE_CSSValueArray familyList;
   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));
-        if (pValue != NULL) {
+        if (pValue) {
           switch (pValue->eName) {
             case FDE_CSSPROPERTYVALUE_XxSmall:
             case FDE_CSSPROPERTYVALUE_XSmall:
             case FDE_CSSPROPERTYVALUE_Small:
             case FDE_CSSPROPERTYVALUE_Medium:
             case FDE_CSSPROPERTYVALUE_Large:
             case FDE_CSSPROPERTYVALUE_XLarge:
             case FDE_CSSPROPERTYVALUE_XxLarge:
             case FDE_CSSPROPERTYVALUE_Smaller:
             case FDE_CSSPROPERTYVALUE_Larger:
-              if (pFontSize == NULL) {
+              if (!pFontSize)
                 pFontSize = NewEnumValue(pStaticStore, pValue->eName);
-              }
               continue;
             case FDE_CSSPROPERTYVALUE_Bold:
             case FDE_CSSPROPERTYVALUE_Bolder:
             case FDE_CSSPROPERTYVALUE_Lighter:
-              if (pWeight == NULL) {
+              if (!pWeight)
                 pWeight = NewEnumValue(pStaticStore, pValue->eName);
-              }
               continue;
             case FDE_CSSPROPERTYVALUE_Italic:
             case FDE_CSSPROPERTYVALUE_Oblique:
-              if (pStyle == NULL) {
+              if (!pStyle)
                 pStyle = NewEnumValue(pStaticStore, pValue->eName);
-              }
               continue;
             case FDE_CSSPROPERTYVALUE_SmallCaps:
-              if (pVariant == NULL) {
+              if (!pVariant)
                 pVariant = NewEnumValue(pStaticStore, pValue->eName);
-              }
               continue;
             case FDE_CSSPROPERTYVALUE_Normal:
-              if (pStyle == NULL) {
+              if (!pStyle)
                 pStyle = NewEnumValue(pStaticStore, pValue->eName);
-              } else if (pVariant == NULL) {
+              else if (!pVariant)
                 pVariant = NewEnumValue(pStaticStore, pValue->eName);
-              } else if (pWeight == NULL) {
+              else if (!pWeight)
                 pWeight = NewEnumValue(pStaticStore, pValue->eName);
-              } else if (pFontSize == NULL) {
+              else if (!pFontSize)
                 pFontSize = NewEnumValue(pStaticStore, pValue->eName);
-              } else if (pLineHeight == NULL) {
+              else if (!pLineHeight)
                 pLineHeight = NewEnumValue(pStaticStore, pValue->eName);
-              }
               continue;
             default:
               break;
           }
         }
-        if (pFontSize != NULL) {
+        if (pFontSize) {
           familyList.Add(FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(
               eType, CopyToLocal(pArgs, pszValue, iValueLen)));
         }
         parser.m_Separator = ',';
       } break;
       case FDE_CSSPRIMITIVETYPE_Number: {
         FX_FLOAT fValue;
         if (!FDE_ParseCSSNumber(pszValue, iValueLen, fValue, eType)) {
           break;
         }
         if (eType == FDE_CSSPRIMITIVETYPE_Number) {
           switch ((int32_t)fValue) {
             case 100:
             case 200:
             case 300:
             case 400:
             case 500:
             case 600:
             case 700:
             case 800:
             case 900:
-              if (pWeight == NULL) {
+              if (!pWeight) {
                 pWeight = NewNumberValue(pStaticStore,
                                          FDE_CSSPRIMITIVETYPE_Number, fValue);
               }
               continue;
           }
         }
-        if (pFontSize == NULL) {
+        if (!pFontSize)
           pFontSize = NewNumberValue(pStaticStore, eType, fValue);
-        } else if (pLineHeight == NULL) {
+        else if (!pLineHeight)
           pLineHeight = NewNumberValue(pStaticStore, eType, fValue);
-        }
       } break;
       default:
         break;
     }
   }
-  if (pStyle == NULL) {
+  if (!pStyle)
     pStyle = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Normal);
-  }
-  if (pVariant == NULL) {
+  if (!pVariant)
     pVariant = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Normal);
-  }
-  if (pWeight == NULL) {
+  if (!pWeight)
     pWeight = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Normal);
-  }
-  if (pFontSize == NULL) {
+  if (!pFontSize)
     pFontSize = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Medium);
-  }
-  if (pLineHeight == NULL) {
+  if (!pLineHeight)
     pLineHeight = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Normal);
-  }
+
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_FontStyle, pStyle,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_FontVariant, pVariant,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_FontWeight, pWeight,
                     bImportant);
   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;
 }
 FX_BOOL CFDE_CSSDeclaration::ParseColumnRuleProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
     FX_BOOL bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
-  IFDE_CSSPrimitiveValue* pColumnRuleWidth = NULL;
-  IFDE_CSSPrimitiveValue* pColumnRuleStyle = NULL;
-  IFDE_CSSPrimitiveValue* pColumnRuleColor = NULL;
+  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 =
             FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
-        if (pValue != NULL) {
+        if (pValue) {
           switch (pValue->eName) {
             case FDE_CSSPROPERTYVALUE_None:
             case FDE_CSSPROPERTYVALUE_Hidden:
             case FDE_CSSPROPERTYVALUE_Dotted:
             case FDE_CSSPROPERTYVALUE_Dashed:
             case FDE_CSSPROPERTYVALUE_Solid:
             case FDE_CSSPROPERTYVALUE_Double:
             case FDE_CSSPROPERTYVALUE_Groove:
             case FDE_CSSPROPERTYVALUE_Ridge:
             case FDE_CSSPROPERTYVALUE_Inset:
             case FDE_CSSPROPERTYVALUE_Outset:
-              if (pColumnRuleStyle == NULL) {
+              if (!pColumnRuleStyle)
                 pColumnRuleStyle = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             case FDE_CSSPROPERTYVALUE_Transparent:
-              if (pColumnRuleColor == NULL) {
+              if (!pColumnRuleColor)
                 pColumnRuleColor = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             case FDE_CSSPROPERTYVALUE_Thin:
             case FDE_CSSPROPERTYVALUE_Medium:
             case FDE_CSSPROPERTYVALUE_Thick:
-              if (pColumnRuleWidth == NULL) {
+              if (!pColumnRuleWidth)
                 pColumnRuleWidth = NewEnumValue(pStaticStore, pValue->eName);
-              }
               break;
             default:
               break;
           }
           continue;
         }
         FX_ARGB dwColor;
         if (FDE_ParseCSSColor(pszValue, iValueLen, dwColor) &&
-            pColumnRuleColor == NULL) {
+            !pColumnRuleColor) {
           pColumnRuleColor = FXTARGET_NewWith(pStaticStore)
               CFDE_CSSPrimitiveValue((FX_ARGB)dwColor);
           continue;
         }
       } break;
       case FDE_CSSPRIMITIVETYPE_Number: {
         FX_FLOAT fValue;
         if (FDE_ParseCSSNumber(pszValue, iValueLen, fValue, eType) &&
-            pColumnRuleWidth == NULL) {
+            !pColumnRuleWidth) {
           pColumnRuleWidth = NewNumberValue(pStaticStore, eType, fValue);
         }
       } break;
       case FDE_CSSPRIMITIVETYPE_RGB: {
         FX_ARGB dwColor;
-        if (pColumnRuleColor == NULL &&
+        if (!pColumnRuleColor &&
             FDE_ParseCSSColor(pszValue, iValueLen, dwColor)) {
           pColumnRuleColor = FXTARGET_NewWith(pStaticStore)
               CFDE_CSSPrimitiveValue((FX_ARGB)dwColor);
         }
       } break;
       default:
         break;
     }
   }
-  if (pColumnRuleColor == NULL && pColumnRuleStyle == NULL &&
-      pColumnRuleWidth == NULL) {
+  if (!pColumnRuleColor && !pColumnRuleStyle && !pColumnRuleWidth)
     return FALSE;
-  }
-  if (pColumnRuleStyle == NULL) {
+
+  if (!pColumnRuleStyle)
     pColumnRuleStyle = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_None);
-  }
-  if (pColumnRuleWidth == NULL) {
+  if (!pColumnRuleWidth)
     pColumnRuleWidth = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Medium);
-  }
-  if (pColumnRuleColor == NULL) {
+  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;
 }
 FX_BOOL CFDE_CSSDeclaration::ParseTextEmphasisProperty(
     FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
     FX_BOOL bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
   CFDE_CSSValueArray arrEmphasisStyle;
   FDE_CSSPRIMITIVETYPE eType;
-  IFDE_CSSPrimitiveValue* pEmphasisColor = NULL;
+  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));
-        if (pValue != NULL) {
+        if (pValue) {
           arrEmphasisStyle.Add(NewEnumValue(pStaticStore, pValue->eName));
           continue;
         }
         FX_ARGB dwColor;
         if (FDE_ParseCSSColor(pszValue, iValueLen, dwColor)) {
           pEmphasisColor =
               FXTARGET_NewWith(pStaticStore) CFDE_CSSPrimitiveValue(dwColor);
           continue;
         }
         pszValue = CopyToLocal(pArgs, pszValue, iValueLen);
@@ skipping 11 matching lines @@
       default:
         break;
     }
   }
   if (arrEmphasisStyle.GetSize() != 0) {
     AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_TextEmphasisStyle,
                       FXTARGET_NewWith(pStaticStore)
                           CFDE_CSSValueList(pStaticStore, arrEmphasisStyle),
                       bImportant);
   }
-  if (pEmphasisColor != NULL) {
+  if (pEmphasisColor) {
     AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_TextEmphasisColor,
                       pEmphasisColor, bImportant);
   }
   return TRUE;
 }
 FX_BOOL CFDE_CSSDeclaration::ParseColumnsProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
     FX_BOOL bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
-  IFDE_CSSPrimitiveValue* pColumnWidth = NULL;
-  IFDE_CSSPrimitiveValue* pColumnCount = NULL;
+  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));
-        if (pValue == NULL && pValue->eName == FDE_CSSPROPERTYVALUE_Auto) {
+        if (!pValue && pValue->eName == FDE_CSSPROPERTYVALUE_Auto) {
           pColumnWidth = NewEnumValue(pStaticStore, pValue->eName);
         }
       } break;
       case FDE_CSSPRIMITIVETYPE_Number: {
         FX_FLOAT fValue;
         if (FDE_ParseCSSNumber(pszValue, iValueLen, fValue, eType)) {
           switch (eType) {
             case FDE_CSSPRIMITIVETYPE_Number:
-              if (pColumnCount == NULL) {
+              if (!pColumnCount)
                 pColumnCount = NewNumberValue(pStaticStore, eType, fValue);
-              }
               break;
             default:
-              if (pColumnWidth == NULL) {
+              if (!pColumnWidth)
                 pColumnWidth = NewNumberValue(pStaticStore, eType, fValue);
-              }
               break;
           }
         }
       } break;
       default:
         break;
     }
   }
-  if (pColumnWidth == NULL && pColumnCount == NULL) {
+  if (!pColumnWidth && !pColumnCount)
     return FALSE;
-  } else if (pColumnWidth == NULL) {
+
+  if (!pColumnWidth)
     pColumnWidth = NewEnumValue(pStaticStore, FDE_CSSPROPERTYVALUE_Auto);
-  } else if (pColumnCount == NULL) {
+  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;
 }
 FX_BOOL CFDE_CSSDeclaration::ParseOverflowProperty(
     const FDE_CSSPROPERTYARGS* pArgs,
     const FX_WCHAR* pszValue,
     int32_t iValueLen,
     FX_BOOL bImportant) {
   IFX_MemoryAllocator* pStaticStore = pArgs->pStaticStore;
   CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
-  IFDE_CSSPrimitiveValue* pOverflowX = NULL;
-  IFDE_CSSPrimitiveValue* pOverflowY = NULL;
+  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 != NULL) {
+      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 != NULL && pOverflowY != NULL) {
+            if (pOverflowX && pOverflowY)
               return FALSE;
-            } else if (pOverflowX == NULL) {
+            if (!pOverflowX) {
               pOverflowX = NewEnumValue(pStaticStore, pValue->eName);
-            } else if (pOverflowY == NULL) {
+            } else if (!pOverflowY) {
               pOverflowY = NewEnumValue(pStaticStore, pValue->eName);
             }
             break;
           default:
             break;
         }
       }
     }
   }
-  if (pOverflowX == NULL && pOverflowY == NULL) {
+  if (!pOverflowX && !pOverflowY)
     return FALSE;
-  } else if (pOverflowY == NULL) {
+
+  if (!pOverflowY)
     pOverflowY = NewEnumValue(pStaticStore, pOverflowX->GetEnum());
-  }
+
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_OverflowX, pOverflowX,
                     bImportant);
   AddPropertyHolder(pStaticStore, FDE_CSSPROPERTY_OverflowY, pOverflowY,
                     bImportant);
   return TRUE;
 }